termkit 1.7.0 → 2.0.1

package/dist/index.mjs

@@ -0,0 +1,393 @@
+// src/models/Command.ts
+import cosmetic from "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 ? cosmetic.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;
+};
+export {
+  Command,
+  Option,
+  Termkit,
+  Variable,
+  command,
+  middleware,
+  option,
+  parse,
+  setDefaults
+};

package/package.json

@@ -1,27 +1,75 @@
 {
   "name": "termkit",
-  "version": "1.7.0",
-  "description": "Terminal command constructor and parser kit",
-  "main": "index.js",
-  "scripts": {
-    "test": "mocha ./test; exit 0"
-  },
+  "version": "2.0.1",
+  "description": "Fluent CLI framework for Node.js with nested subcommands, middleware, and TypeScript support",
   "keywords": [
-    "terminal",
-    "command",
-    "line",
-    "input",
-    "constructor",
-    "parser"
+    "argv",
+    "builder",
+    "cli",
+    "command-line",
+    "framework",
+    "middleware",
+    "parser",
+    "subcommands",
+    "typescript"
   ],
+  "homepage": "https://github.com/jayrdeaton/termkit#readme",
+  "bugs": {
+    "url": "https://github.com/jayrdeaton/termkit/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jayrdeaton/termkit.git"
+  },
+  "license": "MIT",
   "author": "Jay Deaton",
-  "license": "ISC",
+  "sideEffects": false,
+  "type": "commonjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "fix": "eslint --fix",
+    "lint": "eslint",
+    "prepublishOnly": "npm run build",
+    "release": "git push --follow-tags",
+    "release:major": "npm version major && git push --follow-tags",
+    "release:minor": "npm version minor && git push --follow-tags",
+    "release:patch": "npm version patch && git push --follow-tags",
+    "test": "jest",
+    "test:watch": "jest --watchAll",
+    "typecheck": "tsc --noEmit",
+    "preversion": "npm run lint && npm test"
+  },
   "dependencies": {
-    "cosmetic": "^1.2.1"
+    "cosmetic": "^1.4.0"
   },
   "devDependencies": {
-    "amprisand": "^0.1.3",
-    "faker": "^4.1.0",
-    "mocha": "^8.1.3"
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.9.1",
+    "@typescript-eslint/parser": "^8.60.0",
+    "eslint": "^10.4.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-package-json": "^1.2.0",
+    "eslint-plugin-prettier": "^5.5.6",
+    "eslint-plugin-simple-import-sort": "^13.0.0",
+    "jest": "^30.4.2",
+    "prettier": "^3.8.3",
+    "ts-jest": "^29.4.11",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.60.0"
   }
 }

package/index.js

@@ -1,17 +0,0 @@
-const { models } = require('./src'),
-  { Command, Middleware, Option, Termkit } = models
-
-let base
-let command_defaults = {}
-
-const command = (name, variables, info) => {
-  const command = new Command(Object.assign({ name, variables, info }, command_defaults))
-  if (!base) base = command
-  return command
-}
-const setDefaults = data => command_defaults = data
-const middleware = (data) => data
-const option = (short, long, variables, info) => new Option({ short, long, variables, info })
-const parse = (array) => base.parse(array)
-
-module.exports = { command, middleware, option, parse, setDefaults }

package/src/helpers/findCommand.js

@@ -1,10 +0,0 @@
-module.exports = (array, commands) => {
-  let result
-  for (let command of commands) {
-    if (array[0] === command.name) {
-      array.shift()
-      return command
-    }
-  }
-  return null
-}

package/src/helpers/findCommandVariables.js

@@ -1,11 +0,0 @@
-const findVariables = require('./findVariables')
-
-module.exports = (array, command) => {
-  let variables = findVariables(null, array, command.variables, command.commandStrings)
-  if (variables[null]) variables = variables[null]
-  for (let key of Object.keys(variables)) {
-    if (variables[key] === true) delete variables[key]
-  }
-  if (Object.keys(variables).length === 0) return null
-  return variables
-}

package/src/helpers/findOption.js

@@ -1 +0,0 @@
-module.exports = (string, options) => options.find(o => o.short === string || o.long === string)

package/src/helpers/findOptions.js

@@ -1,39 +0,0 @@
-const findOption = require('./findOption'),
-  findVariables = require('./findVariables')
-
-module.exports = (array, command) => {
-  const options = command.optionsArray
-  const result = {}
-  while (array.length > 0 && array[0].startsWith('-')) {
-    if (array[0].startsWith('--')) {
-      let string = array.shift()
-      string = string.replace('--', '')
-      const option = findOption(string, options)
-      if (!option) throw new Error(`Unknown Option: --${string}`)
-      let vars
-      try {
-        vars = findVariables(option.long, array, option.variables, command.commandStrings)
-      } catch(err) {
-        err.message += ` for --${option.long}`
-        throw err
-      }
-      Object.assign(result, vars)
-    } else {
-      let string = array.shift()
-      const substring = string.slice(1, 2)
-      const option = findOption(substring, options)
-      if (!option) throw new Error(`Unknown Option: -${substring}`)
-      string = string.replace(substring, '')
-      if (string !== '-') array.unshift(string)
-      let vars
-      try {
-        vars = findVariables(option.long, array, option.variables, command.commandStrings)
-      } catch(err) {
-        err.message += ` for --${option.long}`
-        throw err
-      }
-      Object.assign(result, vars)
-    }
-  }
-  return result
-}

package/src/helpers/findVariable.js

@@ -1,15 +0,0 @@
-module.exports = (array, variable, commands) => {
-  let result
-  if (array.length > 0 && !array[0].startsWith('-') && !variable.array) {
-    if ((!commands.includes(array[0]) || variable.required) && array[0] !== 'help') result = array.shift()
-  } else if (array.length > 0 && variable.array) {
-    result = []
-    while(array.length > 0 && !array[0].startsWith('-')) {
-      if (commands.includes(array[0])) break
-      result.push(array.shift())
-    }
-  }
-  if (!result && variable.required) throw new Error(`Missing required variable <${variable.name}>`)
-  if (!result) result = true
-  return result
-}

package/src/helpers/findVariables.js

@@ -1,23 +0,0 @@
-const findVariable = require('./findVariable')
-
-module.exports = (base, array, variables, commands) => {
-  let result = {}
-  if (!variables) {
-    if (base) result[base] = true
-    return result
-  }
-  if (variables.length > 1) result[base] = {}
-  for (let variable of variables) {
-    let newVar = findVariable(array, variable, commands)
-    if (variables.length > 1) {
-      result[base][variable.name] = newVar
-    } else {
-      if (base) {
-        result[base] = newVar
-      } else {
-        result[variable.name] = newVar
-      }
-    }
-  }
-  return result
-}

package/src/helpers/getVariables.js

@@ -1,22 +0,0 @@
-let Variable = require('../models/Variable')
-
-module.exports = (string) => {
-  let results = []
-  let variables = string.split(' ')
-  for (let variable of variables) {
-    let raw = variable.trim()
-    if (variable.startsWith('<') && variable.endsWith('>')) {
-      variable = variable.replace('<', '').replace('>', '')
-      results.push(new Variable({name: variable, raw, required: true}))
-    } else if (variable.startsWith('[') && variable.endsWith('...]')) {
-      variable = variable.replace('[', '').replace('...]', '')
-      results.push(new Variable({array: true, name: variable, raw}))
-    } else if (variable.startsWith('[') && variable.endsWith(']')) {
-      variable = variable.replace('[', '').replace(']', '')
-      results.push(new Variable({name: variable, raw}))
-    } else {
-      throw `Unrecognized variable description: ${variable}`
-    }
-  }
-  return results
-}

package/src/helpers/index.js

@@ -1,17 +0,0 @@
-const findCommand = require('./findCommand'),
-  findCommandVariables = require('./findCommandVariables'),
-  findOption = require('./findOption'),
-  findOptions = require('./findOptions'),
-  findVariable = require('./findVariable'),
-  findVariables = require('./findVariables'),
-  getVariables = require('./getVariables')
-
-module.exports = {
-  findCommand,
-  findCommandVariables,
-  findOption,
-  findOptions,
-  findVariable,
-  findVariables,
-  getVariables
-}

package/src/index.js

@@ -1,5 +0,0 @@
-const config = require('./config'),
-  helpers = require('./helpers'),
-  models = require('./models')
-
-module.exports = { config, helpers, models }