politty 0.4.8 → 0.4.10

package/dist/{runner-nKNXknDl.cjs → runner-DXmgHXNR.cjs}

@@ -5,6 +5,42 @@ let node_util = require("node:util");
 let string_width = require("string-width");
 string_width = require_subcommand_router.__toESM(string_width);
 
+//#region src/core/case-proxy.ts
+/**
+* Wrap an args object with a Proxy that allows dual-case access.
+*
+* Given `{ "my-option": "value" }`, both `obj["my-option"]` and `obj.myOption`
+* will return `"value"`.
+*
+* - `Object.keys()`, `JSON.stringify()`, and spread return only the original keys.
+* - The `in` operator detects both case variants.
+*/
+function createDualCaseProxy(obj) {
+	return new Proxy(obj, {
+		get(target, prop, receiver) {
+			if (typeof prop === "string") {
+				if (prop in target) return Reflect.get(target, prop, receiver);
+				const camel = require_lazy.toCamelCase(prop);
+				if (camel !== prop && camel in target) return Reflect.get(target, camel, receiver);
+				const kebab = require_lazy.toKebabCase(prop);
+				if (kebab !== prop && kebab in target) return Reflect.get(target, kebab, receiver);
+			}
+			return Reflect.get(target, prop, receiver);
+		},
+		has(target, prop) {
+			if (typeof prop === "string") {
+				if (prop in target) return true;
+				const camel = require_lazy.toCamelCase(prop);
+				if (camel !== prop && camel in target) return true;
+				const kebab = require_lazy.toKebabCase(prop);
+				if (kebab !== prop && kebab in target) return true;
+			}
+			return Reflect.has(target, prop);
+		}
+	});
+}
+
+//#endregion
 //#region src/executor/command-runner.ts
 /**
 * Execute a command lifecycle: setup → run → cleanup
@@ -906,6 +942,15 @@ var DuplicateAliasError = class extends Error {
 		this.name = "DuplicateAliasError";
 	}
 };
+/**
+* Error thrown when fields are case variants of each other (e.g. "my-option" and "myOption")
+*/
+var CaseVariantCollisionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CaseVariantCollisionError";
+	}
+};
 
 //#endregion
 //#region src/validator/command-validator.ts
@@ -927,6 +972,25 @@ function checkDuplicateFields(extracted, commandPath) {
 	return errors;
 }
 /**
+* Check for case-variant collisions (e.g. "my-option" and "myOption" defined simultaneously)
+*/
+function checkCaseVariantCollisions(extracted, commandPath) {
+	const errors = [];
+	const canonicalMap = /* @__PURE__ */ new Map();
+	for (const field of extracted.fields) {
+		const camel = require_lazy.toCamelCase(field.name);
+		const existing = canonicalMap.get(camel);
+		if (existing && existing !== field.name) errors.push({
+			commandPath,
+			type: "case_variant_collision",
+			message: `Fields "${existing}" and "${field.name}" are case variants of each other and would collide.`,
+			field: field.name
+		});
+		canonicalMap.set(camel, field.name);
+	}
+	return errors;
+}
+/**
 * Check for duplicate aliases and alias-field name conflicts
 */
 function checkDuplicateAliases(extracted, commandPath) {
@@ -1063,11 +1127,42 @@ function validateReservedAliases(extracted, _hasSubCommands) {
 	}
 }
 /**
+* Validate that no case-variant collisions exist
+*
+* @param extracted - Extracted fields from schema
+* @throws {CaseVariantCollisionError} If case-variant collisions are found
+*/
+function validateCaseVariantCollisions(extracted) {
+	const errors = checkCaseVariantCollisions(extracted, []);
+	if (errors.length > 0) {
+		const err = errors[0];
+		throw new CaseVariantCollisionError(err.message);
+	}
+}
+/**
+* Validate that no case-variant collisions exist between two schemas
+* (e.g., global args and command args).
+*
+* @param extractedA - Extracted fields from first schema (e.g., global args)
+* @param extractedB - Extracted fields from second schema (e.g., command args)
+* @throws {CaseVariantCollisionError} If cross-schema case-variant collisions are found
+*/
+function validateCrossSchemaCollisions(extractedA, extractedB) {
+	const canonicalMap = /* @__PURE__ */ new Map();
+	for (const field of extractedA.fields) canonicalMap.set(require_lazy.toCamelCase(field.name), field.name);
+	for (const field of extractedB.fields) {
+		const camel = require_lazy.toCamelCase(field.name);
+		const existing = canonicalMap.get(camel);
+		if (existing && existing !== field.name) throw new CaseVariantCollisionError(`Global field "${existing}" and command field "${field.name}" are case variants of each other and would collide.`);
+	}
+}
+/**
 * Collect validation errors for a single command's schema (non-throwing)
 */
 function collectSchemaErrors(extracted, _hasSubCommands, commandPath) {
 	return [
 		...checkDuplicateFields(extracted, commandPath),
+		...checkCaseVariantCollisions(extracted, commandPath),
 		...checkDuplicateAliases(extracted, commandPath),
 		...checkPositionalConfig(extracted, commandPath),
 		...checkReservedAliases(extracted, commandPath)
@@ -1499,9 +1594,11 @@ function parseArgs(argv, command, options = {}) {
 		extracted = require_lazy.extractFields(command.args);
 		if (!options.skipValidation) {
 			validateDuplicateFields(extracted);
+			validateCaseVariantCollisions(extracted);
 			validateDuplicateAliases(extracted);
 			validatePositionalConfig(extracted);
 			validateReservedAliases(extracted, hasSubCommands);
+			if (options.globalExtracted) validateCrossSchemaCollisions(options.globalExtracted, extracted);
 		}
 	}
 	const hasUserDefinedH = extracted?.fields.some((f) => f.alias === "H" && f.overrideBuiltinAlias === true) ?? false;
@@ -2086,9 +2183,10 @@ async function runCommandInternal(command, argv, options = {}) {
 			validatedGlobalArgs = globalValidation.data;
 		}
 		if (!command.args) {
-			if (options._globalExtracted) await runEffects(validatedGlobalArgs, options._globalExtracted, validatedGlobalArgs);
+			const proxiedGlobalArgs = createDualCaseProxy(validatedGlobalArgs);
+			if (options._globalExtracted) await runEffects(proxiedGlobalArgs, options._globalExtracted, proxiedGlobalArgs);
 			collector?.stop();
-			return await executeLifecycle(command, validatedGlobalArgs, {
+			return await executeLifecycle(command, proxiedGlobalArgs, {
 				handleSignals: options.handleSignals,
 				captureLogs: options.captureLogs,
 				existingLogs: getCurrentLogs(),
@@ -2106,12 +2204,14 @@ async function runCommandInternal(command, argv, options = {}) {
 				logs: getCurrentLogs()
 			};
 		}
-		if (options._globalExtracted) await runEffects(validatedGlobalArgs, options._globalExtracted, validatedGlobalArgs);
-		if (parseResult.extractedFields) await runEffects(validationResult.data, parseResult.extractedFields, validatedGlobalArgs);
-		const mergedArgs = {
-			...validatedGlobalArgs,
-			...validationResult.data
-		};
+		const proxiedCommandArgs = createDualCaseProxy(validationResult.data);
+		const proxiedGlobalArgs = createDualCaseProxy(validatedGlobalArgs);
+		if (options._globalExtracted) await runEffects(proxiedGlobalArgs, options._globalExtracted, proxiedGlobalArgs);
+		if (parseResult.extractedFields) await runEffects(proxiedCommandArgs, parseResult.extractedFields, proxiedGlobalArgs);
+		const mergedArgs = createDualCaseProxy({
+			...proxiedGlobalArgs,
+			...proxiedCommandArgs
+		});
 		collector?.stop();
 		return await executeLifecycle(command, mergedArgs, {
 			handleSignals: options.handleSignals,
@@ -2141,6 +2241,7 @@ function extractAndValidateGlobal(options) {
 	const extracted = require_lazy.extractFields(options.globalArgs);
 	if (!options.skipValidation) {
 		validateDuplicateFields(extracted);
+		validateCaseVariantCollisions(extracted);
 		validateDuplicateAliases(extracted);
 		validateReservedAliases(extracted, true);
 		const positionalNames = extracted.fields.filter((f) => f.positional).map((f) => f.name);
@@ -2150,6 +2251,12 @@ function extractAndValidateGlobal(options) {
 }
 
 //#endregion
+Object.defineProperty(exports, 'CaseVariantCollisionError', {
+  enumerable: true,
+  get: function () {
+    return CaseVariantCollisionError;
+  }
+});
 Object.defineProperty(exports, 'DuplicateAliasError', {
   enumerable: true,
   get: function () {
@@ -2174,6 +2281,12 @@ Object.defineProperty(exports, 'ReservedAliasError', {
     return ReservedAliasError;
   }
 });
+Object.defineProperty(exports, 'createDualCaseProxy', {
+  enumerable: true,
+  get: function () {
+    return createDualCaseProxy;
+  }
+});
 Object.defineProperty(exports, 'formatCommandValidationErrors', {
   enumerable: true,
   get: function () {
@@ -2258,12 +2371,24 @@ Object.defineProperty(exports, 'symbols', {
     return symbols;
   }
 });
+Object.defineProperty(exports, 'validateCaseVariantCollisions', {
+  enumerable: true,
+  get: function () {
+    return validateCaseVariantCollisions;
+  }
+});
 Object.defineProperty(exports, 'validateCommand', {
   enumerable: true,
   get: function () {
     return validateCommand;
   }
 });
+Object.defineProperty(exports, 'validateCrossSchemaCollisions', {
+  enumerable: true,
+  get: function () {
+    return validateCrossSchemaCollisions;
+  }
+});
 Object.defineProperty(exports, 'validateDuplicateAliases', {
   enumerable: true,
   get: function () {
@@ -2288,4 +2413,4 @@ Object.defineProperty(exports, 'validateReservedAliases', {
     return validateReservedAliases;
   }
 });
-//# sourceMappingURL=runner-nKNXknDl.cjs.map
+//# sourceMappingURL=runner-DXmgHXNR.cjs.map