@oscarpalmer/atoms 0.16.0 → 0.17.0

package/dist/js/array.js

@@ -1,13 +1,65 @@
 // src/js/array.ts
-var _getCallback = function(value) {
-  if (typeof value === "function") {
-    return value;
+var _getCallbacks = function(bool, key) {
+  if (typeof bool === "function") {
+    return { bool };
   }
-  const isString = typeof value === "string";
-  if (!isString && typeof value !== "number") {
+  if (typeof key === "function") {
+    return { key };
+  }
+  const isString = typeof key === "string";
+  if (!isString && typeof key !== "number" || isString && key.includes(".")) {
     return;
   }
-  return isString && value.includes(".") ? undefined : (item) => item[value];
+  return {
+    key: (item) => item?.[key]
+  };
+};
+var _findValue = function(type, array, value, key) {
+  const callbacks = _getCallbacks(value, key);
+  if (callbacks?.bool === undefined && callbacks?.key === undefined) {
+    return type === "index" ? array.indexOf(value) : array.find((item) => item === value);
+  }
+  if (callbacks.bool !== undefined) {
+    const index2 = array.findIndex(callbacks.bool);
+    return type === "index" ? index2 : index2 > -1 ? array[index2] : undefined;
+  }
+  const { length } = array;
+  let index = 0;
+  for (;index < length; index += 1) {
+    const item = array[index];
+    if (callbacks.key?.(item) === value) {
+      return type === "index" ? index : item;
+    }
+  }
+  return type === "index" ? -1 : undefined;
+};
+var _findValues = function(type, array, value, key) {
+  const callbacks = _getCallbacks(value, key);
+  const { length } = array;
+  if (type === "unique" && callbacks?.key === undefined && length >= 100) {
+    return Array.from(new Set(array));
+  }
+  if (typeof callbacks?.bool === "function") {
+    return array.filter(callbacks.bool);
+  }
+  if (type === "all" && key === undefined) {
+    return array.filter((item) => item === value);
+  }
+  const hasCallback = typeof callbacks?.key === "function";
+  const result = [];
+  const values = hasCallback ? [] : result;
+  let index = 0;
+  for (;index < length; index += 1) {
+    const item = array[index];
+    const itemValue = hasCallback ? callbacks.key?.(item) : item;
+    if (type === "all" && itemValue === value || type === "unique" && values.indexOf(itemValue) === -1) {
+      if (values !== result) {
+        values.push(itemValue);
+      }
+      result.push(item);
+    }
+  }
+  return result;
 };
 var _insertValues = function(type, array, values, start, deleteCount) {
   const chunked = chunk(values).reverse();
@@ -37,23 +89,17 @@ function chunk(array, size) {
   return chunks;
 }
 function exists(array, value, key) {
-  const callback = _getCallback(key);
-  if (callback === undefined) {
-    return array.indexOf(value) > -1;
-  }
-  const needle = typeof value === "object" && value !== null ? callback(value) : value;
-  const { length } = array;
-  let index = 0;
-  for (;index < length; index += 1) {
-    if (callback(array[index]) === needle) {
-      return true;
-    }
-  }
-  return false;
+  return _findValue("index", array, value, key) > -1;
+}
+function filter(array, value, key) {
+  return _findValues("all", array, value, key);
+}
+function find(array, value, key) {
+  return _findValue("value", array, value, key);
 }
 function groupBy(array, key) {
-  const keyCallback = _getCallback(key);
-  if (keyCallback === undefined) {
+  const callbacks = _getCallbacks(undefined, key);
+  if (callbacks?.key === undefined) {
     return {};
   }
   const grouped = {};
@@ -61,7 +107,7 @@ function groupBy(array, key) {
   let index = 0;
   for (;index < length; index += 1) {
     const item = array[index];
-    const value = keyCallback(item);
+    const value = callbacks.key(item);
     if (value in grouped) {
       grouped[value].push(item);
     } else {
@@ -70,6 +116,9 @@ function groupBy(array, key) {
   }
   return grouped;
 }
+function indexOf(array, value, key) {
+  return _findValue("index", array, value, key);
+}
 function insert(array, index, values) {
   _insertValues("splice", array, values, index, 0);
 }
@@ -80,32 +129,17 @@ function splice(array, start, deleteCount, values) {
   return _insertValues("splice", array, values, start, deleteCount);
 }
 function unique(array, key) {
-  const keyCallback = _getCallback(key);
-  const { length } = array;
-  if (keyCallback === undefined && length >= 100) {
-    return Array.from(new Set(array));
-  }
-  const result = [];
-  const values = keyCallback === undefined ? result : [];
-  let index = 0;
-  for (;index < length; index += 1) {
-    const item = array[index];
-    const value = keyCallback?.(item) ?? item;
-    if (values.indexOf(value) === -1) {
-      if (values !== result) {
-        values.push(value);
-      }
-      result.push(item);
-    }
-  }
-  return result;
+  return _findValues("unique", array, undefined, key);
 }
 export {
   unique,
   splice,
   push,
   insert,
+  indexOf,
   groupBy,
+  find,
+  filter,
   exists,
   chunk
 };

package/dist/js/array.mjs

@@ -1,13 +1,65 @@
 // src/js/array.ts
-var _getCallback = function(value) {
-  if (typeof value === "function") {
-    return value;
+var _getCallbacks = function(bool, key) {
+  if (typeof bool === "function") {
+    return { bool };
   }
-  const isString = typeof value === "string";
-  if (!isString && typeof value !== "number") {
+  if (typeof key === "function") {
+    return { key };
+  }
+  const isString = typeof key === "string";
+  if (!isString && typeof key !== "number" || isString && key.includes(".")) {
     return;
   }
-  return isString && value.includes(".") ? undefined : (item) => item[value];
+  return {
+    key: (item) => item?.[key]
+  };
+};
+var _findValue = function(type, array, value, key) {
+  const callbacks = _getCallbacks(value, key);
+  if (callbacks?.bool === undefined && callbacks?.key === undefined) {
+    return type === "index" ? array.indexOf(value) : array.find((item) => item === value);
+  }
+  if (callbacks.bool !== undefined) {
+    const index2 = array.findIndex(callbacks.bool);
+    return type === "index" ? index2 : index2 > -1 ? array[index2] : undefined;
+  }
+  const { length } = array;
+  let index = 0;
+  for (;index < length; index += 1) {
+    const item = array[index];
+    if (callbacks.key?.(item) === value) {
+      return type === "index" ? index : item;
+    }
+  }
+  return type === "index" ? -1 : undefined;
+};
+var _findValues = function(type, array, value, key) {
+  const callbacks = _getCallbacks(value, key);
+  const { length } = array;
+  if (type === "unique" && callbacks?.key === undefined && length >= 100) {
+    return Array.from(new Set(array));
+  }
+  if (typeof callbacks?.bool === "function") {
+    return array.filter(callbacks.bool);
+  }
+  if (type === "all" && key === undefined) {
+    return array.filter((item) => item === value);
+  }
+  const hasCallback = typeof callbacks?.key === "function";
+  const result = [];
+  const values = hasCallback ? [] : result;
+  let index = 0;
+  for (;index < length; index += 1) {
+    const item = array[index];
+    const itemValue = hasCallback ? callbacks.key?.(item) : item;
+    if (type === "all" && itemValue === value || type === "unique" && values.indexOf(itemValue) === -1) {
+      if (values !== result) {
+        values.push(itemValue);
+      }
+      result.push(item);
+    }
+  }
+  return result;
 };
 var _insertValues = function(type, array, values, start, deleteCount) {
   const chunked = chunk(values).reverse();
@@ -37,23 +89,17 @@ function chunk(array, size) {
   return chunks;
 }
 function exists(array, value, key) {
-  const callback = _getCallback(key);
-  if (callback === undefined) {
-    return array.indexOf(value) > -1;
-  }
-  const needle = typeof value === "object" && value !== null ? callback(value) : value;
-  const { length } = array;
-  let index = 0;
-  for (;index < length; index += 1) {
-    if (callback(array[index]) === needle) {
-      return true;
-    }
-  }
-  return false;
+  return _findValue("index", array, value, key) > -1;
+}
+function filter(array, value, key) {
+  return _findValues("all", array, value, key);
+}
+function find(array, value, key) {
+  return _findValue("value", array, value, key);
 }
 function groupBy(array, key) {
-  const keyCallback = _getCallback(key);
-  if (keyCallback === undefined) {
+  const callbacks = _getCallbacks(undefined, key);
+  if (callbacks?.key === undefined) {
     return {};
   }
   const grouped = {};
@@ -61,7 +107,7 @@ function groupBy(array, key) {
   let index = 0;
   for (;index < length; index += 1) {
     const item = array[index];
-    const value = keyCallback(item);
+    const value = callbacks.key(item);
     if (value in grouped) {
       grouped[value].push(item);
     } else {
@@ -70,6 +116,9 @@ function groupBy(array, key) {
   }
   return grouped;
 }
+function indexOf(array, value, key) {
+  return _findValue("index", array, value, key);
+}
 function insert(array, index, values) {
   _insertValues("splice", array, values, index, 0);
 }
@@ -80,32 +129,17 @@ function splice(array, start, deleteCount, values) {
   return _insertValues("splice", array, values, start, deleteCount);
 }
 function unique(array, key) {
-  const keyCallback = _getCallback(key);
-  const { length } = array;
-  if (keyCallback === undefined && length >= 100) {
-    return Array.from(new Set(array));
-  }
-  const result = [];
-  const values = keyCallback === undefined ? result : [];
-  let index = 0;
-  for (;index < length; index += 1) {
-    const item = array[index];
-    const value = keyCallback?.(item) ?? item;
-    if (values.indexOf(value) === -1) {
-      if (values !== result) {
-        values.push(value);
-      }
-      result.push(item);
-    }
-  }
-  return result;
+  return _findValues("unique", array, undefined, key);
 }
 export {
   unique,
   splice,
   push,
   insert,
+  indexOf,
   groupBy,
+  find,
+  filter,
   exists,
   chunk
 };

package/dist/js/index.js

@@ -1,13 +1,65 @@
 // src/js/array.ts
-var _getCallback = function(value) {
-  if (typeof value === "function") {
-    return value;
+var _getCallbacks = function(bool, key) {
+  if (typeof bool === "function") {
+    return { bool };
+  }
+  if (typeof key === "function") {
+    return { key };
   }
-  const isString = typeof value === "string";
-  if (!isString && typeof value !== "number") {
+  const isString = typeof key === "string";
+  if (!isString && typeof key !== "number" || isString && key.includes(".")) {
     return;
   }
-  return isString && value.includes(".") ? undefined : (item) => item[value];
+  return {
+    key: (item) => item?.[key]
+  };
+};
+var _findValue = function(type, array, value, key) {
+  const callbacks = _getCallbacks(value, key);
+  if (callbacks?.bool === undefined && callbacks?.key === undefined) {
+    return type === "index" ? array.indexOf(value) : array.find((item) => item === value);
+  }
+  if (callbacks.bool !== undefined) {
+    const index2 = array.findIndex(callbacks.bool);
+    return type === "index" ? index2 : index2 > -1 ? array[index2] : undefined;
+  }
+  const { length } = array;
+  let index = 0;
+  for (;index < length; index += 1) {
+    const item = array[index];
+    if (callbacks.key?.(item) === value) {
+      return type === "index" ? index : item;
+    }
+  }
+  return type === "index" ? -1 : undefined;
+};
+var _findValues = function(type, array, value, key) {
+  const callbacks = _getCallbacks(value, key);
+  const { length } = array;
+  if (type === "unique" && callbacks?.key === undefined && length >= 100) {
+    return Array.from(new Set(array));
+  }
+  if (typeof callbacks?.bool === "function") {
+    return array.filter(callbacks.bool);
+  }
+  if (type === "all" && key === undefined) {
+    return array.filter((item) => item === value);
+  }
+  const hasCallback = typeof callbacks?.key === "function";
+  const result = [];
+  const values = hasCallback ? [] : result;
+  let index = 0;
+  for (;index < length; index += 1) {
+    const item = array[index];
+    const itemValue = hasCallback ? callbacks.key?.(item) : item;
+    if (type === "all" && itemValue === value || type === "unique" && values.indexOf(itemValue) === -1) {
+      if (values !== result) {
+        values.push(itemValue);
+      }
+      result.push(item);
+    }
+  }
+  return result;
 };
 var _insertValues = function(type, array, values, start, deleteCount) {
   const chunked = chunk(values).reverse();
@@ -37,23 +89,17 @@ function chunk(array, size) {
   return chunks;
 }
 function exists(array, value, key) {
-  const callback = _getCallback(key);
-  if (callback === undefined) {
-    return array.indexOf(value) > -1;
-  }
-  const needle = typeof value === "object" && value !== null ? callback(value) : value;
-  const { length } = array;
-  let index = 0;
-  for (;index < length; index += 1) {
-    if (callback(array[index]) === needle) {
-      return true;
-    }
-  }
-  return false;
+  return _findValue("index", array, value, key) > -1;
+}
+function filter(array, value, key) {
+  return _findValues("all", array, value, key);
+}
+function find(array, value, key) {
+  return _findValue("value", array, value, key);
 }
 function groupBy(array, key) {
-  const keyCallback = _getCallback(key);
-  if (keyCallback === undefined) {
+  const callbacks = _getCallbacks(undefined, key);
+  if (callbacks?.key === undefined) {
     return {};
   }
   const grouped = {};
@@ -61,7 +107,7 @@ function groupBy(array, key) {
   let index = 0;
   for (;index < length; index += 1) {
     const item = array[index];
-    const value = keyCallback(item);
+    const value = callbacks.key(item);
     if (value in grouped) {
       grouped[value].push(item);
     } else {
@@ -70,6 +116,9 @@ function groupBy(array, key) {
   }
   return grouped;
 }
+function indexOf(array, value, key) {
+  return _findValue("index", array, value, key);
+}
 function insert(array, index, values) {
   _insertValues("splice", array, values, index, 0);
 }
@@ -80,25 +129,7 @@ function splice(array, start, deleteCount, values) {
   return _insertValues("splice", array, values, start, deleteCount);
 }
 function unique(array, key) {
-  const keyCallback = _getCallback(key);
-  const { length } = array;
-  if (keyCallback === undefined && length >= 100) {
-    return Array.from(new Set(array));
-  }
-  const result = [];
-  const values = keyCallback === undefined ? result : [];
-  let index = 0;
-  for (;index < length; index += 1) {
-    const item = array[index];
-    const value = keyCallback?.(item) ?? item;
-    if (values.indexOf(value) === -1) {
-      if (values !== result) {
-        values.push(value);
-      }
-      result.push(item);
-    }
-  }
-  return result;
+  return _findValues("unique", array, undefined, key);
 }
 // src/js/element/index.ts
 var _findElements = function(selector, context, single) {
@@ -247,6 +278,104 @@ function getString(value) {
 function isNullableOrWhitespace(value) {
   return value == null || getString(value).trim().length === 0;
 }
+
+// src/js/value.ts
+var _getValue = function(data, key) {
+  if (typeof data !== "object" || data === null || /^(__proto__|constructor|prototype)$/i.test(key)) {
+    return;
+  }
+  return data instanceof Map ? data.get(key) : data[key];
+};
+var _setValue = function(data, key, value) {
+  if (typeof data !== "object" || data === null || /^(__proto__|constructor|prototype)$/i.test(key)) {
+    return;
+  }
+  if (data instanceof Map) {
+    data.set(key, value);
+  } else {
+    data[key] = value;
+  }
+};
+function getValue(data, key) {
+  if (typeof data !== "object" || data === null || isNullableOrWhitespace(key)) {
+    return;
+  }
+  const parts = getString(key).split(".");
+  const { length } = parts;
+  let index = 0;
+  let value = data;
+  for (;index < length; index += 1) {
+    value = _getValue(value, parts[index]);
+    if (value == null) {
+      break;
+    }
+  }
+  return value;
+}
+function isArrayOrObject(value) {
+  return /^(array|object)$/i.test(value?.constructor?.name);
+}
+function isNullable(value) {
+  return value == null;
+}
+function isObject(value) {
+  return /^object$/i.test(value?.constructor?.name);
+}
+function setValue(data, key, value) {
+  if (typeof data !== "object" || data === null || isNullableOrWhitespace(key)) {
+    return data;
+  }
+  const parts = getString(key).split(".");
+  const { length } = parts;
+  let index = 0;
+  let target = data;
+  for (;index < length; index += 1) {
+    const part = parts[index];
+    if (parts.indexOf(part) === parts.length - 1) {
+      _setValue(target, part, value);
+      break;
+    }
+    let next = _getValue(target, part);
+    if (typeof next !== "object" || next === null) {
+      next = /^\d+$/.test(part) ? [] : {};
+      target[part] = next;
+    }
+    target = next;
+  }
+  return data;
+}
+
+// src/js/object.ts
+function clone(value2) {
+  return structuredClone(value2);
+}
+function merge(...values) {
+  if (values.length === 0) {
+    return {};
+  }
+  const actual = values.filter(isArrayOrObject);
+  const result = actual.every(Array.isArray) ? [] : {};
+  const { length: itemsLength } = actual;
+  let itemIndex = 0;
+  for (;itemIndex < itemsLength; itemIndex += 1) {
+    const item = actual[itemIndex];
+    const isArray = Array.isArray(item);
+    const keys = isArray ? undefined : Object.keys(item);
+    const keysLength = isArray ? item.length : keys.length;
+    let keyIndex = 0;
+    for (;keyIndex < keysLength; keyIndex += 1) {
+      const key = keys?.[keyIndex] ?? keyIndex;
+      const next = item[key];
+      const previous = result[key];
+      if (isArrayOrObject(previous) && isArrayOrObject(next)) {
+        result[key] = merge(previous, next);
+      } else {
+        result[key] = next;
+      }
+    }
+  }
+  return result;
+}
 // src/js/timer.ts
 function repeat(callback, options) {
   const count = typeof options?.count === "number" ? options.count : Infinity;
@@ -330,71 +459,6 @@ class Timer {
     return work("stop", this, this.state, this.options);
   }
 }
-// src/js/value.ts
-var _getValue = function(data, key) {
-  if (typeof data !== "object" || data === null || /^(__proto__|constructor|prototype)$/i.test(key)) {
-    return;
-  }
-  return data instanceof Map ? data.get(key) : data[key];
-};
-var _setValue = function(data, key, value) {
-  if (typeof data !== "object" || data === null || /^(__proto__|constructor|prototype)$/i.test(key)) {
-    return;
-  }
-  if (data instanceof Map) {
-    data.set(key, value);
-  } else {
-    data[key] = value;
-  }
-};
-function getValue(data, key) {
-  if (typeof data !== "object" || data === null || isNullableOrWhitespace(key)) {
-    return;
-  }
-  const parts = getString(key).split(".");
-  const { length } = parts;
-  let index = 0;
-  let value = data;
-  for (;index < length; index += 1) {
-    value = _getValue(value, parts[index]);
-    if (value == null) {
-      break;
-    }
-  }
-  return value;
-}
-function isArrayOrObject(value) {
-  return /^(array|object)$/i.test(value?.constructor?.name);
-}
-function isNullable(value) {
-  return value == null;
-}
-function isObject(value) {
-  return /^object$/i.test(value?.constructor?.name);
-}
-function setValue(data, key, value) {
-  if (typeof data !== "object" || data === null || isNullableOrWhitespace(key)) {
-    return data;
-  }
-  const parts = getString(key).split(".");
-  const { length } = parts;
-  let index = 0;
-  let target = data;
-  for (;index < length; index += 1) {
-    const part = parts[index];
-    if (parts.indexOf(part) === parts.length - 1) {
-      _setValue(target, part, value);
-      break;
-    }
-    let next = _getValue(target, part);
-    if (typeof next !== "object" || next === null) {
-      next = /^\d+$/.test(part) ? [] : {};
-      target[part] = next;
-    }
-    target = next;
-  }
-  return data;
-}
 export {
   wait,
   unique,
@@ -402,11 +466,13 @@ export {
   setValue,
   repeat,
   push,
+  merge,
   isObject,
   isNullableOrWhitespace,
   isNullable,
   isArrayOrObject,
   insert,
+  indexOf,
   groupBy,
   getValue,
   getTextDirection,
@@ -417,8 +483,11 @@ export {
   findParentElement,
   findElements,
   findElement,
+  find,
+  filter,
   exists,
   createUuid,
+  clone,
   clamp,
   chunk,
   between,

package/dist/js/index.mjs

@@ -3,6 +3,7 @@ export * from "./array";
 export * from "./element";
 export * from "./event";
 export * from "./number";
+export * from "./object";
 export * from "./string";
 export * from "./timer";
 export * from "./value";

package/dist/js/object.js

@@ -0,0 +1,40 @@
+// src/js/value.ts
+function isArrayOrObject(value) {
+  return /^(array|object)$/i.test(value?.constructor?.name);
+}
+
+// src/js/object.ts
+function clone(value2) {
+  return structuredClone(value2);
+}
+function merge(...values) {
+  if (values.length === 0) {
+    return {};
+  }
+  const actual = values.filter(isArrayOrObject);
+  const result = actual.every(Array.isArray) ? [] : {};
+  const { length: itemsLength } = actual;
+  let itemIndex = 0;
+  for (;itemIndex < itemsLength; itemIndex += 1) {
+    const item = actual[itemIndex];
+    const isArray = Array.isArray(item);
+    const keys = isArray ? undefined : Object.keys(item);
+    const keysLength = isArray ? item.length : keys.length;
+    let keyIndex = 0;
+    for (;keyIndex < keysLength; keyIndex += 1) {
+      const key = keys?.[keyIndex] ?? keyIndex;
+      const next = item[key];
+      const previous = result[key];
+      if (isArrayOrObject(previous) && isArrayOrObject(next)) {
+        result[key] = merge(previous, next);
+      } else {
+        result[key] = next;
+      }
+    }
+  }
+  return result;
+}
+export {
+  merge,
+  clone
+};

package/dist/js/object.mjs

@@ -0,0 +1,36 @@
+// src/js/object.ts
+import {isArrayOrObject} from "./value";
+function clone(value2) {
+  return structuredClone(value2);
+}
+function merge(...values) {
+  if (values.length === 0) {
+    return {};
+  }
+  const actual = values.filter(isArrayOrObject);
+  const result = actual.every(Array.isArray) ? [] : {};
+  const { length: itemsLength } = actual;
+  let itemIndex = 0;
+  for (;itemIndex < itemsLength; itemIndex += 1) {
+    const item = actual[itemIndex];
+    const isArray = Array.isArray(item);
+    const keys = isArray ? undefined : Object.keys(item);
+    const keysLength = isArray ? item.length : keys.length;
+    let keyIndex = 0;
+    for (;keyIndex < keysLength; keyIndex += 1) {
+      const key = keys?.[keyIndex] ?? keyIndex;
+      const next = item[key];
+      const previous = result[key];
+      if (isArrayOrObject(previous) && isArrayOrObject(next)) {
+        result[key] = merge(previous, next);
+      } else {
+        result[key] = next;
+      }
+    }
+  }
+  return result;
+}
+export {
+  merge,
+  clone
+};

package/package.json

@@ -42,6 +42,12 @@
 			"require": "./dist/js/number.js",
 			"types": "./types/number.d.ts"
 		},
+		"./object": {
+			"bun": "./src/js/object.ts",
+			"import": "./dist/js/object.mjs",
+			"require": "./dist/js/object.js",
+			"types": "./types/object.d.ts"
+		},
 		"./string": {
 			"bun": "./src/js/string.ts",
 			"import": "./dist/js/string.mjs",
@@ -86,12 +92,12 @@
 		"build": "bun run build:css && bun run build:js && bun run types",
 		"build:css": "bunx sass ./src/css:./dist/css --no-source-map",
 		"build:js": "bunx bun ./.bun.ts && bunx bun ./.bun.ts --mjs",
-		"test": "bun test --preload ./test/_preload.ts --coverage",
+		"test": "bun test",
 		"types": "bunx tsc -p ./tsconfig.json",
 		"watch:css": "bunx sass ./src/css:./dist/css --no-source-map --watch",
 		"watch:js": "bun build ./src/js/index.ts --outfile ./dist/js/index.js --watch"
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.16.0"
+	"version": "0.17.0"
 }

package/src/js/array.ts

@@ -1,25 +1,126 @@
-import {Key} from './value';
+import {GenericObject, Key} from './value';
 
-type KeyCallback<T> = (item: T) => Key;
+type BooleanCallback<T> = (item: T, index: number, array: T[]) => boolean;
+
+type Callbacks<T> = {
+	bool?: BooleanCallback<T>;
+	key?: KeyCallback<T>;
+};
+
+type FindType = 'index' | 'value';
 
 type InsertType = 'push' | 'splice';
 
-function _getCallback<T>(
-	value: Key | KeyCallback<T> | undefined,
-): KeyCallback<T> | undefined {
-	if (typeof value === 'function') {
-		return value;
+type KeyCallback<T> = (item: T) => Key;
+
+function _getCallbacks<T>(
+	bool: unknown,
+	key: unknown,
+): Callbacks<T> | undefined {
+	if (typeof bool === 'function') {
+		return {bool: bool as BooleanCallback<T>};
 	}
 
-	const isString = typeof value === 'string';
+	if (typeof key === 'function') {
+		return {key: key as KeyCallback<T>};
+	}
+
+	const isString = typeof key === 'string';
 
-	if (!isString && typeof value !== 'number') {
+	if (
+		(!isString && typeof key !== 'number') ||
+		(isString && key.includes('.'))
+	) {
 		return;
 	}
 
-	return isString && value.includes('.')
-		? undefined
-		: (item: T): Key => item[value as never];
+	return {
+		key: (item: T) => (item as GenericObject)?.[key as string] as Key,
+	};
+}
+
+function _findValue<T1, T2 = T1>(
+	type: FindType,
+	array: T1[],
+	value: T2 | BooleanCallback<T1>,
+	key?: Key | KeyCallback<T1>,
+): unknown {
+	const callbacks = _getCallbacks(value, key);
+
+	if (callbacks?.bool === undefined && callbacks?.key === undefined) {
+		return type === 'index'
+			? array.indexOf(value as T1)
+			: array.find(item => item === value);
+	}
+
+	if (callbacks.bool !== undefined) {
+		const index = array.findIndex(callbacks.bool);
+
+		return type === 'index' ? index : index > -1 ? array[index] : undefined;
+	}
+
+	const {length} = array;
+
+	let index = 0;
+
+	for (; index < length; index += 1) {
+		const item = array[index];
+
+		if (callbacks.key?.(item) === value) {
+			return type === 'index' ? index : item;
+		}
+	}
+
+	return type === 'index' ? -1 : undefined;
+}
+
+function _findValues<T1, T2 = T1>(
+	type: 'all' | 'unique',
+	array: T1[],
+	value: T2 | BooleanCallback<T1>,
+	key?: Key | KeyCallback<T1>,
+): T1[] {
+	const callbacks = _getCallbacks(value, key);
+
+	const {length} = array;
+
+	if (type === 'unique' && callbacks?.key === undefined && length >= 100) {
+		return Array.from(new Set(array));
+	}
+
+	if (typeof callbacks?.bool === 'function') {
+		return array.filter(callbacks.bool);
+	}
+
+	if (type === 'all' && key === undefined) {
+		return array.filter(item => item === value);
+	}
+
+	const hasCallback = typeof callbacks?.key === 'function';
+
+	const result: T1[] = [];
+
+	const values: unknown[] = hasCallback ? [] : result;
+
+	let index = 0;
+
+	for (; index < length; index += 1) {
+		const item = array[index];
+		const itemValue = hasCallback ? callbacks.key?.(item) : item;
+
+		if (
+			(type === 'all' && itemValue === value) ||
+			(type === 'unique' && values.indexOf(itemValue) === -1)
+		) {
+			if (values !== result) {
+				values.push(itemValue);
+			}
+
+			result.push(item);
+		}
+	}
+
+	return result;
 }
 
 function _insertValues<T>(
@@ -76,37 +177,90 @@ export function chunk<T>(array: T[], size?: number): T[][] {
 }
 
 /**
- * Does the value exist in the array?
- * - `key` is optional and can be used to specify a key or callback for finding a key for comparisons
- * - If `key` is not provided, the item itself is used for comparisons
+ * Does the value exist in array?
+ */
+export function exists<T1, T2>(
+	array: T1[],
+	value: T2 | BooleanCallback<T1>,
+): boolean;
+
+/**
+ * - Does the value exist in array?
+ * - Use `key` to find a comparison value to match with `value`
  */
 export function exists<T1, T2 = T1>(
 	array: T1[],
 	value: T2,
+	key: Key | KeyCallback<T1>,
+): boolean;
+
+/**
+ * Does the value exist in array?
+ */
+export function exists<T1, T2 = T1>(
+	array: T1[],
+	value: T2 | BooleanCallback<T1>,
 	key?: Key | KeyCallback<T1>,
 ): boolean {
-	const callback = _getCallback(key);
+	return (_findValue('index', array, value, key) as number) > -1;
+}
 
-	if (callback === undefined) {
-		return array.indexOf(value as never) > -1;
-	}
+/**
+ * Returns a filtered array of items matching `value`
+ */
+export function filter<T1, T2>(
+	array: T1[],
+	value: T2 | BooleanCallback<T1>,
+): T1[];
 
-	const needle =
-		typeof value === 'object' && value !== null
-			? callback(value as never)
-			: value;
+/**
+ * - Returns a filtered array of items
+ * - Use `key` to find a comparison value to match with `value`
+ */
+export function filter<T1, T2 = T1>(
+	array: T1[],
+	value: T2,
+	key: Key | KeyCallback<T1>,
+): T1[];
 
-	const {length} = array;
+/**
+ * Returns a filtered array of items
+ */
+export function filter<T1, T2 = T1>(
+	array: T1[],
+	value: T2 | BooleanCallback<T1>,
+	key?: Key | KeyCallback<T1>,
+): T1[] {
+	return _findValues('all', array, value, key);
+}
 
-	let index = 0;
+/**
+ * Returns the first item matching `value`, or `undefined` if no match is found
+ */
+export function find<T1, T2>(
+	array: T1[],
+	value: T2 | BooleanCallback<T1>,
+): T1 | undefined;
 
-	for (; index < length; index += 1) {
-		if (callback(array[index]) === needle) {
-			return true;
-		}
-	}
+/**
+ * - Returns the first matching item, or `undefined` if no match is found
+ * - Use `key` to find a comparison value to match with `value`
+ */
+export function find<T1, T2 = T1>(
+	array: T1[],
+	value: T2,
+	key: Key | KeyCallback<T1>,
+): T1 | undefined;
 
-	return false;
+/**
+ * - Returns the first matching item, or `undefined` if no match is found
+ */
+export function find<T1, T2 = T1>(
+	array: T1[],
+	value: T2 | BooleanCallback<T1>,
+	key?: Key | KeyCallback<T1>,
+): T1 | undefined {
+	return _findValue('value', array, value, key) as T1 | undefined;
 }
 
 /**
@@ -114,11 +268,11 @@ export function exists<T1, T2 = T1>(
  */
 export function groupBy<T>(
 	array: T[],
-	key: Key | ((item: T) => Key),
+	key: Key | KeyCallback<T>,
 ): Record<Key, T[]> {
-	const keyCallback = _getCallback(key) as KeyCallback<T>;
+	const callbacks = _getCallbacks(undefined, key);
 
-	if (keyCallback === undefined) {
+	if (callbacks?.key === undefined) {
 		return {};
 	}
 
@@ -130,7 +284,7 @@ export function groupBy<T>(
 
 	for (; index < length; index += 1) {
 		const item = array[index];
-		const value = keyCallback(item);
+		const value = callbacks.key(item);
 
 		if (value in grouped) {
 			grouped[value].push(item);
@@ -142,6 +296,35 @@ export function groupBy<T>(
 	return grouped;
 }
 
+/**
+ * Returns the index for the first item matching `value`, or `-1` if no match is found
+ */
+export function indexOf<T1, T2>(
+	array: T1[],
+	value: T2 | BooleanCallback<T1>,
+): number;
+
+/**
+ * - Returns the index for the first matching item, or `-1` if no match is found
+ * - Use `key` to find a comparison value to match with `value`
+ */
+export function indexOf<T1, T2 = T1>(
+	array: T1[],
+	value: T2,
+	key: Key | KeyCallback<T1>,
+): number;
+
+/**
+ * Returns the index of the first matching item, or `-1` if no match is found
+ */
+export function indexOf<T1, T2 = T1>(
+	array: T1[],
+	value: T2 | BooleanCallback<T1>,
+	key?: Key | KeyCallback<T1>,
+): number {
+	return _findValue('index', array, value, key) as number;
+}
+
 /**
  * - Inserts values into an array at a specified index
  * - Uses chunking to avoid stack overflow
@@ -172,38 +355,19 @@ export function splice<T>(
 }
 
 /**
- * - Returns a new array with unique items
- * - `key` is optional and can be used to specify a key or callback for finding a key for uniqueness
- * - If `key` is not provided, the item itself is used for comparisons
- * - Inspired by Lodash :-)
+ * Returns an array of unique items
  */
-export function unique<T>(array: T[], key?: Key | ((item: T) => Key)): T[] {
-	const keyCallback = _getCallback(key);
-
-	const {length} = array;
-
-	if (keyCallback === undefined && length >= 100) {
-		return Array.from(new Set(array));
-	}
-
-	const result: T[] = [];
-
-	const values: unknown[] = keyCallback === undefined ? result : [];
+export function unique<T>(array: T[]): T[];
 
-	let index = 0;
-
-	for (; index < length; index += 1) {
-		const item = array[index];
-		const value = keyCallback?.(item) ?? item;
-
-		if (values.indexOf(value) === -1) {
-			if (values !== result) {
-				values.push(value);
-			}
-
-			result.push(item);
-		}
-	}
+/**
+ * - Returns an array of unique items
+ * - Use `key` to find a comparison value to match with `value`
+ */
+export function unique<T>(array: T[], key: Key | KeyCallback<T>): T[];
 
-	return result;
+/**
+ * Returns an array of unique items
+ */
+export function unique<T>(array: T[], key?: Key | KeyCallback<T>): T[] {
+	return _findValues('unique', array, undefined, key);
 }

package/src/js/index.ts

@@ -2,6 +2,7 @@ export * from './array';
 export * from './element';
 export * from './event';
 export * from './number';
+export * from './object';
 export * from './string';
 export * from './timer';
 export * from './value';

package/src/js/object.ts

@@ -0,0 +1,48 @@
+import {ArrayOrObject, GenericObject, isArrayOrObject} from './value';
+
+/**
+ * Clones any kind of value
+ */
+export function clone<T>(value: T): T {
+	return structuredClone(value);
+}
+
+/**
+ * Merges multiple arrays or objects into a single one
+ */
+export function merge<T = ArrayOrObject>(...values: T[]): T {
+	if (values.length === 0) {
+		return {} as T;
+	}
+
+	const actual = values.filter(isArrayOrObject) as GenericObject[];
+	const result = (actual.every(Array.isArray) ? [] : {}) as GenericObject;
+
+	const {length: itemsLength} = actual;
+
+	let itemIndex = 0;
+
+	for (; itemIndex < itemsLength; itemIndex += 1) {
+		const item = actual[itemIndex];
+		const isArray = Array.isArray(item);
+		const keys = isArray ? undefined : Object.keys(item);
+
+		const keysLength = isArray ? item.length : (keys as string[]).length;
+
+		let keyIndex = 0;
+
+		for (; keyIndex < keysLength; keyIndex += 1) {
+			const key = keys?.[keyIndex] ?? keyIndex;
+			const next = item[key];
+			const previous = result[key];
+
+			if (isArrayOrObject(previous) && isArrayOrObject(next)) {
+				result[key] = merge(previous as never, next);
+			} else {
+				result[key] = next;
+			}
+		}
+	}
+
+	return result as T;
+}

package/types/array.d.ts

@@ -1,19 +1,50 @@
 import { Key } from './value';
+type BooleanCallback<T> = (item: T, index: number, array: T[]) => boolean;
 type KeyCallback<T> = (item: T) => Key;
 /**
  * Chunks an array into smaller arrays of a specified size
  */
 export declare function chunk<T>(array: T[], size?: number): T[][];
 /**
- * Does the value exist in the array?
- * - `key` is optional and can be used to specify a key or callback for finding a key for comparisons
- * - If `key` is not provided, the item itself is used for comparisons
+ * Does the value exist in array?
  */
-export declare function exists<T1, T2 = T1>(array: T1[], value: T2, key?: Key | KeyCallback<T1>): boolean;
+export declare function exists<T1, T2>(array: T1[], value: T2 | BooleanCallback<T1>): boolean;
+/**
+ * - Does the value exist in array?
+ * - Use `key` to find a comparison value to match with `value`
+ */
+export declare function exists<T1, T2 = T1>(array: T1[], value: T2, key: Key | KeyCallback<T1>): boolean;
+/**
+ * Returns a filtered array of items matching `value`
+ */
+export declare function filter<T1, T2>(array: T1[], value: T2 | BooleanCallback<T1>): T1[];
+/**
+ * - Returns a filtered array of items
+ * - Use `key` to find a comparison value to match with `value`
+ */
+export declare function filter<T1, T2 = T1>(array: T1[], value: T2, key: Key | KeyCallback<T1>): T1[];
+/**
+ * Returns the first item matching `value`, or `undefined` if no match is found
+ */
+export declare function find<T1, T2>(array: T1[], value: T2 | BooleanCallback<T1>): T1 | undefined;
+/**
+ * - Returns the first matching item, or `undefined` if no match is found
+ * - Use `key` to find a comparison value to match with `value`
+ */
+export declare function find<T1, T2 = T1>(array: T1[], value: T2, key: Key | KeyCallback<T1>): T1 | undefined;
 /**
  * Groups an array of items using a key or callback
  */
-export declare function groupBy<T>(array: T[], key: Key | ((item: T) => Key)): Record<Key, T[]>;
+export declare function groupBy<T>(array: T[], key: Key | KeyCallback<T>): Record<Key, T[]>;
+/**
+ * Returns the index for the first item matching `value`, or `-1` if no match is found
+ */
+export declare function indexOf<T1, T2>(array: T1[], value: T2 | BooleanCallback<T1>): number;
+/**
+ * - Returns the index for the first matching item, or `-1` if no match is found
+ * - Use `key` to find a comparison value to match with `value`
+ */
+export declare function indexOf<T1, T2 = T1>(array: T1[], value: T2, key: Key | KeyCallback<T1>): number;
 /**
  * - Inserts values into an array at a specified index
  * - Uses chunking to avoid stack overflow
@@ -30,10 +61,12 @@ export declare function push<T>(array: T[], values: T[]): number;
  */
 export declare function splice<T>(array: T[], start: number, deleteCount: number, values: T[]): T[];
 /**
- * - Returns a new array with unique items
- * - `key` is optional and can be used to specify a key or callback for finding a key for uniqueness
- * - If `key` is not provided, the item itself is used for comparisons
- * - Inspired by Lodash :-)
+ * Returns an array of unique items
+ */
+export declare function unique<T>(array: T[]): T[];
+/**
+ * - Returns an array of unique items
+ * - Use `key` to find a comparison value to match with `value`
  */
-export declare function unique<T>(array: T[], key?: Key | ((item: T) => Key)): T[];
+export declare function unique<T>(array: T[], key: Key | KeyCallback<T>): T[];
 export {};

package/types/index.d.ts

@@ -2,6 +2,7 @@ export * from './array';
 export * from './element';
 export * from './event';
 export * from './number';
+export * from './object';
 export * from './string';
 export * from './timer';
 export * from './value';

package/types/object.d.ts

@@ -0,0 +1,9 @@
+import { ArrayOrObject } from './value';
+/**
+ * Clones any kind of value
+ */
+export declare function clone<T>(value: T): T;
+/**
+ * Merges multiple arrays or objects into a single one
+ */
+export declare function merge<T = ArrayOrObject>(...values: T[]): T;