clerc 0.3.2 → 0.3.4

package/dist/index.cjs

@@ -3,13 +3,14 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var liteEmit = require('lite-emit');
-var minimist = require('minimist');
+var mri = require('mri');
 var typeFlag = require('type-flag');
 var isPlatform = require('is-platform');
+var utils = require('@clerc/utils');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var minimist__default = /*#__PURE__*/_interopDefaultLegacy(minimist);
+var mri__default = /*#__PURE__*/_interopDefaultLegacy(mri);
 
 class SingleCommandError extends Error {
 }
@@ -20,13 +21,10 @@ class CommonCommandExistsError extends Error {
 class NoSuchCommandError extends Error {
 }
 
-const mustArray = (a) => Array.isArray(a) ? a : [a];
-const camelCase = (s) => s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-const kebabCase = (s) => s.replace(/([A-Z])/g, (_, c) => `-${c.toLowerCase()}`);
 const resolveFlagAlias = (_command) => Object.entries((_command == null ? void 0 : _command.flags) || {}).reduce((acc, [name, command]) => {
   if (command.alias) {
-    const item = mustArray(command.alias).map(kebabCase);
-    acc[kebabCase(name)] = item;
+    const item = utils.mustArray(command.alias).map(utils.kebabCase);
+    acc[utils.kebabCase(name)] = item;
   }
   return acc;
 }, {});
@@ -42,7 +40,7 @@ function resolveCommand(commands, name) {
     return commands[SingleCommand];
   }
   const possibleCommands = Object.values(commands).filter(
-    (c) => c.name === name || mustArray(c.alias || []).map(String).includes(name)
+    (c) => c.name === name || utils.mustArray(c.alias || []).map(String).includes(name)
   );
   if (possibleCommands.length > 1) {
     throw new Error(`Multiple commands found with name "${name}"`);
@@ -120,7 +118,7 @@ class Clerc {
     return this;
   }
   parse(argv = resolveArgv()) {
-    const parsed = minimist__default["default"](argv);
+    const parsed = mri__default["default"](argv);
     const name = String(parsed._[0]);
     const command = this.__isSingleCommand ? this._commands[SingleCommand] : resolveCommand(this._commands, name);
     const isCommandResolved = !!command;
@@ -134,6 +132,7 @@ class Clerc {
       raw: parsedWithType,
       parameters,
       flags,
+      unknownFlags: parsedWithType.unknownFlags,
       cli: this
     };
     const handlerContext = inspectorContext;
@@ -159,13 +158,10 @@ exports.CommonCommandExistsError = CommonCommandExistsError;
 exports.NoSuchCommandError = NoSuchCommandError;
 exports.SingleCommand = SingleCommand;
 exports.SingleCommandError = SingleCommandError;
-exports.camelCase = camelCase;
 exports.compose = compose;
 exports.defineHandler = defineHandler;
 exports.defineInspector = defineInspector;
 exports.definePlugin = definePlugin;
-exports.kebabCase = kebabCase;
-exports.mustArray = mustArray;
 exports.resolveArgv = resolveArgv;
 exports.resolveCommand = resolveCommand;
 exports.resolveFlagAlias = resolveFlagAlias;

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { MaybeArray, Dict, LiteralUnion } from '@clerc/utils';
+
 declare const DOUBLE_DASH = "--";
 declare type TypeFunction<ReturnType = any> = (value: any) => ReturnType;
 declare type TypeFunctionArray<ReturnType> = readonly [TypeFunction<ReturnType>];
@@ -66,23 +68,6 @@ declare type TypeFlag<Schemas extends Flags> = ParsedFlags<{
     [flag in keyof Schemas]: InferFlagType<Schemas[flag]>;
 }>;
 
-/**
- * Copied from type-fest
- */
-declare type Primitive = null | undefined | string | number | boolean | symbol | bigint;
-/**
- * Copied from type-fest
- */
-declare type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
-declare type Dict<T> = Record<string, T>;
-declare type MustArray<T> = T extends any[] ? T : [T];
-declare type MaybeArray<T> = T | T[];
-declare type GetLength<T extends any[]> = T extends {
-    length: infer L extends number;
-} ? L : never;
-declare type GetTail<T extends any[]> = T extends [infer _Head, ...infer Tail] ? Tail : never;
-declare type EnhanceSingle<T, E extends Dict<any>> = T & E;
-declare type Enhance<T, E extends Dict<any> | Dict<any>[]> = GetLength<MustArray<E>> extends 0 ? T : Enhance<EnhanceSingle<T, MustArray<E>[0]>, GetTail<MustArray<E>>>;
 declare type FlagOptions = FlagSchema & {
     description: string;
     required?: boolean;
@@ -112,12 +97,14 @@ interface HandlerContext<C extends CommandRecord = CommandRecord, N extends keyo
     isSingleCommand: boolean;
     raw: ParsedFlags;
     parameters: PossibleInputKind[];
+    unknownFlags: ParsedFlags["unknownFlags"];
     flags: TypeFlag<NonNullableFlag<C[N]["flags"]>>["flags"];
     cli: Clerc<C>;
 }
 declare type Handler<C extends CommandRecord = CommandRecord, K extends keyof C = keyof C> = (ctx: HandlerContext<C, K>) => void;
+declare type FallbackType<T, U> = {} extends T ? U : T;
 declare type InspectorContext<C extends CommandRecord = CommandRecord> = HandlerContext<C> & {
-    flags: {} extends TypeFlag<NonNullableFlag<C[keyof C]["flags"]>>["flags"] ? Dict<any> : TypeFlag<NonNullableFlag<C[keyof C]["flags"]>>["flags"];
+    flags: FallbackType<TypeFlag<NonNullableFlag<C[keyof C]["flags"]>>["flags"], Dict<any>>;
 };
 declare type Inspector<C extends CommandRecord = CommandRecord> = (ctx: InspectorContext<C>, next: () => void) => void;
 interface Plugin<T extends Clerc = Clerc, U extends Clerc = Clerc> {
@@ -275,15 +262,10 @@ declare class CommonCommandExistsError extends Error {
 declare class NoSuchCommandError extends Error {
 }
 
-declare const mustArray: <T>(a: MaybeArray<T>) => T[];
-declare type CamelCase<T extends string> = T extends `${infer A}-${infer B}${infer C}` ? `${A}${Capitalize<B>}${CamelCase<C>}` : T;
-declare const camelCase: <T extends string>(s: T) => CamelCase<T>;
-declare type KebabCase<T extends string, A extends string = ""> = T extends `${infer F}${infer R}` ? KebabCase<R, `${A}${F extends Lowercase<F> ? "" : "-"}${Lowercase<F>}`> : A;
-declare const kebabCase: <T extends string>(s: T) => KebabCase<T, "">;
 declare const resolveFlagAlias: (_command: Command) => Dict<string[]>;
 declare const resolveFlagDefault: (_command: Command) => Dict<any>;
 declare function resolveCommand(commands: CommandRecord, name: string | SingleCommandType): Command | undefined;
 declare const resolveArgv: () => string[];
 declare function compose(inspectors: Inspector[]): (ctx: InspectorContext) => void;
 
-export { CamelCase, Clerc, Command, CommandExistsError, CommandOptions, CommandRecord, CommonCommandExistsError, Dict, Enhance, Flag, FlagOptions, Handler, HandlerContext, Inspector, InspectorContext, KebabCase, LiteralUnion, MakeEventMap, MaybeArray, NoSuchCommandError, Plugin, PossibleInputKind, Primitive, SingleCommand, SingleCommandError, SingleCommandType, camelCase, compose, defineHandler, defineInspector, definePlugin, kebabCase, mustArray, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault };
+export { Clerc, Command, CommandExistsError, CommandOptions, CommandRecord, CommonCommandExistsError, FallbackType, Flag, FlagOptions, Handler, HandlerContext, Inspector, InspectorContext, MakeEventMap, NoSuchCommandError, Plugin, PossibleInputKind, SingleCommand, SingleCommandError, SingleCommandType, compose, defineHandler, defineInspector, definePlugin, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault };

package/dist/index.mjs

@@ -1,7 +1,8 @@
 import { LiteEmit } from 'lite-emit';
-import minimist from 'minimist';
+import mri from 'mri';
 import { typeFlag } from 'type-flag';
 import { isNode, isDeno } from 'is-platform';
+import { mustArray, kebabCase } from '@clerc/utils';
 
 class SingleCommandError extends Error {
 }
@@ -12,9 +13,6 @@ class CommonCommandExistsError extends Error {
 class NoSuchCommandError extends Error {
 }
 
-const mustArray = (a) => Array.isArray(a) ? a : [a];
-const camelCase = (s) => s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-const kebabCase = (s) => s.replace(/([A-Z])/g, (_, c) => `-${c.toLowerCase()}`);
 const resolveFlagAlias = (_command) => Object.entries((_command == null ? void 0 : _command.flags) || {}).reduce((acc, [name, command]) => {
   if (command.alias) {
     const item = mustArray(command.alias).map(kebabCase);
@@ -112,7 +110,7 @@ class Clerc {
     return this;
   }
   parse(argv = resolveArgv()) {
-    const parsed = minimist(argv);
+    const parsed = mri(argv);
     const name = String(parsed._[0]);
     const command = this.__isSingleCommand ? this._commands[SingleCommand] : resolveCommand(this._commands, name);
     const isCommandResolved = !!command;
@@ -126,6 +124,7 @@ class Clerc {
       raw: parsedWithType,
       parameters,
       flags,
+      unknownFlags: parsedWithType.unknownFlags,
       cli: this
     };
     const handlerContext = inspectorContext;
@@ -145,4 +144,4 @@ const definePlugin = (p) => p;
 const defineHandler = (_cli, _key, handler) => handler;
 const defineInspector = (_cli, inspector) => inspector;
 
-export { Clerc, CommandExistsError, CommonCommandExistsError, NoSuchCommandError, SingleCommand, SingleCommandError, camelCase, compose, defineHandler, defineInspector, definePlugin, kebabCase, mustArray, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault };
+export { Clerc, CommandExistsError, CommonCommandExistsError, NoSuchCommandError, SingleCommand, SingleCommandError, compose, defineHandler, defineInspector, definePlugin, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clerc",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "author": "Ray <nn_201312@163.com> (https://github.com/so1ve)",
   "description": "Clerc is a simple and easy-to-use cli framework.",
   "keywords": [
@@ -39,6 +39,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@clerc/utils": "0.3.4",
     "is-platform": "^0.2.0",
     "lite-emit": "^1.4.0",
     "mri": "^1.2.0",