@domql/utils 2.5.154 → 2.5.159

package/dist/cjs/object.js

@@ -264,7 +264,7 @@ const objectToString = (obj = {}, indent = 0) => {
     if ((0, import_types.isArray)(value)) {
       str += "[\n";
       for (const element of value) {
-        if ((0, import_types.isObject)(element) && element !== null) {
+        if ((0, import_types.isObjectLike)(element) && element !== null) {
           str += `${spaces}    ${objectToString(element, indent + 2)},
 `;
         } else if ((0, import_types.isString)(element)) {

package/dist/esm/array.js

@@ -0,0 +1,122 @@
+import { deepCloneWithExtend, 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, excludeFrom = []) => {
+  return arr.reduce((a, c) => deepMerge(a, deepCloneWithExtend(c, excludeFrom), excludeFrom), {});
+};
+const mergeAndCloneIfArray = (obj) => {
+  return isArray(obj) ? mergeArray(obj) : deepCloneWithExtend(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 {
+  deepCloneWithExtend,
+  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(deepCloneWithExtend(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
+};

package/dist/esm/function.js

@@ -0,0 +1,61 @@
+function debounce(func, wait, immediate) {
+  let timeout;
+  return function() {
+    const context = this;
+    const args = arguments;
+    const later = function() {
+      timeout = null;
+      if (!immediate)
+        func.apply(context, args);
+    };
+    const callNow = immediate && !timeout;
+    clearTimeout(timeout);
+    timeout = setTimeout(later, wait);
+    if (callNow)
+      func.apply(context, args);
+  };
+}
+const debounceOnContext = (element, func, timeout = 300) => {
+  let timer;
+  return (...args) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      func.apply(element, args);
+    }, timeout);
+  };
+};
+const memoize = (fn) => {
+  const cache = {};
+  return (...args) => {
+    const n = args[0];
+    if (n in cache) {
+      return cache[n];
+    } else {
+      const result = fn(n);
+      cache[n] = result;
+      return result;
+    }
+  };
+};
+const isStringFunction = (inputString) => {
+  const functionRegex = /^((function\s*\([^)]*\)\s*\{[^}]*\})|(\([^)]*\)\s*=>))/;
+  return functionRegex.test(inputString);
+};
+function cloneFunction(fn, win = window) {
+  const temp = function() {
+    return fn.apply(win, arguments);
+  };
+  for (const key in fn) {
+    if (Object.hasOwnProperty.call(fn, key)) {
+      temp[key] = fn[key];
+    }
+  }
+  return temp;
+}
+export {
+  cloneFunction,
+  debounce,
+  debounceOnContext,
+  isStringFunction,
+  memoize
+};

package/dist/esm/globals.js

@@ -0,0 +1,10 @@
+const global = globalThis;
+const self = globalThis;
+const window = globalThis;
+const document = window.document;
+export {
+  document,
+  global,
+  self,
+  window
+};

package/dist/esm/index.js

@@ -0,0 +1,13 @@
+export * from "./key.js";
+export * from "./env.js";
+export * from "./types.js";
+export * from "./object.js";
+export * from "./function.js";
+export * from "./array.js";
+export * from "./node.js";
+export * from "./log.js";
+export * from "./string.js";
+export * from "./globals.js";
+export * from "./cookie.js";
+export * from "./tags.js";
+export * from "./component.js";

package/dist/esm/key.js

@@ -0,0 +1,13 @@
+const generateKey = function() {
+  let index = 0;
+  function newId() {
+    index++;
+    return index;
+  }
+  return newId;
+}();
+const createSnapshotId = generateKey;
+export {
+  createSnapshotId,
+  generateKey
+};

package/dist/esm/log.js

@@ -0,0 +1,15 @@
+const logIf = (bool, ...arg) => {
+  if (bool)
+    arg.map((v) => console.log(v));
+};
+const logGroupIf = (bool, key, ...arg) => {
+  if (bool) {
+    console.group(key);
+    arg.map((v) => console.log(v));
+    console.groupEnd(key);
+  }
+};
+export {
+  logGroupIf,
+  logIf
+};

package/dist/esm/node.js

@@ -0,0 +1,15 @@
+import { window } from "./globals";
+const isNode = (obj) => {
+  return (typeof Node === "object" ? obj instanceof window.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string") || false;
+};
+const isHtmlElement = (obj) => {
+  return (typeof HTMLElement === "object" ? obj instanceof window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string") || false;
+};
+const isDOMNode = (obj) => {
+  return typeof window !== "undefined" && (obj instanceof window.Node || obj instanceof window.Window || obj === window || obj === document);
+};
+export {
+  isDOMNode,
+  isHtmlElement,
+  isNode
+};