@domql/utils 3.2.3 → 3.2.10

package/object.js

@@ -7,9 +7,7 @@ import {
   isObject,
   isArray,
   isString,
-  is,
-  isUndefined,
-  isNull
+  is
 } from './types.js'
 import { unstackArrayOfObjects } from './array.js'
 import { stringIncludesAny } from './string.js'
@@ -18,8 +16,11 @@ import { METHODS_EXL } from './keys.js'
 
 const ENV = process.env.NODE_ENV
 
+const _startsWithDunder = e => e.charCodeAt(0) === 95 && e.charCodeAt(1) === 95
+
 export const exec = (param, element, state, context) => {
   if (isFunction(param)) {
+    if (!element) return
     const result = param.call(
       element,
       element,
@@ -45,26 +46,24 @@ export const map = (obj, extention, element) => {
 }
 
 export const merge = (element, obj, excludeFrom = []) => {
+  const useSet = excludeFrom instanceof Set
   for (const e in obj) {
-    const hasOwnProperty = Object.prototype.hasOwnProperty.call(obj, e)
-    if (!hasOwnProperty || excludeFrom.includes(e) || e.startsWith('__')) {
-      continue
-    }
-    const elementProp = element[e]
-    const objProp = obj[e]
-    if (elementProp === undefined) {
-      element[e] = objProp
+    if (!Object.prototype.hasOwnProperty.call(obj, e)) continue
+    if (_startsWithDunder(e)) continue
+    if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue
+    if (element[e] === undefined) {
+      element[e] = obj[e]
     }
   }
   return element
 }
 
 export const deepMerge = (element, extend, excludeFrom = METHODS_EXL) => {
+  const useSet = excludeFrom instanceof Set
   for (const e in extend) {
-    const hasOwnProperty = Object.prototype.hasOwnProperty.call(extend, e)
-    if (!hasOwnProperty || excludeFrom.includes(e) || e.startsWith('__')) {
-      continue
-    }
+    if (!Object.prototype.hasOwnProperty.call(extend, e)) continue
+    if (_startsWithDunder(e)) continue
+    if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue
     const elementProp = element[e]
     const extendProp = extend[e]
     if (isObjectLike(elementProp) && isObjectLike(extendProp)) {
@@ -77,16 +76,12 @@ export const deepMerge = (element, extend, excludeFrom = METHODS_EXL) => {
 }
 
 export const clone = (obj, excludeFrom = []) => {
+  const useSet = excludeFrom instanceof Set
   const o = {}
   for (const prop in obj) {
-    const hasOwnProperty = Object.prototype.hasOwnProperty.call(obj, prop)
-    if (
-      !hasOwnProperty ||
-      excludeFrom.includes(prop) ||
-      prop.startsWith('__')
-    ) {
-      continue
-    }
+    if (!Object.prototype.hasOwnProperty.call(obj, prop)) continue
+    if (_startsWithDunder(prop)) continue
+    if (useSet ? excludeFrom.has(prop) : excludeFrom.includes(prop)) continue
     o[prop] = obj[prop]
   }
   return o
@@ -127,35 +122,28 @@ export const deepClone = (obj, options = {}) => {
   }
 
   // Create appropriate container based on type and window context
-  const clone = contentWindow
-    ? isArray(obj)
-      ? new contentWindow.Array()
-      : new contentWindow.Object()
-    : isArray(obj)
-    ? []
-    : {}
+  const isArr = isArray(obj)
+  const clone = isArr ? [] : {}
 
   // Store the clone to handle circular references
   visited.set(obj, clone)
 
+  // Convert exclude to Set for O(1) lookups when list is non-trivial
+  const excludeSet = exclude instanceof Set ? exclude : (exclude.length > 3 ? new Set(exclude) : null)
+
   // Clone properties
   for (const key in obj) {
     if (!Object.prototype.hasOwnProperty.call(obj, key)) continue
 
     // Skip excluded properties
-    if (exclude.includes(key) || key.startsWith('__') || key === '__proto__') {
-      continue
-    }
+    if (_startsWithDunder(key) || key === '__proto__') continue
+    if (excludeSet ? excludeSet.has(key) : exclude.includes(key)) continue
 
     const value = obj[key]
 
     // Skip based on cleanup options
-    if (
-      (cleanUndefined && isUndefined(value)) ||
-      (cleanNull && isNull(value))
-    ) {
-      continue
-    }
+    if (cleanUndefined && value === undefined) continue
+    if (cleanNull && value === null) continue
 
     // Handle special cases
     if (isDOMNode(value)) {
@@ -209,17 +197,18 @@ export const deepStringify = (obj, stringified = {}) => {
       stringified[prop] = {}
       deepStringify(objProp, stringified[prop])
     } else if (isArray(objProp)) {
-      stringified[prop] = []
-      objProp.forEach((v, i) => {
+      const arr = stringified[prop] = []
+      for (let i = 0; i < objProp.length; i++) {
+        const v = objProp[i]
         if (isObject(v)) {
-          stringified[prop][i] = {}
-          deepStringify(v, stringified[prop][i])
+          arr[i] = {}
+          deepStringify(v, arr[i])
         } else if (isFunction(v)) {
-          stringified[prop][i] = v.toString()
+          arr[i] = v.toString()
         } else {
-          stringified[prop][i] = v
+          arr[i] = v
         }
-      })
+      }
     } else {
       stringified[prop] = objProp
     }
@@ -227,38 +216,32 @@ export const deepStringify = (obj, stringified = {}) => {
   return stringified
 }
 
+const OBJ_TO_STR_SPECIAL_CHARS = new Set([
+  '&', '*', '-', ':', '%', '{', '}', '>', '<', '@', '.', '/', '!', ' '
+])
+
 export const objectToString = (obj = {}, indent = 0) => {
   // Handle empty object case
   if (obj === null || typeof obj !== 'object') {
     return String(obj)
   }
 
-  // Handle empty object case
-  if (Object.keys(obj).length === 0) {
-    return '{}'
-  }
+  // Handle empty object case - avoid Object.keys allocation
+  let hasKeys = false
+  for (const _k in obj) { hasKeys = true; break } // eslint-disable-line
+  if (!hasKeys) return '{}'
 
   const spaces = '  '.repeat(indent)
   let str = '{\n'
 
-  for (const [key, value] of Object.entries(obj)) {
-    const keyNotAllowdChars = stringIncludesAny(key, [
-      '&',
-      '*',
-      '-',
-      ':',
-      '%',
-      '{',
-      '}',
-      '>',
-      '<',
-      '@',
-      '.',
-      '/',
-      '!',
-      ' '
-    ])
-    const stringedKey = keyNotAllowdChars ? `'${key}'` : key
+  for (const key in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue
+    const value = obj[key]
+    let keyNeedsQuotes = false
+    for (let i = 0; i < key.length; i++) {
+      if (OBJ_TO_STR_SPECIAL_CHARS.has(key[i])) { keyNeedsQuotes = true; break }
+    }
+    const stringedKey = keyNeedsQuotes ? `'${key}'` : key
     str += `${spaces}  ${stringedKey}: `
 
     if (isArray(value)) {
@@ -290,44 +273,46 @@ export const objectToString = (obj = {}, indent = 0) => {
   return str
 }
 
+const FN_PATTERNS = [
+  /^\(\s*\{[^}]*\}\s*\)\s*=>/,
+  /^(\([^)]*\)|[^=]*)\s*=>/,
+  /^function[\s(]/,
+  /^async\s+/,
+  /^\(\s*function/,
+  /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*=>/
+]
+const RE_JSON_LIKE = /^["[{]/
+
 export const hasFunction = str => {
   if (!str) return false
 
   const trimmed = str.trim().replace(/\n\s*/g, ' ').trim()
 
-  if (trimmed === '') return false
-  if (trimmed === '{}') return false
-  if (trimmed === '[]') return false
-
-  const patterns = [
-    /^\(\s*\{[^}]*\}\s*\)\s*=>/,
-    /^(\([^)]*\)|[^=]*)\s*=>/,
-    /^function[\s(]/,
-    /^async\s+/,
-    /^\(\s*function/,
-    /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*=>/
-  ]
-
-  const isFunction = patterns.some(pattern => pattern.test(trimmed))
-  const isObjectLiteral = trimmed.startsWith('{') && !trimmed.includes('=>')
-  const isArrayLiteral = trimmed.startsWith('[')
-  const isJSONLike = /^["[{]/.test(trimmed) && !trimmed.includes('=>')
-
-  return isFunction && !isObjectLiteral && !isArrayLiteral && !isJSONLike
+  if (trimmed === '' || trimmed === '{}' || trimmed === '[]') return false
+
+  const isFn = FN_PATTERNS.some(pattern => pattern.test(trimmed))
+  if (!isFn) return false
+
+  const firstChar = trimmed.charCodeAt(0)
+  const hasArrow = trimmed.includes('=>')
+  // '{' = 123, '[' = 91
+  if (firstChar === 123 && !hasArrow) return false // object literal
+  if (firstChar === 91) return false // array literal
+  if (RE_JSON_LIKE.test(trimmed) && !hasArrow) return false
+
+  return true
 }
 
 export const deepDestringify = (obj, destringified = {}) => {
   for (const prop in obj) {
-    const hasOwnProperty = Object.prototype.hasOwnProperty.call(obj, prop)
-    if (!hasOwnProperty) continue
+    if (!Object.prototype.hasOwnProperty.call(obj, prop)) continue
 
     const objProp = obj[prop]
 
     if (isString(objProp)) {
       if (hasFunction(objProp)) {
         try {
-          const evalProp = window.eval(`(${objProp})`)
-          destringified[prop] = evalProp
+          destringified[prop] = window.eval(`(${objProp})`)
         } catch (e) {
           if (e) destringified[prop] = objProp
         }
@@ -335,25 +320,25 @@ export const deepDestringify = (obj, destringified = {}) => {
         destringified[prop] = objProp
       }
     } else if (isArray(objProp)) {
-      destringified[prop] = []
-      objProp.forEach(arrProp => {
+      const arr = destringified[prop] = []
+      for (let i = 0; i < objProp.length; i++) {
+        const arrProp = objProp[i]
         if (isString(arrProp)) {
           if (hasFunction(arrProp)) {
             try {
-              const evalProp = window.eval(`(${arrProp})`)
-              destringified[prop].push(evalProp)
+              arr.push(window.eval(`(${arrProp})`))
             } catch (e) {
-              if (e) destringified[prop].push(arrProp)
+              if (e) arr.push(arrProp)
             }
           } else {
-            destringified[prop].push(arrProp)
+            arr.push(arrProp)
           }
         } else if (isObject(arrProp)) {
-          destringified[prop].push(deepDestringify(arrProp))
+          arr.push(deepDestringify(arrProp))
         } else {
-          destringified[prop].push(arrProp)
+          arr.push(arrProp)
         }
-      })
+      }
     } else if (isObject(objProp)) {
       destringified[prop] = deepDestringify(objProp, destringified[prop])
     } else {
@@ -374,7 +359,10 @@ export const stringToObject = (str, opts = { verbose: true }) => {
 export const hasOwnProperty = (o, ...args) =>
   Object.prototype.hasOwnProperty.call(o, ...args)
 
-export const isEmpty = o => Object.keys(o).length === 0
+export const isEmpty = o => {
+  for (const _ in o) return false // eslint-disable-line
+  return true
+}
 
 export const isEmptyObject = o => isObject(o) && isEmpty(o)
 
@@ -388,12 +376,9 @@ export const overwrite = (element, params, opts = {}) => {
   const allowUnderscore = opts.preventUnderscore
 
   for (const e in params) {
-    if (excl.includes(e) || (!allowUnderscore && e.startsWith('__'))) continue
-
-    const paramsProp = params[e]
-
-    if (paramsProp !== undefined) {
-      element[e] = paramsProp
+    if (excl.includes(e) || (!allowUnderscore && _startsWithDunder(e))) continue
+    if (params[e] !== undefined) {
+      element[e] = params[e]
     }
   }
 
@@ -401,8 +386,10 @@ export const overwrite = (element, params, opts = {}) => {
 }
 
 export const overwriteShallow = (obj, params, excludeFrom = []) => {
+  const useSet = excludeFrom instanceof Set
   for (const e in params) {
-    if (excludeFrom.includes(e) || e.startsWith('__')) continue
+    if (_startsWithDunder(e)) continue
+    if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue
     obj[e] = params[e]
   }
   return obj
@@ -417,9 +404,6 @@ export const overwriteDeep = (
   opts = {},
   visited = new WeakMap()
 ) => {
-  const excl = opts.exclude || []
-  const forcedExclude = opts.preventForce ? [] : ['node', 'window']
-
   if (
     !isObjectLike(obj) ||
     !isObjectLike(params) ||
@@ -432,9 +416,13 @@ export const overwriteDeep = (
   if (visited.has(obj)) return visited.get(obj)
   visited.set(obj, obj)
 
+  const excl = opts.exclude
+  const exclSet = excl ? (excl instanceof Set ? excl : new Set(excl)) : null
+  const forcedExclude = !opts.preventForce
+
   for (const e in params) {
-    if (!Object.hasOwnProperty.call(params, e)) continue
-    if (excl.includes(e) || (forcedExclude && e.startsWith('__'))) continue
+    if (!Object.prototype.hasOwnProperty.call(params, e)) continue
+    if ((exclSet && exclSet.has(e)) || (forcedExclude && _startsWithDunder(e))) continue
 
     const objProp = obj[e]
     const paramsProp = params[e]
@@ -453,52 +441,19 @@ export const overwriteDeep = (
 
 /**
  * Recursively compares two values to determine if they are deeply equal.
- *
- * This function checks for deep equality between two values, including
- * objects, arrays, and nested structures. It handles circular references to
- * prevent infinite loops.
- *
- * @param {*} param - The first value to compare.
- * @param {*} element - The second value to compare.
- * @param {Set} [visited] - (Optional) A set to track visited objects during recursion
- *   to handle circular references. You can omit this parameter when calling
- *   the function; it is used internally for tracking visited objects.
- *
- * @returns {boolean} Returns `true` if the values are deeply equal, `false` otherwise.
- *
- * @example
- * // Comparing primitive values
- * isEqualDeep(42, 42); // true
- * isEqualDeep('hello', 'hello'); // true
- * isEqualDeep(true, true); // true
- * isEqualDeep(42, '42'); // false
- *
- * // Comparing simple objects
- * const obj1 = { a: 1, b: { c: 2 } };
- * const obj2 = { a: 1, b: { c: 2 } };
- * isEqualDeep(obj1, obj2); // true
- *
- * // Handling circular references
- * const circularObj = { prop: null };
- * circularObj.prop = circularObj;
- * const anotherObj = { prop: null };
- * anotherObj.prop = anotherObj;
- * isEqualDeep(circularObj, anotherObj); // true
  */
 export const isEqualDeep = (param, element, visited = new Set()) => {
-  // Check if both values are non-null objects
   if (
     typeof param !== 'object' ||
     typeof element !== 'object' ||
     param === null ||
     element === null
   ) {
-    return param === element // Compare non-object values directly
+    return param === element
   }
 
-  // Check for circular references
   if (visited.has(param) || visited.has(element)) {
-    return true // Assume equality to break the circular reference
+    return true
   }
 
   visited.add(param)
@@ -507,22 +462,16 @@ export const isEqualDeep = (param, element, visited = new Set()) => {
   const keysParam = Object.keys(param)
   const keysElement = Object.keys(element)
 
-  // Check if both objects have the same number of properties
   if (keysParam.length !== keysElement.length) {
     return false
   }
 
-  // Check if all properties in param also exist in element
-  for (const key of keysParam) {
-    if (!keysElement.includes(key)) {
+  for (let i = 0; i < keysParam.length; i++) {
+    const key = keysParam[i]
+    if (!Object.prototype.hasOwnProperty.call(element, key)) {
       return false
     }
-
-    const paramProp = param[key]
-    const elementProp = element[key]
-
-    // Recursively check property values
-    if (!isEqualDeep(paramProp, elementProp, visited)) {
+    if (!isEqualDeep(param[key], element[key], visited)) {
       return false
     }
   }
@@ -530,23 +479,23 @@ export const isEqualDeep = (param, element, visited = new Set()) => {
   return true
 }
 
-export const deepContains = (obj1, obj2, ignoredKeys = ['node', '__ref']) => {
+const DEEP_CONTAINS_IGNORED = new Set(['node', '__ref'])
+
+export const deepContains = (obj1, obj2, ignoredKeys = DEEP_CONTAINS_IGNORED) => {
   if (obj1 === obj2) return true
   if (!isObjectLike(obj1) || !isObjectLike(obj2)) return obj1 === obj2
   if (isDOMNode(obj1) || isDOMNode(obj2)) return obj1 === obj2
 
+  const ignored = ignoredKeys instanceof Set ? ignoredKeys : new Set(ignoredKeys)
   const visited = new WeakSet()
 
   function checkContains (target, source) {
     if (visited.has(source)) return true
     visited.add(source)
 
-    // Check each property in source
     for (const key in source) {
       if (!Object.prototype.hasOwnProperty.call(source, key)) continue
-      if (ignoredKeys.includes(key)) continue
-
-      // If key doesn't exist in target, return false
+      if (ignored.has(key)) continue
       if (!Object.prototype.hasOwnProperty.call(target, key)) return false
 
       const sourceValue = source[key]
@@ -572,7 +521,7 @@ export const removeFromObject = (obj, props) => {
   if (is(props)('string', 'number')) {
     delete obj[props]
   } else if (isArray(props)) {
-    props.forEach(prop => delete obj[prop])
+    for (let i = 0; i < props.length; i++) delete obj[props[i]]
   } else {
     throw new Error(
       'Invalid input: props must be a string or an array of strings'
@@ -583,14 +532,14 @@ export const removeFromObject = (obj, props) => {
 
 export const createObjectWithoutPrototype = obj => {
   if (obj === null || typeof obj !== 'object') {
-    return obj // Return the value if obj is not an object
+    return obj
   }
 
-  const newObj = Object.create(null) // Create an object without prototype
+  const newObj = Object.create(null)
 
   for (const key in obj) {
     if (Object.prototype.hasOwnProperty.call(obj, key)) {
-      newObj[key] = createObjectWithoutPrototype(obj[key]) // Recursively copy each property
+      newObj[key] = createObjectWithoutPrototype(obj[key])
     }
   }
 
@@ -598,21 +547,19 @@ export const createObjectWithoutPrototype = obj => {
 }
 
 export const createNestedObject = (arr, lastValue) => {
-  const nestedObject = {}
+  if (arr.length === 0) return lastValue
 
-  if (arr.length === 0) {
-    return lastValue
-  }
+  const nestedObject = {}
+  let current = nestedObject
 
-  arr.reduce((obj, value, index) => {
-    if (!obj[value]) {
-      obj[value] = {}
-    }
-    if (index === arr.length - 1 && lastValue) {
-      obj[value] = lastValue
+  for (let i = 0; i < arr.length; i++) {
+    if (i === arr.length - 1 && lastValue) {
+      current[arr[i]] = lastValue
+    } else {
+      current[arr[i]] = {}
+      current = current[arr[i]]
     }
-    return obj[value]
-  }, nestedObject)
+  }
 
   return nestedObject
 }
@@ -625,14 +572,12 @@ export const removeNestedKeyByPath = (obj, path) => {
   let current = obj
 
   for (let i = 0; i < path.length - 1; i++) {
-    if (current[path[i]] === undefined) {
-      return // Path does not exist, so nothing to remove.
-    }
+    if (current[path[i]] === undefined) return
     current = current[path[i]]
   }
 
   const lastKey = path[path.length - 1]
-  if (current && Object.hasOwnProperty.call(current, lastKey)) {
+  if (current && Object.prototype.hasOwnProperty.call(current, lastKey)) {
     delete current[lastKey]
   }
 }
@@ -645,15 +590,13 @@ export const setInObjectByPath = (obj, path, value) => {
   let current = obj
 
   for (let i = 0; i < path.length - 1; i++) {
-    // If the current path segment doesn't exist or isn't an object, create it
     if (!current[path[i]] || typeof current[path[i]] !== 'object') {
       current[path[i]] = {}
     }
     current = current[path[i]]
   }
 
-  const lastKey = path[path.length - 1]
-  current[lastKey] = value
+  current[path[path.length - 1]] = value
 
   return obj
 }
@@ -676,25 +619,21 @@ export const getInObjectByPath = (obj, path) => {
 }
 
 export const detectInfiniteLoop = arr => {
-  const maxRepeats = 10 // Maximum allowed repetitions
+  const maxRepeats = 10
   let pattern = []
   let repeatCount = 0
 
   for (let i = 0; i < arr.length; i++) {
     if (pattern.length < 2) {
-      // Build the initial pattern with two consecutive elements
       pattern.push(arr[i])
     } else {
-      // Check if the current element follows the repeating pattern
       if (arr[i] === pattern[i % 2]) {
         repeatCount++
       } else {
-        // If there's a mismatch, reset the pattern and repeat counter
         pattern = [arr[i - 1], arr[i]]
-        repeatCount = 1 // Reset to 1 because we start a new potential pattern
+        repeatCount = 1
       }
 
-      // If the pattern repeats more than `maxRepeats`, throw a warning
       if (repeatCount >= maxRepeats * 2) {
         if (ENV === 'test' || ENV === 'development') {
           console.warn(
@@ -709,16 +648,14 @@ export const detectInfiniteLoop = arr => {
 }
 
 export const isCyclic = obj => {
-  const seenObjects = []
+  const seen = new WeakSet()
 
   function detect (obj) {
     if (obj && typeof obj === 'object') {
-      if (seenObjects.indexOf(obj) !== -1) {
-        return true
-      }
-      seenObjects.push(obj)
+      if (seen.has(obj)) return true
+      seen.add(obj)
       for (const key in obj) {
-        if (Object.hasOwnProperty.call(obj, key) && detect(obj[key])) {
+        if (Object.prototype.hasOwnProperty.call(obj, key) && detect(obj[key])) {
           console.log(obj, 'cycle at ' + key)
           return true
         }
@@ -731,7 +668,12 @@ export const isCyclic = obj => {
 }
 
 export const excludeKeysFromObject = (obj, excludedKeys) => {
-  const result = { ...obj }
-  excludedKeys.forEach(key => delete result[key])
+  const excluded = excludedKeys instanceof Set ? excludedKeys : new Set(excludedKeys)
+  const result = {}
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key) && !excluded.has(key)) {
+      result[key] = obj[key]
+    }
+  }
   return result
 }