clerc 0.3.4 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clerc",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "author": "Ray <nn_201312@163.com> (https://github.com/so1ve)",
   "description": "Clerc is a simple and easy-to-use cli framework.",
   "keywords": [
@@ -39,7 +39,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@clerc/utils": "0.3.4",
+    "@clerc/utils": "0.4.0",
     "is-platform": "^0.2.0",
     "lite-emit": "^1.4.0",
     "mri": "^1.2.0",

package/dist/index.cjs

@@ -1,168 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var liteEmit = require('lite-emit');
-var mri = require('mri');
-var typeFlag = require('type-flag');
-var isPlatform = require('is-platform');
-var utils = require('@clerc/utils');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var mri__default = /*#__PURE__*/_interopDefaultLegacy(mri);
-
-class SingleCommandError extends Error {
-}
-class CommandExistsError extends Error {
-}
-class CommonCommandExistsError extends Error {
-}
-class NoSuchCommandError extends Error {
-}
-
-const resolveFlagAlias = (_command) => Object.entries((_command == null ? void 0 : _command.flags) || {}).reduce((acc, [name, command]) => {
-  if (command.alias) {
-    const item = utils.mustArray(command.alias).map(utils.kebabCase);
-    acc[utils.kebabCase(name)] = item;
-  }
-  return acc;
-}, {});
-const resolveFlagDefault = (_command) => Object.entries((_command == null ? void 0 : _command.flags) || {}).reduce((acc, [name, command]) => {
-  const item = command.default;
-  if (item) {
-    acc[name] = item;
-  }
-  return acc;
-}, {});
-function resolveCommand(commands, name) {
-  if (name === SingleCommand) {
-    return commands[SingleCommand];
-  }
-  const possibleCommands = Object.values(commands).filter(
-    (c) => c.name === name || utils.mustArray(c.alias || []).map(String).includes(name)
-  );
-  if (possibleCommands.length > 1) {
-    throw new Error(`Multiple commands found with name "${name}"`);
-  }
-  return possibleCommands[0];
-}
-const resolveArgv = () => isPlatform.isNode() ? process.argv.slice(2) : isPlatform.isDeno() ? Deno.args : [];
-function compose(inspectors) {
-  return (ctx) => {
-    return dispatch(0);
-    function dispatch(i) {
-      const inspector = inspectors[i];
-      return inspector(ctx, dispatch.bind(null, i + 1));
-    }
-  };
-}
-
-const SingleCommand = Symbol("SingleCommand");
-class Clerc {
-  constructor() {
-    this._name = "";
-    this._description = "";
-    this._version = "";
-    this._inspectors = [];
-    this._commands = {};
-    this.__commandEmitter = new liteEmit.LiteEmit();
-  }
-  get __isSingleCommand() {
-    return this._commands[SingleCommand] !== void 0;
-  }
-  get __hasCommands() {
-    return Object.keys(this._commands).length > 0;
-  }
-  static create() {
-    return new Clerc();
-  }
-  name(name) {
-    this._name = name;
-    return this;
-  }
-  description(description) {
-    this._description = description;
-    return this;
-  }
-  version(version) {
-    this._version = version;
-    return this;
-  }
-  command(name, description, options = {}) {
-    if (this._commands[name]) {
-      if (name === SingleCommand) {
-        throw new CommandExistsError("Single command already exists");
-      }
-      throw new CommandExistsError(`Command "${name === SingleCommand ? "[SingleCommand]" : name}" already exists`);
-    }
-    if (this.__isSingleCommand) {
-      throw new SingleCommandError("Single command mode enabled");
-    }
-    if (name === SingleCommand && this.__hasCommands) {
-      throw new CommonCommandExistsError("Common command exists");
-    }
-    const { alias, flags } = options;
-    this._commands[name] = { name, description, alias, flags };
-    return this;
-  }
-  on(name, handler) {
-    this.__commandEmitter.on(name, handler);
-    return this;
-  }
-  use(plugin) {
-    return plugin.setup(this);
-  }
-  inspector(inspector) {
-    this._inspectors.push(inspector);
-    return this;
-  }
-  parse(argv = resolveArgv()) {
-    const parsed = mri__default["default"](argv);
-    const name = String(parsed._[0]);
-    const command = this.__isSingleCommand ? this._commands[SingleCommand] : resolveCommand(this._commands, name);
-    const isCommandResolved = !!command;
-    const parsedWithType = typeFlag.typeFlag((command == null ? void 0 : command.flags) || {}, argv);
-    const { _: args, flags } = parsedWithType;
-    const parameters = this.__isSingleCommand || !isCommandResolved ? args : args.slice(1);
-    const inspectorContext = {
-      name: command == null ? void 0 : command.name,
-      resolved: isCommandResolved,
-      isSingleCommand: this.__isSingleCommand,
-      raw: parsedWithType,
-      parameters,
-      flags,
-      unknownFlags: parsedWithType.unknownFlags,
-      cli: this
-    };
-    const handlerContext = inspectorContext;
-    const emitHandler = () => {
-      if (!command) {
-        throw new NoSuchCommandError(`No such command: ${name}`);
-      }
-      this.__commandEmitter.emit(command.name, handlerContext);
-    };
-    const inspectors = [...this._inspectors, emitHandler];
-    const inspector = compose(inspectors);
-    inspector(inspectorContext);
-  }
-}
-
-const definePlugin = (p) => p;
-const defineHandler = (_cli, _key, handler) => handler;
-const defineInspector = (_cli, inspector) => inspector;
-
-exports.Clerc = Clerc;
-exports.CommandExistsError = CommandExistsError;
-exports.CommonCommandExistsError = CommonCommandExistsError;
-exports.NoSuchCommandError = NoSuchCommandError;
-exports.SingleCommand = SingleCommand;
-exports.SingleCommandError = SingleCommandError;
-exports.compose = compose;
-exports.defineHandler = defineHandler;
-exports.defineInspector = defineInspector;
-exports.definePlugin = definePlugin;
-exports.resolveArgv = resolveArgv;
-exports.resolveCommand = resolveCommand;
-exports.resolveFlagAlias = resolveFlagAlias;
-exports.resolveFlagDefault = resolveFlagDefault;

package/dist/index.d.ts

@@ -1,271 +0,0 @@
-import { MaybeArray, Dict, LiteralUnion } from '@clerc/utils';
-
-declare const DOUBLE_DASH = "--";
-declare type TypeFunction<ReturnType = any> = (value: any) => ReturnType;
-declare type TypeFunctionArray<ReturnType> = readonly [TypeFunction<ReturnType>];
-declare type FlagType<ReturnType = any> = TypeFunction<ReturnType> | TypeFunctionArray<ReturnType>;
-declare type FlagSchemaBase<TF> = {
-    /**
-      Type of the flag as a function that parses the argv string and returns the parsed value.
-  
-      @example
-      ```
-      type: String
-      ```
-  
-      @example Wrap in an array to accept multiple values.
-      ```
-      type: [Boolean]
-      ```
-  
-      @example Custom function type that uses moment.js to parse string as date.
-      ```
-      type: function CustomDate(value: string) {
-          return moment(value).toDate();
-      }
-      ```
-      */
-    type: TF;
-    /**
-      A single-character alias for the flag.
-  
-      @example
-      ```
-      alias: 's'
-      ```
-      */
-    alias?: string;
-} & Record<PropertyKey, unknown>;
-declare type FlagSchemaDefault<TF, DefaultType = any> = FlagSchemaBase<TF> & {
-    /**
-      Default value of the flag. Also accepts a function that returns the default value.
-      [Default: undefined]
-  
-      @example
-      ```
-      default: 'hello'
-      ```
-  
-      @example
-      ```
-      default: () => [1, 2, 3]
-      ```
-      */
-    default: DefaultType | (() => DefaultType);
-};
-declare type FlagSchema<TF = FlagType> = (FlagSchemaBase<TF> | FlagSchemaDefault<TF>);
-declare type FlagTypeOrSchema<ExtraOptions = Record<string, unknown>> = FlagType | (FlagSchema & ExtraOptions);
-declare type Flags<ExtraOptions = Record<string, unknown>> = Record<string, FlagTypeOrSchema<ExtraOptions>>;
-declare type InferFlagType<Flag extends FlagTypeOrSchema> = (Flag extends (TypeFunctionArray<infer T> | FlagSchema<TypeFunctionArray<infer T>>) ? (Flag extends FlagSchemaDefault<TypeFunctionArray<T>, infer D> ? T[] | D : T[]) : (Flag extends TypeFunction<infer T> | FlagSchema<TypeFunction<infer T>> ? (Flag extends FlagSchemaDefault<TypeFunction<T>, infer D> ? T | D : T | undefined) : never));
-interface ParsedFlags<Schemas = Record<string, unknown>> {
-    flags: Schemas;
-    unknownFlags: Record<string, (string | boolean)[]>;
-    _: string[] & {
-        [DOUBLE_DASH]: string[];
-    };
-}
-declare type TypeFlag<Schemas extends Flags> = ParsedFlags<{
-    [flag in keyof Schemas]: InferFlagType<Schemas[flag]>;
-}>;
-
-declare type FlagOptions = FlagSchema & {
-    description: string;
-    required?: boolean;
-};
-declare type Flag = FlagOptions & {
-    name: string;
-};
-interface CommandOptions<A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>> {
-    alias?: A;
-    flags?: F;
-}
-declare type Command<N extends string | SingleCommandType = string, D extends string = string, Options extends CommandOptions = CommandOptions> = Options & {
-    name: N;
-    description: D;
-};
-declare type CommandRecord = Dict<Command> & {
-    [SingleCommand]?: Command;
-};
-declare type MakeEventMap<T extends CommandRecord> = {
-    [K in keyof T]: [InspectorContext];
-};
-declare type PossibleInputKind = string | number | boolean | Dict<any>;
-declare type NonNullableFlag<T extends Dict<FlagOptions> | undefined> = T extends undefined ? {} : NonNullable<T>;
-interface HandlerContext<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> {
-    name?: N;
-    resolved: boolean;
-    isSingleCommand: boolean;
-    raw: ParsedFlags;
-    parameters: PossibleInputKind[];
-    unknownFlags: ParsedFlags["unknownFlags"];
-    flags: TypeFlag<NonNullableFlag<C[N]["flags"]>>["flags"];
-    cli: Clerc<C>;
-}
-declare type Handler<C extends CommandRecord = CommandRecord, K extends keyof C = keyof C> = (ctx: HandlerContext<C, K>) => void;
-declare type FallbackType<T, U> = {} extends T ? U : T;
-declare type InspectorContext<C extends CommandRecord = CommandRecord> = HandlerContext<C> & {
-    flags: FallbackType<TypeFlag<NonNullableFlag<C[keyof C]["flags"]>>["flags"], Dict<any>>;
-};
-declare type Inspector<C extends CommandRecord = CommandRecord> = (ctx: InspectorContext<C>, next: () => void) => void;
-interface Plugin<T extends Clerc = Clerc, U extends Clerc = Clerc> {
-    setup: (cli: T) => U;
-}
-
-declare const SingleCommand: unique symbol;
-declare type SingleCommandType = typeof SingleCommand;
-declare class Clerc<C extends CommandRecord = {}> {
-    _name: string;
-    _description: string;
-    _version: string;
-    _inspectors: Inspector[];
-    _commands: C;
-    private __commandEmitter;
-    private constructor();
-    private get __isSingleCommand();
-    private get __hasCommands();
-    /**
-     * Create a new cli
-     * @returns
-     * @example
-     * ```ts
-     * const cli = Clerc.create()
-     * ```
-     */
-    static create(): Clerc<{}>;
-    /**
-     * Set the name of the cli
-     * @param name
-     * @returns
-     * @example
-     * ```ts
-     * Clerc.create()
-     *   .name("test")
-     * ```
-     */
-    name(name: string): this;
-    /**
-     * Set the description of the cli
-     * @param description
-     * @returns
-     * @example
-     * ```ts
-     * Clerc.create()
-     *  .description("test cli")
-     */
-    description(description: string): this;
-    /**
-     * Set the version of the cli
-     * @param version
-     * @returns
-     * @example
-     * ```ts
-     * Clerc.create()
-     *  .version("1.0.0")
-     */
-    version(version: string): this;
-    /**
-     * Register a command
-     * @param name
-     * @param description
-     * @param options
-     * @returns
-     * @example
-     * ```ts
-     * Clerc.create()
-     *   .command("test", "test command", {
-     *     alias: "t",
-     *     flags: {
-     *       foo: {
-     *         alias: "f",
-     *         description: "foo flag",
-     *       }
-     *     }
-     *   })
-     * ```
-     * @example
-     * ```ts
-     * Clerc.create()
-     *   .command("", "single command", {
-     *     flags: {
-     *       foo: {
-     *         alias: "f",
-     *         description: "foo flag",
-     *       }
-     *     }
-     *   })
-     * ```
-     */
-    command<N extends string | SingleCommandType, D extends string, O extends CommandOptions>(name: N, description: D, options?: O): this & Clerc<C & Record<N, Command<N, D, O>>>;
-    /**
-     * Register a handler
-     * @param name
-     * @param handler
-     * @returns
-     * @example
-     * ```ts
-     * Clerc.create()
-     *   .command("test", "test command")
-     *   .on("test", (ctx) => {
-     *     console.log(ctx);
-     *   })
-     * ```
-     */
-    on<K extends keyof CM, CM extends this["_commands"] = this["_commands"]>(name: LiteralUnion<K, string>, handler: Handler<CM, K>): this;
-    /**
-     * Use a plugin
-     * @param plugin
-     * @returns
-     * @example
-     * ```ts
-     * Clerc.create()
-     *   .use(plugin)
-     * ```
-     */
-    use<T extends Clerc, U extends Clerc>(plugin: Plugin<T, U>): U;
-    /**
-     * Register a inspector
-     * @param inspector
-     * @returns
-     * @example
-     * ```ts
-     * Clerc.create()
-     *   .inspector((ctx, next) => {
-     *     console.log(ctx);
-     *     next();
-     *   })
-     * ```
-     */
-    inspector(inspector: Inspector): this;
-    /**
-     * Parse the command line arguments
-     * @param args
-     * @returns
-     * @example
-     * ```ts
-     * Clerc.create()
-     *   .parse(process.argv.slice(2)) // Optional
-     * ```
-     */
-    parse(argv?: string[]): void;
-}
-
-declare const definePlugin: <T extends Clerc<{}>, U extends Clerc<{}>>(p: Plugin<T, U>) => Plugin<T, U>;
-declare const defineHandler: <C extends Clerc<{}>, K extends keyof C["_commands"]>(_cli: C, _key: K, handler: Handler<C["_commands"], K>) => Handler<C["_commands"], K>;
-declare const defineInspector: <C extends Clerc<{}>>(_cli: C, inspector: Inspector<C["_commands"]>) => Inspector<C["_commands"]>;
-
-declare class SingleCommandError extends Error {
-}
-declare class CommandExistsError extends Error {
-}
-declare class CommonCommandExistsError extends Error {
-}
-declare class NoSuchCommandError extends Error {
-}
-
-declare const resolveFlagAlias: (_command: Command) => Dict<string[]>;
-declare const resolveFlagDefault: (_command: Command) => Dict<any>;
-declare function resolveCommand(commands: CommandRecord, name: string | SingleCommandType): Command | undefined;
-declare const resolveArgv: () => string[];
-declare function compose(inspectors: Inspector[]): (ctx: InspectorContext) => void;
-
-export { Clerc, Command, CommandExistsError, CommandOptions, CommandRecord, CommonCommandExistsError, FallbackType, Flag, FlagOptions, Handler, HandlerContext, Inspector, InspectorContext, MakeEventMap, NoSuchCommandError, Plugin, PossibleInputKind, SingleCommand, SingleCommandError, SingleCommandType, compose, defineHandler, defineInspector, definePlugin, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault };

package/dist/index.mjs

@@ -1,147 +0,0 @@
-import { LiteEmit } from 'lite-emit';
-import mri from 'mri';
-import { typeFlag } from 'type-flag';
-import { isNode, isDeno } from 'is-platform';
-import { mustArray, kebabCase } from '@clerc/utils';
-
-class SingleCommandError extends Error {
-}
-class CommandExistsError extends Error {
-}
-class CommonCommandExistsError extends Error {
-}
-class NoSuchCommandError extends Error {
-}
-
-const resolveFlagAlias = (_command) => Object.entries((_command == null ? void 0 : _command.flags) || {}).reduce((acc, [name, command]) => {
-  if (command.alias) {
-    const item = mustArray(command.alias).map(kebabCase);
-    acc[kebabCase(name)] = item;
-  }
-  return acc;
-}, {});
-const resolveFlagDefault = (_command) => Object.entries((_command == null ? void 0 : _command.flags) || {}).reduce((acc, [name, command]) => {
-  const item = command.default;
-  if (item) {
-    acc[name] = item;
-  }
-  return acc;
-}, {});
-function resolveCommand(commands, name) {
-  if (name === SingleCommand) {
-    return commands[SingleCommand];
-  }
-  const possibleCommands = Object.values(commands).filter(
-    (c) => c.name === name || mustArray(c.alias || []).map(String).includes(name)
-  );
-  if (possibleCommands.length > 1) {
-    throw new Error(`Multiple commands found with name "${name}"`);
-  }
-  return possibleCommands[0];
-}
-const resolveArgv = () => isNode() ? process.argv.slice(2) : isDeno() ? Deno.args : [];
-function compose(inspectors) {
-  return (ctx) => {
-    return dispatch(0);
-    function dispatch(i) {
-      const inspector = inspectors[i];
-      return inspector(ctx, dispatch.bind(null, i + 1));
-    }
-  };
-}
-
-const SingleCommand = Symbol("SingleCommand");
-class Clerc {
-  constructor() {
-    this._name = "";
-    this._description = "";
-    this._version = "";
-    this._inspectors = [];
-    this._commands = {};
-    this.__commandEmitter = new LiteEmit();
-  }
-  get __isSingleCommand() {
-    return this._commands[SingleCommand] !== void 0;
-  }
-  get __hasCommands() {
-    return Object.keys(this._commands).length > 0;
-  }
-  static create() {
-    return new Clerc();
-  }
-  name(name) {
-    this._name = name;
-    return this;
-  }
-  description(description) {
-    this._description = description;
-    return this;
-  }
-  version(version) {
-    this._version = version;
-    return this;
-  }
-  command(name, description, options = {}) {
-    if (this._commands[name]) {
-      if (name === SingleCommand) {
-        throw new CommandExistsError("Single command already exists");
-      }
-      throw new CommandExistsError(`Command "${name === SingleCommand ? "[SingleCommand]" : name}" already exists`);
-    }
-    if (this.__isSingleCommand) {
-      throw new SingleCommandError("Single command mode enabled");
-    }
-    if (name === SingleCommand && this.__hasCommands) {
-      throw new CommonCommandExistsError("Common command exists");
-    }
-    const { alias, flags } = options;
-    this._commands[name] = { name, description, alias, flags };
-    return this;
-  }
-  on(name, handler) {
-    this.__commandEmitter.on(name, handler);
-    return this;
-  }
-  use(plugin) {
-    return plugin.setup(this);
-  }
-  inspector(inspector) {
-    this._inspectors.push(inspector);
-    return this;
-  }
-  parse(argv = resolveArgv()) {
-    const parsed = mri(argv);
-    const name = String(parsed._[0]);
-    const command = this.__isSingleCommand ? this._commands[SingleCommand] : resolveCommand(this._commands, name);
-    const isCommandResolved = !!command;
-    const parsedWithType = typeFlag((command == null ? void 0 : command.flags) || {}, argv);
-    const { _: args, flags } = parsedWithType;
-    const parameters = this.__isSingleCommand || !isCommandResolved ? args : args.slice(1);
-    const inspectorContext = {
-      name: command == null ? void 0 : command.name,
-      resolved: isCommandResolved,
-      isSingleCommand: this.__isSingleCommand,
-      raw: parsedWithType,
-      parameters,
-      flags,
-      unknownFlags: parsedWithType.unknownFlags,
-      cli: this
-    };
-    const handlerContext = inspectorContext;
-    const emitHandler = () => {
-      if (!command) {
-        throw new NoSuchCommandError(`No such command: ${name}`);
-      }
-      this.__commandEmitter.emit(command.name, handlerContext);
-    };
-    const inspectors = [...this._inspectors, emitHandler];
-    const inspector = compose(inspectors);
-    inspector(inspectorContext);
-  }
-}
-
-const definePlugin = (p) => p;
-const defineHandler = (_cli, _key, handler) => handler;
-const defineInspector = (_cli, inspector) => inspector;
-
-export { Clerc, CommandExistsError, CommonCommandExistsError, NoSuchCommandError, SingleCommand, SingleCommandError, compose, defineHandler, defineInspector, definePlugin, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault };