@clerc/core 0.42.1 → 0.43.0

package/dist/index.d.ts

@@ -13,8 +13,7 @@ type FlagSchemaBase<TF> = {
      * @example
      *
      * ```
-     *     type: String
-     *     ```
+     * type: String;
      * ```
      *
      * @example Wrap in an array to accept multiple values. `type: [Boolean]`
@@ -30,8 +29,7 @@ type FlagSchemaBase<TF> = {
      * @example
      *
      * ```
-     *     alias: 's'
-     *     ```
+     * alias: "s";
      * ```
      */
     alias?: string;
@@ -44,15 +42,13 @@ type FlagSchemaDefault<TF, DefaultType = any> = FlagSchemaBase<TF> & {
      * @example
      *
      * ```
-     *     default: 'hello'
-     *     ```
+     * default: 'hello'
      * ```
      *
      * @example
      *
      * ```
-     *     default: () => [1, 2, 3]
-     *     ```
+     * default: () => [1, 2, 3]
      * ```
      */
     default: DefaultType | (() => DefaultType);
@@ -79,7 +75,7 @@ type TransformParameters<C extends Command> = {
     [Parameter in NonNullableParameters<C["parameters"]>[number] as CamelCase<StripBrackets<Parameter>>]: ParameterType<Parameter>;
 };
 type MakeEventMap<T extends Commands> = {
-    [K in keyof T]: [InspectorContext];
+    [K in keyof T]: [InterceptorContext];
 };
 type FallbackFlags<F extends Flags | undefined> = Equals<NonNullableFlag<F>["flags"], {}> extends true ? Dict<any> : NonNullableFlag<F>["flags"];
 type NonNullableFlag<F extends Flags | undefined> = TypeFlag<NonNullable<F>>;
@@ -153,27 +149,31 @@ 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 Commands = Commands> = HandlerContext<C> & {
+type InterceptorContext<C extends Commands = Commands> = HandlerContext<C> & {
     flags: FallbackType<TypeFlag<NonNullable<C[keyof C]["flags"]>>["flags"], Dict<any>>;
 };
-type Inspector<C extends Commands = Commands> = InspectorFn<C> | InspectorObject<C>;
-type InspectorFn<C extends Commands = Commands> = (ctx: InspectorContext<C>, next: () => void) => void;
-interface InspectorObject<C extends Commands = Commands> {
+type Interceptor<C extends Commands = Commands> = InterceptorFn<C> | InterceptorObject<C>;
+type InterceptorFn<C extends Commands = Commands> = (ctx: InterceptorContext<C>, next: () => void) => void;
+interface InterceptorObject<C extends Commands = Commands> {
     enforce?: "pre" | "post";
-    fn: InspectorFn<C>;
+    fn: InterceptorFn<C>;
 }
 
 declare const Root: unique symbol;
 type RootType = typeof Root;
 declare class Clerc<C extends Commands = {}, GF extends GlobalFlagOptions = {}> {
     #private;
-    i18n: I18N;
+    get i18n(): I18N;
     private constructor();
     get _name(): string;
     get _scriptName(): string;
     get _description(): string;
     get _version(): string;
-    get _inspectors(): Inspector[];
+    /**
+     * @deprecated This is a typo. Use `_interceptor` instead.
+     */
+    get _inspectors(): Interceptor[];
+    get _interceptors(): Interceptor[];
     get _commands(): C;
     get _flags(): GF;
     /**
@@ -377,21 +377,25 @@ declare class Clerc<C extends Commands = {}, GF extends GlobalFlagOptions = {}>
      */
     use<T extends Clerc, U extends Clerc>(plugin: Plugin<T, U>): this & Clerc<C & U["_commands"]> & U;
     /**
-     * Register a inspector
+     * @deprecated This is a typo. Use `intercetor()` instead.
+     */
+    inspector(interceptor: Interceptor): this;
+    /**
+     * Register a interceptor
      *
      * @example
      *
      * ```ts
-     * Clerc.create().inspector((ctx, next) => {
+     * Clerc.create().interceptor((ctx, next) => {
      * 	console.log(ctx);
      * 	next();
      * });
      * ```
      *
-     * @param inspector
+     * @param interceptor
      * @returns
      */
-    inspector(inspector: Inspector): this;
+    interceptor(interceptor: Interceptor): this;
     /**
      * Parse the command line arguments
      *
@@ -457,17 +461,21 @@ 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 defineInterceptor: <C extends Clerc<{}, {}>>(_cli: C, interceptor: Interceptor<C["_commands"]>) => Interceptor<C["_commands"]>;
+/**
+ * @deprecated This is a typo. Use `defineInterceptor` instead.
+ */
+declare const defineInspector: <C extends Clerc<{}, {}>>(_cli: C, interceptor: Interceptor<C["_commands"]>) => Interceptor<C["_commands"]>;
 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 function resolveFlattenCommands(commands: Commands, t: TranslateFn): Map<string[] | typeof Root, CommandAlias>;
 declare function resolveCommand(commands: Commands, argv: string[], t: TranslateFn): [Command<string | RootType> | undefined, string[] | RootType | undefined];
 declare const resolveArgv: () => string[];
-declare function compose(inspectors: Inspector[]): (ctx: InspectorContext) => void;
+declare function compose(interceptors: Interceptor[]): (ctx: InterceptorContext) => void;
 declare const isValidName: (name: CommandType) => boolean;
 declare const withBrackets: (s: string, isOptional?: boolean) => string;
 declare const formatCommandName: (name: string | string[] | RootType) => string;
 declare const detectLocale: () => string;
 declare const stripFlags: (argv: string[]) => string[];
 
-export { Clerc, Command, CommandAlias, CommandCustomProperties, CommandExistsError, CommandNameConflictError, CommandOptions, CommandType, CommandWithHandler, Commands, DescriptionNotSetError, FallbackType, Flag, FlagOptions, Flags, GlobalFlagOption, GlobalFlagOptions, Handler, HandlerContext, HandlerInCommand, I18N, Inspector, InspectorContext, InspectorFn, InspectorObject, InvalidCommandNameError, LocaleNotCalledFirstError, Locales, MakeEventMap, NoCommandGivenError, NoSuchCommandError, ParseOptions, Plugin, Root, RootType, ScriptNameNotSetError, TranslateFn, VersionNotSetError, compose, defineCommand, defineHandler, defineInspector, definePlugin, detectLocale, formatCommandName, isValidName, resolveArgv, resolveCommand, resolveFlattenCommands, stripFlags, withBrackets };
+export { Clerc, Command, CommandAlias, CommandCustomProperties, CommandExistsError, CommandNameConflictError, CommandOptions, CommandType, CommandWithHandler, Commands, DescriptionNotSetError, FallbackType, Flag, FlagOptions, Flags, GlobalFlagOption, GlobalFlagOptions, Handler, HandlerContext, HandlerInCommand, I18N, Interceptor, InterceptorContext, InterceptorFn, InterceptorObject, InvalidCommandNameError, LocaleNotCalledFirstError, Locales, MakeEventMap, NoCommandGivenError, NoSuchCommandError, ParseOptions, Plugin, Root, RootType, ScriptNameNotSetError, TranslateFn, VersionNotSetError, compose, defineCommand, defineHandler, defineInspector, defineInterceptor, definePlugin, detectLocale, formatCommandName, isValidName, resolveArgv, resolveCommand, resolveFlattenCommands, stripFlags, withBrackets };

package/dist/index.js

@@ -1,6 +1,6 @@
 import { format } from 'node:util';
 import { camelCase, arrayStartsWith, toArray } from '@clerc/utils';
-import defu from 'defu';
+import { defu } from 'defu';
 import { LiteEmit } from 'lite-emit';
 import { typeFlag } from 'type-flag';
 import { IS_NODE, IS_ELECTRON, IS_DENO } from 'is-platform';
@@ -213,31 +213,31 @@ const resolveArgv = () => IS_NODE ? process.argv.slice(IS_ELECTRON ? 1 : 2) : IS
   // @ts-expect-error Ignore
   Deno.args
 ) : [];
-function compose(inspectors) {
-  const inspectorMap = {
+function compose(interceptors) {
+  const interceptorMap = {
     pre: [],
     normal: [],
     post: []
   };
-  for (const inspector of inspectors) {
-    const objectInspector = typeof inspector === "object" ? inspector : { fn: inspector };
-    const { enforce, fn } = objectInspector;
+  for (const interceptor of interceptors) {
+    const objectInterceptor = typeof interceptor === "object" ? interceptor : { fn: interceptor };
+    const { enforce, fn } = objectInterceptor;
     if (enforce === "post" || enforce === "pre") {
-      inspectorMap[enforce].push(fn);
+      interceptorMap[enforce].push(fn);
     } else {
-      inspectorMap.normal.push(fn);
+      interceptorMap.normal.push(fn);
     }
   }
-  const mergedInspectorFns = [
-    ...inspectorMap.pre,
-    ...inspectorMap.normal,
-    ...inspectorMap.post
+  const mergedInterceptorFns = [
+    ...interceptorMap.pre,
+    ...interceptorMap.normal,
+    ...interceptorMap.post
   ];
   return (ctx) => {
     return dispatch(0);
     function dispatch(i) {
-      const inspector = mergedInspectorFns[i];
-      return inspector(ctx, dispatch.bind(null, i + 1));
+      const interceptor = mergedInterceptorFns[i];
+      return interceptor(ctx, dispatch.bind(null, i + 1));
     }
   };
 }
@@ -271,9 +271,9 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
-var _name, _scriptName, _description, _version, _inspectors, _commands, _commandEmitter, _flags, _usedNames, _argv, _errorHandlers, _isOtherMethodCalled, _defaultLocale, _locale, _locales, _hasRootOrAlias, hasRootOrAlias_get, _hasRoot, hasRoot_get, _addCoreLocales, addCoreLocales_fn, _otherMethodCalled, otherMethodCalled_fn, _command, command_fn, _validateMeta, validateMeta_fn, _getContext, getContext_fn, _callWithErrorHandling, callWithErrorHandling_fn, _runMatchedCommand, runMatchedCommand_fn;
+var _name, _scriptName, _description, _version, _interceptors, _commands, _commandEmitter, _flags, _usedNames, _argv, _errorHandlers, _isOtherMethodCalled, _defaultLocale, _locale, _locales, _hasRootOrAlias, hasRootOrAlias_get, _hasRoot, hasRoot_get, _addCoreLocales, addCoreLocales_fn, _otherMethodCalled, otherMethodCalled_fn, _command, command_fn, _validateMeta, validateMeta_fn, _getContext, getContext_fn, _handleError, handleError_fn, _callWithErrorHandling, callWithErrorHandling_fn, _runMatchedCommand, runMatchedCommand_fn;
 const Root = Symbol.for("Clerc.Root");
-const _Clerc = class {
+const _Clerc = class _Clerc {
   constructor(scriptName, description, version) {
     __privateAdd(this, _hasRootOrAlias);
     __privateAdd(this, _hasRoot);
@@ -282,15 +282,20 @@ const _Clerc = class {
     __privateAdd(this, _command);
     __privateAdd(this, _validateMeta);
     __privateAdd(this, _getContext);
+    __privateAdd(this, _handleError);
     __privateAdd(this, _callWithErrorHandling);
     __privateAdd(this, _runMatchedCommand);
     __privateAdd(this, _name, "");
     __privateAdd(this, _scriptName, "");
     __privateAdd(this, _description, "");
     __privateAdd(this, _version, "");
-    __privateAdd(this, _inspectors, []);
+    __privateAdd(this, _interceptors, []);
     __privateAdd(this, _commands, /* @__PURE__ */ Object.create(null));
-    __privateAdd(this, _commandEmitter, new LiteEmit());
+    __privateAdd(this, _commandEmitter, new LiteEmit({
+      errorHandler: (msg) => {
+        __privateMethod(this, _handleError, handleError_fn).call(this, new Error(msg));
+      }
+    }));
     __privateAdd(this, _flags, /* @__PURE__ */ Object.create(null));
     __privateAdd(this, _usedNames, /* @__PURE__ */ new Set());
     __privateAdd(this, _argv, void 0);
@@ -299,7 +304,14 @@ const _Clerc = class {
     __privateAdd(this, _defaultLocale, "en");
     __privateAdd(this, _locale, "en");
     __privateAdd(this, _locales, /* @__PURE__ */ Object.create(null));
-    this.i18n = {
+    __privateSet(this, _scriptName, scriptName != null ? scriptName : __privateGet(this, _scriptName));
+    __privateSet(this, _description, description != null ? description : __privateGet(this, _description));
+    __privateSet(this, _version, version != null ? version : __privateGet(this, _version));
+    __privateSet(this, _locale, detectLocale());
+    __privateMethod(this, _addCoreLocales, addCoreLocales_fn).call(this);
+  }
+  get i18n() {
+    return {
       add: (locales2) => {
         __privateSet(this, _locales, defu(__privateGet(this, _locales), locales2));
       },
@@ -309,11 +321,6 @@ const _Clerc = class {
         return localeObject[name] ? format(localeObject[name], ...args) : defaultLocaleObject[name] ? format(defaultLocaleObject[name], ...args) : void 0;
       }
     };
-    __privateSet(this, _scriptName, scriptName != null ? scriptName : __privateGet(this, _scriptName));
-    __privateSet(this, _description, description != null ? description : __privateGet(this, _description));
-    __privateSet(this, _version, version != null ? version : __privateGet(this, _version));
-    __privateSet(this, _locale, detectLocale());
-    __privateMethod(this, _addCoreLocales, addCoreLocales_fn).call(this);
   }
   get _name() {
     return __privateGet(this, _name) || __privateGet(this, _scriptName);
@@ -327,8 +334,14 @@ const _Clerc = class {
   get _version() {
     return __privateGet(this, _version);
   }
+  /**
+   * @deprecated This is a typo. Use `_interceptor` instead.
+   */
   get _inspectors() {
-    return __privateGet(this, _inspectors);
+    return __privateGet(this, _interceptors);
+  }
+  get _interceptors() {
+    return __privateGet(this, _interceptors);
   }
   get _commands() {
     return __privateGet(this, _commands);
@@ -549,23 +562,29 @@ const _Clerc = class {
     return plugin.setup(this);
   }
   /**
-   * Register a inspector
+   * @deprecated This is a typo. Use `intercetor()` instead.
+   */
+  inspector(interceptor) {
+    return this.interceptor(interceptor);
+  }
+  /**
+   * Register a interceptor
    *
    * @example
    *
    * ```ts
-   * Clerc.create().inspector((ctx, next) => {
+   * Clerc.create().interceptor((ctx, next) => {
    * 	console.log(ctx);
    * 	next();
    * });
    * ```
    *
-   * @param inspector
+   * @param interceptor
    * @returns
    */
-  inspector(inspector) {
+  interceptor(interceptor) {
     __privateMethod(this, _otherMethodCalled, otherMethodCalled_fn).call(this);
-    __privateGet(this, _inspectors).push(inspector);
+    __privateGet(this, _interceptors).push(interceptor);
     return this;
   }
   /**
@@ -614,12 +633,11 @@ const _Clerc = class {
     return this;
   }
 };
-let Clerc = _Clerc;
 _name = new WeakMap();
 _scriptName = new WeakMap();
 _description = new WeakMap();
 _version = new WeakMap();
-_inspectors = new WeakMap();
+_interceptors = new WeakMap();
 _commands = new WeakMap();
 _commandEmitter = new WeakMap();
 _flags = new WeakMap();
@@ -744,18 +762,22 @@ getContext_fn = function(getCommand) {
   };
   return context;
 };
+_handleError = new WeakSet();
+handleError_fn = function(e) {
+  if (__privateGet(this, _errorHandlers).length > 0) {
+    for (const cb of __privateGet(this, _errorHandlers)) {
+      cb(e);
+    }
+  } else {
+    throw e;
+  }
+};
 _callWithErrorHandling = new WeakSet();
 callWithErrorHandling_fn = function(fn) {
   try {
     fn();
   } catch (e) {
-    if (__privateGet(this, _errorHandlers).length > 0) {
-      for (const cb of __privateGet(this, _errorHandlers)) {
-        cb(e);
-      }
-    } else {
-      throw e;
-    }
+    __privateMethod(this, _handleError, handleError_fn).call(this, e);
   }
 };
 _runMatchedCommand = new WeakSet();
@@ -780,17 +802,19 @@ runMatchedCommand_fn = function() {
       __privateGet(this, _commandEmitter).emit(command.name, ctx);
     }
   };
-  const inspectors = [...__privateGet(this, _inspectors), emitHandler];
-  const callInspector = compose(inspectors);
-  callInspector(getContext());
+  const interceptor = [...__privateGet(this, _interceptors), emitHandler];
+  const callInterceptor = compose(interceptor);
+  callInterceptor(getContext());
 };
+let Clerc = _Clerc;
 
 const definePlugin = (p) => p;
 const defineHandler = (_cli, _key, handler) => handler;
-const defineInspector = (_cli, inspector) => inspector;
+const defineInterceptor = (_cli, interceptor) => interceptor;
+const defineInspector = defineInterceptor;
 const defineCommand = (command, handler) => ({
   ...command,
   handler
 });
 
-export { Clerc, CommandExistsError, CommandNameConflictError, DescriptionNotSetError, InvalidCommandNameError, LocaleNotCalledFirstError, NoCommandGivenError, NoSuchCommandError, Root, ScriptNameNotSetError, VersionNotSetError, compose, defineCommand, defineHandler, defineInspector, definePlugin, detectLocale, formatCommandName, isValidName, resolveArgv, resolveCommand, resolveFlattenCommands, stripFlags, withBrackets };
+export { Clerc, CommandExistsError, CommandNameConflictError, DescriptionNotSetError, InvalidCommandNameError, LocaleNotCalledFirstError, NoCommandGivenError, NoSuchCommandError, Root, ScriptNameNotSetError, VersionNotSetError, compose, defineCommand, defineHandler, defineInspector, defineInterceptor, definePlugin, detectLocale, formatCommandName, isValidName, resolveArgv, resolveCommand, resolveFlattenCommands, stripFlags, withBrackets };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clerc/core",
-  "version": "0.42.1",
+  "version": "0.43.0",
   "author": "Ray <i@mk1.io> (https://github.com/so1ve)",
   "type": "module",
   "description": "Clerc core",
@@ -49,10 +49,10 @@
   "dependencies": {
     "defu": "^6.1.2",
     "is-platform": "^1.0.0",
-    "lite-emit": "^2.2.0",
-    "type-fest": "^4.0.0",
+    "lite-emit": "^2.3.0",
+    "type-fest": "^4.3.1",
     "type-flag": "^3.0.0",
-    "@clerc/utils": "0.42.1"
+    "@clerc/utils": "0.43.0"
   },
   "scripts": {
     "build": "pkgroll",