termkit 1.7.0 → 2.0.1

package/dist/index.js

@@ -0,0 +1,438 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Command: () => Command,
+  Option: () => Option,
+  Termkit: () => Termkit,
+  Variable: () => Variable,
+  command: () => command,
+  middleware: () => middleware,
+  option: () => option,
+  parse: () => parse,
+  setDefaults: () => setDefaults
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/models/Command.ts
+var import_cosmetic = __toESM(require("cosmetic"));
+
+// src/helpers/findCommand.ts
+function findCommand(array, commands) {
+  for (const command2 of commands) {
+    if (array[0] === command2.name) {
+      array.shift();
+      return command2;
+    }
+  }
+  return null;
+}
+
+// src/helpers/findVariable.ts
+function coerce(value, type) {
+  if (type === "number") return Number(value);
+  if (type === "boolean") return value === "true";
+  return value;
+}
+function findVariable(array, variable, commands) {
+  if (variable.array) {
+    const result = [];
+    while (array.length > 0 && !array[0].startsWith("-")) {
+      if (commands.includes(array[0])) break;
+      result.push(coerce(array.shift(), variable.type));
+    }
+    if (result.length === 0 && variable.required) throw new Error(`Missing required variable <${variable.name}>`);
+    return result.length > 0 ? result : true;
+  }
+  if (array.length > 0 && !array[0].startsWith("-")) {
+    if ((!commands.includes(array[0]) || variable.required) && array[0] !== "help") {
+      return coerce(array.shift(), variable.type);
+    }
+  }
+  if (variable.required) throw new Error(`Missing required variable <${variable.name}>`);
+  return true;
+}
+
+// src/helpers/findCommandVariables.ts
+function findCommandVariables(array, command2) {
+  if (!command2.variables) return null;
+  const result = {};
+  for (const variable of command2.variables) {
+    const value = findVariable(array, variable, command2.commandStrings);
+    if (value !== true) result[variable.name] = value;
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+
+// src/helpers/findOption.ts
+function findOption(string, options) {
+  return options.find((o) => o.short === string || o.long === string);
+}
+
+// src/helpers/findVariables.ts
+function findVariables(base2, array, variables, commands) {
+  const result = {};
+  if (!variables) {
+    if (base2) result[base2] = true;
+    return result;
+  }
+  if (variables.length > 1 && base2) result[base2] = {};
+  for (const variable of variables) {
+    const value = findVariable(array, variable, commands);
+    if (variables.length > 1 && base2) {
+      ;
+      result[base2][variable.name] = value;
+    } else if (base2) {
+      result[base2] = value;
+    } else {
+      result[variable.name] = value;
+    }
+  }
+  return result;
+}
+
+// src/helpers/findOptions.ts
+function findOptions(array, command2) {
+  const result = {};
+  while (array.length > 0 && array[0].startsWith("-")) {
+    if (array[0].startsWith("--")) {
+      const raw = array.shift().slice(2);
+      const option2 = findOption(raw, command2.optionsArray);
+      if (!option2) throw new Error(`Unknown Option: --${raw}`);
+      try {
+        Object.assign(result, findVariables(option2.long, array, option2.variables, command2.commandStrings));
+      } catch (err) {
+        ;
+        err.message += ` for --${option2.long}`;
+        throw err;
+      }
+    } else {
+      let string = array.shift();
+      const short = string.slice(1, 2);
+      const option2 = findOption(short, command2.optionsArray);
+      if (!option2) throw new Error(`Unknown Option: -${short}`);
+      string = string.replace(short, "");
+      if (string !== "-") array.unshift(string);
+      try {
+        Object.assign(result, findVariables(option2.long, array, option2.variables, command2.commandStrings));
+      } catch (err) {
+        ;
+        err.message += ` for --${option2.long}`;
+        throw err;
+      }
+    }
+  }
+  return result;
+}
+
+// src/models/Variable.ts
+var Variable = class {
+  constructor(data) {
+    this.array = false;
+    this.name = null;
+    this.raw = null;
+    this.required = false;
+    this.type = "string";
+    this.value = null;
+    if (!data) return;
+    if (data.array) this.array = data.array;
+    if (data.name) this.name = data.name;
+    if (data.raw) this.raw = data.raw;
+    if (data.required) this.required = data.required;
+    if (data.type) this.type = data.type;
+    if (this.array) this.value = [];
+  }
+};
+
+// src/helpers/getVariables.ts
+function parseName(raw) {
+  const colon = raw.indexOf(":");
+  if (colon === -1) return { name: raw, type: "string" };
+  return {
+    name: raw.slice(0, colon),
+    type: raw.slice(colon + 1)
+  };
+}
+function getVariables(string) {
+  const results = [];
+  for (const part of string.split(" ")) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("<") && trimmed.endsWith(">")) {
+      const { name, type } = parseName(trimmed.slice(1, -1));
+      results.push(new Variable({ name, raw: trimmed, required: true, type }));
+    } else if (trimmed.startsWith("[") && trimmed.endsWith("...]")) {
+      const { name, type } = parseName(trimmed.slice(1, -4));
+      results.push(new Variable({ array: true, name, raw: trimmed, type }));
+    } else if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      const { name, type } = parseName(trimmed.slice(1, -1));
+      results.push(new Variable({ name, raw: trimmed, type }));
+    } else {
+      throw new Error(`Unrecognized variable description: ${trimmed}`);
+    }
+  }
+  return results;
+}
+
+// src/models/Option.ts
+var Option = class {
+  constructor(data) {
+    this.short = null;
+    this.long = null;
+    this.info = null;
+    this.variables = null;
+    if (!data) return;
+    if (data.short) this.short = data.short;
+    if (data.long) this.long = data.long;
+    if (data.info) this.info = data.info;
+    if (data.variables) this.variables = getVariables(data.variables);
+  }
+  description(info) {
+    this.info = info;
+    return this;
+  }
+};
+
+// src/models/Command.ts
+var Command = class {
+  constructor(data) {
+    this.actionFunction = null;
+    this.commandsArray = [];
+    this.commandStrings = ["help"];
+    this.info = null;
+    this.middlewaresArray = [];
+    this.name = null;
+    this.optionsArray = [];
+    this.variables = null;
+    this.versionString = null;
+    if (!data) return;
+    if (data.info) this.info = data.info;
+    if (data.name) this.name = data.name;
+    if (data.variables) this.variables = getVariables(data.variables);
+    if (data.middlewares) this.middlewaresArray = [...data.middlewares];
+    if (data.options) this.optionsArray = [...data.options];
+  }
+  description(info) {
+    this.info = info;
+    return this;
+  }
+  variable(string) {
+    const vars = getVariables(string);
+    if (!this.variables) {
+      this.variables = vars;
+    } else {
+      this.variables.push(...vars);
+    }
+    return this;
+  }
+  action(fn) {
+    this.actionFunction = fn;
+    return this;
+  }
+  command(cmd) {
+    this.commandsArray.push(cmd);
+    return this;
+  }
+  commands(cmds) {
+    this.commandsArray = [...cmds];
+    for (const cmd of cmds) {
+      if (cmd.name) this.commandStrings.unshift(cmd.name);
+    }
+    return this;
+  }
+  middleware(fn) {
+    this.middlewaresArray.push(fn);
+    return this;
+  }
+  middlewares(fns) {
+    this.middlewaresArray.push(...fns);
+    return this;
+  }
+  option(short, long, variables, info) {
+    this.optionsArray.push(new Option({ short, long, variables, info }));
+    return this;
+  }
+  options(opts) {
+    this.optionsArray.push(...opts);
+    return this;
+  }
+  version(v) {
+    this.versionString = v;
+    return this;
+  }
+  help(_source) {
+    const table = [];
+    let program = this.name ?? "Program";
+    if (this.variables) for (const v of this.variables) program += ` ${v.raw}`;
+    if (this.optionsArray.length > 0) program += " [...options]";
+    table.push({ title: "\nCommand", info: program, data: [] });
+    if (this.versionString) table.push({ title: "Version", info: `v${this.versionString}`, data: [] });
+    if (this.info) table.push({ title: "Info", info: this.info, data: [] });
+    if (this.optionsArray.length > 0) {
+      const section = { title: "Options", data: [] };
+      for (const opt of this.optionsArray) {
+        let name = "";
+        if (opt.short) name = `-${opt.short}`;
+        if (opt.short && opt.long) name += ", ";
+        if (opt.long) name += `--${opt.long}`;
+        if (opt.variables) for (const v of opt.variables) name += ` ${v.raw}`;
+        section.data.push([name, opt.info ?? ""]);
+      }
+      table.push(section);
+    }
+    if (this.commandsArray.length > 0) {
+      const section = { title: "Subcommands", data: [] };
+      for (const cmd of this.commandsArray) {
+        let name = cmd.name ?? "";
+        if (cmd.variables) for (const v of cmd.variables) name += ` ${v.raw}`;
+        section.data.push([name, cmd.info ?? ""]);
+      }
+      table.push(section);
+    }
+    const padding = {};
+    for (const section of table) {
+      for (const row of section.data) {
+        for (const [i, s] of row.entries()) {
+          if (padding[i] === void 0 || s.length > padding[i]) padding[i] = s.length;
+        }
+      }
+    }
+    const lines = [];
+    for (const section of table) {
+      lines.push(section.title ? import_cosmetic.default.cyan.underline.encoder(section.title) : "");
+      if (section.info) lines.push(section.info);
+      for (const row of section.data) {
+        let line = "";
+        for (const [i, s] of row.entries()) {
+          const padded = padding[i] !== void 0 ? s.padEnd(padding[i]) : s;
+          line = line ? `${line}  ${padded}` : padded;
+        }
+        lines.push(line);
+      }
+      lines.push("");
+    }
+    for (const line of lines) console.log(line);
+  }
+  async parse(input) {
+    const array = [...input];
+    array.splice(0, 2);
+    let command2 = this;
+    const options = { _source: Array.from(array) };
+    while (array.length) {
+      if (!array.includes("help")) {
+        Object.assign(options, findOptions(array, command2));
+        const cmdVars = findCommandVariables(array, command2);
+        if (cmdVars) Object.assign(options, cmdVars);
+        Object.assign(options, findOptions(array, command2));
+      }
+      if (array.length) {
+        if (!array.includes("help")) {
+          for (const mw of command2.middlewaresArray) await mw(options);
+        }
+        const next = findCommand(array, command2.commandsArray);
+        if (!next && array[0] === "help") return command2.help(options._source);
+        if (!next) throw new SyntaxError(`Unknown command: ${array[0]}`);
+        const name = command2.name ?? "_base";
+        if (!options._parents) options._parents = {};
+        options._parents[name] = {};
+        for (const key of Object.keys(options)) {
+          if (!key.startsWith("_")) {
+            options._parents[name][key] = options[key];
+            delete options[key];
+          }
+        }
+        command2 = next;
+      }
+    }
+    for (const mw of command2.middlewaresArray) await mw(options);
+    if (command2.actionFunction) return command2.actionFunction(options);
+    if (options._source.length === 2) return command2.help(options._source);
+    throw new Error(`No action for command: ${command2.name ?? "_base"}`);
+  }
+};
+
+// src/models/Termkit.ts
+var _Termkit = class _Termkit {
+  static set defaults(obj) {
+    _Termkit.commandDefaults = obj;
+  }
+  static setDefaults(obj) {
+    _Termkit.commandDefaults = obj;
+  }
+  static command(name, variables, info) {
+    const cmd = new Command(Object.assign({ name, variables, info }, _Termkit.commandDefaults));
+    if (!_Termkit.base) _Termkit.base = cmd;
+    return cmd;
+  }
+  static middleware(action) {
+    return action;
+  }
+  static option(short, long, variables, info) {
+    return new Option({ short, long, variables, info });
+  }
+  static parse(arr) {
+    if (!_Termkit.base) throw new Error("No command defined");
+    return _Termkit.base.parse(arr);
+  }
+};
+_Termkit.base = null;
+_Termkit.commandDefaults = {};
+var Termkit = _Termkit;
+
+// src/index.ts
+var base = null;
+var commandDefaults = {};
+var command = (name, variables, info) => {
+  const cmd = new Command(Object.assign({ name, variables, info }, commandDefaults));
+  if (!base) base = cmd;
+  return cmd;
+};
+var middleware = (fn) => fn;
+var option = (short, long, variables, info) => new Option({ short, long, variables, info });
+var parse = (arr) => {
+  if (!base) throw new Error("No command defined");
+  return base.parse(arr);
+};
+var setDefaults = (data) => {
+  commandDefaults = data;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Command,
+  Option,
+  Termkit,
+  Variable,
+  command,
+  middleware,
+  option,
+  parse,
+  setDefaults
+});