@tkeron/commands 0.0.2 → 0.1.1

package/changelog.md

@@ -0,0 +1,8 @@
+# v0.1.1
+
+- fixed commands ordered arguments
+
+# v0.1.0
+
+- passes positioned arguments to the callback in the second parameter.
+

package/dist/index.d.ts

@@ -2,14 +2,22 @@ export interface CommandHandler {
     name: string;
     aliases: string[];
     options: string[];
-    callback: CallableFunction;
+    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;
-    setCallback: (callback: CallableFunction) => Command;
+    addPositionedArgument: (arg: string) => Command;
+    setCallback: (callback: Callback) => Command;
 }
 export interface Commands {
     addCommand: (commandName: string) => Command;

package/dist/index.js

@@ -2,6 +2,7 @@
 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
@@ -12,16 +13,32 @@ const run = () => {
         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 = parsedOptions && command.options
-            ? command.options.reduce((p, c) => {
-                p[c] = parsedOptions[c];
-                return p;
-            }, {})
-            : {};
+        const options = {
+            ...orderedOptions,
+            ...(parsedOptions && command.options
+                ? command.options.reduce((p, c) => {
+                    p[c] = parsedOptions[c];
+                    return p;
+                }, {})
+                : {}),
+        };
         command.callback(options);
     }
 };
@@ -35,6 +52,7 @@ const getCommands = () => {
             name,
             addAliases: undefined,
             addOptions: undefined,
+            addPositionedArgument: undefined,
             next: undefined,
             setCallback: undefined,
         };
@@ -62,6 +80,10 @@ const getCommands = () => {
             _commands[name].callback = callback;
             return command;
         };
+        command.addPositionedArgument = (arg) => {
+            orderedArgumentNames.push(arg);
+            return command;
+        };
         return command;
     };
     return commands;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tkeron/commands",
-  "version": "0.0.2",
+  "version": "0.1.1",
   "description": "node library for handling command line arguments",
   "main": "dist/index.js",
   "scripts": {