argv-flags 0.1.1 → 0.2.1

package/README.md

@@ -1 +1,62 @@
 # 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');
+```
+
+### Inline values
+
+Flags can be passed as `--flag=value` for string, number, boolean, and array types:
+
+```sh
+--enabled=false
+--count=5
+--items=a b
+```
+
+### 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,40 +1,92 @@
-function parseFlag ( targetArgument, argumentType ) {
-	const processArguments = process.argv;
+'use strict';
 
-	if ( processArguments.includes( targetArgument ) ) {
+const isLongFlag = ( value ) => typeof value === 'string' && value.startsWith( '--' );
 
-		if ( argumentType === 'string' ) {
-			return processArguments[processArguments.indexOf( targetArgument ) + 1];
+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;
+};
+
+const findFlagMatch = ( argv, targetArgument ) => {
+	const directIndex = argv.indexOf( targetArgument );
+	if ( directIndex !== -1 ) {
+		return { index: directIndex };
+	}
+
+	const prefix = `${targetArgument}=`;
+	const inlineIndex = argv.findIndex( ( value ) => typeof value === 'string' && value.startsWith( prefix ) );
+	if ( inlineIndex === -1 ) {
+		return null;
+	}
+
+	return {
+		index: inlineIndex,
+		inlineValue: argv[ inlineIndex ].slice( prefix.length )
+	};
+};
+
+function parseFlag( targetArgument, argumentType, argv = process.argv ) {
+	const processArguments = Array.isArray( argv ) ? argv : process.argv;
+	const match = findFlagMatch( processArguments, targetArgument );
+
+	if ( ! match ) {
+		return false;
+	}
+
+	const inlineValue = Object.prototype.hasOwnProperty.call( match, 'inlineValue' )
+		? match.inlineValue
+		: undefined;
+	const nextValue = processArguments[ match.index + 1 ];
+
+	if ( argumentType === 'string' ) {
+		if ( typeof inlineValue === 'string' ) {
+			return inlineValue;
 		}
-	
-		if ( argumentType === 'array' ) {
-	
-			let flagsIndex = [];
-
-			for ( const key in processArguments ) {
-				if ( processArguments[key].charAt( 0 ) === '-' && processArguments[key].charAt( 0 ) === '-' ) {
-					flagsIndex.push( [ processArguments[key], key ] );
-				}
-			}
+		if ( typeof nextValue !== 'string' || isLongFlag( nextValue ) ) {
+			return false;
+		}
+		return nextValue;
+	}
 
-			for ( const key in flagsIndex ) {
-				if ( flagsIndex[key][0] === targetArgument ) {
-					if ( flagsIndex[key][1] < flagsIndex[flagsIndex.length - 1][1] ) {
-						return processArguments.slice( Number( flagsIndex[key][1] ) + 1, flagsIndex[Number( key ) + 1][1] );
-					} else {
-						return processArguments.slice( Number( flagsIndex[key][1] ) + 1 );
-					}
-				}
+	if ( argumentType === 'array' ) {
+		const values = [];
+		if ( typeof inlineValue === 'string' && inlineValue.length > 0 ) {
+			values.push( inlineValue );
+		}
+		for ( let i = match.index + 1; i < processArguments.length; i++ ) {
+			const value = processArguments[ i ];
+			if ( isLongFlag( value ) ) {
+				break;
 			}
+			values.push( value );
 		}
-	
-		if ( argumentType === 'boolean' ) {
-			return true;
+		return values;
+	}
+
+	if ( argumentType === 'boolean' ) {
+		const normalizedValue = normalizeBooleanValue( typeof inlineValue === 'string' ? inlineValue : nextValue );
+		if ( typeof normalizedValue === 'boolean' ) {
+			return normalizedValue;
 		}
-	
-		if ( argumentType === 'number' ) {
-			return Number( processArguments[processArguments.indexOf( targetArgument ) + 1] );
+		return true;
+	}
+
+	if ( argumentType === 'number' ) {
+		const candidate = typeof inlineValue === 'string' ? inlineValue : nextValue;
+		if ( typeof candidate !== 'string' || isLongFlag( candidate ) ) {
+			return false;
 		}
+		const parsed = Number( candidate );
+		return Number.isNaN( parsed ) ? false : parsed;
 	}
 
 	return false;

package/package.json

@@ -1,20 +1,35 @@
 {
   "name": "argv-flags",
-  "version": "0.1.1",
-  "description": "",
+  "version": "0.2.1",
+  "description": "Minimal CLI flag parser for strings, booleans, numbers, and arrays.",
   "main": "index.js",
+  "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"
+  }
 }