clerc 0.0.0 → 0.0.1

package/dist/index.cjs

@@ -0,0 +1,118 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var liteEmit = require('lite-emit');
+var minimist = require('minimist');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var minimist__default = /*#__PURE__*/_interopDefaultLegacy(minimist);
+
+function resolveFlagAlias(command) {
+  return Object.entries((command == null ? void 0 : command.flags) || {}).reduce((acc, [name, { alias }]) => {
+    if (alias) {
+      acc[name] = alias;
+    }
+    return acc;
+  }, {});
+}
+function resolveCommand(commands, name) {
+  const possibleCommands = Object.values(commands).filter((c) => {
+    var _a;
+    return c.name === name || ((_a = c.alias) == null ? void 0 : _a.includes(name));
+  });
+  if (possibleCommands.length > 1) {
+    throw new Error(`Multiple commands found with name "${name}"`);
+  }
+  return possibleCommands[0];
+}
+function compose(invokers) {
+  return function fn(ctx) {
+    return dispatch(0);
+    function dispatch(i) {
+      const invoker = invokers[i];
+      return invoker(ctx, dispatch.bind(null, i + 1));
+    }
+  };
+}
+
+class Clerc {
+  constructor() {
+    this._name = "";
+    this._description = "";
+    this._version = "";
+    this._invokers = [];
+    this._commands = {};
+    this.__command_emitter = new liteEmit.LiteEmit();
+  }
+  static create() {
+    return new Clerc();
+  }
+  name(name) {
+    this._name = name;
+    return this;
+  }
+  description(description) {
+    this._description = description;
+    return this;
+  }
+  version(version) {
+    this._version = version;
+    return this;
+  }
+  command(name, description, options = {}) {
+    const { alias = [], flags = {} } = options;
+    this._commands[name] = { name, description, alias, flags };
+    return this;
+  }
+  on(name, cb) {
+    this.__command_emitter.on(name, cb);
+    return this;
+  }
+  use(plugin) {
+    return plugin.setup(this);
+  }
+  registerInvoker(invoker) {
+    this._invokers.push(invoker);
+    return this;
+  }
+  parse() {
+    const argv = process.argv.slice(2);
+    let parsed = minimist__default["default"](argv);
+    const name = parsed._[0];
+    const command = resolveCommand(this._commands, name || "_");
+    if (!command) {
+      throw new Error(`No such command: ${name}`);
+    }
+    const commandName = command.name;
+    parsed = minimist__default["default"](argv, {
+      alias: resolveFlagAlias(this._commands[commandName])
+    });
+    if (!command) {
+      throw new Error(`Command "${name}" not found`);
+    }
+    const invokerContext = {
+      name,
+      flags: parsed,
+      cli: this
+    };
+    const handlerContext = invokerContext;
+    const emitHandler = () => {
+      this.__command_emitter.emit(commandName, handlerContext);
+    };
+    const invokers = [...this._invokers, emitHandler];
+    const invoker = compose(invokers);
+    invoker(invokerContext);
+  }
+}
+
+function definePlugin(p) {
+  return p;
+}
+
+exports.Clerc = Clerc;
+exports.compose = compose;
+exports.definePlugin = definePlugin;
+exports.resolveCommand = resolveCommand;
+exports.resolveFlagAlias = resolveFlagAlias;

package/dist/index.d.ts

@@ -0,0 +1,70 @@
+import { LiteEmit } from 'lite-emit';
+
+interface Plugin<U, T extends Clerc = Clerc> {
+    setup: (cli: T) => U;
+}
+declare function definePlugin<T extends Clerc, U extends Clerc>(p: Plugin<T, U>): Plugin<T, U>;
+
+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>>>;
+interface FlagOptions {
+    alias?: MaybeArray<string>;
+    description: string;
+}
+interface Flag extends FlagOptions {
+    name: string;
+}
+interface CommandOptions {
+    alias?: MaybeArray<string>;
+    flags?: Dict<FlagOptions>;
+}
+interface Command<N extends string = string, D extends string = string> extends CommandOptions {
+    name: N;
+    description: D;
+}
+declare type CommandRecord = Dict<Command>;
+declare type MakeEventMap<T extends CommandRecord> = {
+    [K in keyof T]: [InvokerContext];
+};
+declare type PossibleFlagKind = string | number | boolean | Dict<any>;
+interface HandlerContext<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> {
+    name: N;
+    flags: Dict<PossibleFlagKind | PossibleFlagKind[]>;
+    cli: Clerc<C>;
+}
+declare type Handler = (ctx: HandlerContext) => void;
+interface InvokerContext<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> extends HandlerContext<C, N> {
+}
+declare type Invoker = (ctx: InvokerContext<any>, next: Invoker) => void;
+
+declare class Clerc<C extends CommandRecord = {}> {
+    _name: string;
+    _description: string;
+    _version: string;
+    _invokers: Invoker[];
+    _commands: C;
+    __command_emitter: LiteEmit<MakeEventMap<C>>;
+    private constructor();
+    static create(): Clerc<{}>;
+    name(name: string): this;
+    description(description: string): this;
+    version(version: string): this;
+    command<N extends string, D extends string>(name: N, description: D, options?: CommandOptions): this & Clerc<C & Record<N, Command<N, D>>>;
+    on<K extends keyof C>(name: K, cb: Handler): this;
+    use<T extends Clerc, U>(plugin: Plugin<U, T>): U;
+    registerInvoker(invoker: Invoker): this;
+    parse(): void;
+}
+
+declare function resolveFlagAlias(command: Command): Dict<MaybeArray<string>>;
+declare function resolveCommand(commands: CommandRecord, name: string): Command<string, string>;
+declare function compose(invokers: Invoker[]): (ctx: HandlerContext) => void;
+
+export { Clerc, Command, CommandOptions, CommandRecord, Dict, Enhance, Flag, FlagOptions, Handler, HandlerContext, Invoker, InvokerContext, MakeEventMap, MaybeArray, Plugin, PossibleFlagKind, compose, definePlugin, resolveCommand, resolveFlagAlias };

package/dist/index.mjs

@@ -0,0 +1,106 @@
+import { LiteEmit } from 'lite-emit';
+import minimist from 'minimist';
+
+function resolveFlagAlias(command) {
+  return Object.entries((command == null ? void 0 : command.flags) || {}).reduce((acc, [name, { alias }]) => {
+    if (alias) {
+      acc[name] = alias;
+    }
+    return acc;
+  }, {});
+}
+function resolveCommand(commands, name) {
+  const possibleCommands = Object.values(commands).filter((c) => {
+    var _a;
+    return c.name === name || ((_a = c.alias) == null ? void 0 : _a.includes(name));
+  });
+  if (possibleCommands.length > 1) {
+    throw new Error(`Multiple commands found with name "${name}"`);
+  }
+  return possibleCommands[0];
+}
+function compose(invokers) {
+  return function fn(ctx) {
+    return dispatch(0);
+    function dispatch(i) {
+      const invoker = invokers[i];
+      return invoker(ctx, dispatch.bind(null, i + 1));
+    }
+  };
+}
+
+class Clerc {
+  constructor() {
+    this._name = "";
+    this._description = "";
+    this._version = "";
+    this._invokers = [];
+    this._commands = {};
+    this.__command_emitter = new LiteEmit();
+  }
+  static create() {
+    return new Clerc();
+  }
+  name(name) {
+    this._name = name;
+    return this;
+  }
+  description(description) {
+    this._description = description;
+    return this;
+  }
+  version(version) {
+    this._version = version;
+    return this;
+  }
+  command(name, description, options = {}) {
+    const { alias = [], flags = {} } = options;
+    this._commands[name] = { name, description, alias, flags };
+    return this;
+  }
+  on(name, cb) {
+    this.__command_emitter.on(name, cb);
+    return this;
+  }
+  use(plugin) {
+    return plugin.setup(this);
+  }
+  registerInvoker(invoker) {
+    this._invokers.push(invoker);
+    return this;
+  }
+  parse() {
+    const argv = process.argv.slice(2);
+    let parsed = minimist(argv);
+    const name = parsed._[0];
+    const command = resolveCommand(this._commands, name || "_");
+    if (!command) {
+      throw new Error(`No such command: ${name}`);
+    }
+    const commandName = command.name;
+    parsed = minimist(argv, {
+      alias: resolveFlagAlias(this._commands[commandName])
+    });
+    if (!command) {
+      throw new Error(`Command "${name}" not found`);
+    }
+    const invokerContext = {
+      name,
+      flags: parsed,
+      cli: this
+    };
+    const handlerContext = invokerContext;
+    const emitHandler = () => {
+      this.__command_emitter.emit(commandName, handlerContext);
+    };
+    const invokers = [...this._invokers, emitHandler];
+    const invoker = compose(invokers);
+    invoker(invokerContext);
+  }
+}
+
+function definePlugin(p) {
+  return p;
+}
+
+export { Clerc, compose, definePlugin, resolveCommand, resolveFlagAlias };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clerc",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "author": "Ray <nn_201312@163.com> (https://github.com/so1ve)",
   "description": "Clerc",
   "keywords": [],
@@ -14,9 +14,6 @@
     "url": "https://github.com/so1ve/clerc/issues"
   },
   "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
   "sideEffects": false,
   "exports": {
     ".": {
@@ -31,16 +28,18 @@
   "files": [
     "dist"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
     "lite-emit": "^1.4.0",
-    "minimist": "^1.2.6",
-    "type-gym": "^0.5.0"
+    "minimist": "^1.2.7"
   },
   "devDependencies": {
     "@types/minimist": "^1.2.2"
   },
   "scripts": {
     "build": "puild",
-    "stub": "puild --stub"
+    "watch": "puild --watch"
   }
 }