@tkeron/commands 0.1.1 → 0.2.0

package/changelog.md

@@ -5,4 +5,3 @@
 # v0.1.0
 
 - passes positioned arguments to the callback in the second parameter.
-

package/dist/example.e2e.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/example.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+const commands = (0, _1.getCommands)("test program", "0.0.14")
+    .addCommand("com1")
+    .addAlias("c1")
+    .addOption("opt1")
+    .addOption("opt2")
+    .addDescription("command 001 test...")
+    .addPositionedArgument("pos0")
+    .addPositionedArgument("pos1")
+    .setCallback(console.log)
+    .commands()
+    .addCommand("com2")
+    .addAlias("c2")
+    .addAlias("a2")
+    .addOption("opt1")
+    .addDescription("command 002 test...")
+    .setCallback(console.log)
+    .commands()
+    .addCommand("com3")
+    .addAlias("c3")
+    .addOption("opt1")
+    .addOption("opt2", "exOpt2...")
+    .addOption("opt3")
+    .addDescription("command 003 test...")
+    .addPositionedArgument("pos0")
+    .addPositionedArgument("pos1")
+    .addPositionedArgument("pos3")
+    .setCallback(console.log)
+    .commands()
+    .addHeaderText("header...\n\n")
+    .addFooterText("\n\nFooter...");
+commands.start([
+    "",
+    "",
+    ..."com1 pos0value  opt1=qw111erty pos1value opt2=as222d  asdasd"
+        .replace(/\s+/g, " ")
+        .split(" "),
+]);
+commands.start([
+    "",
+    "",
+    ..."a2 pos0value  opt1=qw111erty pos1value opt2=as222d  asdasd"
+        .replace(/\s+/g, " ")
+        .split(" "),
+]);
+commands.start([
+    "",
+    "",
+    ..."c3 pos0value  opt1=qw111erty pos1value opt2=as222d  asdasd"
+        .replace(/\s+/g, " ")
+        .split(" "),
+]);
+globalThis.commands = commands;

package/dist/getCommandsFuncs.d.ts

@@ -0,0 +1,17 @@
+import { CommandFactory, Command, Commands, CommandsCollection, Callback } from "./types";
+export * from "./types";
+export declare const getCommands: (programName?: string, version?: string) => Commands;
+export declare const initCommands: (commandsCollection: CommandsCollection, commands?: Commands, commandFactory?: CommandFactory) => Commands;
+export declare const initHelpAndVersion: (commands: Commands, commandsCollection: CommandsCollection) => {
+    helpCallback: () => void;
+    versionCallback: () => void;
+};
+export declare const getAddCommand: (commandsCollection: CommandsCollection, commandFactory: CommandFactory) => (commandName: string) => CommandFactory;
+export declare const getAddAlias: (commandFactory: CommandFactory, commandsCollection: CommandsCollection) => (alias: string) => CommandFactory;
+export declare const getAddOption: (commandFactory: CommandFactory, commandsCollection: CommandsCollection) => (option: string, example?: string) => CommandFactory;
+export declare const getAddPositionedArgument: (commandFactory: CommandFactory, commandsCollection: CommandsCollection) => (arg: string) => CommandFactory;
+export declare const getSetCallback: (commandFactory: CommandFactory, commandsCollection: CommandsCollection) => (fn: Callback) => CommandFactory;
+export declare const getAddDescription: (commandFactory: CommandFactory, commandsCollection: CommandsCollection) => (description: string) => CommandFactory;
+export declare const getAddHeaderText: (commands: Commands) => (text: string) => Commands;
+export declare const getAddFooterText: (commands: Commands) => (text: string) => Commands;
+export declare const getGetHelpLine: (command: Command) => (width?: number) => string;

package/dist/getCommandsFuncs.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGetHelpLine = exports.getAddFooterText = exports.getAddHeaderText = exports.getAddDescription = exports.getSetCallback = exports.getAddPositionedArgument = exports.getAddOption = exports.getAddAlias = exports.getAddCommand = exports.initHelpAndVersion = exports.initCommands = exports.getCommands = void 0;
+const getStart_1 = require("./getStart");
+const textFuncs_1 = require("./textFuncs");
+__exportStar(require("./types"), exports);
+const getCommands = (programName = "program", version = "0.0.1") => {
+    const commandsCollection = {};
+    const commands = (0, exports.initCommands)(commandsCollection);
+    commands.programName = programName;
+    commands.version = version;
+    (0, exports.initHelpAndVersion)(commands, commandsCollection);
+    return commands;
+};
+exports.getCommands = getCommands;
+const initCommands = (commandsCollection, commands = {
+    programName: "",
+    version: "",
+    footerText: "",
+    headerText: "",
+    addCommand: undefined,
+    start: undefined,
+    addHeaderText: undefined,
+    addFooterText: undefined,
+}, commandFactory = {
+    commands: undefined,
+    name: undefined,
+    addAlias: undefined,
+    addOption: undefined,
+    addPositionedArgument: undefined,
+    addDescription: undefined,
+    setCallback: undefined,
+}) => {
+    if (!commandFactory.commands)
+        commandFactory.commands = () => commands;
+    commands.addCommand = (0, exports.getAddCommand)(commandsCollection, commandFactory);
+    commands.start = (0, getStart_1.getStart)(commandsCollection);
+    commands.addHeaderText = (0, exports.getAddHeaderText)(commands);
+    commands.addFooterText = (0, exports.getAddFooterText)(commands);
+    return commands;
+};
+exports.initCommands = initCommands;
+const initHelpAndVersion = (commands, commandsCollection) => {
+    const helpCallback = () => console["log"]((0, textFuncs_1.buildHelpText)(commands, commandsCollection));
+    const versionCallback = () => console["log"](`${commands.headerText || ""}\n${commands.version}\n${commands.footerText || ""}\n`);
+    commands
+        .addCommand("help")
+        .addAlias("-h")
+        .addAlias("--help")
+        .addDescription("show program help")
+        .setCallback(helpCallback);
+    commands
+        .addCommand("version")
+        .addAlias("-v")
+        .addAlias("--version")
+        .addDescription("show program version")
+        .setCallback(versionCallback);
+    return { helpCallback, versionCallback };
+};
+exports.initHelpAndVersion = initHelpAndVersion;
+const getAddCommand = (commandsCollection, commandFactory) => (commandName) => {
+    commandFactory.name = commandName;
+    const command = {
+        aliases: [],
+        callback: undefined,
+        description: "",
+        name: commandName,
+        options: [],
+        optionsExamples: [],
+        positionedArguments: [],
+        getHelpLine: undefined,
+    };
+    commandsCollection[commandName] = command;
+    command.getHelpLine = (0, exports.getGetHelpLine)(command);
+    commandFactory.addAlias = (0, exports.getAddAlias)(commandFactory, commandsCollection);
+    commandFactory.addOption = (0, exports.getAddOption)(commandFactory, commandsCollection);
+    commandFactory.addDescription = (0, exports.getAddDescription)(commandFactory, commandsCollection);
+    commandFactory.setCallback = (0, exports.getSetCallback)(commandFactory, commandsCollection);
+    commandFactory.addPositionedArgument = (0, exports.getAddPositionedArgument)(commandFactory, commandsCollection);
+    return commandFactory;
+};
+exports.getAddCommand = getAddCommand;
+const getAddAlias = (commandFactory, commandsCollection) => {
+    return (alias) => {
+        commandsCollection[commandFactory.name].aliases.push(alias);
+        commandsCollection[alias] = commandsCollection[commandFactory.name];
+        return commandFactory;
+    };
+};
+exports.getAddAlias = getAddAlias;
+const getAddOption = (commandFactory, commandsCollection) => (option, example) => {
+    commandsCollection[commandFactory.name].options.push(option);
+    commandsCollection[commandFactory.name].optionsExamples.push(example || "");
+    return commandFactory;
+};
+exports.getAddOption = getAddOption;
+const getAddPositionedArgument = (commandFactory, commandsCollection) => {
+    return (arg) => {
+        const positionedArguments = commandsCollection[commandFactory.name].positionedArguments;
+        if (!positionedArguments.includes(commandFactory.name)) {
+            positionedArguments.push(arg);
+        }
+        return commandFactory;
+    };
+};
+exports.getAddPositionedArgument = getAddPositionedArgument;
+const getSetCallback = (commandFactory, commandsCollection) => {
+    return (fn) => {
+        commandsCollection[commandFactory.name].callback = fn;
+        return commandFactory;
+    };
+};
+exports.getSetCallback = getSetCallback;
+const getAddDescription = (commandFactory, commandsCollection) => {
+    return (description) => {
+        commandsCollection[commandFactory.name].description = description;
+        return commandFactory;
+    };
+};
+exports.getAddDescription = getAddDescription;
+const getAddHeaderText = (commands) => {
+    return (text) => {
+        commands.headerText = text;
+        return commands;
+    };
+};
+exports.getAddHeaderText = getAddHeaderText;
+const getAddFooterText = (commands) => {
+    return (text) => {
+        commands.footerText = text;
+        return commands;
+    };
+};
+exports.getAddFooterText = getAddFooterText;
+const getGetHelpLine = (command) => (width = 50) => {
+    let helpLine = (0, textFuncs_1.getCommandText)(command).padEnd(width, ".") +
+        "  " +
+        command.description +
+        "\n";
+    return helpLine;
+};
+exports.getGetHelpLine = getGetHelpLine;

package/dist/getCommandsFuncs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/getStart.d.ts

@@ -0,0 +1,2 @@
+import { CommandsCollection } from "./types";
+export declare const getStart: (commandsCollection: CommandsCollection) => (argv?: string[]) => void;

package/dist/getStart.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStart = void 0;
+const getStart = (commandsCollection) => (argv) => {
+    if (!argv)
+        argv = process.argv;
+    if (!Array.isArray(argv))
+        throw new Error("no arguments passed");
+    if (argv.length < 2)
+        throw Error("arguments out of range");
+    argv = argv.slice(2);
+    if (argv.length === 0) {
+        commandsCollection.help.callback();
+        return;
+    }
+    const commandName = argv[0];
+    const command = commandsCollection[commandName];
+    if (!command) {
+        console["log"](`command '${commandName}' not found`);
+        return;
+    }
+    const options = argv
+        .slice(1)
+        .filter((arg) => /\=/g.test(arg))
+        .map((arg) => arg.split("="))
+        .reduce((p, c) => {
+        p[c[0]] = c[1];
+        return p;
+    }, {});
+    const positionedArgsValues = argv
+        .slice(1)
+        .filter((arg) => !/\=/g.test(arg));
+    if (positionedArgsValues.length <= command.positionedArguments.length) {
+        positionedArgsValues.forEach((arg, n) => (options[command.positionedArguments[n]] = arg));
+    }
+    if (positionedArgsValues.length > command.positionedArguments.length) {
+        console["log"](`argument${positionedArgsValues.length - command.positionedArguments.length === 1
+            ? ""
+            : "s"} '${positionedArgsValues
+            .slice(command.positionedArguments.length)
+            .join(", ")}' not defined`);
+        return;
+    }
+    command.callback(options);
+};
+exports.getStart = getStart;

package/dist/getStart.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -1,26 +1 @@
-export interface CommandHandler {
-    name: string;
-    aliases: string[];
-    options: string[];
-    callback: Callback;
-}
-export type Options = {
-    [key: string]: CommandHandler;
-};
-export type parsedOptions = {
-    [key: string]: string;
-};
-export type Callback = (options: parsedOptions) => void;
-export interface Command {
-    name: string;
-    next: () => Commands;
-    addAliases: (...alias: string[]) => Command;
-    addOptions: (...options: string[]) => Command;
-    addPositionedArgument: (arg: string) => Command;
-    setCallback: (callback: Callback) => Command;
-}
-export interface Commands {
-    addCommand: (commandName: string) => Command;
-    run: () => void;
-}
-export declare const getCommands: () => Commands;
+export { getCommands } from "./getCommandsFuncs";

package/dist/index.js

@@ -1,91 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCommands = void 0;
-const _commands = {};
-const orderedArgumentNames = [];
-const run = () => {
-    const currentCommands = process.argv.slice(2);
-    const parsedOptions = currentCommands
-        .join(" ")
-        .match(/(\w+[:=]\w+)/g)
-        ?.reduce((p, c) => {
-        const [k, v] = c.split(/[:=]/);
-        p[k] = v;
-        return p;
-    }, {});
-    const orderedArguments = currentCommands?.filter((c) => !/[:=-]/g.test(c));
-    if (orderedArguments &&
-        orderedArguments.length &&
-        Object.keys(_commands).includes(orderedArguments[0]))
-        orderedArguments.shift();
-    const orderedOptions = {};
-    if (orderedArguments &&
-        orderedArguments.length > 0 &&
-        orderedArgumentNames.length === orderedArguments.length) {
-        orderedArgumentNames.forEach((key, n) => {
-            orderedOptions[key] = orderedArguments[n];
-        });
-    }
-    for (const commandIndex of currentCommands) {
-        const command = _commands[commandIndex];
-        if (!command)
-            continue;
-        const options = {
-            ...orderedOptions,
-            ...(parsedOptions && command.options
-                ? command.options.reduce((p, c) => {
-                    p[c] = parsedOptions[c];
-                    return p;
-                }, {})
-                : {}),
-        };
-        command.callback(options);
-    }
-};
-const getCommands = () => {
-    const commands = {
-        run,
-        addCommand: undefined,
-    };
-    commands.addCommand = (name) => {
-        const command = {
-            name,
-            addAliases: undefined,
-            addOptions: undefined,
-            addPositionedArgument: undefined,
-            next: undefined,
-            setCallback: undefined,
-        };
-        _commands[name] = {
-            name,
-            callback: undefined,
-            aliases: [],
-            options: [],
-        };
-        command.next = () => commands;
-        command.addAliases = (...alias) => {
-            _commands[name].aliases = [..._commands[name].aliases, ...alias];
-            alias.forEach((alias) => {
-                _commands[alias] = _commands[name];
-            });
-            return command;
-        };
-        command.addOptions = (...options) => {
-            options.forEach((option) => {
-                _commands[name].options.push(option);
-            });
-            return command;
-        };
-        command.setCallback = (callback) => {
-            _commands[name].callback = callback;
-            return command;
-        };
-        command.addPositionedArgument = (arg) => {
-            orderedArgumentNames.push(arg);
-            return command;
-        };
-        return command;
-    };
-    return commands;
-};
-exports.getCommands = getCommands;
+var getCommandsFuncs_1 = require("./getCommandsFuncs");
+Object.defineProperty(exports, "getCommands", { enumerable: true, get: function () { return getCommandsFuncs_1.getCommands; } });

package/dist/testConstants.d.ts

@@ -0,0 +1,4 @@
+import { Command, Commands, CommandsCollection } from "./types";
+export declare const command: Command;
+export declare const commands: Commands;
+export declare const commandsCollection: CommandsCollection;

package/dist/testConstants.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandsCollection = exports.commands = exports.command = void 0;
+exports.command = {
+    name: "command_1",
+    aliases: ["al1", "al2"],
+    callback: undefined,
+    description: "command 1 description",
+    getHelpLine: () => "help line...\n",
+    options: ["op1", "op2"],
+    optionsExamples: ["opEx1"],
+    positionedArguments: ["pos1", "pos2"],
+};
+exports.commands = {
+    headerText: "header text...",
+    footerText: "footer text...",
+};
+exports.commandsCollection = {
+    command_1: exports.command,
+    al1: exports.command,
+    al2: exports.command,
+    command_2: {
+        ...exports.command,
+        name: "command_2",
+        description: "command 2 description",
+        aliases: [],
+    },
+    help: {
+        ...exports.command,
+        name: "help",
+        callback: () => console["log"]("help text..."),
+    },
+};

package/dist/textFuncs.d.ts

@@ -0,0 +1,4 @@
+import { Command, Commands, CommandsCollection } from "./types";
+export declare const buildHelpText: (commands: Commands, commandsCollection: CommandsCollection) => string;
+export declare const buildDescriptionsText: (commandsCollection: CommandsCollection) => string;
+export declare const getCommandText: (command: Command) => string;

package/dist/textFuncs.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommandText = exports.buildDescriptionsText = exports.buildHelpText = void 0;
+const buildHelpText = (commands, commandsCollection) => {
+    let descriptions = (0, exports.buildDescriptionsText)(commandsCollection);
+    const helpText = `\n${(commands.headerText.length > 0 && commands.headerText) || ""}\n${descriptions}${(commands.footerText.length > 0 && commands.footerText) || ""}\n`;
+    return helpText;
+};
+exports.buildHelpText = buildHelpText;
+const buildDescriptionsText = (commandsCollection) => {
+    let descriptions = "";
+    let max = 0;
+    const ready = [];
+    for (const com of Object.values(commandsCollection)) {
+        const commandText = (0, exports.getCommandText)(com);
+        if (commandText.length > max)
+            max = commandText.length;
+    }
+    for (const com of Object.values(commandsCollection)) {
+        if (ready.includes(com.name))
+            continue;
+        descriptions += com.getHelpLine(max + 4);
+        ready.push(com.name);
+    }
+    return descriptions;
+};
+exports.buildDescriptionsText = buildDescriptionsText;
+const getCommandText = (command) => {
+    const names = [command.name, ...command.aliases].join("|");
+    const args = command.positionedArguments.map((a) => `[${a}]`).join(" ");
+    const options = command.options
+        .map((o, n) => `[${o}=${command.optionsExamples[n] || "VALUE"}]`)
+        .join(" ");
+    return `${names}   ${args}   ${options}`.trim() + "  ";
+};
+exports.getCommandText = getCommandText;

package/dist/textFuncs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -0,0 +1,39 @@
+export interface Command {
+    name: string;
+    description: string;
+    aliases: string[];
+    options: string[];
+    optionsExamples: string[];
+    positionedArguments: string[];
+    getHelpLine: (width?: number) => string;
+    callback: Callback;
+}
+export type parsedOptions = {
+    [key: string]: string;
+};
+export type Callback = (options?: parsedOptions) => void;
+export type CommandsCollection = {
+    [key: string]: Command;
+};
+export type OrderedArgumentNames = {
+    [key: string]: string[];
+};
+export interface CommandFactory {
+    name: string;
+    commands: () => Commands;
+    addAlias: (alias: string) => CommandFactory;
+    addDescription: (description: string) => CommandFactory;
+    addOption: (option: string, example?: string) => CommandFactory;
+    addPositionedArgument: (arg: string) => CommandFactory;
+    setCallback: (callback: Callback) => CommandFactory;
+}
+export interface Commands {
+    addCommand: (commandName: string) => CommandFactory;
+    programName: string;
+    headerText: string;
+    footerText: string;
+    version: string;
+    addHeaderText: (text: string) => Commands;
+    addFooterText: (text: string) => Commands;
+    start: (argv?: string[]) => void;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/jest.config.js

@@ -0,0 +1,8 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  verbose: true,
+  collectCoverage: true,
+  testRegex: ".test.ts$",
+};

package/package.json

@@ -1,27 +1,30 @@
-{
-  "name": "@tkeron/commands",
-  "version": "0.1.1",
-  "description": "node library for handling command line arguments",
-  "main": "dist/index.js",
-  "scripts": {
-    "build": "tsc",
-    "test": "jest --roots dist --detectOpenHandles --coverage --verbose "
-  },
-  "author": "tkeron",
-  "license": "MIT",
-  "devDependencies": {
-    "@types/jest": "^29.2.4",
-    "@types/node": "^18.11.12",
-    "jest": "^29.3.1",
-    "typescript": "^4.9.4"
-  },
-  "keywords": [
-    "cli",
-    "commands",
-    "command-line",
-    "arguments"
-  ],
-  "repository": {
-    "url": "git@github.com:tkeron/tkeron.git"
-  }
-}
+{
+  "name": "@tkeron/commands",
+  "version": "0.2.0",
+  "description": "node library for handling command line arguments",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "prettier --write ."
+  },
+  "author": "tkeron",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.6",
+    "@types/node": "^18.11.12",
+    "jest": "^29.3.1",
+    "prettier": "^3.0.3",
+    "ts-jest": "^29.1.1",
+    "typescript": "^4.9.4"
+  },
+  "keywords": [
+    "cli",
+    "commands",
+    "command-line",
+    "arguments"
+  ],
+  "repository": {
+    "url": "git@github.com:tkeron/tkeron.git"
+  }
+}

package/readme.md

@@ -1,3 +1,3 @@
 # Tkeron Commands
 
-        Simple package to evaluate cli arguments, with minimun dependencies.
+        Simple package to evaluate cli arguments, with minimun dependencies.

package/tsconfig.json

@@ -1,15 +1,15 @@
-{
-  "compilerOptions": {
-    "module": "NodeNext",
-    "outDir": "dist",
-    "target": "ESNext",
-    "esModuleInterop": true,
-    "declaration": true
-  },
-  "exclude": [
-    "node_modules"
-  ],
-  "include": [
-    "src"
-  ]
-}
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "outDir": "dist",
+    "target": "ESNext",
+    "esModuleInterop": true,
+    "declaration": true
+  },
+  "exclude": [
+    "node_modules"
+  ],
+  "include": [
+    "src"
+  ]
+}