@clerc/core 0.42.0 → 0.42.2

package/dist/index.d.ts

@@ -92,10 +92,10 @@ type ParseRaw<C extends Command, GF extends GlobalFlagOptions = {}> = NonNullabl
 type ParseParameters<C extends Commands = Commands, N extends keyof C = keyof C> = Equals<TransformParameters<C[N]>, {}> extends true ? N extends keyof C ? TransformParameters<C[N]> : Dict<string | string[] | undefined> : TransformParameters<C[N]>;
 
 type Locales = Dict<Dict<string>>;
-type TranslateFunction = (name: string, ...arguments_: string[]) => string | undefined;
+type TranslateFn = (name: string, ...args: string[]) => string | undefined;
 interface I18N {
     add: (locales: Locales) => void;
-    t: TranslateFunction;
+    t: TranslateFn;
 }
 
 interface Plugin<T extends Clerc = Clerc, U extends Clerc = Clerc> {
@@ -148,19 +148,19 @@ interface HandlerContext<C extends Commands = Commands, N extends keyof C = keyo
     flags: Simplify<ParseFlag<C, N, GF> & Record<string, any>>;
     cli: Clerc<C, GF>;
 }
-type Handler<C extends Commands = Commands, K extends keyof C = keyof C, GF extends GlobalFlagOptions = {}> = (context: HandlerContext<C, K, GF>) => void;
-type HandlerInCommand<C extends HandlerContext> = (context: {
+type Handler<C extends Commands = Commands, K extends keyof C = keyof C, GF extends GlobalFlagOptions = {}> = (ctx: HandlerContext<C, K, GF>) => void;
+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> & {
     flags: FallbackType<TypeFlag<NonNullable<C[keyof C]["flags"]>>["flags"], Dict<any>>;
 };
-type Inspector<C extends Commands = Commands> = InspectorFunction<C> | InspectorObject<C>;
-type InspectorFunction<C extends Commands = Commands> = (context: InspectorContext<C>, next: () => void) => void;
+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> {
     enforce?: "pre" | "post";
-    fn: InspectorFunction<C>;
+    fn: InspectorFn<C>;
 }
 
 declare const Root: unique symbol;
@@ -289,7 +289,7 @@ declare class Clerc<C extends Commands = {}, GF extends GlobalFlagOptions = {}>
      * @param handler
      * @returns
      */
-    errorHandler(handler: (error: any) => void): this;
+    errorHandler(handler: (err: any) => void): this;
     /**
      * Register a command
      *
@@ -422,35 +422,35 @@ declare class Clerc<C extends Commands = {}, GF extends GlobalFlagOptions = {}>
 
 declare class CommandExistsError extends Error {
     commandName: string;
-    constructor(commandName: string, t: TranslateFunction);
+    constructor(commandName: string, t: TranslateFn);
 }
 declare class NoSuchCommandError extends Error {
     commandName: string;
-    constructor(commandName: string, t: TranslateFunction);
+    constructor(commandName: string, t: TranslateFn);
 }
 declare class NoCommandGivenError extends Error {
-    constructor(t: TranslateFunction);
+    constructor(t: TranslateFn);
 }
 declare class CommandNameConflictError extends Error {
     n1: string;
     n2: string;
-    constructor(n1: string, n2: string, t: TranslateFunction);
+    constructor(n1: string, n2: string, t: TranslateFn);
 }
 declare class ScriptNameNotSetError extends Error {
-    constructor(t: TranslateFunction);
+    constructor(t: TranslateFn);
 }
 declare class DescriptionNotSetError extends Error {
-    constructor(t: TranslateFunction);
+    constructor(t: TranslateFn);
 }
 declare class VersionNotSetError extends Error {
-    constructor(t: TranslateFunction);
+    constructor(t: TranslateFn);
 }
 declare class InvalidCommandNameError extends Error {
     commandName: string;
-    constructor(commandName: string, t: TranslateFunction);
+    constructor(commandName: string, t: TranslateFn);
 }
 declare class LocaleNotCalledFirstError extends Error {
-    constructor(t: TranslateFunction);
+    constructor(t: TranslateFn);
 }
 
 type MaybeArray<T> = T | T[];
@@ -460,14 +460,14 @@ declare const defineHandler: <C extends Clerc<{}, {}>, K extends keyof C["_comma
 declare const defineInspector: <C extends Clerc<{}, {}>>(_cli: C, inspector: Inspector<C["_commands"]>) => Inspector<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: TranslateFunction): Map<string[] | typeof Root, CommandAlias>;
-declare function resolveCommand(commands: Commands, argv: string[], t: TranslateFunction): [Command<string | RootType> | undefined, string[] | RootType | undefined];
+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[]): (context: InspectorContext) => void;
+declare function compose(inspectors: Inspector[]): (ctx: InspectorContext) => 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, InspectorFunction, InspectorObject, InvalidCommandNameError, LocaleNotCalledFirstError, Locales, MakeEventMap, NoCommandGivenError, NoSuchCommandError, ParseOptions, Plugin, Root, RootType, ScriptNameNotSetError, TranslateFunction, 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, 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 };

package/dist/index.js

@@ -144,15 +144,15 @@ function parseParameters(parameters, t) {
   return parsedParameters;
 }
 function mapParametersToArguments(mapping, parameters, cliArguments, t) {
-  for (let index = 0; index < parameters.length; index += 1) {
-    const { name, required, spread } = parameters[index];
+  for (let i = 0; i < parameters.length; i += 1) {
+    const { name, required, spread } = parameters[i];
     const camelCaseName = camelCase(name);
     if (camelCaseName in mapping) {
       throw new Error(t("core.parameterIsUsedMoreThanOnce", stringify(name)));
     }
-    const value = spread ? cliArguments.slice(index) : cliArguments[index];
+    const value = spread ? cliArguments.slice(i) : cliArguments[i];
     if (spread) {
-      index = parameters.length;
+      i = parameters.length;
     }
     if (required && (!value || spread && value.length === 0)) {
       throw new Error(t("core.missingRequiredParameter", stringify(name)));
@@ -196,11 +196,11 @@ function resolveCommand(commands, argv, t) {
   const commandsMap = resolveFlattenCommands(commands, t);
   for (const [name, command] of commandsMap.entries()) {
     const parsed = typeFlag((_a = command == null ? void 0 : command.flags) != null ? _a : /* @__PURE__ */ Object.create(null), [...argv]);
-    const { _: arguments_ } = parsed;
+    const { _: args } = parsed;
     if (name === Root) {
       continue;
     }
-    if (arrayStartsWith(arguments_, name)) {
+    if (arrayStartsWith(args, name)) {
       return [command, name];
     }
   }
@@ -228,16 +228,16 @@ function compose(inspectors) {
       inspectorMap.normal.push(fn);
     }
   }
-  const mergedInspectorFunctions = [
+  const mergedInspectorFns = [
     ...inspectorMap.pre,
     ...inspectorMap.normal,
     ...inspectorMap.post
   ];
-  return (context) => {
+  return (ctx) => {
     return dispatch(0);
-    function dispatch(index) {
-      const inspector = mergedInspectorFunctions[index];
-      return inspector(context, dispatch.bind(null, index + 1));
+    function dispatch(i) {
+      const inspector = mergedInspectorFns[i];
+      return inspector(ctx, dispatch.bind(null, i + 1));
     }
   };
 }
@@ -247,7 +247,7 @@ const withBrackets = (s, isOptional) => isOptional ? `[${s}]` : `<${s}>`;
 const ROOT = "<Root>";
 const formatCommandName = (name) => Array.isArray(name) ? name.join(" ") : typeof name === "string" ? name : ROOT;
 const detectLocale = () => process.env.CLERC_LOCALE ? process.env.CLERC_LOCALE : Intl.DateTimeFormat().resolvedOptions().locale;
-const stripFlags = (argv) => argv.filter((argument) => !argument.startsWith("-"));
+const stripFlags = (argv) => argv.filter((arg) => !arg.startsWith("-"));
 
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
@@ -271,7 +271,7 @@ 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, _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, _handleError, handleError_fn, _callWithErrorHandling, callWithErrorHandling_fn, _runMatchedCommand, runMatchedCommand_fn;
 const Root = Symbol.for("Clerc.Root");
 const _Clerc = class {
   constructor(scriptName, description, version) {
@@ -282,6 +282,7 @@ const _Clerc = class {
     __privateAdd(this, _command);
     __privateAdd(this, _validateMeta);
     __privateAdd(this, _getContext);
+    __privateAdd(this, _handleError);
     __privateAdd(this, _callWithErrorHandling);
     __privateAdd(this, _runMatchedCommand);
     __privateAdd(this, _name, "");
@@ -290,7 +291,11 @@ const _Clerc = class {
     __privateAdd(this, _version, "");
     __privateAdd(this, _inspectors, []);
     __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);
@@ -303,10 +308,10 @@ const _Clerc = class {
       add: (locales2) => {
         __privateSet(this, _locales, defu(__privateGet(this, _locales), locales2));
       },
-      t: (name, ...arguments_) => {
+      t: (name, ...args) => {
         const localeObject = __privateGet(this, _locales)[__privateGet(this, _locale)] || __privateGet(this, _locales)[__privateGet(this, _defaultLocale)];
         const defaultLocaleObject = __privateGet(this, _locales)[__privateGet(this, _defaultLocale)];
-        return localeObject[name] ? format(localeObject[name], ...arguments_) : defaultLocaleObject[name] ? format(defaultLocaleObject[name], ...arguments_) : void 0;
+        return localeObject[name] ? format(localeObject[name], ...args) : defaultLocaleObject[name] ? format(defaultLocaleObject[name], ...args) : void 0;
       }
     };
     __privateSet(this, _scriptName, scriptName != null ? scriptName : __privateGet(this, _scriptName));
@@ -698,15 +703,16 @@ getContext_fn = function(getCommand) {
     ...command == null ? void 0 : command.flags
   };
   const parsed = typeFlag(flagsMerged, [...argv]);
-  const { _: arguments_, flags, unknownFlags } = parsed;
-  let parameters = !isCommandResolved || command.name === Root ? arguments_ : arguments_.slice(command.name.split(" ").length);
+  const parametersOffset = (command == null ? void 0 : command.name) === Root || called === Root ? 0 : (called == null ? void 0 : called.length) ? called.length : command == null ? void 0 : command.name.split(" ").length;
+  const { _: args, flags, unknownFlags } = parsed;
+  let parameters = !isCommandResolved || command.name === Root ? args : args.slice(parametersOffset);
   let commandParameters = (_a = command == null ? void 0 : command.parameters) != null ? _a : [];
   const hasEof = commandParameters.indexOf("--");
   const eofParameters = commandParameters.slice(hasEof + 1) || [];
   const mapping = /* @__PURE__ */ Object.create(null);
   if (hasEof > -1 && eofParameters.length > 0) {
     commandParameters = commandParameters.slice(0, hasEof);
-    const eofArguments = arguments_["--"];
+    const eofArguments = args["--"];
     parameters = parameters.slice(0, -eofArguments.length || void 0);
     mapParametersToArguments(
       mapping,
@@ -743,18 +749,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(function_) {
+callWithErrorHandling_fn = function(fn) {
   try {
-    function_();
-  } catch (error) {
-    if (__privateGet(this, _errorHandlers).length > 0) {
-      for (const callback of __privateGet(this, _errorHandlers)) {
-        callback(error);
-      }
-    } else {
-      throw error;
-    }
+    fn();
+  } catch (e) {
+    __privateMethod(this, _handleError, handleError_fn).call(this, e);
   }
 };
 _runMatchedCommand = new WeakSet();
@@ -769,14 +779,18 @@ runMatchedCommand_fn = function() {
   const getContext = () => __privateMethod(this, _getContext, getContext_fn).call(this, getCommand);
   const emitHandler = {
     enforce: "post",
-    fn: (context) => {
+    fn: (ctx) => {
       const [command] = getCommand();
       const stringName = stripFlags(argv).join(" ");
       if (!command) {
         const error = stringName ? new NoSuchCommandError(stringName, t) : new NoCommandGivenError(t);
         throw error;
       }
-      __privateGet(this, _commandEmitter).emit(command.name, context);
+      try {
+        __privateGet(this, _commandEmitter).emit(command.name, ctx);
+      } catch (e) {
+        console.log(1);
+      }
     }
   };
   const inspectors = [...__privateGet(this, _inspectors), emitHandler];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clerc/core",
-  "version": "0.42.0",
+  "version": "0.42.2",
   "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",
+    "lite-emit": "^2.3.0",
     "type-fest": "^4.0.0",
     "type-flag": "^3.0.0",
-    "@clerc/utils": "0.42.0"
+    "@clerc/utils": "0.42.2"
   },
   "scripts": {
     "build": "pkgroll",