@domql/utils 2.5.187 → 3.0.0

package/array.js

@@ -20,8 +20,6 @@ export const removeFromArray = (arr, 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')
   }
@@ -29,7 +27,7 @@ export const removeFromArray = (arr, index) => {
 }
 
 export const swapItemsInArray = (arr, i, j) => {
-  [arr[i], arr[j]] = [arr[j], arr[i]]
+  ;[arr[i], arr[j]] = [arr[j], arr[i]]
 }
 
 export const joinArrays = (...arrays) => {
@@ -39,15 +37,11 @@ export const joinArrays = (...arrays) => {
 /**
  * Merges array extendtypes
  */
-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) : deepClone(obj)
+export const unstackArrayOfObjects = (arr, exclude = []) => {
+  return arr.reduce(
+    (a, c) => deepMerge(a, deepClone(c, { exclude }), exclude),
+    {}
+  )
 }
 
 export const cutArrayBeforeValue = (arr, value) => {
@@ -105,7 +99,10 @@ export const reorderArrayByValues = (array, valueToMove, insertBeforeValue) => {
   const indexToInsertBefore = newArray.indexOf(insertBeforeValue) // Find the index to insert before
   if (indexToMove !== -1 && indexToInsertBefore !== -1) {
     const removedItem = newArray.splice(indexToMove, 1)[0] // Remove the item to move
-    const insertIndex = indexToInsertBefore < indexToMove ? indexToInsertBefore : indexToInsertBefore + 1 // Adjust insert index
+    const insertIndex =
+      indexToInsertBefore < indexToMove
+        ? indexToInsertBefore
+        : indexToInsertBefore + 1 // Adjust insert index
     newArray.splice(insertIndex, 0, removedItem) // Insert the removed item before the specified value
   }
   return newArray
@@ -140,3 +137,19 @@ export const checkIfStringIsInArray = (string, arr) => {
   if (!string) return
   return arr.filter(v => string.includes(v)).length
 }
+
+export const removeDuplicatesInArray = arr => {
+  if (!isArray(arr)) return arr
+  return [...new Set(arr)]
+}
+
+export 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
+    })
+  }
+}

package/cache.js

@@ -0,0 +1,4 @@
+'use strict'
+
+export const cache = {}
+export const OPTIONS = {}

package/component.js

@@ -1,243 +1,26 @@
 'use strict'
 
-import { joinArrays } from './array.js'
-import { deepClone, exec } from './object.js'
-import { isArray, isFunction, isObject, isString } from './types.js'
+import { createExtendsFromKeys } from './extends.js'
+import { isString } from './types.js'
 
-const ENV = process.env.NODE_ENV
-
-export const checkIfKeyIsComponent = (key) => {
+export const matchesComponentNaming = key => {
   const isFirstKeyString = isString(key)
   if (!isFirstKeyString) return
   const firstCharKey = key.slice(0, 1)
   return /^[A-Z]*$/.test(firstCharKey)
 }
 
-export const checkIfKeyIsProperty = (key) => {
-  const isFirstKeyString = isString(key)
-  if (!isFirstKeyString) return
-  const firstCharKey = key.slice(0, 1)
-  return /^[a-z]*$/.test(firstCharKey)
-}
-
-export 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 { ...element, extend }
-}
-
-export const checkIfSugar = (element, parent, key) => {
-  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 = (parent || element)?.error
-    if (logErr) logErr.call(element, 'Sugar component includes params for builtin components', { verbose: true })
-  }
-  return !hasComponentAttrs || childProps || extendProps || children || childExtends
-}
-
-export const extractComponentKeyFromKey = (key) => {
-  return key.includes('+')
-    ? key.split('+') // get array of componentKeys
-    : key.includes('_')
-      ? [key.split('_')[0]] // get component key split _
-      : key.includes('.') && !checkIfKeyIsComponent(key.split('.')[1])
-        ? [key.split('.')[0]] // get component key split .
-        : [key]
-}
-
-export const extendizeByKey = (element, parent, key) => {
-  const { context } = parent
-  const { tag, extend, childExtends } = element
-  const isSugar = checkIfSugar(element, parent, key)
-  const extendFromKey = extractComponentKeyFromKey(key)
-  const isExtendKeyComponent = context && context.components[extendFromKey]
-  if (element === isExtendKeyComponent) return element
-  else if (isSugar) {
-    const newElem = addAdditionalExtend(element.extends, {
-      extend: extendFromKey,
-      tag,
-      props: { ...element }
-    })
-    if (newElem.props.data) {
-      newElem.data = newElem.props.data
-      delete newElem.props.data
-    }
-    if (newElem.props.state) {
-      newElem.state = newElem.props.state
-      delete newElem.props.state
-    }
-    if (newElem.props.attr) {
-      newElem.attr = newElem.props.attr
-      delete newElem.props.attr
-    }
-    if (newElem.props.if) {
-      newElem.if = newElem.props.if
-      delete newElem.props.if
-    }
-    if (childExtends) newElem.childExtend = childExtends
-    return newElem
-  } else if (!extend || extend === true) {
-    return {
-      ...element,
-      tag,
-      extend: extendFromKey
-    }
-  } else if (extend) {
-    return addAdditionalExtend(extendFromKey, element)
-  } else if (isFunction(element)) {
-    return {
-      extend: extendFromKey,
-      tag,
-      props: { ...exec(element, parent) }
-    }
-  }
-}
-
 export function getCapitalCaseKeys (obj) {
   return Object.keys(obj).filter(key => /^[A-Z]/.test(key))
 }
 
-export 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?.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
-      })
-    }
-  }
-}
-
-export const applyKeyComponentAsExtend = (element, parent, key) => {
-  return extendizeByKey(element, parent, key) || element
-}
-
-export 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 = {}
-    }
-  }
-}
-
-export const isVariant = (param) => {
-  if (!isString(param)) return
-  const firstCharKey = param.slice(0, 1)
-  // return (firstCharKey === '.' || firstCharKey === '$')
-  return (firstCharKey === '.')
-}
-
-export const hasVariantProp = (element) => {
-  const { props } = element
-  if (isObject(props) && isString(props.variant)) return true
-}
-
-export const getChildrenComponentsByKey = (key, el) => {
-  if (key === el.key || el.__ref.__componentKey === key) {
-    return el
-  }
-
-  // Check if the prop is "extend" and it's either a string or an array
-  if (el.extend) {
-    // Add the value of the extend key to the result array
-    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) {
-    // Add the value of the extend key to the result array
-    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
-  }
-}
-
-export const getExtendsInElement = (obj) => {
-  let result = []
-
-  function traverse (o) {
-    for (const key in o) {
-      if (Object.hasOwnProperty.call(o, key)) {
-        // Check if the key starts with a capital letter and exclude keys like @mobileL, $propsCollection
-        if (checkIfKeyIsComponent(key)) {
-          result.push(key)
-        }
-
-        // Check if the key is "extend" and it's either a string or an array
-        if (key === 'extend' || key === 'extends') {
-          // Add the value of the extend key to the result array
-          if (typeof o[key] === 'string') {
-            result.push(o[key])
-          } else if (Array.isArray(o[key])) {
-            result = result.concat(o[key])
-          }
-        }
-
-        // If the property is an object, traverse it
-        if (typeof o[key] === 'object' && o[key] !== null) {
-          traverse(o[key])
-        }
-      }
-    }
-  }
-
-  traverse(obj)
-  return result
+export function getSpreadChildren (obj) {
+  return Object.keys(obj).filter(key => /^\d+$/.test(key))
 }
 
-export 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 function isContextComponent (element, parent, passedKey) {
+  const { context } = parent || {}
+  const [extendsKey] = createExtendsFromKeys(passedKey)
+  const key = passedKey || extendsKey
+  return context?.components?.[key] || context?.pages?.[key]
 }

package/cookie.js

@@ -3,19 +3,18 @@
 import { isUndefined } from './types.js'
 import { document } from './globals.js'
 
-export const isMobile = (() => typeof navigator === 'undefined'
-  ? false
-  : /Mobi/.test(navigator.userAgent))()
+export const isMobile = (() =>
+  typeof navigator === 'undefined' ? false : /Mobi/.test(navigator.userAgent))()
 
 export const setCookie = (cname, cvalue, exdays = 365) => {
   if (isUndefined(document) || isUndefined(document.cookie)) return
   const d = new Date()
-  d.setTime(d.getTime() + (exdays * 24 * 60 * 60 * 1000))
+  d.setTime(d.getTime() + exdays * 24 * 60 * 60 * 1000)
   const expires = `expires=${d.toUTCString()}`
   document.cookie = `${cname}=${cvalue};${expires};path=/`
 }
 
-export const getCookie = (cname) => {
+export const getCookie = cname => {
   if (isUndefined(document) || isUndefined(document.cookie)) return
   const name = `${cname}=`
   const decodedCookie = decodeURIComponent(document.cookie)
@@ -28,29 +27,34 @@ export const getCookie = (cname) => {
   return ''
 }
 
-export const removeCookie = (cname) => {
+export const removeCookie = cname => {
   if (isUndefined(document) || isUndefined(document.cookie)) return
   document.cookie = cname + '=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;'
 }
-
 /**
-   * Load item from the localStorage
-   *
-   * @param key -- string to identify the storage item
-   */
+ * Load item from the localStorage
+ *
+ * @param key -- string to identify the storage item
+ * @returns {*} -- parsed data or undefined
+ */
 export function getLocalStorage (key) {
-  let savedJSON
+  if (!window.localStorage) {
+    return undefined
+  }
 
-  if (window.localStorage) {
-    try {
-      savedJSON = JSON.parse(window.localStorage.getItem(key))
-    } catch (e) {}
+  const item = window.localStorage.getItem(key)
+
+  if (item === null) {
+    return undefined
   }
 
-  if (typeof savedJSON !== 'undefined') {
-    return savedJSON
+  try {
+    return JSON.parse(item)
+  } catch (e) {
+    return undefined
   }
 }
+
 /**
  * Save the data to window.localStorage
  *
@@ -58,11 +62,10 @@ export function getLocalStorage (key) {
  * @param data - the data to save
  */
 export 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)
-    }
+  if (!window.localStorage || data === undefined || data === null) {
+    return
   }
+
+  const value = typeof data === 'object' ? JSON.stringify(data) : data
+  window.localStorage.setItem(key, value)
 }

package/dist/cjs/array.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var array_exports = {};
 __export(array_exports, {
   addItemAfterEveryElement: () => addItemAfterEveryElement,
+  addProtoToArray: () => addProtoToArray,
   arrayContainsOtherArray: () => arrayContainsOtherArray,
   arraysEqual: () => arraysEqual,
   checkIfStringIsInArray: () => checkIfStringIsInArray,
@@ -28,13 +29,13 @@ __export(array_exports, {
   filterArraysFast: () => filterArraysFast,
   getFrequencyInArray: () => getFrequencyInArray,
   joinArrays: () => joinArrays,
-  mergeAndCloneIfArray: () => mergeAndCloneIfArray,
-  mergeArray: () => mergeArray,
+  removeDuplicatesInArray: () => removeDuplicatesInArray,
   removeFromArray: () => removeFromArray,
   removeValueFromArray: () => removeValueFromArray,
   removeValueFromArrayAll: () => removeValueFromArrayAll,
   reorderArrayByValues: () => reorderArrayByValues,
-  swapItemsInArray: () => swapItemsInArray
+  swapItemsInArray: () => swapItemsInArray,
+  unstackArrayOfObjects: () => unstackArrayOfObjects
 });
 module.exports = __toCommonJS(array_exports);
 var import_object = require("./object.js");
@@ -48,31 +49,29 @@ const getFrequencyInArray = (arr, value) => {
   }, 0);
 };
 const removeFromArray = (arr, index) => {
-  if ((0, import_types.isString)(index))
-    index = parseInt(index);
+  if ((0, import_types.isString)(index)) index = parseInt(index);
   if ((0, import_types.isNumber)(index)) {
     if (index < 0 || index >= arr.length || isNaN(index)) {
       throw new Error("Invalid index");
     }
     arr.splice(index, 1);
-  } else if ((0, import_types.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) => (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.deepClone)(obj);
+const unstackArrayOfObjects = (arr, exclude = []) => {
+  return arr.reduce(
+    (a, c) => (0, import_object.deepMerge)(a, (0, import_object.deepClone)(c, { exclude }), exclude),
+    {}
+  );
 };
 const cutArrayBeforeValue = (arr, value) => {
   const index = arr.indexOf(value);
@@ -82,8 +81,7 @@ const cutArrayBeforeValue = (arr, value) => {
   return arr;
 };
 const cutArrayAfterValue = (arr, value) => {
-  if (!(0, import_types.isArray)(arr))
-    return;
+  if (!(0, import_types.isArray)(arr)) return;
   const index = arr.indexOf(value);
   if (index !== -1) {
     return arr.slice(index + 1);
@@ -142,7 +140,23 @@ 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 (!(0, import_types.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
+    });
+  }
+};

package/dist/cjs/cache.js

@@ -0,0 +1,26 @@
+"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 cache_exports = {};
+__export(cache_exports, {
+  OPTIONS: () => OPTIONS,
+  cache: () => cache
+});
+module.exports = __toCommonJS(cache_exports);
+const cache = {};
+const OPTIONS = {};