argv-flags 0.1.0 → 0.2.0

package/README.md

@@ -1 +1,52 @@
 # argv-flags
+
+Tiny helper for parsing simple CLI flags from `process.argv`.
+
+## Installation
+
+```sh
+npm install argv-flags
+```
+
+## Usage
+
+```js
+const parseFlag = require('argv-flags');
+
+const name = parseFlag('--name', 'string');
+const enabled = parseFlag('--enabled', 'boolean');
+const count = parseFlag('--count', 'number');
+const items = parseFlag('--items', 'array');
+```
+
+### Boolean flags
+
+Boolean flags accept explicit values when provided:
+
+```sh
+--enabled true
+--enabled false
+```
+
+If no value is provided, the presence of the flag returns `true`.
+
+### Array flags
+
+Array flags collect values until the next `--flag`:
+
+```sh
+--items a b c --other
+```
+
+### Testing / custom argv
+
+You can pass a custom argv array (useful for tests):
+
+```js
+const argv = ['node', 'script.js', '--flag', 'true'];
+parseFlag('--flag', 'boolean', argv);
+```
+
+## License
+
+MIT

package/index.d.ts

@@ -0,0 +1,7 @@
+declare function parseFlag(
+	flag: string,
+	type?: 'string' | 'boolean' | 'array' | 'number',
+	argv?: string[]
+): string | boolean | string[] | number | false;
+
+export = parseFlag;

package/index.js

@@ -1,41 +1,67 @@
-function parseFlag ( targetArgument, argumentType ) {
-	const processArguments = process.argv;
-	let argsIndex = [];
+'use strict';
 
-	for ( const key in processArguments ) {
-		if ( processArguments[key].charAt( 0 ) === '-' && processArguments[key].charAt( 0 ) === '-' ) {
-			argsIndex.push( [ processArguments[key], key ] );
-		}
+const isLongFlag = ( value ) => typeof value === 'string' && value.startsWith( '--' );
+
+const normalizeBooleanValue = ( value ) => {
+	if ( typeof value !== 'string' ) {
+		return undefined;
+	}
+	const normalized = value.toLowerCase();
+	if ( normalized === 'true' ) {
+		return true;
+	}
+	if ( normalized === 'false' ) {
+		return false;
 	}
+	return undefined;
+};
+
+function parseFlag( targetArgument, argumentType, argv = process.argv ) {
+	const processArguments = Array.isArray( argv ) ? argv : process.argv;
+	const targetIndex = processArguments.indexOf( targetArgument );
+
+	if ( targetIndex === -1 ) {
+		return false;
+	}
+
+	const nextValue = processArguments[ targetIndex + 1 ];
 
-	for ( const key in processArguments ) {
-		if ( argumentType === 'string' && processArguments[key] === targetArgument ) {
-			return processArguments[Number( key ) + 1];
+	if ( argumentType === 'string' ) {
+		if ( typeof nextValue !== 'string' || isLongFlag( nextValue ) ) {
+			return false;
 		}
+		return nextValue;
+	}
 
-		if ( argumentType === 'array' && processArguments[key] === targetArgument ) {
-			for ( const key in argsIndex ) {
-				if ( argsIndex[key][0] === targetArgument ) {
-					if ( argsIndex[key][1] > argsIndex[argsIndex.length - 1][1] ) {
-						return processArguments.slice( Number( argsIndex[key][1] ) + 1, argsIndex[Number( key ) + 1][1] );
-					} else {
-						return processArguments.slice( Number( argsIndex[key][1] ) + 1 );
-					}
-				}
+	if ( argumentType === 'array' ) {
+		const values = [];
+		for ( let i = targetIndex + 1; i < processArguments.length; i++ ) {
+			const value = processArguments[ i ];
+			if ( isLongFlag( value ) ) {
+				break;
 			}
+			values.push( value );
 		}
+		return values;
+	}
 
-		if ( argumentType === 'boolean' ) {
-			if ( processArguments.indexOf( targetArgument ) !== -1 ) {
-				return true;
-			}
-			return false;
+	if ( argumentType === 'boolean' ) {
+		const normalizedValue = normalizeBooleanValue( nextValue );
+		if ( typeof normalizedValue === 'boolean' ) {
+			return normalizedValue;
 		}
+		return true;
+	}
 
-		if ( argumentType === 'number' && processArguments[key] === targetArgument ) {
-			return Number( processArguments[Number( key ) + 1] );
+	if ( argumentType === 'number' ) {
+		if ( typeof nextValue !== 'string' || isLongFlag( nextValue ) ) {
+			return false;
 		}
+		const parsed = Number( nextValue );
+		return Number.isNaN( parsed ) ? false : parsed;
 	}
+
+	return false;
 }
 
-export { parseFlag };
+module.exports = parseFlag;

package/package.json

@@ -1,21 +1,35 @@
 {
   "name": "argv-flags",
-  "version": "0.1.0",
-  "description": "",
+  "version": "0.2.0",
+  "description": "Minimal CLI flag parser for strings, booleans, numbers, and arrays.",
   "main": "index.js",
-  "type": "module",
+  "types": "index.d.ts",
+  "files": [
+    "LICENSE",
+    "README.md",
+    "index.js",
+    "index.d.ts"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node --test"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Ismail-elkorchi/argv-flags.git"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
+  "keywords": [
+    "argv",
+    "cli",
+    "flags",
+    "parser"
+  ],
+  "author": "Ismail El Korchi",
+  "license": "MIT",
   "bugs": {
     "url": "https://github.com/Ismail-elkorchi/argv-flags/issues"
   },
-  "homepage": "https://github.com/Ismail-elkorchi/argv-flags#readme"
+  "homepage": "https://github.com/Ismail-elkorchi/argv-flags#readme",
+  "engines": {
+    "node": ">=18"
+  }
 }