v3.2.3-beta :: fix some edge cases

Author: Chinory

.npmignore

@@ -3,4 +3,5 @@
 LICENSE
 examples
 test.js
+poke.js
 README.md

README.md

@@ -58,7 +58,7 @@ function main() {
   const gitRes = {};
 
   // First parse to handle global options and identify subcommand
-  const ret = parse(process.argv, 2, gitReq, gitRes, errorHandler);
+  const ret = parse(process.argv, 2, gitReq, gitRes, console.log);
 
   // Handle help flag
   if (gitRes.help) {
@@ -79,7 +79,7 @@ function main() {
       case 'commit':
         // Parse commit-specific options starting from ret.i
         const commitRes = {};
-        parse(process.argv, ret.i, commitReq, commitRes, errorHandler);
+        parse(process.argv, ret.i, commitReq, commitRes, console.log);
 
         // Use the results
         console.log(
@@ -97,12 +97,6 @@ function main() {
     }
   }
 }
-
-// Error handler
-function errorHandler(err) {
-  console.error(`Error at arg ${err.i}: ${err.msg}`);
-  return false; // Continue parsing
-}
 ```
 
 ## 🛠️ API
@@ -132,7 +126,7 @@ The function returns either:
 {
   // Regular variable with default value and option definitions
   variableName: {
-    def: defaultValue,    // Required: Boolean, string, or string[]
+    def: defaultValue,     // Boolean, string, or string[]
     set: optionDefinition, // Options that set this variable
     rst: optionDefinition  // Options that reset this variable to default
   },
@@ -145,9 +139,7 @@ The function returns either:
 Option definitions can be:  
 - A string: `'--option'`  
 - An array: `['--option', '-o']`  
-- `null` (refers to the variable name)  
-
-Note: `undefined` is not supported. While it may work like `null` in `OptKit`, this is unintended. At `ExitKit`, `undefined` behaves differently from `null`.  
+- `null` refers to the variable name. `[null, ...]` is also supported.
 
 ## ⚡ Powerful Features
 
@@ -222,7 +214,7 @@ parse(['node', 'app.js', '-abc'], 2, {
   a: { def: false, set: '-a' },
   b: { def: false, set: '-b' },
   c: { def: false, set: '-c' }
-}, res, errorHandler);
+}, res, console.log);
 // res = { a: true, b: true, c: true }
 ```
 ```javascript
@@ -232,7 +224,7 @@ parse(['node', 'app.js', '-abcd'], 2, {
   b: { def: [], set: '-b' },
   c: { def: false, set: '-c' },
   d: { def: false, set: '-d' }
-}, res, errorHandler);
+}, res, console.log);
 // { a: true, b: [ 'cd' ], c: false, d: false }
 ```
 
@@ -252,7 +244,7 @@ const mainReq = {
 };
 
 const mainRes = {};
-const ret = parse(process.argv, 2, mainReq, mainRes, errorHandler);
+const ret = parse(process.argv, 2, mainReq, mainRes, console.log);
 
 if (typeof ret === 'object') {
   // When a command is found via the exit mechanism:
@@ -264,7 +256,7 @@ if (typeof ret === 'object') {
     case 'build':
       const buildReq = { /* build options */ };
       const buildRes = {};
-      parse(process.argv, ret.i, buildReq, buildRes, errorHandler);
+      parse(process.argv, ret.i, buildReq, buildRes, console.log);
       break;
   }
 }

index.js

@@ -1,25 +1,25 @@
 'use strict';
 const isA = Array.isArray;
 /**
- * @typedef {string} VarKey Variable name
+ * @typedef {string} KeyStr Variable name
  * @typedef {string | boolean | string[]} VarVal Variable value
  * @typedef {string} OptStr Option string, e.g. '--', '-o', '--option'
  * @typedef {OptStr | null} OptDef Option definitions, e.g. '--', '-o', '--option', or null to refer to the variable name
  * @typedef {OptDef | OptDef[]} OptKit one or more option definitions
  * 
  * @typedef {object} VarKit Variable configuration object
- * @property {VarVal} def Variable **def**inition & **def**ault value (pun intended)
+ * @property {VarVal} [def] Variable **def**inition & **def**ault value (pun intended)
  * @property {OptKit} [set] Array of options to set the variable value
  * @property {OptKit} [rst] Array of options to reset the variable value
  * 
  * @typedef {OptDef | OptDef[]} ExitKit Exit options, identical to `OptKit` for now
- * @typedef {Record<VarKey, VarKit | ExitKit>} KeyKitMap
- * @typedef {Record<VarKey, VarVal>} KeyValMap
+ * @typedef {Record<KeyStr, VarKit | ExitKit>} KeyKitMap
+ * @typedef {Record<KeyStr, VarVal>} KeyValMap
  * 
  * @callback IsFatal
- * @param {{msg: string, i: number, opt: OptStr, key?: VarKey, val?: VarVal }} err
+ * @param {{msg: string, i: number, opt: OptStr, key?: KeyStr, val?: VarVal }} err
  * @returns {boolean} Whether the parsing should continue (false) or quit (true)
- * @typedef {Record<OptStr, VarKey>} OptKeyMap internal type
+ * @typedef {Record<OptStr, KeyStr>} OptKeyMap internal type
  */
 /** Get OD! @param {OptKit} ok */
 const god = ok => ok === undefined ? [] : isA(ok) ? ok : [ok];
@@ -30,13 +30,13 @@ const god = ok => ok === undefined ? [] : isA(ok) ? ok : [ok];
  * @param {KeyKitMap} req Options structure definition
  * @param {KeyValMap} res Object to store parsed results
  * @param {IsFatal} err Error handler function, return true to quit parsing
- * @returns {number | { i: number, key: VarKey, opt: OptStr }}
+ * @returns {number | { i: number, key: KeyStr, opt: OptStr }}
  * @example
  */
 export default function parse(argv, i, req, res, err) {
 	/** @type {OptStr} option */
 	let opt = '';
-	/** @type {VarKey | undefined} key */
+	/** @type {KeyStr | undefined} key */
 	let key;
 	/** @param {VarVal} val */
 	const set = val => {
@@ -51,30 +51,32 @@ export default function parse(argv, i, req, res, err) {
 			res[key] = !def;
 			return false;
 		 } return true;
-	}, k = o => o == null ? key : o, // split undefined? hmm ugly
+	}, k = o => o == null ? key : o,
 	ask = (msg, val) => err({msg, i, opt, key, val}),
 	exit = c => ({ i: i + c, key, opt });
 	// prepare
 	/** @type {OptKeyMap} */
 	const set_ = {}, rst_ = {}, exit_ = {};
-	/** @type {VarKey | undefined} */
+	/** @type {KeyStr | undefined} */
 	let _key, _exit = false;
 	for (key in req) {
 		const vk = req[key];
-		X: { let xk; // stricter than god()
+		X: { let xk;
 			switch (typeof vk) {
 				case 'object':
 					if (vk === null) xk = [vk];
 					else if (isA(vk)) xk = vk; 
 					else break X; break;
-				case 'string': xk = [vk]; break;
-				default: continue; }
-			for (const o of xk) if (o!=='--') exit_[k(o)] = key; else _key = key, _exit = true;
+				case 'undefined': continue;
+				default: xk = [vk]; }
+			for (let o of xk) if ((o=k(o))!=='--') exit_[o] = key;
+				else _key = key, _exit = true;
 			continue; }
-		const def = vk.def;
+		const def = vk.def; // if (def === undefined) continue;
 		res[key] = isA(def) ? def.slice() : def;
-		for (const o of god(vk.set)) if (o!=='--') set_[k(o)] = key; else _key = key, _exit = false;
-		for (const o of god(vk.rst)) if (o!=='--') rst_[k(o)] = key; // do not reset around
+		for (let o of god(vk.set)) if ((o=k(o))!=='--') set_[o] = key;
+			else if (typeof def !== 'boolean') _key = key, _exit = false;
+		for (let o of god(vk.rst)) if ((o=k(o))!=='--') rst_[o] = key;
 	}
 	// process
 	let ext = false;
@@ -133,7 +135,8 @@ export default function parse(argv, i, req, res, err) {
 					default: set(v); continue; }
 			else if (key = rst_[opt]) t = 'reset';
 			else if (key = exit_[opt]) t = 'exit';
-			else if (ask('invalid option', v)) return i; else continue;
+			else if (ask('invalid option', v)) return i;
+			else continue;
 			if (ask(`cannot assign value to ${t} option`, v)) return i;
 			continue;
 		}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "pargv-lite",
-  "version": "3.2.2-beta",
+  "version": "3.2.3-beta",
   "description": "A lightning-fast, single-pass command line argument parser with structure validation",
   "main": "index.js",
   "type": "module",

poke.js

@@ -0,0 +1,86 @@
+'use strict';
+import parse from './index.js';
+
+const $ = console.log, e = a => $('💥', a), hr = '-'.repeat(42); $(hr);
+
+const poke = (title, argv, req) => {
+  $('🤓', title);
+  $('⌨️ ', argv.length, argv);
+  $('🔍', req);
+  const res = {}, ret = parse(argv, 0, req, res, e);
+  $('📖', res);
+  $('😇', ret);
+  $(hr);
+};
+
+poke('give all to a bool', ['awawaw'], {
+  bool: { def: false, set: ['--'] },
+}); // else if (typeof def !== 'boolean') _key = key, _exit = false;
+
+poke('My key is two dashes but I dont know how to set', ['awawaw', 'sdfsdf'], {
+  '--': { def: [], set: null },
+});
+
+poke('super long dash', ['awawaw', '-----D', 'sdfsdf'], {
+  '--': { def: [], set: null },
+  '-----D': null
+});
+
+poke('Set Bool Get Chain Bomb', ['-bawawaw', 'sdfsdf'], {
+  bool: { def: false, set: ['--', '-b'] },
+});
+
+poke('Assign Bool', ['--b=awawaw', 'sdfsdf'], {
+  bool: { def: false, set: ['--', '--b'] },
+});
+
+poke('Assign Bool + Pool', ['--b=awawaw', 'sdfsdf'], {
+  bool: { def: false, set: ['--', '--b'] },
+  pool: { def: [], set: ['--', '--b'] },
+}); // Overwritten all, which is expected behavior.
+
+poke('Assign Pool + Bool', ['--b=awawaw', 'sdfsdf'], {
+  pool: { def: [], set: ['--', '--b'] },
+  bool: { def: false, set: ['--', '--b'] },
+}); // bool only overwrites '--b', which is expected
+
+poke('My New Home is in Random Place After a b', ['--b=awawaw', 'sdfsdf'], {
+  '--': null
+});
+
+poke('My New Home is in Random Place', ['awawaw', 'sdfsdf'], {
+  '--': null
+});
+
+poke('My New Home is after two Dashes', ['--', 'awawaw', 'sdfsdf'], {
+  '--': null
+});
+
+poke('My New Home is An Empty Bad Guy', ['awawaw', 'sdfsdf'], {
+  good: { def: [], set: '--' },
+  home: { set: '--' }
+}); // if (def === undefined) continue;
+
+poke('My set is undefined', ['awawaw', 'sdfsdf'], {
+  '--': { def: [], set: undefined }
+});
+
+poke('My set is null', ['awawaw', 'sdfsdf'], {
+  '--': { def: [], set: null }
+});
+
+poke('My exit is [null]', ['awawaw', 'sdfsdf'], {
+  '--': [null]
+});
+
+poke('My exit is [undefined]', ['awawaw', 'sdfsdf'], {
+  '--': [undefined]
+}); // this is I said undefined acts like null in OptKit
+
+poke('My Dashes are undefined', ['awawaw', 'sdfsdf'], {
+  '--': undefined
+}); // Can't use undefined in ExitKit 
+
+poke('My Dashes are null', ['awawaw', 'sdfsdf'], {
+  '--': null
+}); // But null is ok

test.js

@@ -314,7 +314,7 @@ runTest('Exit on anonymous arguments', () => {
   if (typeof ret !== 'object') throw ret;
   assert.strictEqual(ret.key, 'files');
   assert.strictEqual(ret.opt, '1.txt');
-  assert.strictEqual(ret.i, 4);
+  assert.strictEqual(ret.i, 3);
 });
 
 console.log('🎉 All tests completed!');