polymer-cli

  • Version 1.9.11
  • Published
  • 1.22 MB
  • 51 dependencies
  • BSD-3-Clause license

Install

npm i polymer-cli
yarn add polymer-cli
pnpm add polymer-cli

Overview

A commandline tool for Polymer projects

Index

Classes

class PolymerCli

class PolymerCli {}

    constructor

    constructor(args: string[], configOptions?: any);

      property args

      args: string[];

        property commands

        commands: Map<string, Command>;

          property defaultConfigOptions

          defaultConfigOptions: any;

            method addCommand

            addCommand: (command: Command) => void;

              method run

              run: () => Promise<void | CommandResult>;

                Namespaces

                namespace bower

                module 'bower' {}

                  variable commands

                  const commands: {
                  install(packages: string[], installOptions: {}, config: Config): any;
                  list(readOptions: {}, config: Config): any;
                  };

                    variable config

                    const config: Config;

                      interface Config

                      interface Config {}

                        property color

                        color?: boolean;

                          property cwd

                          cwd?: string;

                            property directory

                            directory?: string;

                              property interactive

                              interactive?: boolean;

                                property offline

                                offline?: boolean;

                                  property save

                                  save?: boolean;

                                    interface Conflict

                                    interface Conflict {}

                                      property data

                                      data: {
                                      // Name of package with conflict
                                      name: string;
                                      picks: Pick[];
                                      };

                                        property id

                                        id: 'incompatible' | string;

                                          property level

                                          level: 'conflict';

                                            property message

                                            message: string;

                                              interface Pick

                                              interface Pick {}

                                                property canonicalDir

                                                canonicalDir: string;
                                                • local path to temporary dir on filesystem

                                                property endpoint

                                                endpoint: {
                                                name: string;
                                                /** repo */
                                                source: string;
                                                /** version name */
                                                target: string;
                                                };
                                                • This is the package request.

                                                property pkgMeta

                                                pkgMeta: {
                                                name: string;
                                                version: string;
                                                // lot of stuff here we don't care about...
                                                /*
                                                main: [Object];
                                                license: string;
                                                ignore: [Object];
                                                authors: [Object];
                                                repository: [Object],
                                                dependencies: [Object],
                                                devDependencies: [Object],
                                                private: true,
                                                homepage: 'https://github.com/Polymer/polymer',
                                                _release: '1.7.0',
                                                _resolution: [Object],
                                                _source: 'https://github.com/Polymer/polymer.git',
                                                _target: '>=1.0.8'
                                                */
                                                };
                                                • This is the bower.json of the package that was resolved

                                                interface Warning

                                                interface Warning {}

                                                  property id

                                                  id: string;

                                                    property level

                                                    level: 'warn';

                                                      property message

                                                      message: string;

                                                        type LogData

                                                        type LogData = Warning | Conflict;

                                                          namespace bower-json

                                                          module 'bower-json' {}

                                                            function read

                                                            read: (
                                                            path: string,
                                                            options: any,
                                                            callback: (err: any, json: any) => void
                                                            ) => void;

                                                              namespace bower-logger

                                                              module 'bower-logger' {}

                                                                class BowerLogger

                                                                class BowerLogger {}

                                                                  interface BowerLogger

                                                                  interface BowerLogger extends NodeJS.EventEmitter {}

                                                                    namespace bower/lib/config

                                                                    module 'bower/lib/config' {}

                                                                      function defaultConfig

                                                                      defaultConfig: (config: any) => Config;

                                                                        namespace bower/lib/core/Project

                                                                        module 'bower/lib/core/Project' {}

                                                                          class Project

                                                                          class Project {}

                                                                            constructor

                                                                            constructor(config: Config, logger: Logger);

                                                                              method install

                                                                              install: (endpoints: string[], options: any, config: Config) => void;

                                                                                namespace bower/lib/renderers/StandardRenderer

                                                                                module 'bower/lib/renderers/StandardRenderer' {}

                                                                                  class StandardRenderer

                                                                                  class StandardRenderer {}

                                                                                    constructor

                                                                                    constructor(command: string, config: Config);

                                                                                      method end

                                                                                      end: (data: any) => void;

                                                                                        method error

                                                                                        error: (error: Error) => void;

                                                                                          method log

                                                                                          log: (data: LogData) => void;

                                                                                            namespace command-line-args

                                                                                            module 'command-line-args' {}

                                                                                              function commandLineArgs

                                                                                              commandLineArgs: (
                                                                                              descriptors: commandLineArgs.ArgDescriptor[],
                                                                                              options: { argv?: string[] }
                                                                                              ) => any;
                                                                                              • Parameter descriptors

                                                                                                An array of objects that describe the arguments that we want to parse.

                                                                                                Parameter args

                                                                                                Optional arguments to parse. If not given, process.argv is used.

                                                                                              interface ArgDescriptor

                                                                                              interface ArgDescriptor {}

                                                                                                property alias

                                                                                                alias?: string;

                                                                                                  property defaultOption

                                                                                                  defaultOption?: boolean;

                                                                                                    property defaultValue

                                                                                                    defaultValue?: any;

                                                                                                      property description

                                                                                                      description?: string;

                                                                                                        property group

                                                                                                        group?: string;

                                                                                                          property multiple

                                                                                                          multiple?: boolean;

                                                                                                            property name

                                                                                                            name: string;

                                                                                                              property type

                                                                                                              type?: Object;

                                                                                                                namespace command-line-commands

                                                                                                                module 'command-line-commands' {}

                                                                                                                  function commandLineCommands

                                                                                                                  commandLineCommands: (
                                                                                                                  commands: string[],
                                                                                                                  argv?: string[]
                                                                                                                  ) => commandLineCommands.ParsedCommand;

                                                                                                                    interface ParsedCommand

                                                                                                                    interface ParsedCommand {}

                                                                                                                      property argv

                                                                                                                      argv: string[];

                                                                                                                        property command

                                                                                                                        command: string;

                                                                                                                          namespace command-line-usage

                                                                                                                          module 'command-line-usage' {}

                                                                                                                            function commandLineUsage

                                                                                                                            commandLineUsage: (groups: commandLineUsage.UsageGroup[]) => string;

                                                                                                                              interface ArgDescriptor

                                                                                                                              interface ArgDescriptor {}

                                                                                                                                property alias

                                                                                                                                alias?: string;

                                                                                                                                  property defaultOption

                                                                                                                                  defaultOption?: boolean;

                                                                                                                                    property defaultValue

                                                                                                                                    defaultValue?: any;

                                                                                                                                      property description

                                                                                                                                      description?: string;

                                                                                                                                        property group

                                                                                                                                        group?: string;

                                                                                                                                          property multiple

                                                                                                                                          multiple?: boolean;

                                                                                                                                            property name

                                                                                                                                            name: string;

                                                                                                                                              property type

                                                                                                                                              type?: Object;

                                                                                                                                                interface UsageGroup

                                                                                                                                                interface UsageGroup {}

                                                                                                                                                  property content

                                                                                                                                                  content?: any;

                                                                                                                                                    property header

                                                                                                                                                    header?: string;

                                                                                                                                                      property optionList

                                                                                                                                                      optionList?: ArgDescriptor[];

                                                                                                                                                        property raw

                                                                                                                                                        raw?: boolean;

                                                                                                                                                          namespace matcher

                                                                                                                                                          module 'matcher' {}

                                                                                                                                                            namespace slash

                                                                                                                                                            module 'slash' {}

                                                                                                                                                              function slash

                                                                                                                                                              slash: (source: string) => string;

                                                                                                                                                                namespace validate-element-name

                                                                                                                                                                module 'validate-element-name' {}

                                                                                                                                                                  function validateElementName

                                                                                                                                                                  validateElementName: (name: string) => { isValid: boolean; message: string };

                                                                                                                                                                    namespace vinyl-fs-fake

                                                                                                                                                                    module 'vinyl-fs-fake' {}

                                                                                                                                                                      function src

                                                                                                                                                                      src: (files: File[], options?: Options) => any;

                                                                                                                                                                        interface File

                                                                                                                                                                        interface File {}

                                                                                                                                                                          property contents

                                                                                                                                                                          contents: string;

                                                                                                                                                                            property path

                                                                                                                                                                            path: string;

                                                                                                                                                                              interface Options

                                                                                                                                                                              interface Options {}

                                                                                                                                                                                property cwdbase

                                                                                                                                                                                cwdbase: boolean;

                                                                                                                                                                                  namespace web-component-tester

                                                                                                                                                                                  module 'web-component-tester' {}

                                                                                                                                                                                    variable cli

                                                                                                                                                                                    let cli: CLI;

                                                                                                                                                                                      interface CLI

                                                                                                                                                                                      interface CLI {}

                                                                                                                                                                                        method run

                                                                                                                                                                                        run: (env: any, args: string[], stdout: any) => Promise<void>;

                                                                                                                                                                                          namespace yeoman-assert

                                                                                                                                                                                          module 'yeoman-assert' {}

                                                                                                                                                                                            function file

                                                                                                                                                                                            file: (filenames: string[]) => any;

                                                                                                                                                                                              function fileContent

                                                                                                                                                                                              fileContent: (path: string, content: string) => any;

                                                                                                                                                                                                function noFile

                                                                                                                                                                                                noFile: (filenames: string[]) => any;

                                                                                                                                                                                                  namespace yeoman-environment

                                                                                                                                                                                                  module 'yeoman-environment' {}

                                                                                                                                                                                                    class YeomanEnvironment

                                                                                                                                                                                                    class YeomanEnvironment {}

                                                                                                                                                                                                      method getGeneratorsMeta

                                                                                                                                                                                                      getGeneratorsMeta: () => { [name: string]: YeomanEnvironment.GeneratorMeta };

                                                                                                                                                                                                        method lookup

                                                                                                                                                                                                        lookup: (callback: (error?: any) => void) => void;

                                                                                                                                                                                                          method register

                                                                                                                                                                                                          register: (library: any, target: string) => string;

                                                                                                                                                                                                            method registerStub

                                                                                                                                                                                                            registerStub: (generator: any, namespace: string) => any;

                                                                                                                                                                                                              method run

                                                                                                                                                                                                              run: (target: string, options: any, done: Function) => void;

                                                                                                                                                                                                                interface GeneratorMeta

                                                                                                                                                                                                                interface GeneratorMeta {}

                                                                                                                                                                                                                  property namespace

                                                                                                                                                                                                                  namespace: string;

                                                                                                                                                                                                                    property resolved

                                                                                                                                                                                                                    resolved: string;

                                                                                                                                                                                                                      Package Files (14)

                                                                                                                                                                                                                      Dependencies (51)

                                                                                                                                                                                                                      Dev Dependencies (19)

                                                                                                                                                                                                                      Peer Dependencies (0)

                                                                                                                                                                                                                      No peer dependencies.

                                                                                                                                                                                                                      Badge

                                                                                                                                                                                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/polymer-cli.

                                                                                                                                                                                                                      • Markdown
                                                                                                                                                                                                                        [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/polymer-cli)
                                                                                                                                                                                                                      • HTML
                                                                                                                                                                                                                        <a href="https://www.jsdocs.io/package/polymer-cli"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>