@clerc/core 0.22.1 → 0.24.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _clerc_utils from '@clerc/utils';
-import { MaybeArray, Dict, CamelCase, LiteralUnion } from '@clerc/utils';
+import { Dict, MaybeArray as MaybeArray$1, Equals, CamelCase, LiteralUnion } from '@clerc/utils';
 
 declare const DOUBLE_DASH = "--";
 type TypeFunction<ReturnType = any> = (value: any) => ReturnType;
@@ -56,7 +56,7 @@ type FlagSchemaDefault<TF, DefaultType = any> = FlagSchemaBase<TF> & {
 };
 type FlagSchema<TF = FlagType> = (FlagSchemaBase<TF> | FlagSchemaDefault<TF>);
 type FlagTypeOrSchema<ExtraOptions = Record<string, unknown>> = FlagType | (FlagSchema & ExtraOptions);
-type Flags<ExtraOptions = Record<string, unknown>> = Record<string, FlagTypeOrSchema<ExtraOptions>>;
+type Flags$1<ExtraOptions = Record<string, unknown>> = Record<string, FlagTypeOrSchema<ExtraOptions>>;
 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;
@@ -65,7 +65,7 @@ interface ParsedFlags<Schemas = Record<string, unknown>> {
         [DOUBLE_DASH]: string[];
     };
 }
-type TypeFlag<Schemas extends Flags> = ParsedFlags<{
+type TypeFlag<Schemas extends Flags$1> = ParsedFlags<{
     [flag in keyof Schemas]: InferFlagType<Schemas[flag]>;
 }>;
 
@@ -76,9 +76,10 @@ type FlagOptions = FlagSchema & {
 type Flag = FlagOptions & {
     name: string;
 };
+type Flags = Dict<FlagOptions>;
 declare interface CommandCustomProperties {
 }
-interface CommandOptions<P extends string[] = string[], A extends MaybeArray<string | RootType> = MaybeArray<string | RootType>, F extends Dict<FlagOptions> = Dict<FlagOptions>> extends CommandCustomProperties {
+interface CommandOptions<P extends string[] = string[], A extends MaybeArray$1<string | RootType> = MaybeArray$1<string | RootType>, F extends Flags = Flags> extends CommandCustomProperties {
     alias?: A;
     parameters?: P;
     flags?: F;
@@ -93,7 +94,7 @@ type CommandAlias<N extends string | RootType = string, O extends CommandOptions
     __isAlias?: true;
 };
 type CommandWithHandler<N extends string | RootType = string, O extends CommandOptions = CommandOptions> = Command<N, O> & {
-    handler?: HandlerInCommand<Record<N, Command<N, O>> & Record<never, never>, N>;
+    handler?: HandlerInCommand<HandlerContext<Record<N, Command<N, O>> & Record<never, never>, N>>;
 };
 type StripBrackets<Parameter extends string> = (Parameter extends `<${infer ParameterName}>` | `[${infer ParameterName}]` ? (ParameterName extends `${infer SpreadName}...` ? SpreadName : ParameterName) : never);
 type ParameterType<Parameter extends string> = (Parameter extends `<${infer _ParameterName}...>` | `[${infer _ParameterName}...]` ? string[] : Parameter extends `<${infer _ParameterName}>` ? string : Parameter extends `[${infer _ParameterName}]` ? string | undefined : never);
@@ -105,34 +106,35 @@ type MakeEventMap<T extends CommandRecord> = {
 };
 type PossibleInputKind = string | number | boolean | Dict<any>;
 type NonNullableParameters<T extends string[] | undefined> = T extends undefined ? [] : NonNullable<T>;
-type TransformParameters<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> = {
-    [Parameter in [...NonNullableParameters<C[N]["parameters"]>][number] as CamelCase<StripBrackets<Parameter>>]: ParameterType<Parameter>;
+type TransformParameters<C extends Command> = {
+    [Parameter in NonNullableParameters<C["parameters"]>[number] as CamelCase<StripBrackets<Parameter>>]: ParameterType<Parameter>;
 };
-type TransformFlags<F extends Record<string, FlagSchema>> = {
-    [K in keyof F]: F[K]["type"] extends any[] ? F[K]["default"] extends never[] ? F[K] & {
-        default: any[];
-    } : F[K] : F[K];
-};
-type TypeFlagWithDefault<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> = TypeFlag<TransformFlags<NonNullable<C[N]["flags"]>>>;
-type Raw<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> = TypeFlagWithDefault<C, N> & {
+type TypeFlagWithDefault<C extends Command> = TypeFlag<NonNullable<C["flags"]>>;
+type Raw<C extends Command> = TypeFlagWithDefault<C> & {
     parameters: string[];
-    mergedFlags: TypeFlagWithDefault<C, N>["flags"] & TypeFlagWithDefault<C, N>["unknownFlags"];
+    mergedFlags: TypeFlagWithDefault<C>["flags"] & TypeFlagWithDefault<C>["unknownFlags"];
 };
 interface HandlerContext<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> {
-    name: N extends keyof C ? N : N | undefined;
+    name?: N;
     called?: string | RootType;
-    resolved: N extends keyof C ? true : boolean;
+    resolved: boolean;
     hasRootOrAlias: boolean;
     hasRoot: boolean;
-    raw: Raw<C, N>;
-    parameters: TransformParameters<C, N>;
+    raw: {
+        [K in keyof Raw<C[N]>]: Raw<C[N]>[K];
+    };
+    parameters: Equals<{
+        [K in keyof TransformParameters<C[N]>]: TransformParameters<C[N]>[K];
+    }, {}> extends true ? Dict<string | string[] | undefined> : {
+        [K in keyof TransformParameters<C[N]>]: TransformParameters<C[N]>[K];
+    };
     unknownFlags: ParsedFlags["unknownFlags"];
-    flags: TypeFlagWithDefault<C, N>["flags"];
+    flags: Equals<TypeFlagWithDefault<C[N]>["flags"], {}> extends true ? Dict<any> : TypeFlagWithDefault<C[N]>["flags"];
     cli: Clerc<C>;
 }
 type Handler<C extends CommandRecord = CommandRecord, K extends keyof C = keyof C> = (ctx: HandlerContext<C, K>) => void;
-type HandlerInCommand<C extends CommandRecord = CommandRecord, K extends keyof C = keyof C> = (ctx: HandlerContext<C, K> & {
-    name: K;
+type HandlerInCommand<C extends HandlerContext> = (ctx: {
+    [K in keyof C]: C[K];
 }) => void;
 type FallbackType<T, U> = {} extends T ? U : T;
 type InspectorContext<C extends CommandRecord = CommandRecord> = HandlerContext<C> & {
@@ -230,8 +232,8 @@ declare class Clerc<C extends CommandRecord = {}> {
      *   })
      * ```
      */
-    command<N extends string | RootType, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray<string | RootType> = MaybeArray<string | RootType>, F extends Dict<FlagOptions> = Dict<FlagOptions>>(c: CommandWithHandler<N, O & CommandOptions<[...P], A, F>>): this & Clerc<C & Record<N, Command<N, O>>>;
-    command<N extends string | RootType, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray<string | RootType> = MaybeArray<string | RootType>, F extends Dict<FlagOptions> = Dict<FlagOptions>>(name: N, description: string, options?: O & CommandOptions<[...P], A, F>): this & Clerc<C & Record<N, Command<N, O>>>;
+    command<N extends string | RootType, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray$1<string | RootType> = MaybeArray$1<string | RootType>, F extends Flags = Flags>(c: CommandWithHandler<N, O & CommandOptions<[...P], A, F>>): this & Clerc<C & Record<N, Command<N, O>>>;
+    command<N extends string | RootType, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray$1<string | RootType> = MaybeArray$1<string | RootType>, F extends Flags = Flags>(name: N, description: string, options?: O & CommandOptions<[...P], A, F>): this & Clerc<C & Record<N, Command<N, O>>>;
     /**
      * Register a handler
      * @param name
@@ -285,10 +287,12 @@ declare class Clerc<C extends CommandRecord = {}> {
     parse(argv?: string[]): this;
 }
 
+type MaybeArray<T> = T | T[];
+
 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 const defineCommand: <N extends string | typeof Root, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>>(command: CommandWithHandler<N, O & CommandOptions<[...P], A, F>>) => CommandWithHandler<N, O & CommandOptions<[...P], A, F>>;
+declare const defineCommand: <N extends string | typeof Root, O extends CommandOptions<[...P], MaybeArray<string | typeof Root>, Flags>, P extends string[]>(command: Command<N, O & CommandOptions<[...P], MaybeArray<string | typeof Root>, Flags>>, handler?: HandlerInCommand<HandlerContext<Record<N, Command<N, O>> & Record<never, never>, N>> | undefined) => CommandWithHandler<N, O & CommandOptions<[...P], MaybeArray<string | typeof Root>, Flags>>;
 
 declare class CommandExistsError extends Error {
     commandName: string;
@@ -320,10 +324,10 @@ declare class InvalidCommandNameError extends Error {
     constructor(commandName: string);
 }
 
-declare function resolveFlattenCommands(commands: CommandRecord): Map<string[] | typeof Root, CommandAlias<string, CommandOptions<string[], _clerc_utils.MaybeArray<string | typeof Root>, _clerc_utils.Dict<FlagOptions>>>>;
+declare function resolveFlattenCommands(commands: CommandRecord): Map<string[] | typeof Root, CommandAlias<string, CommandOptions<string[], _clerc_utils.MaybeArray<string | typeof Root>, Flags>>>;
 declare function resolveCommand(commands: CommandRecord, name: string | string[] | RootType): Command<string | RootType> | undefined;
-declare function resolveSubcommandsByParent(commands: CommandRecord, parent: string | string[], depth?: number): Command<string, CommandOptions<string[], _clerc_utils.MaybeArray<string | typeof Root>, _clerc_utils.Dict<FlagOptions>>>[];
-declare const resolveRootCommands: (commands: CommandRecord) => Command<string, CommandOptions<string[], _clerc_utils.MaybeArray<string | typeof Root>, _clerc_utils.Dict<FlagOptions>>>[];
+declare function resolveSubcommandsByParent(commands: CommandRecord, parent: string | string[], depth?: number): Command<string, CommandOptions<string[], _clerc_utils.MaybeArray<string | typeof Root>, Flags>>[];
+declare const resolveRootCommands: (commands: CommandRecord) => Command<string, CommandOptions<string[], _clerc_utils.MaybeArray<string | typeof Root>, Flags>>[];
 declare function resolveParametersBeforeFlag(argv: string[]): string[];
 declare const resolveArgv: () => string[];
 declare function compose(inspectors: Inspector[]): (getCtx: () => InspectorContext) => void;
@@ -331,4 +335,4 @@ declare const isInvalidName: (name: CommandType) => boolean;
 declare const withBrackets: (s: string, isOptional?: boolean) => string;
 declare const formatCommandName: (name: string | string[] | RootType) => string;
 
-export { Clerc, Command, CommandAlias, CommandCustomProperties, CommandExistsError, CommandNameConflictError, CommandOptions, CommandRecord, CommandType, CommandWithHandler, DescriptionNotSetError, FallbackType, Flag, FlagOptions, Handler, HandlerContext, HandlerInCommand, Inspector, InspectorContext, InspectorFn, InspectorObject, InvalidCommandNameError, MakeEventMap, NameNotSetError, NoCommandGivenError, NoSuchCommandError, Plugin, PossibleInputKind, Root, RootType, VersionNotSetError, compose, defineCommand, defineHandler, defineInspector, definePlugin, formatCommandName, isInvalidName, resolveArgv, resolveCommand, resolveFlattenCommands, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent, withBrackets };
+export { Clerc, Command, CommandAlias, CommandCustomProperties, CommandExistsError, CommandNameConflictError, CommandOptions, CommandRecord, CommandType, CommandWithHandler, DescriptionNotSetError, FallbackType, Flag, FlagOptions, Flags, Handler, HandlerContext, HandlerInCommand, Inspector, InspectorContext, InspectorFn, InspectorObject, InvalidCommandNameError, MakeEventMap, NameNotSetError, NoCommandGivenError, NoSuchCommandError, Plugin, PossibleInputKind, Root, RootType, VersionNotSetError, compose, defineCommand, defineHandler, defineInspector, definePlugin, formatCommandName, isInvalidName, resolveArgv, resolveCommand, resolveFlattenCommands, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent, withBrackets };

package/dist/index.js

@@ -399,12 +399,12 @@ hasRootOrAlias_get = function() {
 };
 _hasRoot = new WeakSet();
 hasRoot_get = function() {
-  return Object.hasOwn(this._commands, Root);
+  return Object.prototype.hasOwnProperty.call(this._commands, Root);
 };
 
 const definePlugin = (p) => p;
 const defineHandler = (_cli, _key, handler) => handler;
 const defineInspector = (_cli, inspector) => inspector;
-const defineCommand = (command) => command;
+const defineCommand = (command, handler) => ({ ...command, handler });
 
 export { Clerc, CommandExistsError, CommandNameConflictError, DescriptionNotSetError, InvalidCommandNameError, NameNotSetError, NoCommandGivenError, NoSuchCommandError, Root, VersionNotSetError, compose, defineCommand, defineHandler, defineInspector, definePlugin, formatCommandName, isInvalidName, resolveArgv, resolveCommand, resolveFlattenCommands, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent, withBrackets };

package/dist/index.mjs

@@ -399,12 +399,12 @@ hasRootOrAlias_get = function() {
 };
 _hasRoot = new WeakSet();
 hasRoot_get = function() {
-  return Object.hasOwn(this._commands, Root);
+  return Object.prototype.hasOwnProperty.call(this._commands, Root);
 };
 
 const definePlugin = (p) => p;
 const defineHandler = (_cli, _key, handler) => handler;
 const defineInspector = (_cli, inspector) => inspector;
-const defineCommand = (command) => command;
+const defineCommand = (command, handler) => ({ ...command, handler });
 
 export { Clerc, CommandExistsError, CommandNameConflictError, DescriptionNotSetError, InvalidCommandNameError, NameNotSetError, NoCommandGivenError, NoSuchCommandError, Root, VersionNotSetError, compose, defineCommand, defineHandler, defineInspector, definePlugin, formatCommandName, isInvalidName, resolveArgv, resolveCommand, resolveFlattenCommands, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent, withBrackets };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clerc/core",
-  "version": "0.22.1",
+  "version": "0.24.0",
   "author": "Ray <nn_201312@163.com> (https://github.com/so1ve)",
   "description": "Clerc core",
   "keywords": [
@@ -50,7 +50,7 @@
     "is-platform": "^0.2.0",
     "lite-emit": "^1.4.0",
     "type-flag": "^3.0.0",
-    "@clerc/utils": "0.22.1"
+    "@clerc/utils": "0.24.0"
   },
   "scripts": {
     "build": "puild",