@domql/utils 2.5.187 → 3.0.0

package/dist/cjs/props.js

@@ -0,0 +1,220 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var props_exports = {};
+__export(props_exports, {
+  applyProps: () => applyProps,
+  createProps: () => createProps,
+  createPropsStack: () => createPropsStack,
+  inheritParentProps: () => inheritParentProps,
+  initProps: () => initProps,
+  objectizeStringProperty: () => objectizeStringProperty,
+  pickupElementFromProps: () => pickupElementFromProps,
+  pickupPropsFromElement: () => pickupPropsFromElement,
+  propExists: () => propExists,
+  propertizeElement: () => propertizeElement,
+  removeDuplicateProps: () => removeDuplicateProps,
+  setPropsPrototype: () => setPropsPrototype,
+  syncProps: () => syncProps,
+  update: () => update,
+  updateProps: () => updateProps
+});
+module.exports = __toCommonJS(props_exports);
+var import_keys = require("./keys.js");
+var import_events = require("./events.js");
+var import_object = require("./object.js");
+var import_types = require("./types.js");
+const createProps = (element, parent, key) => {
+  const { props, __ref: ref } = element;
+  ref.__propsStack = [];
+  if (props) ref.__initialProps = props;
+  else return {};
+  if (!(0, import_types.isObjectLike)(props)) {
+    ref.__propsStack.push(props);
+    return {};
+  }
+  return { ...props };
+};
+function pickupPropsFromElement(element, opts = {}) {
+  var _a, _b, _c;
+  const cachedKeys = opts.cachedKeys || [];
+  for (const key in element) {
+    const value = element[key];
+    const hasDefine = (0, import_types.isObject)((_a = element.define) == null ? void 0 : _a[key]);
+    const hasGlobalDefine = (0, import_types.isObject)((_c = (_b = element.context) == null ? void 0 : _b.define) == null ? void 0 : _c[key]);
+    const isElement = /^[A-Z]/.test(key) || /^\d+$/.test(key);
+    const isBuiltin = import_keys.DOMQ_PROPERTIES.includes(key);
+    if (!isElement && !isBuiltin && !hasDefine && !hasGlobalDefine) {
+      element.props[key] = value;
+      delete element[key];
+      cachedKeys.push(key);
+    }
+  }
+  return element;
+}
+function pickupElementFromProps(element, opts) {
+  var _a, _b, _c;
+  const cachedKeys = opts.cachedKeys || [];
+  for (const key in element.props) {
+    const value = element.props[key];
+    const isEvent = key.startsWith("on") && key.length > 2;
+    const isFn = (0, import_types.isFunction)(value);
+    if (isEvent && isFn) {
+      (0, import_events.addEventFromProps)(key, element);
+      delete element.props[key];
+      continue;
+    }
+    if (cachedKeys.includes(key)) continue;
+    const hasDefine = (0, import_types.isObject)((_a = element.define) == null ? void 0 : _a[key]);
+    const hasGlobalDefine = (0, import_types.isObject)((_c = (_b = element.context) == null ? void 0 : _b.define) == null ? void 0 : _c[key]);
+    const isElement = /^[A-Z]/.test(key) || /^\d+$/.test(key);
+    const isBuiltin = import_keys.DOMQ_PROPERTIES.includes(key);
+    if (isElement || isBuiltin || hasDefine || hasGlobalDefine) {
+      element[key] = value;
+      delete element.props[key];
+    }
+  }
+  return element;
+}
+function propertizeElement(element, opts = {}) {
+  const cachedKeys = [];
+  pickupPropsFromElement(element, { cachedKeys });
+  pickupElementFromProps(element, { cachedKeys });
+  return element;
+}
+const objectizeStringProperty = (propValue) => {
+  if ((0, import_types.is)(propValue)("string", "number")) {
+    return { inheritedString: propValue };
+  }
+  return propValue;
+};
+const propExists = (prop, stack) => {
+  if (!prop || !stack.length) return false;
+  const key = (0, import_types.isObject)(prop) ? JSON.stringify(prop) : prop;
+  return stack.some((existing) => {
+    const existingKey = (0, import_types.isObject)(existing) ? JSON.stringify(existing) : existing;
+    return existingKey === key;
+  });
+};
+const inheritParentProps = (element, parent) => {
+  var _a;
+  const { __ref: ref } = element;
+  const propsStack = ref.__propsStack || [];
+  const parentProps = parent.props;
+  if (!parentProps) return propsStack;
+  const matchParentKeyProps = parentProps[element.key];
+  const matchParentChildProps = parentProps.childProps;
+  const ignoreChildProps = (_a = element.props) == null ? void 0 : _a.ignoreChildProps;
+  if (matchParentChildProps && !ignoreChildProps) {
+    const childProps = objectizeStringProperty(matchParentChildProps);
+    propsStack.unshift(childProps);
+  }
+  if (matchParentKeyProps) {
+    const keyProps = objectizeStringProperty(matchParentKeyProps);
+    propsStack.unshift(keyProps);
+  }
+  return propsStack;
+};
+async function update(props, options) {
+  const element = this.__element;
+  await element.update({ props }, options);
+}
+function setPropsPrototype(element) {
+  const methods = { update: update.bind(element.props), __element: element };
+  Object.setPrototypeOf(element.props, methods);
+}
+const removeDuplicateProps = (propsStack) => {
+  const seen = /* @__PURE__ */ new Set();
+  return propsStack.filter((prop) => {
+    if (!prop || import_keys.PROPS_METHODS.includes(prop)) return false;
+    const key = (0, import_types.isObject)(prop) ? JSON.stringify(prop) : prop;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+};
+const syncProps = (propsStack, element, opts) => {
+  element.props = propsStack.reduce((mergedProps, v) => {
+    if (import_keys.PROPS_METHODS.includes(v)) return mergedProps;
+    while ((0, import_types.isFunction)(v)) v = (0, import_object.exec)(v, element);
+    return (0, import_object.deepMerge)(mergedProps, (0, import_object.deepClone)(v, { exclude: import_keys.PROPS_METHODS }));
+  }, {});
+  setPropsPrototype(element);
+  return element.props;
+};
+const createPropsStack = (element, parent) => {
+  const { props, __ref: ref } = element;
+  let propsStack = ref.__propsStack || [];
+  if (parent && parent.props) {
+    const parentStack = inheritParentProps(element, parent);
+    propsStack = [...parentStack];
+  }
+  if ((0, import_types.isObject)(props)) propsStack.push(props);
+  else if (props === "inherit" && (parent == null ? void 0 : parent.props)) propsStack.push(parent.props);
+  else if (props) propsStack.push(props);
+  if ((0, import_types.isArray)(ref.__extendsStack)) {
+    ref.__extendsStack.forEach((_extends) => {
+      if (_extends.props && _extends.props !== props) {
+        propsStack.push(_extends.props);
+      }
+    });
+  }
+  ref.__propsStack = removeDuplicateProps(propsStack);
+  return ref.__propsStack;
+};
+const applyProps = (element, parent) => {
+  const { __ref: ref } = element;
+  const propsStack = createPropsStack(element, parent);
+  if (propsStack.length) {
+    syncProps(propsStack, element);
+  } else {
+    ref.__propsStack = [];
+    element.props = {};
+  }
+};
+const initProps = function(element, parent, options) {
+  const { __ref: ref } = element;
+  if (ref.__if) applyProps(element, parent);
+  else {
+    try {
+      applyProps(element, parent);
+    } catch {
+      element.props = {};
+      ref.__propsStack = [];
+    }
+  }
+  setPropsPrototype(element);
+  return element;
+};
+const updateProps = (newProps, element, parent) => {
+  const { __ref: ref } = element;
+  const propsStack = ref.__propsStack || [];
+  let newStack = [...propsStack];
+  const parentProps = inheritParentProps(element, parent);
+  if (parentProps.length) {
+    newStack = [...parentProps, ...newStack];
+  }
+  if (newProps) {
+    newStack = [newProps, ...newStack];
+  }
+  ref.__propsStack = removeDuplicateProps(newStack);
+  if (ref.__propsStack.length) {
+    syncProps(ref.__propsStack, element);
+  }
+  return element;
+};

package/dist/cjs/scope.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var scope_exports = {};
+__export(scope_exports, {
+  createScope: () => createScope
+});
+module.exports = __toCommonJS(scope_exports);
+const createScope = (element, parent) => {
+  var _a;
+  const { __ref: ref } = element;
+  if (!element.scope) element.scope = parent.scope || ((_a = ref.root) == null ? void 0 : _a.scope) || {};
+};

package/dist/cjs/state.js

@@ -0,0 +1,175 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var state_exports = {};
+__export(state_exports, {
+  applyDependentState: () => applyDependentState,
+  checkForStateTypes: () => checkForStateTypes,
+  checkIfInherits: () => checkIfInherits,
+  createInheritedState: () => createInheritedState,
+  createNestedObjectByKeyPath: () => createNestedObjectByKeyPath,
+  findInheritedState: () => findInheritedState,
+  getChildStateInKey: () => getChildStateInKey,
+  getParentStateInKey: () => getParentStateInKey,
+  getRootStateInKey: () => getRootStateInKey,
+  isState: () => isState,
+  overwriteState: () => overwriteState
+});
+module.exports = __toCommonJS(state_exports);
+var import_array = require("./array.js");
+var import_keys = require("./keys.js");
+var import_object = require("./object.js");
+var import_types = require("./types.js");
+const checkForStateTypes = async (element) => {
+  const { state: orig, props, __ref: ref } = element;
+  const state = (props == null ? void 0 : props.state) || orig;
+  if ((0, import_types.isFunction)(state)) {
+    ref.__state = state;
+    return await (0, import_object.execPromise)(state, element);
+  } else if ((0, import_types.is)(state)("string", "number")) {
+    ref.__state = state;
+    return { value: state };
+  } else if (state === true) {
+    ref.__state = element.key;
+    return {};
+  } else if (state) {
+    ref.__hasRootState = true;
+    return state;
+  } else {
+    return false;
+  }
+};
+const getRootStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("~/")) return;
+  const arr = stateKey.split("~/");
+  if (arr.length > 1) return parentState.root;
+};
+const getParentStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("../")) return;
+  const arr = stateKey.split("../");
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    if (!parentState.parent) return null;
+    parentState = parentState.parent;
+  }
+  return parentState;
+};
+const getChildStateInKey = (stateKey, parentState, options = {}) => {
+  const arr = (0, import_types.isString)(stateKey) ? stateKey.split("/") : [stateKey];
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    const childKey = arr[i];
+    const grandChildKey = arr[i + 1];
+    if (childKey === "__proto__" || grandChildKey === "__proto__") return;
+    let childInParent = parentState[childKey];
+    if (!childInParent) childInParent = parentState[childKey] = {};
+    if (!childInParent[grandChildKey]) childInParent[grandChildKey] = {};
+    stateKey = grandChildKey;
+    parentState = childInParent;
+  }
+  if (options.returnParent) return parentState;
+  return parentState[stateKey];
+};
+const findInheritedState = (element, parent, options = {}) => {
+  const ref = element.__ref;
+  let stateKey = ref.__state;
+  if (!checkIfInherits(element)) return;
+  const rootState = getRootStateInKey(stateKey, parent.state);
+  let parentState = parent.state;
+  if (rootState) {
+    parentState = rootState;
+    stateKey = stateKey.replaceAll("~/", "");
+  } else {
+    const findGrandParentState = getParentStateInKey(stateKey, parent.state);
+    if (findGrandParentState) {
+      parentState = findGrandParentState;
+      stateKey = stateKey.replaceAll("../", "");
+    }
+  }
+  if (!parentState) return;
+  return getChildStateInKey(stateKey, parentState, options);
+};
+const createInheritedState = (element, parent) => {
+  const ref = element.__ref;
+  const inheritedState = findInheritedState(element, parent);
+  if ((0, import_types.isUndefined)(inheritedState)) return element.state;
+  if ((0, import_types.is)(inheritedState)("object", "array")) {
+    return (0, import_object.deepClone)(inheritedState);
+  } else if ((0, import_types.is)(inheritedState)("string", "number", "boolean")) {
+    ref.__stateType = typeof inheritedState;
+    return { value: inheritedState };
+  }
+  console.warn(ref.__state, "is not present. Replacing with", {});
+};
+const checkIfInherits = (element) => {
+  const { __ref: ref } = element;
+  const stateKey = ref == null ? void 0 : ref.__state;
+  if (stateKey && (0, import_types.is)(stateKey)("number", "string", "boolean")) return true;
+  return false;
+};
+const isState = function(state) {
+  if (!(0, import_types.isObjectLike)(state)) return false;
+  return Boolean(
+    state.update && state.parse && state.clean && state.create && state.parent && state.destroy && state.rootUpdate && state.parentUpdate && state.keys && state.values && state.toggle && state.replace && state.quietUpdate && state.quietReplace && state.add && state.apply && state.applyReplace && state.setByPath && state.setPathCollection && state.removeByPath && state.removePathCollection && state.getByPath && state.applyFunction && state.__element && state.__children
+  );
+};
+const createNestedObjectByKeyPath = (path, value) => {
+  if (!path) {
+    return value || {};
+  }
+  const keys = path.split("/");
+  const obj = {};
+  let ref = obj;
+  keys.forEach((key, index) => {
+    ref[key] = index === keys.length - 1 ? value || {} : {};
+    ref = ref[key];
+  });
+  return obj;
+};
+const applyDependentState = async (element, state) => {
+  const { __element } = state;
+  const origState = await (0, import_object.execPromise)(__element == null ? void 0 : __element.state, element);
+  if (!origState) return;
+  const dependentState = (0, import_object.deepClone)(origState, import_keys.STATE_METHODS);
+  const newDepends = { [element.key]: dependentState };
+  const __depends = (0, import_types.isObject)(origState.__depends) ? { ...origState.__depends, ...newDepends } : newDepends;
+  if (Array.isArray(origState)) {
+    (0, import_array.addProtoToArray)(origState, {
+      ...Object.getPrototypeOf(origState),
+      __depends
+    });
+  } else {
+    Object.setPrototypeOf(origState, {
+      ...Object.getPrototypeOf(origState),
+      __depends
+    });
+  }
+  return dependentState;
+};
+const overwriteState = (state, obj, options = {}) => {
+  const { overwrite } = options;
+  if (!overwrite) return;
+  const shallow = overwrite === "shallow";
+  const merge = overwrite === "merge";
+  if (merge) {
+    (0, import_object.deepMerge)(state, obj, import_keys.STATE_METHODS);
+    return;
+  }
+  const overwriteFunc = shallow ? import_object.overwriteShallow : import_object.overwriteDeep;
+  overwriteFunc(state, obj, import_keys.STATE_METHODS);
+};

package/dist/cjs/string.js

@@ -43,29 +43,37 @@ const trimStringFromSymbols = (str, characters) => {
   return str.replace(pattern, "");
 };
 const brackRegex = {
-  2: /\{\{\s*((?:\.\.\/)+)?([^}\s]+)\s*\}\}/g,
-  3: /\{\{\{\s*((?:\.\.\/)+)?([^}\s]+)\s*\}\}\}/g
+  2: /{{\s*((?:\.\.\/)*)([\w\d.]+)\s*}}/g,
+  3: /{{{(\s*(?:\.\.\/)*)([\w\d.]+)\s*}}}/g
 };
-function replaceLiteralsWithObjectFields(str, options = {}, forcedState) {
-  if (!str.includes(options.bracketsLength === 3 ? "{{{" : "{{"))
-    return str;
-  const reg = brackRegex[options.bracketsLength || 2];
-  const obj = forcedState || (this == null ? void 0 : this.state) || {};
+const getNestedValue = (obj, path) => {
+  return path.split(".").reduce((acc, part) => {
+    return acc && acc[part] !== void 0 ? acc[part] : void 0;
+  }, obj);
+};
+function replaceLiteralsWithObjectFields(str, state = {}, options = {}) {
+  const { bracketsLength = 2 } = options;
+  const bracketPattern = bracketsLength === 3 ? "{{{" : "{{";
+  if (!str.includes(bracketPattern)) return str;
+  const reg = brackRegex[bracketsLength];
+  const obj = state || {};
   return str.replace(reg, (_, parentPath, variable) => {
     if (parentPath) {
-      const parentLevels = parentPath.match(options.bracketsLength === 3 ? /\.\.\.\//g : /\.\.\//g).length;
+      const parentLevels = (parentPath.match(/\.\.\//g) || []).length;
       let parentState = obj;
       for (let i = 0; i < parentLevels; i++) {
+        if (!parentState || !parentState.parent) return "";
         parentState = parentState.parent;
-        if (!parentState) {
-          return "";
-        }
       }
-      const value = parentState[variable.trim()];
-      return value !== void 0 ? `${value}` : "";
+      const key = variable.trim();
+      if (key === "parent") {
+        return parentState.value !== void 0 ? String(parentState.value) : "";
+      }
+      const value = getNestedValue(parentState, key);
+      return value !== void 0 ? String(value) : "";
     } else {
-      const value = obj[variable.trim()];
-      return value !== void 0 ? `${value}` : "";
+      const value = getNestedValue(obj, variable.trim());
+      return value !== void 0 ? String(value) : "";
     }
   });
 }
@@ -141,5 +149,8 @@ const customEncodeURIComponent = (str) => {
   }).join("");
 };
 const customDecodeURIComponent = (encodedStr) => {
-  return encodedStr.replace(/%[0-9A-Fa-f]{2}/g, (match) => String.fromCharCode(parseInt(match.slice(1), 16)));
+  return encodedStr.replace(
+    /%[0-9A-Fa-f]{2}/g,
+    (match) => String.fromCharCode(parseInt(match.slice(1), 16))
+  );
 };

package/dist/cjs/types.js

@@ -36,8 +36,7 @@ __export(types_exports, {
 module.exports = __toCommonJS(types_exports);
 var import_node = require("./node.js");
 const isObject = (arg) => {
-  if (arg === null)
-    return false;
+  if (arg === null) return false;
   return typeof arg === "object" && arg.constructor === Object;
 };
 const isString = (arg) => typeof arg === "string";
@@ -48,8 +47,7 @@ const isNull = (arg) => arg === null;
 const isArray = (arg) => Array.isArray(arg);
 const isDate = (d) => d instanceof Date;
 const isObjectLike = (arg) => {
-  if (arg === null)
-    return false;
+  if (arg === null) return false;
   return typeof arg === "object";
 };
 const isDefined = (arg) => {

package/dist/cjs/update.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var update_exports = {};
+__export(update_exports, {
+  captureSnapshot: () => captureSnapshot
+});
+module.exports = __toCommonJS(update_exports);
+var import_key = require("./key.js");
+const snapshot = {
+  snapshotId: import_key.createSnapshotId
+};
+const captureSnapshot = (element, options) => {
+  const ref = element.__ref;
+  const { currentSnapshot, calleeElement } = options;
+  const isCallee = calleeElement === element;
+  if (!calleeElement || isCallee) {
+    const createdStanpshot = snapshot.snapshotId();
+    ref.__currentSnapshot = createdStanpshot;
+    return [createdStanpshot, element];
+  }
+  const snapshotOnCallee = calleeElement.__ref.__currentSnapshot;
+  if (currentSnapshot < snapshotOnCallee) {
+    return [snapshotOnCallee, calleeElement, true];
+  }
+  return [snapshotOnCallee, calleeElement];
+};

package/dist/esm/array.js

@@ -9,31 +9,29 @@ const getFrequencyInArray = (arr, value) => {
   }, 0);
 };
 const removeFromArray = (arr, index) => {
-  if (isString(index))
-    index = parseInt(index);
+  if (isString(index)) index = parseInt(index);
   if (isNumber(index)) {
     if (index < 0 || index >= arr.length || isNaN(index)) {
       throw new Error("Invalid index");
     }
     arr.splice(index, 1);
-  } else if (isArray(index)) {
-    index.forEach((idx) => removeFromArray(arr, idx));
   } else {
     throw new Error("Invalid index");
   }
   return arr;
 };
 const swapItemsInArray = (arr, i, j) => {
+  ;
   [arr[i], arr[j]] = [arr[j], arr[i]];
 };
 const joinArrays = (...arrays) => {
   return [].concat(...arrays);
 };
-const mergeArray = (arr, exclude = []) => {
-  return arr.reduce((a, c) => deepMerge(a, deepClone(c, { exclude }), exclude), {});
-};
-const mergeAndCloneIfArray = (obj) => {
-  return isArray(obj) ? mergeArray(obj) : deepClone(obj);
+const unstackArrayOfObjects = (arr, exclude = []) => {
+  return arr.reduce(
+    (a, c) => deepMerge(a, deepClone(c, { exclude }), exclude),
+    {}
+  );
 };
 const cutArrayBeforeValue = (arr, value) => {
   const index = arr.indexOf(value);
@@ -43,8 +41,7 @@ const cutArrayBeforeValue = (arr, value) => {
   return arr;
 };
 const cutArrayAfterValue = (arr, value) => {
-  if (!isArray(arr))
-    return;
+  if (!isArray(arr)) return;
   const index = arr.indexOf(value);
   if (index !== -1) {
     return arr.slice(index + 1);
@@ -103,12 +100,29 @@ const filterArraysFast = (sourceArr, excludeArr) => {
   return sourceArr.filter((item) => !excludeSet.has(item));
 };
 const checkIfStringIsInArray = (string, arr) => {
-  if (!string)
-    return;
+  if (!string) return;
   return arr.filter((v) => string.includes(v)).length;
 };
+const removeDuplicatesInArray = (arr) => {
+  if (!isArray(arr)) return arr;
+  return [...new Set(arr)];
+};
+const addProtoToArray = (state, proto) => {
+  for (const key in proto) {
+    Object.defineProperty(state, key, {
+      value: proto[key],
+      enumerable: false,
+      // Set this to true if you want the method to appear in for...in loops
+      configurable: true,
+      // Set this to true if you want to allow redefining/removing the property later
+      writable: true
+      // Set this to true if you want to allow changing the function later
+    });
+  }
+};
 export {
   addItemAfterEveryElement,
+  addProtoToArray,
   arrayContainsOtherArray,
   arraysEqual,
   checkIfStringIsInArray,
@@ -118,11 +132,11 @@ export {
   filterArraysFast,
   getFrequencyInArray,
   joinArrays,
-  mergeAndCloneIfArray,
-  mergeArray,
+  removeDuplicatesInArray,
   removeFromArray,
   removeValueFromArray,
   removeValueFromArrayAll,
   reorderArrayByValues,
-  swapItemsInArray
+  swapItemsInArray,
+  unstackArrayOfObjects
 };

package/dist/esm/cache.js

@@ -0,0 +1,6 @@
+const cache = {};
+const OPTIONS = {};
+export {
+  OPTIONS,
+  cache
+};