@clerc/plugin-completions 0.10.0 → 0.10.1

package/dist/index.cjs

@@ -2,9 +2,10 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var core = require('@clerc/core');
 var utils = require('@clerc/utils');
 
+const definePlugin = (p) => p;
+
 const generateCommandCompletion = (name) => `
             ${name})
                 cmd+="__${name}"
@@ -94,7 +95,7 @@ const completionMap = {
   bash: getBashCompletion,
   pwsh: getPwshCompletion
 };
-const completionsPlugin = (options = {}) => core.definePlugin({
+const completionsPlugin = (options = {}) => definePlugin({
   setup(cli) {
     const { command = true } = options;
     if (command) {

package/dist/index.d.ts

@@ -1,8 +1,265 @@
-import * as _clerc_core from '@clerc/core';
+import { MaybeArray, Dict, LiteralUnion, CamelCase } from '@clerc/utils';
+
+declare const DOUBLE_DASH = "--";
+type TypeFunction<ReturnType = any> = (value: any) => ReturnType;
+type TypeFunctionArray<ReturnType> = readonly [TypeFunction<ReturnType>];
+type FlagType<ReturnType = any> = TypeFunction<ReturnType> | TypeFunctionArray<ReturnType>;
+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>;
+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);
+};
+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 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[];
+    };
+}
+type TypeFlag<Schemas extends Flags> = ParsedFlags<{
+    [flag in keyof Schemas]: InferFlagType<Schemas[flag]>;
+}>;
+
+type FlagOptions = FlagSchema & {
+    description?: string;
+};
+declare interface CommandCustomProperties {
+}
+interface CommandOptions<P extends string[] = string[], A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>> extends CommandCustomProperties {
+    alias?: A;
+    parameters?: P;
+    flags?: F;
+    examples?: [string, string][];
+    notes?: string[];
+}
+type Command<N extends string | SingleCommandType = string, O extends CommandOptions = CommandOptions> = O & {
+    name: N;
+    description: string;
+};
+type CommandWithHandler<N extends string | SingleCommandType = string, O extends CommandOptions = CommandOptions> = Command<N, O> & {
+    handler?: HandlerInCommand<Record<N, Command<N, 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> & {
+    [SingleCommand]?: Command;
+};
+type NonNullableParameters<T extends string[] | 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: TypeFlag<NonNullable<C[N]["flags"]>> & {
+        parameters: string[];
+    };
+    parameters: {
+        [Parameter in [...NonNullableParameters<C[N]["parameters"]>][number] as CamelCase<StripBrackets<Parameter>>]: ParameterType<Parameter>;
+    };
+    unknownFlags: ParsedFlags["unknownFlags"];
+    flags: TypeFlag<NonNullable<C[N]["flags"]>>["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;
+}) => void;
+type FallbackType<T, U> = {} extends T ? U : T;
+type InspectorContext<C extends CommandRecord = CommandRecord> = HandlerContext<C> & {
+    flags: FallbackType<TypeFlag<NonNullable<C[keyof C]["flags"]>>["flags"], Dict<any>>;
+};
+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;
+type SingleCommandType = typeof SingleCommand;
+declare class Clerc<C extends CommandRecord = {}> {
+    #private;
+    private constructor();
+    get _name(): string;
+    get _description(): string;
+    get _version(): string;
+    get _inspectors(): Inspector<CommandRecord>[];
+    get _commands(): C;
+    /**
+     * 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, 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, O & CommandOptions<[...P], A, F>>): this & Clerc<C & Record<N, Command<N, O>>>;
+    command<N extends string | SingleCommandType, P extends string[], O extends CommandOptions<[...P]>>(name: N, description: string, options?: O & CommandOptions<[...P]>): this & Clerc<C & Record<N, Command<N, 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[]): this;
+}
 
 interface Options {
     command?: boolean;
 }
-declare const completionsPlugin: (options?: Options) => _clerc_core.Plugin<_clerc_core.Clerc<{}>, _clerc_core.Clerc<{}>>;
+declare const completionsPlugin: (options?: Options) => Plugin<Clerc<{}>, Clerc<{}>>;
 
 export { Options, completionsPlugin };

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { definePlugin } from '@clerc/core';
 import { gracefulFlagName, mustArray } from '@clerc/utils';
 
+const definePlugin = (p) => p;
+
 const generateCommandCompletion = (name) => `
             ${name})
                 cmd+="__${name}"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clerc/plugin-completions",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "author": "Ray <nn_201312@163.com> (https://github.com/so1ve)",
   "description": "Clerc plugin completions",
   "keywords": [
@@ -43,8 +43,10 @@
     "clerc": "*"
   },
   "dependencies": {
-    "@clerc/core": "0.10.0",
-    "@clerc/utils": "0.10.0"
+    "@clerc/utils": "0.10.1"
+  },
+  "devDependencies": {
+    "@clerc/core": "0.10.1"
   },
   "scripts": {
     "build": "puild",