command-line-director 1.0.2 → 2.0.0-beta.1

package/CHANGELOG

@@ -4,6 +4,11 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [1.0.3] - 2025-01-12
+
+### Fixes
+- Bump versions
+
 ## [1.0.2] - 2025-30-11
 
 ### Fixes

package/dist/index.d.ts

@@ -0,0 +1,121 @@
+declare class ArgumentLookup {
+    values: string[];
+    keyValues: Map<string, string | number | boolean | null>;
+    constructor();
+}
+
+declare enum CommandLineArgumentDataType {
+    Boolean = 0,
+    Number = 1,
+    String = 2
+}
+
+declare enum CommandLineArgumentType {
+    KeyValue = 0,
+    Value = 1
+}
+
+declare class CommandLineArgument {
+    propertyName: string;
+    required: boolean;
+    argumentName: string | null;
+    alias: string | null;
+    dataType: CommandLineArgumentDataType;
+    type: CommandLineArgumentType;
+    defaultValue: string | number | boolean | null;
+    allowedValues: string[] | number[] | boolean[] | null;
+    regularExpression: RegExp | null;
+    description: string | null;
+    constructor(propertyName: string, required: boolean, argumentName: string | null, alias: string | null, dataType: CommandLineArgumentDataType | null, type: CommandLineArgumentType, defaultValue?: string | number | boolean | null, allowedValues?: string[] | number[] | boolean[] | null, regularExpression?: RegExp | null, description?: string | null);
+    toString(): string;
+}
+
+declare class Command {
+    identifier: string;
+    commandLineArguments: Array<CommandLineArgument>;
+    values: Map<string, string | number | boolean | null>;
+    constructor(identifier: string, commandLineArguments: Array<CommandLineArgument>, values: Map<string, string | number | boolean | null>);
+}
+
+declare class CommandLine {
+    identifier: string;
+    title: string;
+    description: string;
+    commandLineArguments: CommandLineArgument[];
+    /**
+       * CommandLine constructor
+       * @param identifier - string
+       * @param commandLineArguments - array
+       * @thows Error
+       */
+    constructor(identifier: string, title: string, description: string, commandLineArguments: CommandLineArgument[]);
+    /**
+       * Create lookup table for process arguments
+       * @result object
+       */
+    private parseDataType;
+    /**
+       * Create command from argument lookup
+       * @param argument lookup
+       * @result command
+       * @throws Error
+       */
+    commandFromLookup(argumentLookup: ArgumentLookup): Command;
+}
+
+declare class CommandLineArgumentFactory {
+    /**s
+     * Create string argument
+     * Examples:
+     * --dir="/var/www/test"
+     * -d="/var/www/test"
+     *
+     * @param propertyName - string
+     * @param description - string
+     * @param required - boolean
+     * @param argumentName - string
+     * @param alias - string
+     * @param defaultValue - any
+     * @param allowedValues
+     * @param regularExpression
+     */
+    keyValueArgument(propertyName: string, description: string, required: boolean, argumentName: string, alias: string, defaultValue?: string | number | boolean | null, allowedValues?: string[] | number[] | boolean[] | null, regularExpression?: RegExp | null): CommandLineArgument;
+    /**
+     * Create boolean argument
+     * Examples:
+     * --force
+     * -f
+     *
+     * @param propertyName - string
+     * @param description - string
+     * @param argumentName - string
+     * @param alias - string
+     */
+    flagArgument(propertyName: string, description: string, argumentName: string, alias: string): CommandLineArgument;
+    /**
+     * Create command
+     * Examples:
+     * init
+     *
+     * @param propertyName - string
+     * @param description
+     * @param required - boolean
+     * @param allowedValues
+     * @param regularExpression
+     */
+    valueArgument(propertyName: string, description: string, required: boolean, allowedValues?: string[] | number[] | boolean[] | null, regularExpression?: RegExp | null): CommandLineArgument;
+}
+
+declare class CommandLineDirector {
+    private title;
+    private description;
+    private commandLines;
+    constructor(title: string, description: string, commandLines: CommandLine[]);
+    private removeQuotes;
+    private createArgumentLookupFromProcessArguments;
+    parseArguments(cmdArguments: string[], verbose: boolean): Command | null;
+    parse(verbose?: boolean): Command | null;
+    generateHelp(): string;
+}
+
+export { ArgumentLookup, Command, CommandLine, CommandLineArgument, CommandLineArgumentDataType, CommandLineArgumentFactory, CommandLineArgumentType, CommandLineDirector };

package/dist/index.js

@@ -0,0 +1,393 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ArgumentLookup: () => ArgumentLookup,
+  Command: () => Command,
+  CommandLine: () => CommandLine,
+  CommandLineArgument: () => CommandLineArgument,
+  CommandLineArgumentDataType: () => CommandLineArgumentDataType,
+  CommandLineArgumentFactory: () => CommandLineArgumentFactory,
+  CommandLineArgumentType: () => CommandLineArgumentType,
+  CommandLineDirector: () => CommandLineDirector
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/argument-lookup.ts
+var ArgumentLookup = class {
+  constructor() {
+    this.values = [];
+    this.keyValues = /* @__PURE__ */ new Map();
+  }
+};
+
+// src/command.ts
+var Command = class {
+  constructor(identifier, commandLineArguments, values) {
+    this.identifier = identifier;
+    this.commandLineArguments = commandLineArguments;
+    this.values = values;
+  }
+};
+
+// src/command-line-argument-data-type.ts
+var CommandLineArgumentDataType = /* @__PURE__ */ ((CommandLineArgumentDataType2) => {
+  CommandLineArgumentDataType2[CommandLineArgumentDataType2["Boolean"] = 0] = "Boolean";
+  CommandLineArgumentDataType2[CommandLineArgumentDataType2["Number"] = 1] = "Number";
+  CommandLineArgumentDataType2[CommandLineArgumentDataType2["String"] = 2] = "String";
+  return CommandLineArgumentDataType2;
+})(CommandLineArgumentDataType || {});
+
+// src/command-line-argument-type.ts
+var CommandLineArgumentType = /* @__PURE__ */ ((CommandLineArgumentType2) => {
+  CommandLineArgumentType2[CommandLineArgumentType2["KeyValue"] = 0] = "KeyValue";
+  CommandLineArgumentType2[CommandLineArgumentType2["Value"] = 1] = "Value";
+  return CommandLineArgumentType2;
+})(CommandLineArgumentType || {});
+
+// src/command-line.ts
+var CommandLine = class {
+  /**
+     * CommandLine constructor
+     * @param identifier - string
+     * @param commandLineArguments - array
+     * @thows Error
+     */
+  constructor(identifier, title, description, commandLineArguments) {
+    this.identifier = identifier;
+    this.title = title;
+    this.description = description;
+    this.commandLineArguments = [];
+    if (Array.isArray(commandLineArguments)) {
+      this.commandLineArguments = commandLineArguments;
+    } else {
+      throw new Error("Invalid argument 'commandLineArguments', value should be of type 'array'");
+    }
+  }
+  /**
+     * Create lookup table for process arguments
+     * @result object
+     */
+  parseDataType(value, dataType) {
+    let parsedValue = null;
+    if (value !== void 0 && value !== null) {
+      switch (dataType) {
+        case 0 /* Boolean */:
+          parsedValue = Boolean(value);
+          break;
+        case 1 /* Number */:
+          parsedValue = Number(value);
+          if (isNaN(parsedValue)) {
+            parsedValue = null;
+          }
+          break;
+        case 2 /* String */:
+          parsedValue = String(value);
+          break;
+        default: {
+          throw new Error(`Unknown data type '${dataType}.`);
+        }
+      }
+      if (parsedValue === null) {
+        throw new Error(`Could not parse value '${value}' to data type '${dataType}.`);
+      }
+    }
+    return parsedValue;
+  }
+  /**
+     * Create command from argument lookup
+     * @param argument lookup
+     * @result command
+     * @throws Error
+     */
+  commandFromLookup(argumentLookup) {
+    const result = /* @__PURE__ */ new Map();
+    const values = argumentLookup.values;
+    const keyValues = argumentLookup.keyValues;
+    let valueIndex = 0;
+    this.commandLineArguments.forEach((arg) => {
+      var _a, _b, _c;
+      if (arg.type === 0 /* KeyValue */) {
+        if (arg.argumentName && keyValues.has(arg.argumentName)) {
+          result.set(arg.propertyName, (_a = keyValues.get(arg.argumentName)) != null ? _a : null);
+        } else if (arg.alias && keyValues.has(arg.alias)) {
+          result.set(arg.propertyName, (_b = keyValues.get(arg.alias)) != null ? _b : null);
+        }
+      } else if (arg.type === 1 /* Value */) {
+        if (values.length > valueIndex) {
+          result.set(arg.propertyName, values[valueIndex]);
+          valueIndex++;
+        }
+      } else {
+        throw new Error("Invalid command line argument type");
+      }
+      if (result.has(arg.propertyName) === false && arg.defaultValue !== null) {
+        result.set(arg.propertyName, arg.defaultValue);
+      }
+      if (result.has(arg.propertyName)) {
+        result.set(arg.propertyName, this.parseDataType((_c = result.get(arg.propertyName)) != null ? _c : null, arg.dataType));
+      }
+    });
+    this.commandLineArguments.forEach(function(arg) {
+      var _a;
+      if (arg.required === true && (result.get(arg.propertyName) === void 0 || result.get(arg.propertyName) === null)) {
+        throw new Error(`Required field '${arg.propertyName}' is missing.`);
+      }
+      if (arg.allowedValues && arg.allowedValues.length > 0 && (arg.required === true || result.has(arg.propertyName) && result.get(arg.propertyName) !== null)) {
+        if (((_a = arg.allowedValues) == null ? void 0 : _a.indexOf(result.get(arg.propertyName))) === -1) {
+          throw new Error(`Value for field '${arg.propertyName}' is not allowed.`);
+        }
+      }
+      ;
+      if (arg.regularExpression && (arg.required === true || result.has(arg.propertyName) && result.get(arg.propertyName) !== null)) {
+        if (!arg.regularExpression.test(result.get(arg.propertyName))) {
+          throw new Error(`Value for field field '${arg.propertyName}' is invalid.`);
+        }
+      }
+    });
+    return new Command(this.identifier, this.commandLineArguments, result);
+  }
+};
+
+// src/command-line-argument.ts
+var CommandLineArgument = class {
+  constructor(propertyName, required, argumentName, alias, dataType, type, defaultValue = null, allowedValues = null, regularExpression = null, description = null) {
+    if (!propertyName) {
+      throw new Error("'propertyName' parameter not defined.");
+    }
+    if (required === void 0 || required === null) {
+      throw new Error("'required' parameter not defined.");
+    }
+    if (type !== 0 /* KeyValue */ && type !== 1 /* Value */) {
+      throw new Error("'type' parameter invalid.");
+    }
+    if (!argumentName && type === 0 /* KeyValue */) {
+      throw new Error("'argumentName' parameter not defined.");
+    }
+    if (allowedValues && Array.isArray(allowedValues) === false) {
+      throw new Error("'allowedValues' parameter should be an array.");
+    }
+    this.propertyName = propertyName;
+    this.required = Boolean(required);
+    this.argumentName = argumentName;
+    this.alias = alias !== void 0 ? alias : "";
+    this.dataType = dataType != null ? dataType : 2 /* String */;
+    this.type = type;
+    this.defaultValue = defaultValue;
+    this.allowedValues = allowedValues != null ? allowedValues : [];
+    this.regularExpression = regularExpression != null ? regularExpression : null;
+    this.description = description;
+  }
+  toString() {
+    let help = "";
+    let title = "";
+    if (this.argumentName) {
+      title = `  ${this.argumentName},${this.alias}`;
+    } else if (this.allowedValues) {
+      title = `  ${this.allowedValues}`;
+    } else {
+      title = "  <string>";
+    }
+    help += title;
+    for (let i = 0; i < 24 - title.length; i++) {
+      help += " ";
+    }
+    help += ` ${this.required ? "R" : "O"} | ${this.dataType}`;
+    if (this.argumentName && this.allowedValues) {
+      help += ` | VALUES = ${this.allowedValues}`;
+    }
+    if (this.regularExpression) {
+      help += ` | PATTERN = ${this.regularExpression.toString()}`;
+    }
+    help += ` | ${this.description}`;
+    return help;
+  }
+};
+
+// src/command-line-argument-factory.ts
+var CommandLineArgumentFactory = class {
+  /**s
+   * Create string argument
+   * Examples:
+   * --dir="/var/www/test"
+   * -d="/var/www/test"
+   *
+   * @param propertyName - string
+   * @param description - string
+   * @param required - boolean
+   * @param argumentName - string
+   * @param alias - string
+   * @param defaultValue - any
+   * @param allowedValues
+   * @param regularExpression
+   */
+  keyValueArgument(propertyName, description, required, argumentName, alias, defaultValue = null, allowedValues = null, regularExpression = null) {
+    return new CommandLineArgument(
+      propertyName,
+      required,
+      argumentName,
+      alias,
+      2 /* String */,
+      0 /* KeyValue */,
+      defaultValue,
+      allowedValues,
+      regularExpression,
+      description
+    );
+  }
+  /**
+   * Create boolean argument
+   * Examples:
+   * --force
+   * -f
+   *
+   * @param propertyName - string
+   * @param description - string
+   * @param argumentName - string
+   * @param alias - string
+   */
+  flagArgument(propertyName, description, argumentName, alias) {
+    return new CommandLineArgument(
+      propertyName,
+      false,
+      argumentName,
+      alias,
+      0 /* Boolean */,
+      0 /* KeyValue */,
+      false,
+      null,
+      null,
+      description
+    );
+  }
+  /**
+   * Create command
+   * Examples:
+   * init
+   *
+   * @param propertyName - string
+   * @param description
+   * @param required - boolean
+   * @param allowedValues
+   * @param regularExpression
+   */
+  valueArgument(propertyName, description, required, allowedValues = null, regularExpression = null) {
+    return new CommandLineArgument(
+      propertyName,
+      required,
+      null,
+      null,
+      2 /* String */,
+      1 /* Value */,
+      null,
+      allowedValues,
+      regularExpression,
+      description
+    );
+  }
+};
+
+// src/command-line-director.ts
+var CommandLineDirector = class {
+  constructor(title, description, commandLines) {
+    this.title = title;
+    this.description = description;
+    if (Array.isArray(commandLines)) {
+      this.commandLines = commandLines;
+    } else {
+      throw new Error("Invalid argument 'commandLines', value should be of type 'array'");
+    }
+  }
+  removeQuotes(text) {
+    return text.replace(/['"]+/g, "");
+  }
+  createArgumentLookupFromProcessArguments(cmdArguments) {
+    const lookup = new ArgumentLookup();
+    cmdArguments.forEach((cmdArgument) => {
+      const keyValue = cmdArgument.split("=");
+      if (typeof keyValue[0] === "string" && keyValue[0].charAt(0) === "-") {
+        const value = keyValue.length === 2 ? this.removeQuotes(keyValue[1]) : true;
+        const keyName = keyValue[0];
+        lookup.keyValues.set(keyName, value);
+      } else {
+        lookup.values.push(this.removeQuotes(cmdArgument));
+      }
+    });
+    return lookup;
+  }
+  parseArguments(cmdArguments, verbose) {
+    const lookup = this.createArgumentLookupFromProcessArguments(cmdArguments);
+    let command = null;
+    for (let i = 0; i < this.commandLines.length; i++) {
+      const commandLine = this.commandLines[i];
+      try {
+        command = commandLine.commandFromLookup(lookup);
+        break;
+      } catch (error) {
+        if (verbose) {
+          if (error instanceof Error) {
+            console.info(error.message);
+          } else {
+            console.info(String(error));
+          }
+        }
+        command = null;
+      }
+    }
+    ;
+    return command;
+  }
+  parse(verbose = false) {
+    return this.parseArguments(process.argv.slice(2), verbose);
+  }
+  generateHelp() {
+    let help = "\r\n=======================================================================\r\n";
+    help += `\r
+${this.title.toUpperCase()}\r
+${this.description}\r
+\r
+`;
+    for (const commandLine of this.commandLines) {
+      help += "-----------------------------------------------------------------------\r\n";
+      help += `${commandLine.title.toUpperCase()} - ${commandLine.description}\r
+\r
+`;
+      for (const argument of commandLine.commandLineArguments) {
+        help += `${argument.toString()}\r
+`;
+      }
+      help += "\r\n";
+    }
+    help += "=======================================================================\r\n";
+    return help;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArgumentLookup,
+  Command,
+  CommandLine,
+  CommandLineArgument,
+  CommandLineArgumentDataType,
+  CommandLineArgumentFactory,
+  CommandLineArgumentType,
+  CommandLineDirector
+});