@clerc/plugin-completions 0.10.4 → 0.11.0

package/dist/index.d.ts

@@ -1,274 +1,8 @@
-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>;
-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 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> & {
-    parameters: string[];
-    mergedFlags: TypeFlagWithDefault<C, N>["flags"] & TypeFlagWithDefault<C, N>["unknownFlags"];
-};
-interface HandlerContext<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> {
-    name?: N;
-    resolved: boolean;
-    isSingleCommand: boolean;
-    raw: Raw<C, N>;
-    parameters: TransformParameters<C, N>;
-    unknownFlags: ParsedFlags["unknownFlags"];
-    flags: 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;
-}) => 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> = {}>(c: CommandWithHandler<N, O & CommandOptions<[...P], A, F>>): this & Clerc<C & Record<N, Command<N, O>>>;
-    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> = {}>(name: N, description: string, options?: O & CommandOptions<[...P], A, F>): 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;
-}
+import * as _clerc_core from '@clerc/core';
 
 interface Options {
     command?: boolean;
 }
-declare const completionsPlugin: (options?: Options) => Plugin<Clerc<{}>, Clerc<{}>>;
+declare const completionsPlugin: (options?: Options) => _clerc_core.Plugin<_clerc_core.Clerc<{}>, _clerc_core.Clerc<{}>>;
 
 export { Options, completionsPlugin };

package/dist/{index.cjs → index.js}

@@ -1,10 +1,5 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var utils = require('@clerc/utils');
-
-const definePlugin = (p) => p;
+import { definePlugin } from '@clerc/core';
+import { gracefulFlagName, mustArray } from '@clerc/utils';
 
 const generateCommandCompletion = (name) => `
             ${name})
@@ -42,11 +37,11 @@ const NO_DESCRIPTION = "(No Description)";
 const getCompletionValue = (command) => `[CompletionResult]::new('${command.name}', '${command.name}', [CompletionResultType]::ParameterValue, '${command.description}')`;
 const getCompletionFlag = (command) => {
   return Object.entries(command.flags || {}).map(([flagName, flag]) => {
-    const gen = [`[CompletionResult]::new('${utils.gracefulFlagName(flagName)}', '${flagName}', [CompletionResultType]::ParameterName, '${command.flags[flagName].description || NO_DESCRIPTION}')`];
+    const gen = [`[CompletionResult]::new('${gracefulFlagName(flagName)}', '${flagName}', [CompletionResultType]::ParameterName, '${command.flags[flagName].description || NO_DESCRIPTION}')`];
     if (flag == null ? void 0 : flag.alias) {
-      const arrayAlias = utils.mustArray(flag.alias);
+      const arrayAlias = mustArray(flag.alias);
       gen.push(
-        ...arrayAlias.map((n) => `[CompletionResult]::new('${utils.gracefulFlagName(n)}', '${n}', [CompletionResultType]::ParameterName, '${command.flags[flagName].description || NO_DESCRIPTION}')`)
+        ...arrayAlias.map((n) => `[CompletionResult]::new('${gracefulFlagName(n)}', '${n}', [CompletionResultType]::ParameterName, '${command.flags[flagName].description || NO_DESCRIPTION}')`)
       );
     }
     return gen.join("\n            ");
@@ -96,7 +91,7 @@ const completionMap = {
   pwsh: getPwshCompletion
 };
 const completionsPlugin = (options = {}) => definePlugin({
-  setup(cli) {
+  setup: (cli) => {
     const { command = true } = options;
     if (command) {
       cli = cli.command("completions", "Print shell completions to stdout", {
@@ -129,4 +124,4 @@ const completionsPlugin = (options = {}) => definePlugin({
   }
 });
 
-exports.completionsPlugin = completionsPlugin;
+export { completionsPlugin };

package/dist/index.mjs

@@ -1,7 +1,6 @@
+import { definePlugin } from '@clerc/core';
 import { gracefulFlagName, mustArray } from '@clerc/utils';
 
-const definePlugin = (p) => p;
-
 const generateCommandCompletion = (name) => `
             ${name})
                 cmd+="__${name}"
@@ -92,7 +91,7 @@ const completionMap = {
   pwsh: getPwshCompletion
 };
 const completionsPlugin = (options = {}) => definePlugin({
-  setup(cli) {
+  setup: (cli) => {
     const { command = true } = options;
     if (command) {
       cli = cli.command("completions", "Print shell completions to stdout", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clerc/plugin-completions",
-  "version": "0.10.4",
+  "version": "0.11.0",
   "author": "Ray <nn_201312@163.com> (https://github.com/so1ve)",
   "description": "Clerc plugin completions",
   "keywords": [
@@ -12,6 +12,7 @@
     "args",
     "terminal"
   ],
+  "type": "module",
   "homepage": "https://github.com/so1ve/clerc/tree/main/packages/plugin-completions#readme",
   "repository": {
     "type": "git",
@@ -26,11 +27,10 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "require": "./dist/index.cjs",
       "import": "./dist/index.mjs"
     }
   },
-  "main": "dist/index.cjs",
+  "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "typesVersions": {
@@ -48,13 +48,13 @@
     "access": "public"
   },
   "peerDependencies": {
-    "clerc": "*"
+    "@clerc/core": "*"
   },
   "dependencies": {
-    "@clerc/utils": "0.10.4"
+    "@clerc/utils": "0.11.0"
   },
   "devDependencies": {
-    "@clerc/core": "0.10.4"
+    "@clerc/core": "0.11.0"
   },
   "scripts": {
     "build": "puild",