@oscarpalmer/atoms 0.119.0 → 0.120.0

package/dist/array/group-by.js

@@ -1,4 +1,11 @@
 import { groupValues } from "../internal/array/group.js";
-var groupBy = ((array, first, second) => groupValues(array, first, second, false));
-groupBy.arrays = ((array, first, second) => groupValues(array, first, second, true));
+function groupBy(array, first, second) {
+	return groupValues(array, first, second, false);
+}
+(function(_groupBy) {
+	function arrays(array, first, second) {
+		return groupValues(array, first, second, true);
+	}
+	_groupBy.arrays = arrays;
+})(groupBy || (groupBy = {}));
 export { groupBy };

package/dist/array/to-map.js

@@ -16,6 +16,13 @@ function getMapValues(array, first, second, arrays) {
 	}
 	return map;
 }
-var toMap = ((array, first, second, arrays) => getMapValues(array, first, second, arrays));
-toMap.arrays = ((array, first, second) => getMapValues(array, first, second, true));
+function toMap(array, first, second) {
+	return getMapValues(array, first, second, false);
+}
+(function(_toMap) {
+	function arrays(array, first, second) {
+		return getMapValues(array, first, second, true);
+	}
+	_toMap.arrays = arrays;
+})(toMap || (toMap = {}));
 export { toMap };

package/dist/array/to-record.js

@@ -1,4 +1,11 @@
 import { groupValues } from "../internal/array/group.js";
-var toRecord = ((array, first, second) => groupValues(array, first, second, false));
-toRecord.arrays = ((array, first, second) => groupValues(array, first, second, true));
+function toRecord(array, first, second) {
+	return groupValues(array, first, second, false);
+}
+(function(_toRecord) {
+	function arrays(array, first, second) {
+		return groupValues(array, first, second, true);
+	}
+	_toRecord.arrays = arrays;
+})(toRecord || (toRecord = {}));
 export { toRecord };

package/dist/atoms.full.js

@@ -206,8 +206,15 @@ function groupValues(array, key, value, arrays) {
 	}
 	return record;
 }
-const groupBy = ((array, first, second) => groupValues(array, first, second, false));
-groupBy.arrays = ((array, first, second) => groupValues(array, first, second, true));
+function groupBy(array, first, second) {
+	return groupValues(array, first, second, false);
+}
+(function(_groupBy) {
+	function arrays(array, first, second) {
+		return groupValues(array, first, second, true);
+	}
+	_groupBy.arrays = arrays;
+})(groupBy || (groupBy = {}));
 function indexOf(array, ...parameters) {
 	return findValue("index", array, parameters);
 }
@@ -435,10 +442,24 @@ function getMapValues(array, first, second, arrays) {
 	}
 	return map;
 }
-const toMap = ((array, first, second, arrays) => getMapValues(array, first, second, arrays));
-toMap.arrays = ((array, first, second) => getMapValues(array, first, second, true));
-const toRecord = ((array, first, second) => groupValues(array, first, second, false));
-toRecord.arrays = ((array, first, second) => groupValues(array, first, second, true));
+function toMap(array, first, second) {
+	return getMapValues(array, first, second, false);
+}
+(function(_toMap) {
+	function arrays(array, first, second) {
+		return getMapValues(array, first, second, true);
+	}
+	_toMap.arrays = arrays;
+})(toMap || (toMap = {}));
+function toRecord(array, first, second) {
+	return groupValues(array, first, second, false);
+}
+(function(_toRecord) {
+	function arrays(array, first, second) {
+		return groupValues(array, first, second, true);
+	}
+	_toRecord.arrays = arrays;
+})(toRecord || (toRecord = {}));
 function toSet(array, value) {
 	if (!Array.isArray(array)) return /* @__PURE__ */ new Set();
 	const callbacks = getArrayCallbacks(void 0, void 0, value);
@@ -1660,24 +1681,30 @@ function handleTemplate(value, pattern, ignoreCase, variables) {
 		return values[key];
 	});
 }
-const template = ((value, variables, options) => {
+function template(value, variables, options) {
 	const { ignoreCase, pattern } = getTemplateOptions(options);
 	return handleTemplate(value, pattern, ignoreCase, variables);
-});
-template.initialize = (options) => {
-	const { ignoreCase, pattern } = getTemplateOptions(options);
-	return (value, variables) => {
-		return handleTemplate(value, pattern, ignoreCase, variables);
-	};
-};
+}
+(function(_template) {
+	function initialize(options) {
+		const { ignoreCase, pattern } = getTemplateOptions(options);
+		return (value, variables) => {
+			return handleTemplate(value, pattern, ignoreCase, variables);
+		};
+	}
+	_template.initialize = initialize;
+})(template || (template = {}));
 const EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
-const equal = ((first, second, options) => {
+function equal(first, second, options) {
 	return equalValue(first, second, getEqualOptions(options));
-});
-equal.initialize = (options) => {
-	const actual = getEqualOptions(options);
-	return (first, second) => equalValue(first, second, actual);
-};
+}
+(function(_equal) {
+	function initialize(options) {
+		const actual = getEqualOptions(options);
+		return (first, second) => equalValue(first, second, actual);
+	}
+	_equal.initialize = initialize;
+})(equal || (equal = {}));
 function equalArray(first, second, options) {
 	const { length } = first;
 	if (length !== second.length) return false;
@@ -2008,13 +2035,16 @@ function getReplaceableObjects(value) {
 function handleMerge(values, options) {
 	return !Array.isArray(values) || values.length === 0 ? {} : mergeValues(values, options, true);
 }
-const merge = ((values, options) => {
+function merge(values, options) {
 	return handleMerge(values, getMergeOptions(options));
-});
-merge.initialize = (options) => {
-	const actual = getMergeOptions(options);
-	return (values) => handleMerge(values, actual);
-};
+}
+(function(_merge) {
+	function initialize(options) {
+		const actual = getMergeOptions(options);
+		return (values) => handleMerge(values, actual);
+	}
+	_merge.initialize = initialize;
+})(merge || (merge = {}));
 function mergeObjects(values, options, prefix) {
 	const { length } = values;
 	const isArray = values.every(Array.isArray);

package/dist/internal/value/equal.js

@@ -1,12 +1,15 @@
 import { isPlainObject, isTypedArray } from "../is.js";
 import { chunk } from "../array/chunk.js";
-var equal = ((first, second, options) => {
+function equal(first, second, options) {
 	return equalValue(first, second, getEqualOptions(options));
-});
-equal.initialize = (options) => {
-	const actual = getEqualOptions(options);
-	return (first, second) => equalValue(first, second, actual);
-};
+}
+(function(_equal) {
+	function initialize(options) {
+		const actual = getEqualOptions(options);
+		return (first, second) => equalValue(first, second, actual);
+	}
+	_equal.initialize = initialize;
+})(equal || (equal = {}));
 function equalArray(first, second, options) {
 	const { length } = first;
 	if (length !== second.length) return false;

package/dist/string/template.js

@@ -21,15 +21,18 @@ function handleTemplate(value, pattern, ignoreCase, variables) {
 		return values[key];
 	});
 }
-var template = ((value, variables, options) => {
+function template(value, variables, options) {
 	const { ignoreCase, pattern } = getTemplateOptions(options);
 	return handleTemplate(value, pattern, ignoreCase, variables);
-});
-template.initialize = (options) => {
-	const { ignoreCase, pattern } = getTemplateOptions(options);
-	return (value, variables) => {
-		return handleTemplate(value, pattern, ignoreCase, variables);
-	};
-};
+}
+(function(_template) {
+	function initialize(options) {
+		const { ignoreCase, pattern } = getTemplateOptions(options);
+		return (value, variables) => {
+			return handleTemplate(value, pattern, ignoreCase, variables);
+		};
+	}
+	_template.initialize = initialize;
+})(template || (template = {}));
 var EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
 export { template };

package/dist/value/merge.js

@@ -17,13 +17,16 @@ function getReplaceableObjects(value) {
 function handleMerge(values, options) {
 	return !Array.isArray(values) || values.length === 0 ? {} : mergeValues(values, options, true);
 }
-var merge = ((values, options) => {
+function merge(values, options) {
 	return handleMerge(values, getMergeOptions(options));
-});
-merge.initialize = (options) => {
-	const actual = getMergeOptions(options);
-	return (values) => handleMerge(values, actual);
-};
+}
+(function(_merge) {
+	function initialize(options) {
+		const actual = getMergeOptions(options);
+		return (values) => handleMerge(values, actual);
+	}
+	_merge.initialize = initialize;
+})(merge || (merge = {}));
 function mergeObjects(values, options, prefix) {
 	const { length } = values;
 	const isArray = values.every(Array.isArray);

package/package.json

@@ -8,8 +8,8 @@
 		"@types/node": "^25",
 		"@vitest/coverage-istanbul": "^4",
 		"jsdom": "^27.4",
-		"oxfmt": "^0.20",
-		"oxlint": "^1.35",
+		"oxfmt": "^0.21",
+		"oxlint": "^1.36",
 		"rolldown": "1.0.0-beta.57",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
@@ -101,5 +101,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.119.0"
+	"version": "0.120.0"
 }

package/src/array/group-by.ts

@@ -1,112 +1,120 @@
 import {groupValues} from '../internal/array/group';
 import type {Key, KeyedValue, PlainObject, Simplify} from '../models';
 
-type GroupBy = {
-	/**
-	 * Create a record from an array of items using a specific key and value
-	 *
-	 * If multiple items have the same key, the latest item's value will be used
-	 * @param array Array to group
-	 * @param key Callback to get an item's grouping key
-	 * @param value Callback to get an item's value
-	 * @returns Record of keyed values
-	 */
-	<
-		Item,
-		KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
-		ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
-	>(
-		array: Item[],
-		key: KeyCallback,
-		value: ValueCallback,
-	): Simplify<Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>>>;
-
-	/**
-	 * Create a record from an array of items using a specific key and value
-	 *
-	 * If multiple items have the same key, the latest item's value will be used
-	 * @param array Array to group
-	 * @param key Callback to get an item's grouping key
-	 * @param value Key to use for value
-	 * @returns Record of keyed values
-	 */
-	<
-		Item extends PlainObject,
-		KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
-		ItemValue extends keyof Item,
-	>(
-		array: Item[],
-		key: KeyCallback,
-		value: ItemValue,
-	): Record<ReturnType<KeyCallback>, Item[ItemValue]>;
-
-	/**
-	 * Create a record from an array of items using a specific key and value
-	 *
-	 * If multiple items have the same key, the latest item's value will be used
-	 * @param array Array to group
-	 * @param key Key to use for grouping
-	 * @param value Callback to get an item's value
-	 * @returns Record of keyed values
-	 */
-	<
-		Item extends PlainObject,
-		ItemKey extends keyof Item,
-		ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
-	>(
-		array: Item[],
-		key: ItemKey,
-		value: ValueCallback,
-	): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ValueCallback>>>;
-
-	/**
-	 * Create a record from an array of items using a specific key and value
-	 *
-	 * If multiple items have the same key, the latest item's value will be used
-	 * @param array Array to group
-	 * @param key Key to use for grouping
-	 * @param value Key to use for value
-	 * @returns Record of keyed values
-	 */
-	<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(
-		array: Item[],
-		key: ItemKey,
-		value: ItemValue,
-	): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue]>>;
-
-	/**
-	 * Create a record from an array of items using a specific key
-	 *
-	 * If multiple items have the same key, the latest item will be used
-	 * @param array Array to group
-	 * @param callback Callback to get an item's grouping key
-	 * @returns Record of keyed items
-	 */
-	<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(
-		array: Item[],
-		callback: Callback,
-	): Record<ReturnType<Callback>, Item>;
-
-	/**
-	 * Create a record from an array of items using a specific key
-	 *
-	 * If multiple items have the same key, the latest item will be used
-	 * @param array Array to group
-	 * @param key Key to use for grouping
-	 * @returns Record of keyed items
-	 */
-	<Item extends PlainObject, ItemKey extends keyof Item>(
-		array: Item[],
-		key: ItemKey,
-	): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
-
-	/**
-	 * Create a record from an array of items _(using indices as keys)_
-	 * @param array Array to group
-	 * @returns Record of indiced items
-	 */
-	<Item>(array: Item[]): Record<number, Item>;
-
+/**
+ * Create a record from an array of items using a specific key and value
+ *
+ * If multiple items have the same key, the latest item's value will be used
+ * @param array Array to group
+ * @param key Callback to get an item's grouping key
+ * @param value Callback to get an item's value
+ * @returns Record of keyed values
+ */
+function groupBy<
+	Item,
+	KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
+	ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
+>(
+	array: Item[],
+	key: KeyCallback,
+	value: ValueCallback,
+): Simplify<Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>>>;
+
+/**
+ * Create a record from an array of items using a specific key and value
+ *
+ * If multiple items have the same key, the latest item's value will be used
+ * @param array Array to group
+ * @param key Callback to get an item's grouping key
+ * @param value Key to use for value
+ * @returns Record of keyed values
+ */
+function groupBy<
+	Item extends PlainObject,
+	KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
+	ItemValue extends keyof Item,
+>(
+	array: Item[],
+	key: KeyCallback,
+	value: ItemValue,
+): Record<ReturnType<KeyCallback>, Item[ItemValue]>;
+
+/**
+ * Create a record from an array of items using a specific key and value
+ *
+ * If multiple items have the same key, the latest item's value will be used
+ * @param array Array to group
+ * @param key Key to use for grouping
+ * @param value Callback to get an item's value
+ * @returns Record of keyed values
+ */
+function groupBy<
+	Item extends PlainObject,
+	ItemKey extends keyof Item,
+	ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
+>(
+	array: Item[],
+	key: ItemKey,
+	value: ValueCallback,
+): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ValueCallback>>>;
+
+/**
+ * Create a record from an array of items using a specific key and value
+ *
+ * If multiple items have the same key, the latest item's value will be used
+ * @param array Array to group
+ * @param key Key to use for grouping
+ * @param value Key to use for value
+ * @returns Record of keyed values
+ */
+function groupBy<
+	Item extends PlainObject,
+	ItemKey extends keyof Item,
+	ItemValue extends keyof Item,
+>(
+	array: Item[],
+	key: ItemKey,
+	value: ItemValue,
+): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue]>>;
+
+/**
+ * Create a record from an array of items using a specific key
+ *
+ * If multiple items have the same key, the latest item will be used
+ * @param array Array to group
+ * @param callback Callback to get an item's grouping key
+ * @returns Record of keyed items
+ */
+function groupBy<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(
+	array: Item[],
+	callback: Callback,
+): Record<ReturnType<Callback>, Item>;
+
+/**
+ * Create a record from an array of items using a specific key
+ *
+ * If multiple items have the same key, the latest item will be used
+ * @param array Array to group
+ * @param key Key to use for grouping
+ * @returns Record of keyed items
+ */
+function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(
+	array: Item[],
+	key: ItemKey,
+): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
+
+/**
+ * Create a record from an array of items _(using indices as keys)_
+ * @param array Array to group
+ * @returns Record of indiced items
+ */
+function groupBy<Item>(array: Item[]): Record<number, Item>;
+
+function groupBy(array: unknown[], first?: unknown, second?: unknown): unknown {
+	return groupValues(array, first, second, false);
+}
+
+namespace groupBy {
 	/**
 	 * Create a record from an array of items using a specific key and value, grouping values into arrays
 	 * @param array Array to group
@@ -114,7 +122,7 @@ type GroupBy = {
 	 * @param value Callback to get an item's value
 	 * @returns Record of keyed values
 	 */
-	arrays<
+	export function arrays<
 		Item,
 		KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
 		ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
@@ -131,7 +139,7 @@ type GroupBy = {
 	 * @param value Key to use for value
 	 * @returns Record of keyed values
 	 */
-	arrays<
+	export function arrays<
 		Item extends PlainObject,
 		KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
 		ItemValue extends keyof Item,
@@ -148,7 +156,7 @@ type GroupBy = {
 	 * @param value Callback to get an item's value
 	 * @returns Record of keyed values
 	 */
-	arrays<
+	export function arrays<
 		Item extends PlainObject,
 		ItemKey extends keyof Item,
 		ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
@@ -165,7 +173,11 @@ type GroupBy = {
 	 * @param value Key to use for value
 	 * @returns Record of keyed values
 	 */
-	arrays<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(
+	export function arrays<
+		Item extends PlainObject,
+		ItemKey extends keyof Item,
+		ItemValue extends keyof Item,
+	>(
 		array: Item[],
 		key: ItemKey,
 		value: ItemValue,
@@ -177,7 +189,7 @@ type GroupBy = {
 	 * @param callback Callback to get an item's grouping key
 	 * @returns Record of keyed items
 	 */
-	arrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(
+	export function arrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(
 		array: Item[],
 		callback: Callback,
 	): Record<ReturnType<Callback>, Item[]>;
@@ -188,16 +200,14 @@ type GroupBy = {
 	 * @param key Key to use for grouping
 	 * @returns Record of keyed items
 	 */
-	arrays<Item extends PlainObject, ItemKey extends keyof Item>(
+	export function arrays<Item extends PlainObject, ItemKey extends keyof Item>(
 		array: Item[],
 		key: ItemKey,
 	): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
-};
-
-const groupBy = ((array: unknown[], first: unknown, second: unknown) =>
-	groupValues(array, first, second, false)) as GroupBy;
 
-groupBy.arrays = ((array: unknown[], first: unknown, second: unknown): unknown =>
-	groupValues(array, first, second, true) as never) as GroupBy['arrays'];
+	export function arrays(array: unknown[], first?: unknown, second?: unknown): unknown {
+		return groupValues(array, first, second, true);
+	}
+}
 
 export {groupBy};