clerc - npm Package Compare versions

Comparing version 0.6.1 to 0.7.0

dist/index.d.ts

 import * as _clerc_utils from '@clerc/utils';
-import { MaybeArray, Dict, LiteralUnion } from '@clerc/utils';
+import { MaybeArray, Dict, CamelCase, LiteralUnion } from '@clerc/utils';
 
@@ -79,4 +79,5 @@ declare const DOUBLE_DASH = "--";
 };
-interface CommandOptions<A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>> {
+interface CommandOptions<P extends string[] = string[], A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>> {
     alias?: A;
+    parameters?: P;
     flags?: F;
@@ -86,6 +87,11 @@ examples?: [string, string][];
 }
-type Command<N extends string | SingleCommandType = string, D extends string = string, Options extends CommandOptions = CommandOptions> = Options & {
+type Command<N extends string | SingleCommandType = string, D extends string = string, O extends CommandOptions = CommandOptions> = O & {
     name: N;
     description: D;
 };
+type CommandWithHandler<N extends string | SingleCommandType = string, D extends string = string, O extends CommandOptions = CommandOptions> = Command<N, D, O> & {
+    handler?: HandlerInCommand<Record<N, Command<N, D, O>>, 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);
 type CommandRecord = Dict<Command> & {
@@ -99,2 +105,3 @@ [SingleCommand]?: Command;
 type NonNullableFlag<T extends Dict<FlagOptions> | undefined> = T extends undefined ? {} : NonNullable<T>;
+type NonNullableParameters<T extends string[] | undefined> = T extends undefined ? [] : NonNullable<T>;
 interface HandlerContext<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> {
@@ -105,3 +112,5 @@ name?: N;
     raw: ParsedFlags;
-    parameters: PossibleInputKind[];
+    parameters: {
+        [Parameter in [...NonNullableParameters<C[N]["parameters"]>][number] as CamelCase<StripBrackets<Parameter>>]: ParameterType<Parameter>;
+    };
     unknownFlags: ParsedFlags["unknownFlags"];
@@ -112,2 +121,5 @@ flags: TypeFlag<NonNullableFlag<C[N]["flags"]>>["flags"];
 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;
+}) => void;
 type FallbackType<T, U> = {} extends T ? U : T;
@@ -204,3 +216,4 @@ type InspectorContext<C extends CommandRecord = CommandRecord> = HandlerContext<C> & {
      */
-    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>>>;
+    command<N extends string | SingleCommandType, D extends string, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>>(c: CommandWithHandler<N, D, O & CommandOptions<[...P], A, F>>): this & Clerc<C & Record<N, Command<N, D, O>>>;
+    command<N extends string | SingleCommandType, D extends string, P extends string[], O extends CommandOptions<[...P]>>(name: N, description: D, options: O & CommandOptions<[...P]>): this & Clerc<C & Record<N, Command<N, D, O>>>;
     /**
@@ -262,2 +275,4 @@ * Register a handler
 declare const defineInspector: <C extends Clerc<{}>>(_cli: C, inspector: Inspector<C["_commands"]>) => Inspector<C["_commands"]>;
+declare const defineCommand: <N extends string | typeof SingleCommand, D extends string, P extends string[], O extends CommandOptions<[...P], MaybeArray<string>, Dict<FlagOptions>>>(c: Command<N, D, O>) => Command<N, D, O>;
+declare const defineCommandWithHandler: <N extends string | typeof SingleCommand, D extends string, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>>(c: CommandWithHandler<N, D, O & CommandOptions<[...P], A, F>>) => CommandWithHandler<N, D, O & CommandOptions<[...P], A, F>>;
 
@@ -267,3 +282,7 @@ declare class SingleCommandError extends Error {
 }
+declare class SingleCommandAliasError extends Error {
+    constructor();
+}
 declare class CommandExistsError extends Error {
+    constructor(name: string);
 }
@@ -282,12 +301,24 @@ declare class CommonCommandExistsError extends Error {
 }
+declare class MultipleCommandsMatchedError extends Error {
+    constructor(name: string);
+}
+declare class CommandNameConflictError extends Error {
+    constructor(n1: string, n2: string);
+}
 
-declare const resolveFlagAlias: (_command: Command) => Dict<string[]>;
-declare const resolveFlagDefault: (_command: Command) => Dict<any>;
 declare function resolveCommand(commands: CommandRecord, name: string | string[] | SingleCommandType): Command | undefined;
-declare function resolveSubcommandsByParent(commands: CommandRecord, parent: string | string[], depth?: number): Command<string, string, CommandOptions<_clerc_utils.MaybeArray<string>, Dict<FlagOptions>>>[];
-declare const resolveRootCommands: (commands: CommandRecord) => Command<string, string, CommandOptions<_clerc_utils.MaybeArray<string>, Dict<FlagOptions>>>[];
-declare function resolveParametersBeforeFlag(argv: string[]): string[];
+declare function resolveSubcommandsByParent(commands: CommandRecord, parent: string | string[], depth?: number): Command<string, string, CommandOptions<string[], _clerc_utils.MaybeArray<string>, _clerc_utils.Dict<FlagOptions>>>[];
+declare const resolveRootCommands: (commands: CommandRecord) => Command<string, string, CommandOptions<string[], _clerc_utils.MaybeArray<string>, _clerc_utils.Dict<FlagOptions>>>[];
+declare function resolveParametersBeforeFlag(argv: string[], isSingleCommand: boolean): string[];
 declare const resolveArgv: () => string[];
 declare function compose(inspectors: Inspector[]): (getCtx: () => InspectorContext) => void;
 
-export { Clerc, Command, CommandExistsError, CommandOptions, CommandRecord, CommonCommandExistsError, FallbackType, Flag, FlagOptions, Handler, HandlerContext, Inspector, InspectorContext, MakeEventMap, NoSuchCommandError, ParentCommandExistsError, Plugin, PossibleInputKind, SingleCommand, SingleCommandError, SingleCommandType, SubcommandExistsError, compose, defineHandler, defineInspector, definePlugin, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent };
+interface ParsedParameter {
+    name: string;
+    required: boolean;
+    spread: boolean;
+}
+declare function parseParameters(parameters: string[]): ParsedParameter[];
+declare function mapParametersToArguments(mapping: Record<string, string | string[]>, parameters: ParsedParameter[], cliArguments: string[]): undefined;
+
+export { Clerc, Command, CommandExistsError, CommandNameConflictError, CommandOptions, CommandRecord, CommandWithHandler, CommonCommandExistsError, FallbackType, Flag, FlagOptions, Handler, HandlerContext, HandlerInCommand, Inspector, InspectorContext, MakeEventMap, MultipleCommandsMatchedError, NoSuchCommandError, ParentCommandExistsError, Plugin, PossibleInputKind, SingleCommand, SingleCommandAliasError, SingleCommandError, SingleCommandType, SubcommandExistsError, compose, defineCommand, defineCommandWithHandler, defineHandler, defineInspector, definePlugin, mapParametersToArguments, parseParameters, resolveArgv, resolveCommand, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent };

package.json

 {
   "name": "clerc",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "author": "Ray <[e-mail]> (https://github.com/so1ve)",
@@ -42,3 +42,3 @@ "description": "Clerc is a simple and easy-to-use cli framework.",
   "dependencies": {
-    "@clerc/utils": "0.6.1",
+    "@clerc/utils": "0.7.0",
     "is-platform": "^0.2.0",
@@ -45,0 +45,0 @@ "lite-emit": "^1.4.0",

No alert changes

Improved metrics

Total package byte prevSize

41276

increased by36.53%

Lines of code

1044

increased by34.71%

Dependency changes

• + Added@clerc/utils@0.7.0(transitive)

• - Removed@clerc/utils@0.6.1(transitive)

• Updated@clerc/utils@0.7.0