better-command 1.0.0 → 1.0.1

package/dist/chunk-EQS53463.js

@@ -0,0 +1,149 @@
+// src/mod.ts
+var ArgType = /* @__PURE__ */ ((ArgType2) => {
+  ArgType2[ArgType2["String"] = 0] = "String";
+  ArgType2[ArgType2["Number"] = 1] = "Number";
+  ArgType2[ArgType2["Boolean"] = 2] = "Boolean";
+  return ArgType2;
+})(ArgType || {});
+var arg = (name, init) => ({
+  ...init,
+  name: Array.isArray(name) ? name[0] : name,
+  alias: Array.isArray(name) ? name.slice(1) : [],
+  isArray: init.isArray ?? false,
+  required: init.required ?? false,
+  type: init.type ?? 0 /* String */
+});
+var parseValue = (value, type, name) => {
+  if (type === 1 /* Number */) {
+    const num = Number(value);
+    if (isNaN(num)) throw new Error(`Invalid number value: ${value} for ${name}`);
+    return num;
+  }
+  if (type === 2 /* Boolean */) {
+    return value.toLowerCase() === "true" || value === "1";
+  }
+  return value;
+};
+var parseArg = (current) => {
+  if (current.includes("=")) {
+    const [key, value] = current.split("=", 2);
+    return [key, value];
+  }
+  return [current, null];
+};
+var addOrSetValue = (result, name, value, isArray) => {
+  if (isArray) {
+    if (!result[name]) {
+      result[name] = [value];
+    } else {
+      result[name].push(value);
+    }
+  } else {
+    result[name] = value;
+  }
+};
+var isCommandParser = (obj) => {
+  return "parse" in obj;
+};
+var command = (init, ...args) => {
+  if (isCommandParser(init)) {
+    return {
+      ...init.opts,
+      name: init.opts.name,
+      alias: init.opts.alias ?? [],
+      action: (e) => {
+        init.parse(e.argv.splice(1), ...args);
+      }
+    };
+  } else {
+    return {
+      ...init,
+      alias: init.alias ?? []
+    };
+  }
+};
+var defineCommandParser = (opts, ...args) => {
+  const commands = opts.commands ?? [];
+  return {
+    opts,
+    parse: async (argv, callback = console.log, onError = (error) => {
+      console.error(error.message);
+    }) => {
+      argv = argv.filter(Boolean);
+      const currentBasicCmd = commands.find(
+        (cmd) => cmd.name === argv[0] || cmd.alias.includes(argv[0])
+      );
+      if (currentBasicCmd) {
+        currentBasicCmd.action({ opts, args, argv, commands });
+        return true;
+      }
+      const argMap = /* @__PURE__ */ new Map();
+      for (const arg2 of args) {
+        argMap.set(`--${arg2.name}`, arg2);
+        for (const alias of arg2.alias) {
+          argMap.set(`-${alias}`, arg2);
+        }
+      }
+      const result = {};
+      let i = 0;
+      let usingNamedArgs = false;
+      let positionalIndex = 0;
+      try {
+        while (i < argv.length) {
+          const current = argv[i];
+          if (current.startsWith("-")) {
+            usingNamedArgs = true;
+            const [key, value] = parseArg(current);
+            const argDef = argMap.get(key);
+            if (!argDef) throw new Error(`Unknown option: ${key}`);
+            if (argDef.type === 2 /* Boolean */) {
+              if (value !== null) {
+                addOrSetValue(result, argDef.name, value.toLowerCase() === "true" || value === "1", argDef.isArray);
+              } else if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+                addOrSetValue(result, argDef.name, parseValue(argv[++i], 2 /* Boolean */, argDef.name), argDef.isArray);
+              } else {
+                addOrSetValue(result, argDef.name, true, argDef.isArray);
+              }
+              i++;
+            } else {
+              if (value !== null) {
+                addOrSetValue(result, argDef.name, parseValue(value, argDef.type, argDef.name), argDef.isArray);
+                i++;
+              } else {
+                if (i + 1 >= argv.length) throw new Error(`Missing value for option: ${key}`);
+                addOrSetValue(result, argDef.name, parseValue(argv[++i], argDef.type, argDef.name), argDef.isArray);
+                i++;
+              }
+            }
+          } else if (usingNamedArgs) {
+            throw new Error(`Unexpected positional argument: ${current} after named arguments`);
+          } else if (positionalIndex < args.length) {
+            const argDef = args[positionalIndex++];
+            addOrSetValue(result, argDef.name, parseValue(current, argDef.type, argDef.name), argDef.isArray);
+            i++;
+          } else {
+            i++;
+          }
+        }
+        for (const argDef of args) {
+          if (result[argDef.name] === void 0) {
+            if (argDef.required) throw new Error(`Missing required argument: ${argDef.name}`);
+            result[argDef.name] = argDef.isArray ? [] : argDef.type === 2 /* Boolean */ ? false : void 0;
+          }
+        }
+        await callback(result);
+        return true;
+      } catch (error) {
+        onError(error instanceof Error ? error : new Error(String(error)), argv);
+        return false;
+      }
+    }
+  };
+};
+
+export {
+  ArgType,
+  arg,
+  command,
+  defineCommandParser
+};

package/dist/{chunk-QDFNMQ2V.js → chunk-R24CO3NO.js}

@@ -9,6 +9,7 @@ var arg = (name, init) => ({
   ...init,
   name: Array.isArray(name) ? name[0] : name,
   alias: Array.isArray(name) ? name.slice(1) : [],
+  isArray: init.isArray ?? false,
   required: init.required ?? false,
   type: init.type ?? 0 /* String */
 });
@@ -23,6 +24,13 @@ var parseValue = (value, type, name) => {
   }
   return value;
 };
+var parseArg = (current) => {
+  if (current.includes("=")) {
+    const [key, value] = current.split("=", 2);
+    return [key, value];
+  }
+  return [current, null];
+};
 var isCommandParser = (obj) => {
   return "parse" in obj;
 };
@@ -74,15 +82,27 @@ var defineCommandParser = (opts, ...args) => {
           const current = argv[i];
           if (current.startsWith("-")) {
             usingNamedArgs = true;
-            const argDef = argMap.get(current);
-            if (!argDef) throw new Error(`Unknown option: ${current}`);
+            const [key, value] = parseArg(current);
+            const argDef = argMap.get(key);
+            if (!argDef) throw new Error(`Unknown option: ${key}`);
             if (argDef.type === 2 /* Boolean */) {
-              result[argDef.name] = true;
+              if (value !== null) {
+                result[argDef.name] = value.toLowerCase() === "true" || value === "1";
+              } else if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+                result[argDef.name] = parseValue(argv[++i], 2 /* Boolean */, argDef.name);
+              } else {
+                result[argDef.name] = true;
+              }
               i++;
             } else {
-              if (i + 1 >= argv.length) throw new Error(`Missing value for option: ${current}`);
-              result[argDef.name] = parseValue(argv[++i], argDef.type, argDef.name);
-              i++;
+              if (value !== null) {
+                result[argDef.name] = parseValue(value, argDef.type, argDef.name);
+                i++;
+              } else {
+                if (i + 1 >= argv.length) throw new Error(`Missing value for option: ${key}`);
+                result[argDef.name] = parseValue(argv[++i], argDef.type, argDef.name);
+                i++;
+              }
             }
           } else if (usingNamedArgs) {
             throw new Error(`Unexpected positional argument: ${current} after named arguments`);

package/dist/mod.d.ts

@@ -5,7 +5,7 @@ declare enum ArgType {
 }
 type CommandActionEvent<T extends CommandParserInit = CommandParserInit> = {
     opts: T;
-    args: readonly ArgumentObject<any, any>[];
+    args: readonly ArgumentObject[];
     argv: string[];
     commands: CommandObject[];
 };
@@ -15,30 +15,32 @@ declare interface Command {
 }
 declare interface CommandParserOpts extends Command {
 }
-type ArgumentObject<TName extends string = string, TRequired extends boolean = false, TType extends ArgType = ArgType> = Argument & {
+type ArgumentObject<TName extends string = string, TRequired extends boolean = false, TAaray extends boolean = false, TType extends ArgType = ArgType> = Argument & {
     name: TName;
     alias: string[];
     type: TType;
     required: TRequired;
+    isArray: TAaray;
 };
 type CommandObject = Command & {
     name: string;
     alias: string[];
     action: (e: CommandActionEvent) => void;
 };
-type CommandParserObject<T extends readonly ArgumentObject<any, any>[], Opts extends CommandParserInit = CommandParserInit> = {
+type CommandParserObject<T extends readonly ArgumentObject<any, any, any, any>[], Opts extends CommandParserInit = CommandParserInit> = {
     opts: Opts;
-    parse: (argv: string[], callback: (args: ArgumentsToObject<T>) => void, onError?: (err: Error, args: string[]) => void) => void;
+    parse: (argv: string[], callback: (args: ArgumentsToObject<T>) => void, onError?: (err: Error, args: string[]) => void) => Promise<boolean>;
 };
 type ArgTypeToTS<T extends ArgType> = T extends ArgType.String ? string : T extends ArgType.Number ? number : T extends ArgType.Boolean ? boolean : never;
-type ArgumentsToObject<T extends readonly ArgumentObject<any, any>[]> = {
-    [P in T[number] as P['name']]: P extends ArgumentObject<any, true, any> ? ArgTypeToTS<P['type']> : ArgTypeToTS<P['type']> | undefined;
+type ArgumentsToObject<T extends readonly ArgumentObject<any, any, any, any>[]> = {
+    [P in T[number] as P['name']]: P extends ArgumentObject<any, any, true, any> ? ArgTypeToTS<P['type']>[] : P extends ArgumentObject<any, true, false, any> ? ArgTypeToTS<P['type']> : ArgTypeToTS<P['type']> | undefined;
 };
-interface CommandArgInit<TType extends ArgType = ArgType, TRequired extends boolean = false> extends Argument {
+interface CommandArgInit<TType extends ArgType = ArgType, TRequired extends boolean = false, TAaray extends boolean = false> extends Argument {
     type: TType;
     required?: TRequired;
+    isArray?: TAaray;
 }
-declare const arg: <const TName extends string, const TRequired extends boolean = false, TType extends ArgType = ArgType.String>(name: TName | [TName, ...string[]], init: CommandArgInit<TType, TRequired>) => ArgumentObject<TName, TRequired, TType>;
+declare const arg: <const TName extends string, const TRequired extends boolean = false, const TArray extends boolean = false, const TType extends ArgType = ArgType.String>(name: TName | [TName, ...string[]], init: CommandArgInit<TType, TRequired, TArray>) => ArgumentObject<TName, TRequired, TArray, TType>;
 interface CommandInit extends Command {
     name: string;
     alias?: string[];
@@ -50,6 +52,6 @@ interface CommandParserInit extends CommandParserOpts {
     alias?: string[];
     commands?: CommandObject[];
 }
-declare const defineCommandParser: <Opts extends CommandParserInit, T extends readonly ArgumentObject<any, any>[]>(opts: Opts, ...args: T) => CommandParserObject<T, Opts>;
+declare const defineCommandParser: <Opts extends CommandParserInit, T extends readonly ArgumentObject<any, any, any, any>[]>(opts: Opts, ...args: T) => CommandParserObject<T, Opts>;
 
 export { ArgType, type Argument, type ArgumentObject, type Command, type CommandActionEvent, type CommandObject, type CommandParserObject, type CommandParserOpts, arg, command, defineCommandParser };

package/dist/mod.js

@@ -3,7 +3,7 @@ import {
   arg,
   command,
   defineCommandParser
-} from "./chunk-QDFNMQ2V.js";
+} from "./chunk-EQS53463.js";
 export {
   ArgType,
   arg,

package/dist/plugin.js

@@ -1,7 +1,7 @@
 import {
   ArgType,
   command
-} from "./chunk-QDFNMQ2V.js";
+} from "./chunk-EQS53463.js";
 
 // src/plugin.ts
 var helpCommand = command({

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "better-command",
-    "version": "1.0.0",
+    "version": "1.0.1",
     "license": "MIT",
     "description": "一个轻量化的类型友好的命令行解析工具，适用于Bun运行时",
     "repository": {