@clerc/core 0.10.4 → 0.11.0

package/dist/index.d.ts

@@ -118,8 +118,8 @@ type Raw<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> =
     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;
+    name: N extends keyof C ? N : N | undefined;
+    resolved: N extends keyof C ? true : boolean;
     isSingleCommand: boolean;
     raw: Raw<C, N>;
     parameters: TransformParameters<C, N>;
@@ -135,7 +135,12 @@ 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;
+type Inspector<C extends CommandRecord = CommandRecord> = InspectorFn<C> | InspectorObject<C>;
+type InspectorFn<C extends CommandRecord = CommandRecord> = (ctx: InspectorContext<C>, next: () => void) => void;
+interface InspectorObject<C extends CommandRecord = CommandRecord> {
+    enforce?: "pre" | "post";
+    fn: InspectorFn<C>;
+}
 interface Plugin<T extends Clerc = Clerc, U extends Clerc = Clerc> {
     setup: (cli: T) => U;
 }
@@ -222,8 +227,8 @@ declare class Clerc<C extends CommandRecord = {}> {
      *   })
      * ```
      */
-    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>>>;
+    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, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = 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
@@ -238,7 +243,7 @@ declare class Clerc<C extends CommandRecord = {}> {
      *   })
      * ```
      */
-    on<K extends keyof CM, CM extends this["_commands"] = this["_commands"]>(name: LiteralUnion<K, string>, handler: Handler<CM, K>): this;
+    on<K extends LiteralUnion<keyof CM, string>, CM extends this["_commands"] = this["_commands"]>(name: K, handler: Handler<CM, K>): this;
     /**
      * Use a plugin
      * @param plugin
@@ -249,7 +254,7 @@ declare class Clerc<C extends CommandRecord = {}> {
      *   .use(plugin)
      * ```
      */
-    use<T extends Clerc, U extends Clerc>(plugin: Plugin<T, U>): U;
+    use<T extends Clerc, U extends Clerc>(plugin: Plugin<T, U>): this & Clerc<C & U["_commands"]> & U;
     /**
      * Register a inspector
      * @param inspector
@@ -326,4 +331,4 @@ interface ParsedParameter {
 declare function parseParameters(parameters: string[]): ParsedParameter[];
 declare function mapParametersToArguments(mapping: Record<string, string | string[]>, parameters: ParsedParameter[], cliArguments: string[]): undefined;
 
-export { Clerc, Command, CommandAlias, CommandCustomProperties, 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, defineHandler, defineInspector, definePlugin, mapParametersToArguments, parseParameters, resolveArgv, resolveCommand, resolveFlattenCommands, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent };
+export { Clerc, Command, CommandAlias, CommandCustomProperties, CommandExistsError, CommandNameConflictError, CommandOptions, CommandRecord, CommandWithHandler, CommonCommandExistsError, FallbackType, Flag, FlagOptions, Handler, HandlerContext, HandlerInCommand, Inspector, InspectorContext, InspectorFn, InspectorObject, MakeEventMap, MultipleCommandsMatchedError, NoSuchCommandError, ParentCommandExistsError, Plugin, PossibleInputKind, SingleCommand, SingleCommandAliasError, SingleCommandError, SingleCommandType, SubcommandExistsError, compose, defineCommand, defineHandler, defineInspector, definePlugin, mapParametersToArguments, parseParameters, resolveArgv, resolveCommand, resolveFlattenCommands, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent };

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

@@ -1,11 +1,7 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var liteEmit = require('lite-emit');
-var typeFlag = require('type-flag');
-var utils = require('@clerc/utils');
-var isPlatform = require('is-platform');
+import { LiteEmit } from 'lite-emit';
+import { typeFlag } from 'type-flag';
+import { mustArray, arrayStartsWith, camelCase } from '@clerc/utils';
+import { isNode, isDeno } from 'is-platform';
 
 class SingleCommandError extends Error {
   constructor() {
@@ -57,7 +53,7 @@ function resolveFlattenCommands(commands) {
   const commandsMap = /* @__PURE__ */ new Map();
   for (const command of Object.values(commands)) {
     if (command.alias) {
-      const aliases = utils.mustArray(command.alias);
+      const aliases = mustArray(command.alias);
       for (const alias of aliases) {
         if (alias in commands) {
           throw new CommandNameConflictError(commands[alias].name, command.name);
@@ -73,11 +69,11 @@ function resolveCommand(commands, name) {
   if (name === SingleCommand) {
     return commands[SingleCommand];
   }
-  const nameArr = utils.mustArray(name);
+  const nameArr = mustArray(name);
   const commandsMap = resolveFlattenCommands(commands);
   const possibleCommands = [];
   commandsMap.forEach((v, k) => {
-    if (utils.arrayStartsWith(nameArr, k)) {
+    if (arrayStartsWith(nameArr, k)) {
       possibleCommands.push(v);
     }
   });
@@ -91,7 +87,7 @@ function resolveSubcommandsByParent(commands, parent, depth = Infinity) {
   const parentArr = parent === "" ? [] : Array.isArray(parent) ? parent : parent.split(" ");
   return Object.values(commands).filter((c) => {
     const commandNameArr = c.name.split(" ");
-    return utils.arrayStartsWith(commandNameArr, parentArr) && commandNameArr.length - parentArr.length <= depth;
+    return arrayStartsWith(commandNameArr, parentArr) && commandNameArr.length - parentArr.length <= depth;
   });
 }
 const resolveRootCommands = (commands) => resolveSubcommandsByParent(commands, "", 1);
@@ -108,12 +104,25 @@ function resolveParametersBeforeFlag(argv, isSingleCommand) {
   }
   return parameters;
 }
-const resolveArgv = () => isPlatform.isNode() ? process.argv.slice(2) : isPlatform.isDeno() ? Deno.args : [];
+const resolveArgv = () => isNode() ? process.argv.slice(2) : isDeno() ? Deno.args : [];
 function compose(inspectors) {
+  const preInspectors = [];
+  const normalInspectors = [];
+  const postInspectors = [];
+  for (const inspector of inspectors) {
+    const objectInspector = typeof inspector === "object" ? inspector : { fn: inspector };
+    const { enforce } = objectInspector;
+    (enforce === "pre" ? preInspectors : enforce === "post" ? postInspectors : normalInspectors).push(objectInspector.fn);
+  }
+  const mergedInspectorFns = [
+    ...preInspectors,
+    ...normalInspectors,
+    ...postInspectors
+  ];
   return (getCtx) => {
     return dispatch(0);
     function dispatch(i) {
-      const inspector = inspectors[i];
+      const inspector = mergedInspectorFns[i];
       return inspector(getCtx(), dispatch.bind(null, i + 1));
     }
   };
@@ -161,7 +170,7 @@ function parseParameters(parameters) {
 function mapParametersToArguments(mapping, parameters, cliArguments) {
   for (let i = 0; i < parameters.length; i += 1) {
     const { name, required, spread } = parameters[i];
-    const camelCaseName = utils.camelCase(name);
+    const camelCaseName = camelCase(name);
     if (camelCaseName in mapping) {
       throw new Error(`Invalid parameter: ${stringify(name)} is used more than once.`);
     }
@@ -207,7 +216,7 @@ const _Clerc = class {
     __privateAdd(this, _version, "");
     __privateAdd(this, _inspectors, []);
     __privateAdd(this, _commands, {});
-    __privateAdd(this, _commandEmitter, new liteEmit.LiteEmit());
+    __privateAdd(this, _commandEmitter, new LiteEmit());
   }
   get _name() {
     return __privateGet(this, _name);
@@ -260,10 +269,10 @@ const _Clerc = class {
     if (name !== SingleCommand) {
       const splitedName = name.split(" ");
       const existedCommandNames = Object.keys(__privateGet(this, _commands)).filter((name2) => typeof name2 === "string").map((name2) => name2.split(" "));
-      if (existedCommandNames.some((name2) => utils.arrayStartsWith(splitedName, name2))) {
+      if (existedCommandNames.some((name2) => arrayStartsWith(splitedName, name2))) {
         throw new ParentCommandExistsError(splitedName.join(" "));
       }
-      if (existedCommandNames.some((name2) => utils.arrayStartsWith(name2, splitedName))) {
+      if (existedCommandNames.some((name2) => arrayStartsWith(name2, splitedName))) {
         throw new SubcommandExistsError(splitedName.join(" "));
       }
     }
@@ -292,7 +301,7 @@ const _Clerc = class {
     const getContext = () => {
       const command = getCommand();
       const isCommandResolved = !!command;
-      const parsed = typeFlag.typeFlag((command == null ? void 0 : command.flags) || {}, [...argv]);
+      const parsed = typeFlag((command == null ? void 0 : command.flags) || {}, [...argv]);
       const { _: args, flags } = parsed;
       let parameters = __privateGet(this, _isSingleCommand, isSingleCommand_get) || !isCommandResolved ? args : args.slice(command.name.split(" ").length);
       let commandParameters = (command == null ? void 0 : command.parameters) || [];
@@ -333,13 +342,16 @@ const _Clerc = class {
       };
       return context;
     };
-    const emitHandler = () => {
-      const command = getCommand();
-      const handlerContext = getContext();
-      if (!command) {
-        throw new NoSuchCommandError(stringName);
+    const emitHandler = {
+      enforce: "post",
+      fn: () => {
+        const command = getCommand();
+        const handlerContext = getContext();
+        if (!command) {
+          throw new NoSuchCommandError(stringName);
+        }
+        __privateGet(this, _commandEmitter).emit(command.name, handlerContext);
       }
-      __privateGet(this, _commandEmitter).emit(command.name, handlerContext);
     };
     const inspectors = [...__privateGet(this, _inspectors), emitHandler];
     const callInspector = compose(inspectors);
@@ -368,27 +380,4 @@ const defineHandler = (_cli, _key, handler) => handler;
 const defineInspector = (_cli, inspector) => inspector;
 const defineCommand = (c) => c;
 
-exports.Clerc = Clerc;
-exports.CommandExistsError = CommandExistsError;
-exports.CommandNameConflictError = CommandNameConflictError;
-exports.CommonCommandExistsError = CommonCommandExistsError;
-exports.MultipleCommandsMatchedError = MultipleCommandsMatchedError;
-exports.NoSuchCommandError = NoSuchCommandError;
-exports.ParentCommandExistsError = ParentCommandExistsError;
-exports.SingleCommand = SingleCommand;
-exports.SingleCommandAliasError = SingleCommandAliasError;
-exports.SingleCommandError = SingleCommandError;
-exports.SubcommandExistsError = SubcommandExistsError;
-exports.compose = compose;
-exports.defineCommand = defineCommand;
-exports.defineHandler = defineHandler;
-exports.defineInspector = defineInspector;
-exports.definePlugin = definePlugin;
-exports.mapParametersToArguments = mapParametersToArguments;
-exports.parseParameters = parseParameters;
-exports.resolveArgv = resolveArgv;
-exports.resolveCommand = resolveCommand;
-exports.resolveFlattenCommands = resolveFlattenCommands;
-exports.resolveParametersBeforeFlag = resolveParametersBeforeFlag;
-exports.resolveRootCommands = resolveRootCommands;
-exports.resolveSubcommandsByParent = resolveSubcommandsByParent;
+export { Clerc, CommandExistsError, CommandNameConflictError, CommonCommandExistsError, MultipleCommandsMatchedError, NoSuchCommandError, ParentCommandExistsError, SingleCommand, SingleCommandAliasError, SingleCommandError, SubcommandExistsError, compose, defineCommand, defineHandler, defineInspector, definePlugin, mapParametersToArguments, parseParameters, resolveArgv, resolveCommand, resolveFlattenCommands, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent };

package/dist/index.mjs

@@ -106,10 +106,23 @@ function resolveParametersBeforeFlag(argv, isSingleCommand) {
 }
 const resolveArgv = () => isNode() ? process.argv.slice(2) : isDeno() ? Deno.args : [];
 function compose(inspectors) {
+  const preInspectors = [];
+  const normalInspectors = [];
+  const postInspectors = [];
+  for (const inspector of inspectors) {
+    const objectInspector = typeof inspector === "object" ? inspector : { fn: inspector };
+    const { enforce } = objectInspector;
+    (enforce === "pre" ? preInspectors : enforce === "post" ? postInspectors : normalInspectors).push(objectInspector.fn);
+  }
+  const mergedInspectorFns = [
+    ...preInspectors,
+    ...normalInspectors,
+    ...postInspectors
+  ];
   return (getCtx) => {
     return dispatch(0);
     function dispatch(i) {
-      const inspector = inspectors[i];
+      const inspector = mergedInspectorFns[i];
       return inspector(getCtx(), dispatch.bind(null, i + 1));
     }
   };
@@ -329,13 +342,16 @@ const _Clerc = class {
       };
       return context;
     };
-    const emitHandler = () => {
-      const command = getCommand();
-      const handlerContext = getContext();
-      if (!command) {
-        throw new NoSuchCommandError(stringName);
+    const emitHandler = {
+      enforce: "post",
+      fn: () => {
+        const command = getCommand();
+        const handlerContext = getContext();
+        if (!command) {
+          throw new NoSuchCommandError(stringName);
+        }
+        __privateGet(this, _commandEmitter).emit(command.name, handlerContext);
       }
-      __privateGet(this, _commandEmitter).emit(command.name, handlerContext);
     };
     const inspectors = [...__privateGet(this, _inspectors), emitHandler];
     const callInspector = compose(inspectors);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clerc/core",
-  "version": "0.10.4",
+  "version": "0.11.0",
   "author": "Ray <nn_201312@163.com> (https://github.com/so1ve)",
   "description": "Clerc core",
   "keywords": [
@@ -11,6 +11,7 @@
     "args",
     "terminal"
   ],
+  "type": "module",
   "homepage": "https://github.com/so1ve/clerc/tree/main/packages/core#readme",
   "repository": {
     "type": "git",
@@ -25,11 +26,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": {
@@ -50,7 +50,7 @@
     "is-platform": "^0.2.0",
     "lite-emit": "^1.4.0",
     "type-flag": "^3.0.0",
-    "@clerc/utils": "0.10.4"
+    "@clerc/utils": "0.11.0"
   },
   "scripts": {
     "build": "puild",