@domql/utils 2.5.156 → 2.5.161

package/array.js

@@ -1,6 +1,6 @@
 'use strict'
 
-import { deepCloneWithExtend, deepMerge } from './object'
+import { deepClone, deepMerge } from './object'
 import { isArray, isNumber, isString } from './types'
 
 export const arrayContainsOtherArray = (arr1, arr2) => {
@@ -39,15 +39,15 @@ export const joinArrays = (...arrays) => {
 /**
  * Merges array extendtypes
  */
-export const mergeArray = (arr, excludeFrom = []) => {
-  return arr.reduce((a, c) => deepMerge(a, deepCloneWithExtend(c, excludeFrom), excludeFrom), {})
+export const mergeArray = (arr, exclude = []) => {
+  return arr.reduce((a, c) => deepMerge(a, deepClone(c, { exclude }), exclude), {})
 }
 
 /**
  * Merges array extends
  */
 export const mergeAndCloneIfArray = obj => {
-  return isArray(obj) ? mergeArray(obj) : deepCloneWithExtend(obj)
+  return isArray(obj) ? mergeArray(obj) : deepClone(obj)
 }
 
 export const cutArrayBeforeValue = (arr, value) => {

package/component.js

@@ -1,7 +1,7 @@
 'use strict'
 
 import {
-  deepCloneWithExtend,
+  deepClone,
   exec,
   isArray,
   isFunction,
@@ -116,7 +116,7 @@ export const addChildrenIfNotInOriginal = (element, parent, key) => {
 
     if (newChild?.ignoreExtend) continue
     if (newChild === null) assignChild(null)
-    else if (!childElem) assignChild(deepCloneWithExtend(newChild))
+    else if (!childElem) assignChild(deepClone(newChild))
     else {
       const isSugarChildElem = checkIfSugar(childElem, parent, key)
       if (isSugarChildElem) continue

package/dist/cjs/array.js

@@ -67,11 +67,11 @@ const swapItemsInArray = (arr, i, j) => {
 const joinArrays = (...arrays) => {
   return [].concat(...arrays);
 };
-const mergeArray = (arr, excludeFrom = []) => {
-  return arr.reduce((a, c) => (0, import_object.deepMerge)(a, (0, import_object.deepCloneWithExtend)(c, excludeFrom), excludeFrom), {});
+const mergeArray = (arr, exclude = []) => {
+  return arr.reduce((a, c) => (0, import_object.deepMerge)(a, (0, import_object.deepClone)(c, { exclude }), exclude), {});
 };
 const mergeAndCloneIfArray = (obj) => {
-  return (0, import_types.isArray)(obj) ? mergeArray(obj) : (0, import_object.deepCloneWithExtend)(obj);
+  return (0, import_types.isArray)(obj) ? mergeArray(obj) : (0, import_object.deepClone)(obj);
 };
 const cutArrayBeforeValue = (arr, value) => {
   const index = arr.indexOf(value);

package/dist/cjs/component.js

@@ -135,7 +135,7 @@ const addChildrenIfNotInOriginal = (element, parent, key) => {
     if (newChild === null)
       assignChild(null);
     else if (!childElem)
-      assignChild((0, import__.deepCloneWithExtend)(newChild));
+      assignChild((0, import__.deepClone)(newChild));
     else {
       const isSugarChildElem = checkIfSugar(childElem, parent, key);
       if (isSugarChildElem)

package/dist/cjs/object.js

@@ -22,8 +22,6 @@ __export(object_exports, {
   createNestedObject: () => createNestedObject,
   createObjectWithoutPrototype: () => createObjectWithoutPrototype,
   deepClone: () => deepClone,
-  deepCloneExclude: () => deepCloneExclude,
-  deepCloneWithExtend: () => deepCloneWithExtend,
   deepContains: () => deepContains,
   deepDestringify: () => deepDestringify,
   deepDiff: () => deepDiff,
@@ -117,78 +115,56 @@ const clone = (obj, excludeFrom = []) => {
   }
   return o;
 };
-const deepCloneExclude = (obj, excludeFrom = []) => {
-  if ((0, import_types.isArray)(obj)) {
-    return obj.map((x) => deepCloneExclude(x, excludeFrom));
-  }
-  const o = {};
-  for (const k in obj) {
-    const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, k);
-    if (!hasOwnProperty2 || excludeFrom.includes(k) || k.startsWith("__"))
-      continue;
-    let v = obj[k];
-    if (k === "extend" && (0, import_types.isArray)(v)) {
-      v = mergeArrayExclude(v, excludeFrom);
-    }
-    if ((0, import_types.isArray)(v)) {
-      o[k] = v.map((x) => deepCloneExclude(x, excludeFrom));
-    } else if ((0, import_types.isObject)(v)) {
-      o[k] = deepCloneExclude(v, excludeFrom);
-    } else
-      o[k] = v;
-  }
-  return o;
-};
-const mergeArrayExclude = (arr, excl = []) => {
-  return arr.reduce((acc, curr) => deepMerge(acc, deepCloneExclude(curr, excl)), {});
-};
-const deepClone = (obj, exclude = [], cleanUndefined = false, visited = /* @__PURE__ */ new WeakMap()) => {
-  if (!(0, import_types.isObjectLike)(obj) || (0, import_node.isDOMNode)(obj))
+const mergeArrayExclude = (arr, exclude = []) => {
+  return arr.reduce((acc, curr) => deepMerge(acc, deepClone(curr, { exclude })), {});
+};
+const deepClone = (obj, options = {}) => {
+  const {
+    exclude = [],
+    cleanUndefined = false,
+    cleanNull = false,
+    window: targetWindow,
+    visited = /* @__PURE__ */ new WeakMap(),
+    handleExtend = false
+  } = options;
+  if (!(0, import_types.isObjectLike)(obj) || (0, import_node.isDOMNode)(obj)) {
     return obj;
-  if (visited.has(obj))
+  }
+  if (visited.has(obj)) {
     return visited.get(obj);
-  const clone2 = (0, import_types.isArray)(obj) ? [] : {};
+  }
+  const clone2 = targetWindow ? (0, import_types.isArray)(obj) ? new targetWindow.Array() : new targetWindow.Object() : (0, import_types.isArray)(obj) ? [] : {};
   visited.set(obj, clone2);
   for (const key in obj) {
-    if (Object.prototype.hasOwnProperty.call(obj, key) && !exclude.includes(key)) {
-      const value = obj[key];
-      if ((0, import_node.isDOMNode)(value)) {
-        clone2[key] = value;
-      } else if (key === "extend" && (0, import_types.isArray)(value)) {
-        clone2[key] = (0, import_array.mergeArray)(value, exclude);
-      } else if ((0, import_types.isObjectLike)(value)) {
-        clone2[key] = deepClone(value, exclude, cleanUndefined, visited);
-      } else {
-        clone2[key] = value;
-      }
-    }
-  }
-  return clone2;
-};
-const deepCloneWithExtend = (obj, excludeFrom = ["node"], options = {}, visited = /* @__PURE__ */ new WeakSet()) => {
-  if ((0, import_types.isObjectLike)(obj)) {
-    if (visited.has(obj)) {
-      return obj;
+    if (!Object.prototype.hasOwnProperty.call(obj, key))
+      continue;
+    if (exclude.includes(key) || key.startsWith("__") || key === "__proto__")
+      continue;
+    const value = obj[key];
+    if (cleanUndefined && (0, import_types.isUndefined)(value) || cleanNull && (0, import_types.isNull)(value))
+      continue;
+    if ((0, import_node.isDOMNode)(value)) {
+      clone2[key] = value;
+      continue;
     }
-    visited.add(obj);
-  }
-  const o = options.window ? (0, import_types.isArray)(obj) ? new options.window.Array([]) : new options.window.Object({}) : (0, import_types.isArray)(obj) ? [] : {};
-  for (const prop in obj) {
-    if (!Object.prototype.hasOwnProperty.call(obj, prop))
+    if (handleExtend && key === "extend" && (0, import_types.isArray)(value)) {
+      clone2[key] = (0, import_array.mergeArray)(value, exclude);
       continue;
-    const objProp = obj[prop];
-    if (excludeFrom.includes(prop) || prop.startsWith("__") || options.cleanUndefined && (0, import_types.isUndefined)(objProp) || options.cleanNull && (0, import_types.isNull)(objProp)) {
+    }
+    if ((0, import_types.isFunction)(value) && targetWindow) {
+      clone2[key] = targetWindow.eval("(" + value.toString() + ")");
       continue;
     }
-    if ((0, import_types.isObjectLike)(objProp)) {
-      o[prop] = deepCloneWithExtend(objProp, excludeFrom, options, visited);
-    } else if ((0, import_types.isFunction)(objProp) && options.window) {
-      o[prop] = (options.window || import_globals.window).eval("(" + objProp.toString() + ")");
+    if ((0, import_types.isObjectLike)(value)) {
+      clone2[key] = deepClone(value, {
+        ...options,
+        visited
+      });
     } else {
-      o[prop] = objProp;
+      clone2[key] = value;
     }
   }
-  return o;
+  return clone2;
 };
 const deepStringify = (obj, stringified = {}) => {
   var _a, _b;

package/dist/esm/array.js

@@ -0,0 +1,122 @@
+import { deepClone, deepMerge } from "./object";
+import { isArray, isNumber, isString } from "./types";
+const arrayContainsOtherArray = (arr1, arr2) => {
+  return arr2.every((val) => arr1.includes(val));
+};
+const getFrequencyInArray = (arr, value) => {
+  return arr.reduce((count, currentValue) => {
+    return currentValue === value ? count + 1 : count;
+  }, 0);
+};
+const removeFromArray = (arr, 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 cutArrayBeforeValue = (arr, value) => {
+  const index = arr.indexOf(value);
+  if (index !== -1) {
+    return arr.slice(0, index);
+  }
+  return arr;
+};
+const cutArrayAfterValue = (arr, value) => {
+  if (!isArray(arr))
+    return;
+  const index = arr.indexOf(value);
+  if (index !== -1) {
+    return arr.slice(index + 1);
+  }
+  return arr;
+};
+const removeValueFromArray = (arr, value) => {
+  const index = arr.indexOf(value);
+  if (index > -1) {
+    const newArray = [...arr];
+    newArray.splice(index, 1);
+    return newArray;
+  }
+  return arr;
+};
+const removeValueFromArrayAll = (arr, value) => {
+  return arr.filter((item) => item !== value);
+};
+const addItemAfterEveryElement = (array, item) => {
+  const result = [];
+  for (let i = 0; i < array.length; i++) {
+    result.push(array[i]);
+    if (i < array.length - 1) {
+      result.push(item);
+    }
+  }
+  return result;
+};
+const reorderArrayByValues = (array, valueToMove, insertBeforeValue) => {
+  const newArray = [...array];
+  const indexToMove = newArray.indexOf(valueToMove);
+  const indexToInsertBefore = newArray.indexOf(insertBeforeValue);
+  if (indexToMove !== -1 && indexToInsertBefore !== -1) {
+    const removedItem = newArray.splice(indexToMove, 1)[0];
+    const insertIndex = indexToInsertBefore < indexToMove ? indexToInsertBefore : indexToInsertBefore + 1;
+    newArray.splice(insertIndex, 0, removedItem);
+  }
+  return newArray;
+};
+const arraysEqual = (arr1, arr2) => {
+  if (arr1.length !== arr2.length) {
+    return false;
+  }
+  for (let i = 0; i < arr1.length; i++) {
+    if (arr1[i] !== arr2[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+const filterArrays = (sourceArr, excludeArr) => {
+  return sourceArr.filter((item) => !excludeArr.includes(item));
+};
+const filterArraysFast = (sourceArr, excludeArr) => {
+  const excludeSet = new Set(excludeArr);
+  return sourceArr.filter((item) => !excludeSet.has(item));
+};
+export {
+  addItemAfterEveryElement,
+  arrayContainsOtherArray,
+  arraysEqual,
+  cutArrayAfterValue,
+  cutArrayBeforeValue,
+  filterArrays,
+  filterArraysFast,
+  getFrequencyInArray,
+  joinArrays,
+  mergeAndCloneIfArray,
+  mergeArray,
+  removeFromArray,
+  removeValueFromArray,
+  removeValueFromArrayAll,
+  reorderArrayByValues,
+  swapItemsInArray
+};

package/dist/esm/component.js

@@ -0,0 +1,241 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import {
+  deepClone,
+  exec,
+  isArray,
+  isFunction,
+  isObject,
+  isString,
+  joinArrays
+} from ".";
+const ENV = "development";
+const checkIfKeyIsComponent = (key) => {
+  const isFirstKeyString = isString(key);
+  if (!isFirstKeyString)
+    return;
+  const firstCharKey = key.slice(0, 1);
+  return /^[A-Z]*$/.test(firstCharKey);
+};
+const checkIfKeyIsProperty = (key) => {
+  const isFirstKeyString = isString(key);
+  if (!isFirstKeyString)
+    return;
+  const firstCharKey = key.slice(0, 1);
+  return /^[a-z]*$/.test(firstCharKey);
+};
+const addAdditionalExtend = (newExtend, element) => {
+  if (!newExtend)
+    return element;
+  const { extend: elementExtend } = element;
+  const originalArray = isArray(elementExtend) ? elementExtend : [elementExtend];
+  const receivedArray = isArray(newExtend) ? newExtend : [newExtend];
+  const extend = joinArrays(receivedArray, originalArray);
+  return __spreadProps(__spreadValues({}, element), { extend });
+};
+const checkIfSugar = (element, parent, key) => {
+  var _a;
+  const {
+    extend,
+    props,
+    childExtend,
+    extends: extendProps,
+    childExtends,
+    childProps,
+    children,
+    on,
+    $collection,
+    $stateCollection,
+    $propsCollection
+  } = element;
+  const hasComponentAttrs = extend || childExtend || props || on || $collection || $stateCollection || $propsCollection;
+  if (hasComponentAttrs && (childProps || extendProps || children || childExtends)) {
+    const logErr = (_a = parent || element) == null ? void 0 : _a.error;
+    if (logErr)
+      logErr.call(element, "Sugar component includes params for builtin components", { verbose: true });
+  }
+  return !hasComponentAttrs || childProps || extendProps || children || childExtends;
+};
+const extendizeByKey = (element, parent, key) => {
+  const { context } = parent;
+  const { tag, extend, childExtends } = element;
+  const isSugar = checkIfSugar(element, parent, key);
+  const extendFromKey = key.includes("+") ? key.split("+") : key.includes("_") ? [key.split("_")[0]] : key.includes(".") && !checkIfKeyIsComponent(key.split(".")[1]) ? [key.split(".")[0]] : [key];
+  const isExtendKeyComponent = context && context.components[extendFromKey];
+  if (element === isExtendKeyComponent)
+    return element;
+  else if (isSugar) {
+    const newElem = addAdditionalExtend(element.extends, {
+      extend: extendFromKey,
+      tag,
+      props: __spreadValues({}, element)
+    });
+    if (childExtends)
+      newElem.childExtend = childExtends;
+    return newElem;
+  } else if (!extend || extend === true) {
+    return __spreadProps(__spreadValues({}, element), {
+      tag,
+      extend: extendFromKey
+    });
+  } else if (extend) {
+    return addAdditionalExtend(extendFromKey, element);
+  } else if (isFunction(element)) {
+    return {
+      extend: extendFromKey,
+      tag,
+      props: __spreadValues({}, exec(element, parent))
+    };
+  }
+};
+function getCapitalCaseKeys(obj) {
+  return Object.keys(obj).filter((key) => /^[A-Z]/.test(key));
+}
+const addChildrenIfNotInOriginal = (element, parent, key) => {
+  const childElems = getCapitalCaseKeys(element.props);
+  if (!childElems.length)
+    return element;
+  for (const i in childElems) {
+    const childKey = childElems[i];
+    const childElem = element[childKey];
+    const newChild = element.props[childKey];
+    const assignChild = (val) => {
+      element[childKey] = val;
+      delete element.props[childKey];
+    };
+    if (newChild == null ? void 0 : newChild.ignoreExtend)
+      continue;
+    if (newChild === null)
+      assignChild(null);
+    else if (!childElem)
+      assignChild(deepClone(newChild));
+    else {
+      const isSugarChildElem = checkIfSugar(childElem, parent, key);
+      if (isSugarChildElem)
+        continue;
+      assignChild({
+        extend: element[childKey],
+        props: newChild
+      });
+    }
+  }
+};
+const applyKeyComponentAsExtend = (element, parent, key) => {
+  return extendizeByKey(element, parent, key) || element;
+};
+const applyComponentFromContext = (element, parent, options) => {
+  const { context } = element;
+  if (!context || !context.components)
+    return;
+  const { components } = context;
+  const { extend } = element;
+  const execExtend = exec(extend, element);
+  if (isString(execExtend)) {
+    const componentExists = components[execExtend] || components["smbls." + execExtend];
+    if (componentExists)
+      element.extend = componentExists;
+    else {
+      if ((ENV === "test" || ENV === "development") && options.verbose) {
+        console.warn(execExtend, "is not in library", components, element);
+        console.warn("replacing with ", {});
+      }
+      element.extend = {};
+    }
+  }
+};
+const isVariant = (param) => {
+  if (!isString(param))
+    return;
+  const firstCharKey = param.slice(0, 1);
+  return firstCharKey === ".";
+};
+const hasVariantProp = (element) => {
+  const { props } = element;
+  if (isObject(props) && isString(props.variant))
+    return true;
+};
+const getChildrenComponentsByKey = (key, el) => {
+  if (key === el.key || el.__ref.__componentKey === key) {
+    return el;
+  }
+  if (el.extend) {
+    const foundString = isString(el.extend) && el.extend === key;
+    const foundInArray = isArray(el.extend) && el.extend.filter((v) => v === key).length;
+    if (foundString || foundInArray)
+      return el;
+  }
+  if (el.parent && el.parent.childExtend) {
+    const foundString = isString(el.parent.childExtend) && el.parent.childExtend === key;
+    const foundInArray = isArray(el.parent.childExtend) && el.parent.childExtend.filter((v) => v === key).length;
+    if (foundString || foundInArray)
+      return el;
+  }
+};
+const getExtendsInElement = (obj) => {
+  let result = [];
+  function traverse(o) {
+    for (const key in o) {
+      if (Object.hasOwnProperty.call(o, key)) {
+        if (checkIfKeyIsComponent(key)) {
+          result.push(key);
+        }
+        if (key === "extend") {
+          if (typeof o[key] === "string") {
+            result.push(o[key]);
+          } else if (Array.isArray(o[key])) {
+            result = result.concat(o[key]);
+          }
+        }
+        if (typeof o[key] === "object" && o[key] !== null) {
+          traverse(o[key]);
+        }
+      }
+    }
+  }
+  traverse(obj);
+  return result;
+};
+const setContentKey = (el, opts = {}) => {
+  const { __ref: ref } = el;
+  const contentElementKey = opts.contentElementKey;
+  if (contentElementKey !== "content" && contentElementKey !== ref.contentElementKey || !ref.contentElementKey) {
+    ref.contentElementKey = contentElementKey || "content";
+  } else
+    ref.contentElementKey = "content";
+  if (contentElementKey !== "content")
+    opts.contentElementKey = "content";
+  return ref.contentElementKey;
+};
+export {
+  addAdditionalExtend,
+  addChildrenIfNotInOriginal,
+  applyComponentFromContext,
+  applyKeyComponentAsExtend,
+  checkIfKeyIsComponent,
+  checkIfKeyIsProperty,
+  checkIfSugar,
+  extendizeByKey,
+  getCapitalCaseKeys,
+  getChildrenComponentsByKey,
+  getExtendsInElement,
+  hasVariantProp,
+  isVariant,
+  setContentKey
+};

package/dist/esm/cookie.js

@@ -0,0 +1,60 @@
+import { isUndefined } from "./types";
+import { document } from "@domql/utils";
+const isMobile = (() => typeof navigator === "undefined" ? false : /Mobi/.test(navigator.userAgent))();
+const setCookie = (cname, cvalue, exdays = 365) => {
+  if (isUndefined(document) || isUndefined(document.cookie))
+    return;
+  const d = /* @__PURE__ */ new Date();
+  d.setTime(d.getTime() + exdays * 24 * 60 * 60 * 1e3);
+  const expires = `expires=${d.toUTCString()}`;
+  document.cookie = `${cname}=${cvalue};${expires};path=/`;
+};
+const getCookie = (cname) => {
+  if (isUndefined(document) || isUndefined(document.cookie))
+    return;
+  const name = `${cname}=`;
+  const decodedCookie = decodeURIComponent(document.cookie);
+  const ca = decodedCookie.split(";");
+  for (let i = 0; i < ca.length; i++) {
+    let c = ca[i];
+    while (c.charAt(0) === " ")
+      c = c.substring(1);
+    if (c.indexOf(name) === 0)
+      return c.substring(name.length, c.length);
+  }
+  return "";
+};
+const removeCookie = (cname) => {
+  if (isUndefined(document) || isUndefined(document.cookie))
+    return;
+  document.cookie = cname + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;";
+};
+function getLocalStorage(key) {
+  let savedJSON;
+  if (window.localStorage) {
+    try {
+      savedJSON = JSON.parse(window.localStorage.getItem(key));
+    } catch (e) {
+    }
+  }
+  if (typeof savedJSON !== "undefined") {
+    return savedJSON;
+  }
+}
+function setLocalStorage(key, data) {
+  if (data && window.localStorage) {
+    if (typeof data === "object") {
+      window.localStorage.setItem(key, JSON.stringify(data));
+    } else {
+      window.localStorage.setItem(key, data);
+    }
+  }
+}
+export {
+  getCookie,
+  getLocalStorage,
+  isMobile,
+  removeCookie,
+  setCookie,
+  setLocalStorage
+};

package/dist/esm/env.js

@@ -0,0 +1,12 @@
+const NODE_ENV = "development";
+const isProduction = (env = NODE_ENV) => env === "production" || env === "prod" || env !== "development" && env !== "dev" && env !== "test";
+const isTest = (env = NODE_ENV) => env === "test";
+const isDevelopment = (env = NODE_ENV) => env === "development" || env === "dev";
+const getNev = (key, env = NODE_ENV) => env[key];
+export {
+  NODE_ENV,
+  getNev,
+  isDevelopment,
+  isProduction,
+  isTest
+};