lowercase-keys 3.0.0 → 4.0.1

package/index.d.ts

@@ -1,3 +1,49 @@
+export type OnConflictArgument<T> = {
+	/**
+	The lowercased key that conflicts.
+	*/
+	key: string;
+
+	/**
+	The new value that is being set.
+	*/
+	newValue: T;
+
+	/**
+	The existing value that was already set.
+	*/
+	existingValue: T;
+};
+
+export type Options<T> = {
+	/**
+	A function that is called when multiple keys in the input object map to the same lowercased key.
+
+	The function receives the lowercased key, the new value, and the existing value, and should return the value to use.
+
+	By default, the last value wins.
+
+	@example
+	```
+	import lowercaseKeys from 'lowercase-keys';
+
+	// Throw on conflict
+	lowercaseKeys({Key: 'value1', key: 'value2'}, {
+		onConflict({key}) {
+			throw new Error(`Duplicate key: ${key}`);
+		}
+	});
+
+	// Keep the first value
+	lowercaseKeys({Key: 'value1', key: 'value2'}, {
+		onConflict: ({existingValue}) => existingValue,
+	});
+	//=> {key: 'value1'}
+	```
+	*/
+	onConflict?: (argument: OnConflictArgument<T>) => T;
+};
+
 /**
 Lowercase the keys of an object.
 
@@ -11,4 +57,4 @@ lowercaseKeys({FOO: true, bAr: false});
 //=> {foo: true, bar: false}
 ```
 */
-export default function lowercaseKeys<T>(object: Record<string, T>): Record<string, T>;
+export default function lowercaseKeys<T>(object: Record<string, T>, options?: Options<T>): Record<string, T>;

package/index.js

@@ -1,3 +1,26 @@
-export default function lowercaseKeys(object) {
-	return Object.fromEntries(Object.entries(object).map(([key, value]) => [key.toLowerCase(), value]));
+export default function lowercaseKeys(object, {onConflict} = {}) {
+	if (typeof object !== 'object' || object === null) {
+		throw new TypeError(`Expected an object, got ${object === null ? 'null' : typeof object}`);
+	}
+
+	const result = {};
+
+	for (const [key, value] of Object.entries(object)) {
+		const lowercasedKey = key.toLowerCase();
+		const hasExistingKey = Object.hasOwn(result, lowercasedKey);
+		const existingValue = hasExistingKey ? result[lowercasedKey] : undefined;
+
+		const resolvedValue = onConflict && hasExistingKey
+			? onConflict({key: lowercasedKey, newValue: value, existingValue})
+			: value;
+
+		Object.defineProperty(result, lowercasedKey, {
+			value: resolvedValue,
+			writable: true,
+			enumerable: true,
+			configurable: true,
+		});
+	}
+
+	return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "lowercase-keys",
-	"version": "3.0.0",
+	"version": "4.0.1",
 	"description": "Lowercase the keys of an object",
 	"license": "MIT",
 	"repository": "sindresorhus/lowercase-keys",
@@ -11,9 +11,13 @@
 		"url": "https://sindresorhus.com"
 	},
 	"type": "module",
-	"exports": "./index.js",
+	"exports": {
+		"types": "./index.d.ts",
+		"default": "./index.js"
+	},
+	"sideEffects": false,
 	"engines": {
-		"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+		"node": ">=20"
 	},
 	"scripts": {
 		"test": "xo && ava && tsd"
@@ -34,8 +38,8 @@
 		"key"
 	],
 	"devDependencies": {
-		"ava": "^3.15.0",
-		"tsd": "^0.18.0",
-		"xo": "^0.45.0"
+		"ava": "^6.4.1",
+		"tsd": "^0.33.0",
+		"xo": "^1.2.3"
 	}
 }

package/readme.md

@@ -21,12 +21,37 @@ lowercaseKeys({FOO: true, bAr: false});
 
 ## API
 
-### lowercaseKeys(object)
+### lowercaseKeys(object, options?)
 
 Returns a new object with the keys lowercased.
 
-## lowercase-keys for enterprise
+#### options
 
-Available as part of the Tidelift Subscription.
+Type: `object`
 
-The maintainers of lowercase-keys and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-lowercase-keys?utm_source=npm-lowercase-keys&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
+##### onConflict
+
+Type: `Function`
+
+A function that is called when multiple keys in the input object map to the same lowercased key.
+
+The function receives the lowercased key, the new value, and the existing value, and should return the value to use.
+
+By default, the last value wins.
+
+```js
+import lowercaseKeys from 'lowercase-keys';
+
+// Throw on conflict
+lowercaseKeys({Key: 'value1', key: 'value2'}, {
+	onConflict({key}) {
+		throw new Error(`Duplicate key: ${key}`);
+	}
+});
+
+// Keep the first value
+lowercaseKeys({Key: 'value1', key: 'value2'}, {
+	onConflict: ({existingValue}) => existingValue,
+});
+//=> {key: 'value1'}
+```