clerc 0.1.1 → 0.3.0

package/dist/index.cjs

@@ -4,6 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var liteEmit = require('lite-emit');
 var minimist = require('minimist');
+var typeFlag = require('type-flag');
 var isPlatform = require('is-platform');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -16,7 +17,7 @@ class CommandExistsError extends Error {
 }
 class CommonCommandExistsError extends Error {
 }
-class NoSuchCommandsError extends Error {
+class NoSuchCommandError extends Error {
 }
 
 const mustArray = (a) => Array.isArray(a) ? a : [a];
@@ -103,8 +104,8 @@ class Clerc {
     if (name === SingleCommand && this.__hasCommands) {
       throw new CommonCommandExistsError("Common command exists");
     }
-    const { alias, flags, parameters } = options;
-    this._commands[name] = { name, description, alias, flags, parameters };
+    const { alias, flags } = options;
+    this._commands[name] = { name, description, alias, flags };
     return this;
   }
   on(name, handler) {
@@ -119,31 +120,26 @@ class Clerc {
     return this;
   }
   parse(argv = resolveArgv()) {
-    let parsed = minimist__default["default"](argv);
+    const parsed = minimist__default["default"](argv);
     const name = String(parsed._[0]);
     const command = this.__isSingleCommand ? this._commands[SingleCommand] : resolveCommand(this._commands, name);
     const isCommandResolved = !!command;
-    parsed = minimist__default["default"](argv, {
-      alias: command ? resolveFlagAlias(command) : {},
-      default: command ? resolveFlagDefault(command) : {}
-    });
-    const { _: args, ...flags } = parsed;
-    const camelCaseFlags = Object.fromEntries(
-      Object.entries(flags).map(([key, value]) => [camelCase(key), value])
-    );
+    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,
-      raw: parsed,
+      isSingleCommand: this.__isSingleCommand,
+      raw: parsedWithType,
       parameters,
-      flags: camelCaseFlags,
+      flags,
       cli: this
     };
     const handlerContext = inspectorContext;
     const emitHandler = () => {
       if (!command) {
-        throw new NoSuchCommandsError(`No such command: ${name}`);
+        throw new NoSuchCommandError(`No such command: ${name}`);
       }
       this.__commandEmitter.emit(command.name, handlerContext);
     };
@@ -154,17 +150,22 @@ class Clerc {
 }
 
 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.NoSuchCommandsError = NoSuchCommandsError;
+exports.NoSuchCommandError = NoSuchCommandError;
 exports.SingleCommand = SingleCommand;
 exports.SingleCommandError = SingleCommandError;
 exports.camelCase = camelCase;
 exports.compose = compose;
+exports.defineHandler = defineHandler;
+exports.defineInspector = defineInspector;
 exports.definePlugin = definePlugin;
 exports.kebabCase = kebabCase;
+exports.mustArray = mustArray;
 exports.resolveArgv = resolveArgv;
 exports.resolveCommand = resolveCommand;
 exports.resolveFlagAlias = resolveFlagAlias;

package/dist/index.d.ts

@@ -1,8 +1,79 @@
-interface Plugin<T extends Clerc = Clerc, U extends Clerc = Clerc> {
-    setup: (cli: T) => U;
+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 const definePlugin: <T extends Clerc<{}>, U extends Clerc<{}>>(p: Plugin<T, U>) => Plugin<T, U>;
+declare type TypeFlag<Schemas extends Flags> = ParsedFlags<{
+    [flag in keyof Schemas]: InferFlagType<Schemas[flag]>;
+}>;
 
+/**
+ * Copied from type-fest
+ */
+declare type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+/**
+ * Copied from type-fest
+ */
+declare type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
 declare type Dict<T> = Record<string, T>;
 declare type MustArray<T> = T extends any[] ? T : [T];
 declare type MaybeArray<T> = T | T[];
@@ -12,36 +83,21 @@ declare type GetLength<T extends any[]> = T extends {
 declare type GetTail<T extends any[]> = T extends [infer _Head, ...infer Tail] ? Tail : never;
 declare type EnhanceSingle<T, E extends Dict<any>> = T & E;
 declare type Enhance<T, E extends Dict<any> | Dict<any>[]> = GetLength<MustArray<E>> extends 0 ? T : Enhance<EnhanceSingle<T, MustArray<E>[0]>, GetTail<MustArray<E>>>;
-interface ParsedArgs {
-    [arg: string]: any;
-    "--"?: string[] | undefined;
-    _: string[];
-}
-interface FlagOptions {
-    description: string;
-    alias?: MaybeArray<string>;
-    default?: PossibleInputKind;
-    required?: boolean;
-}
-interface Flag extends FlagOptions {
-    name: string;
-}
-interface ParameterOptions {
+declare type FlagOptions = FlagSchema & {
     description: string;
     required?: boolean;
-}
-interface Parameter extends ParameterOptions {
+};
+declare type Flag = FlagOptions & {
     name: string;
+};
+interface CommandOptions<A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>> {
+    alias?: A;
+    flags?: F;
 }
-interface CommandOptions {
-    alias?: MaybeArray<string>;
-    parameters?: Dict<ParameterOptions>;
-    flags?: Dict<FlagOptions>;
-}
-interface Command<N extends string | SingleCommandType = string, D extends string = string> extends CommandOptions {
+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;
 };
@@ -49,18 +105,24 @@ 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;
-    raw: ParsedArgs;
+    isSingleCommand: boolean;
+    raw: ParsedFlags;
     parameters: PossibleInputKind[];
-    flags: Dict<MaybeArray<PossibleInputKind> | undefined>;
+    flags: TypeFlag<NonNullableFlag<C[N]["flags"]>>["flags"];
     cli: Clerc<C>;
 }
-declare type Handler = (ctx: HandlerContext) => void;
-interface InspectorContext<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> extends HandlerContext<C, N> {
-}
-declare type Inspector = (ctx: InspectorContext<any>, next: () => void) => void;
+declare type Handler<C extends CommandRecord = CommandRecord, K extends keyof C = keyof C> = (ctx: HandlerContext<C, K>) => void;
+declare type InspectorContext<C extends CommandRecord = CommandRecord> = HandlerContext<C> & {
+    flags: {} extends TypeFlag<NonNullableFlag<C[keyof C]["flags"]>>["flags"] ? Dict<any> : TypeFlag<NonNullableFlag<C[keyof C]["flags"]>>["flags"];
+};
+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;
@@ -146,7 +208,7 @@ declare class Clerc<C extends CommandRecord = {}> {
      *   })
      * ```
      */
-    command<N extends string | SingleCommandType, D extends string>(name: N, description: D, options?: CommandOptions): this & Clerc<C & Record<N, Command<N, D>>>;
+    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
@@ -161,7 +223,7 @@ declare class Clerc<C extends CommandRecord = {}> {
      *   })
      * ```
      */
-    on<K extends keyof C>(name: K, handler: Handler): this;
+    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
@@ -200,23 +262,28 @@ declare class Clerc<C extends CommandRecord = {}> {
     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 NoSuchCommandsError extends Error {
+declare class NoSuchCommandError extends Error {
 }
 
+declare const mustArray: <T>(a: MaybeArray<T>) => T[];
 declare type CamelCase<T extends string> = T extends `${infer A}-${infer B}${infer C}` ? `${A}${Capitalize<B>}${CamelCase<C>}` : T;
 declare const camelCase: <T extends string>(s: T) => CamelCase<T>;
 declare type KebabCase<T extends string, A extends string = ""> = T extends `${infer F}${infer R}` ? KebabCase<R, `${A}${F extends Lowercase<F> ? "" : "-"}${Lowercase<F>}`> : A;
 declare const kebabCase: <T extends string>(s: T) => KebabCase<T, "">;
 declare const resolveFlagAlias: (_command: Command) => Dict<string[]>;
-declare const resolveFlagDefault: (_command: Command) => Dict<PossibleInputKind | undefined>;
+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 { CamelCase, Clerc, Command, CommandExistsError, CommandOptions, CommandRecord, CommonCommandExistsError, Dict, Enhance, Flag, FlagOptions, Handler, HandlerContext, Inspector, InspectorContext, KebabCase, MakeEventMap, MaybeArray, NoSuchCommandsError, Parameter, ParameterOptions, Plugin, PossibleInputKind, SingleCommand, SingleCommandError, SingleCommandType, camelCase, compose, definePlugin, kebabCase, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault };
+export { CamelCase, Clerc, Command, CommandExistsError, CommandOptions, CommandRecord, CommonCommandExistsError, Dict, Enhance, Flag, FlagOptions, Handler, HandlerContext, Inspector, InspectorContext, KebabCase, LiteralUnion, MakeEventMap, MaybeArray, NoSuchCommandError, Plugin, PossibleInputKind, Primitive, SingleCommand, SingleCommandError, SingleCommandType, camelCase, compose, defineHandler, defineInspector, definePlugin, kebabCase, mustArray, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault };

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { LiteEmit } from 'lite-emit';
 import minimist from 'minimist';
+import { typeFlag } from 'type-flag';
 import { isNode, isDeno } from 'is-platform';
 
 class SingleCommandError extends Error {
@@ -8,7 +9,7 @@ class CommandExistsError extends Error {
 }
 class CommonCommandExistsError extends Error {
 }
-class NoSuchCommandsError extends Error {
+class NoSuchCommandError extends Error {
 }
 
 const mustArray = (a) => Array.isArray(a) ? a : [a];
@@ -95,8 +96,8 @@ class Clerc {
     if (name === SingleCommand && this.__hasCommands) {
       throw new CommonCommandExistsError("Common command exists");
     }
-    const { alias, flags, parameters } = options;
-    this._commands[name] = { name, description, alias, flags, parameters };
+    const { alias, flags } = options;
+    this._commands[name] = { name, description, alias, flags };
     return this;
   }
   on(name, handler) {
@@ -111,31 +112,26 @@ class Clerc {
     return this;
   }
   parse(argv = resolveArgv()) {
-    let parsed = minimist(argv);
+    const parsed = minimist(argv);
     const name = String(parsed._[0]);
     const command = this.__isSingleCommand ? this._commands[SingleCommand] : resolveCommand(this._commands, name);
     const isCommandResolved = !!command;
-    parsed = minimist(argv, {
-      alias: command ? resolveFlagAlias(command) : {},
-      default: command ? resolveFlagDefault(command) : {}
-    });
-    const { _: args, ...flags } = parsed;
-    const camelCaseFlags = Object.fromEntries(
-      Object.entries(flags).map(([key, value]) => [camelCase(key), value])
-    );
+    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,
-      raw: parsed,
+      isSingleCommand: this.__isSingleCommand,
+      raw: parsedWithType,
       parameters,
-      flags: camelCaseFlags,
+      flags,
       cli: this
     };
     const handlerContext = inspectorContext;
     const emitHandler = () => {
       if (!command) {
-        throw new NoSuchCommandsError(`No such command: ${name}`);
+        throw new NoSuchCommandError(`No such command: ${name}`);
       }
       this.__commandEmitter.emit(command.name, handlerContext);
     };
@@ -146,5 +142,7 @@ class Clerc {
 }
 
 const definePlugin = (p) => p;
+const defineHandler = (_cli, _key, handler) => handler;
+const defineInspector = (_cli, inspector) => inspector;
 
-export { Clerc, CommandExistsError, CommonCommandExistsError, NoSuchCommandsError, SingleCommand, SingleCommandError, camelCase, compose, definePlugin, kebabCase, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault };
+export { Clerc, CommandExistsError, CommonCommandExistsError, NoSuchCommandError, SingleCommand, SingleCommandError, camelCase, compose, defineHandler, defineInspector, definePlugin, kebabCase, mustArray, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clerc",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "author": "Ray <nn_201312@163.com> (https://github.com/so1ve)",
   "description": "Clerc is a simple and easy-to-use cli framework.",
   "keywords": [
@@ -41,10 +41,8 @@
   "dependencies": {
     "is-platform": "^0.2.0",
     "lite-emit": "^1.4.0",
-    "minimist": "^1.2.7"
-  },
-  "devDependencies": {
-    "@types/minimist": "^1.2.2"
+    "mri": "^1.2.0",
+    "type-flag": "^3.0.0"
   },
   "scripts": {
     "build": "puild",