@symbo.ls/utils 3.14.10 → 3.14.12

package/object.js

@@ -0,0 +1,859 @@
+'use strict'
+
+import { window } from './globals.js'
+import {
+  isFunction,
+  isObjectLike,
+  isObject,
+  isArray,
+  isString,
+  is
+} from './types.js'
+import { unstackArrayOfObjects } from './array.js'
+import { stringIncludesAny } from './string.js'
+import { isDOMNode } from './node.js'
+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
+    if (typeof param.call !== 'function') return param
+    return param.call(
+      element,
+      element,
+      state || element.state,
+      context || element.context
+    )
+  }
+  // If param is a non-function value and the context has handler-resolving
+  // plugins (e.g. funcql), try to resolve it into a callable function.
+  // This enables funcql schemas as property values (text, if, style, etc.).
+  // Only attempt for array/object params that could be schemas — skip
+  // primitives and DOM nodes to avoid overhead on normal DOMQL values.
+  if (
+    param != null &&
+    element?.context?.plugins &&
+    (isArray(param) || (isObject(param) && !isDOMNode(param)))
+  ) {
+    const plugins = element.context.plugins
+    for (const plugin of plugins) {
+      if (plugin.resolveHandler) {
+        const resolved = plugin.resolveHandler(param, element)
+        if (typeof resolved === 'function') {
+          return exec(resolved, element, state, context)
+        }
+      }
+    }
+  }
+  return param
+}
+
+export const map = (obj, extention, element) => {
+  for (const e in extention) {
+    obj[e] = exec(extention[e], element)
+  }
+}
+
+export const merge = (element, obj, excludeFrom = []) => {
+  const useSet = excludeFrom instanceof Set
+  for (const e in obj) {
+    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) => {
+  return _deepMerge(element, extend, excludeFrom, null)
+}
+
+// Internal worker that carries an ancestors stack to break cycles. The stack
+// is allocated lazily on first recursion so non-cyclic merges have zero
+// overhead. We track only the (element, extend) pairs in the *current
+// descent* — once a pair pops off the stack we forget it, so legitimate
+// reuse of shared extend objects across siblings is unaffected.
+//
+// PROTOTYPE POLLUTION GUARD: dunder keys are already skipped via
+// `_startsWithDunder`, but `constructor` and `prototype` are NOT dunder
+// and would otherwise be merged through. JSON.parse('{"constructor":
+// {"prototype": {"isAdmin": true}}}') passed as `extend` would walk into
+// `element.constructor` (the real Object constructor), then recurse and
+// set `element.constructor.prototype.isAdmin = true` — polluting every
+// object globally. Drop those segments.
+const _deepMerge = (element, extend, excludeFrom, ancestors) => {
+  if (element === extend) return element
+  if (ancestors) {
+    for (let i = 0; i < ancestors.length; i += 2) {
+      if (ancestors[i] === element && ancestors[i + 1] === extend) return element
+    }
+  }
+  const useSet = excludeFrom instanceof Set
+  for (const e in extend) {
+    if (!Object.prototype.hasOwnProperty.call(extend, e)) continue
+    if (_startsWithDunder(e)) continue
+    if (e === 'constructor' || e === 'prototype') continue
+    if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue
+    const elementProp = element[e]
+    const extendProp = extend[e]
+    if (isObjectLike(elementProp) && isObjectLike(extendProp)) {
+      const stack = ancestors || []
+      stack.push(element, extend)
+      _deepMerge(elementProp, extendProp, excludeFrom, stack)
+      stack.length -= 2
+    } else if (elementProp === undefined) {
+      element[e] = extendProp
+    }
+  }
+  return element
+}
+
+export const clone = (obj, excludeFrom = []) => {
+  const useSet = excludeFrom instanceof Set
+  const o = {}
+  for (const prop in obj) {
+    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
+}
+
+/**
+ * Enhanced deep clone function that combines features from multiple implementations
+ * @param {any} obj - Object to clone
+ * @param {Object} options - Configuration options
+ * @param {string[]} options.exclude - Properties to exclude from cloning
+ * @param {boolean} options.cleanUndefined - Remove undefined values
+ * @param {boolean} options.cleanNull - Remove null values
+ * @param {Window} options.window - Window object for cross-frame cloning
+ * @param {WeakMap} options.visited - WeakMap for tracking circular references
+ * @param {boolean} options.handleExtends - Whether to handle 'extends' arrays specially
+ * @returns {any} Cloned object
+ */
+export const deepClone = (obj, options = {}) => {
+  const {
+    exclude = [],
+    cleanUndefined = false,
+    cleanNull = false,
+    window: targetWindow,
+    visited = new WeakMap(),
+    handleExtends = false
+  } = options
+
+  const contentWindow = targetWindow || window || globalThis
+
+  // Handle non-object types and special cases
+  if (!isObjectLike(obj) || isDOMNode(obj)) {
+    return obj
+  }
+
+  // Handle circular references
+  if (visited.has(obj)) {
+    return visited.get(obj)
+  }
+
+  // Create appropriate container based on type and window context
+  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 (_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 && value === undefined) continue
+    if (cleanNull && value === null) continue
+
+    // Handle special cases
+    if (isDOMNode(value)) {
+      clone[key] = value
+      continue
+    }
+
+    // Handle 'extends' array if enabled
+    if (handleExtends && key === 'extends' && isArray(value)) {
+      clone[key] = unstackArrayOfObjects(value, exclude)
+      continue
+    }
+
+    // Handle functions in cross-frame scenario
+    // Keep original function references — DOMQL handles window/document
+    // isolation via element.context, so eval'ing into iframe scope is
+    // unnecessary and breaks closure-dependent functions (e.g. resolveTheme)
+    if (isFunction(value)) {
+      clone[key] = value
+      continue
+    }
+
+    // Recursively clone objects
+    if (isObjectLike(value)) {
+      clone[key] = deepClone(value, {
+        ...options,
+        visited
+      })
+    } else {
+      clone[key] = value
+    }
+  }
+
+  return clone
+}
+
+/**
+ * Stringify object
+ */
+export const deepStringifyFunctions = (obj, stringified = {}) => {
+  if (obj.node || obj.__ref || obj.parent || obj.__element || obj.parse) {
+    ;(obj.__element || obj.parent?.__element).warn(
+      'Trying to clone element or state at',
+      obj
+    )
+    obj = obj.parse?.()
+  }
+
+  for (const prop in obj) {
+    const objProp = obj[prop]
+    if (isFunction(objProp)) {
+      stringified[prop] = objProp.toString()
+    } else if (isObject(objProp)) {
+      stringified[prop] = {}
+      deepStringifyFunctions(objProp, stringified[prop])
+    } else if (isArray(objProp)) {
+      const arr = (stringified[prop] = [])
+      for (let i = 0; i < objProp.length; i++) {
+        const v = objProp[i]
+        if (isObject(v)) {
+          arr[i] = {}
+          deepStringifyFunctions(v, arr[i])
+        } else if (isFunction(v)) {
+          arr[i] = v.toString()
+        } else {
+          arr[i] = v
+        }
+      }
+    } else {
+      stringified[prop] = objProp
+    }
+  }
+  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 - 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 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)) {
+      str += '[\n'
+      for (const element of value) {
+        if (isObjectLike(element) && element !== null) {
+          str += `${spaces}    ${objectToString(element, indent + 2)},\n`
+        } else if (isString(element)) {
+          str += `${spaces}    '${element}',\n`
+        } else {
+          str += `${spaces}    ${element},\n`
+        }
+      }
+      str += `${spaces}  ]`
+    } else if (isObjectLike(value)) {
+      str += objectToString(value, indent + 1)
+    } else if (isString(value)) {
+      str += stringIncludesAny(value, ['\n', "'"])
+        ? `\`${value}\``
+        : `'${value}'`
+    } else {
+      str += value
+    }
+
+    str += ',\n'
+  }
+
+  str += `${spaces}}`
+  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 === '' || 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
+}
+
+// Indirect eval — invokes the global eval, which works in both browser and
+// Node without depending on a `window` object. Required for SSR / Brender
+// passes that hit prepareContext without a real DOM.
+const __globalEval = (src) => (0, eval)(src) // eslint-disable-line no-eval
+
+export const deepDestringifyFunctions = (
+  obj,
+  destringified = {},
+  opts = { window: { eval: __globalEval } }
+) => {
+  for (const prop in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, prop)) continue
+
+    const objProp = obj[prop]
+
+    if (isString(objProp)) {
+      if (hasFunction(objProp)) {
+        try {
+          destringified[prop] = opts.window.eval(`(${objProp})`)
+        } catch (e) {
+          // FR-1 (FRANK-RUNNER.md): the silent string-fallback used to
+          // mask broken serialization — eight aihouse functions stored
+          // as strings instead of functions, `el.call(name)` no-op'd
+          // with no error. Surface the failure so consumers can audit
+          // what frank produced. Keep the fallback (don't crash boot)
+          // but make it loud.
+          if (typeof console !== 'undefined' && console.warn) {
+            console.warn(
+              '[smbls] deepDestringifyFunctions: eval failed on "' + prop + '" — ' +
+              'function will be left as a string and el.call("' + prop + '") ' +
+              'will silently no-op. Reason: ' + (e && e.message ? e.message : String(e)) + '.\n' +
+              'First 200 chars of source: ' + String(objProp).slice(0, 200)
+            )
+          }
+          destringified[prop] = objProp
+        }
+      } else {
+        destringified[prop] = objProp
+      }
+    } else if (isArray(objProp)) {
+      const arr = (destringified[prop] = [])
+      for (let i = 0; i < objProp.length; i++) {
+        const arrProp = objProp[i]
+        if (isString(arrProp)) {
+          if (hasFunction(arrProp)) {
+            try {
+              arr.push(opts.window.eval(`(${arrProp})`))
+            } catch (e) {
+              if (typeof console !== 'undefined' && console.warn) {
+                console.warn(
+                  `[smbls] deepDestringifyFunctions: eval failed in array at index ${i} ` +
+                  `(prop "${prop}"). Reason: ${e && e.message ? e.message : String(e)}.\n` +
+                  `First 200 chars: ${String(arrProp).slice(0, 200)}`
+                )
+              }
+              arr.push(arrProp)
+            }
+          } else {
+            arr.push(arrProp)
+          }
+        } else if (isObject(arrProp)) {
+          arr.push(deepDestringifyFunctions(arrProp))
+        } else {
+          arr.push(arrProp)
+        }
+      }
+    } else if (isObject(objProp)) {
+      destringified[prop] = deepDestringifyFunctions(
+        objProp,
+        destringified[prop]
+      )
+    } else {
+      destringified[prop] = objProp
+    }
+  }
+  return destringified
+}
+
+/**
+ * Rehydrate Set / Map tagged forms (`{ __type: 'Set', values: […] }`,
+ * `{ __type: 'Map', entries: [[k,v],…] }`) into real Set / Map
+ * instances. frank's serializer emits these for live Set/Map values on
+ * globalScope so consumers' `.has()` / `.get()` calls still work after
+ * the JSON round-trip (FT-FRANK-1).
+ *
+ * Pass-through for any other value. Cheap shape check by `__type` so
+ * normal user objects aren't perturbed.
+ */
+const _rehydrateTaggedValue = (val) => {
+  if (!val || typeof val !== 'object') return val
+  if (val.__type === 'Set' && Array.isArray(val.values)) return new Set(val.values)
+  if (val.__type === 'Map' && Array.isArray(val.entries)) return new Map(val.entries)
+  return val
+}
+
+/**
+ * Destringify a globalScope object so that function strings become real functions.
+ * All globalScope values are made available as local variables when eval'ing each
+ * function, so helpers can reference constants and other helpers naturally.
+ *
+ * Also rehydrates Set/Map tagged forms (FT-FRANK-1) so `globalScope.X.has(y)`
+ * works for the original Set/Map constructors authors put on globalScope.js.
+ */
+export const destringifyGlobalScope = (gs) => {
+  if (!gs || typeof gs !== 'object') return gs
+
+  // First pass: collect non-function values (constants, arrays, objects).
+  // Set/Map tagged forms get rehydrated here so they're available as
+  // live instances in the closure that wraps function destringify below.
+  const result = {}
+  const fnEntries = []
+  for (const key of Object.keys(gs)) {
+    const val = gs[key]
+    if (isString(val) && hasFunction(val)) {
+      fnEntries.push([key, val])
+    } else {
+      result[key] = _rehydrateTaggedValue(val)
+    }
+  }
+
+  // Second pass: eval functions in a closure with all values in scope
+  for (const [key, fnStr] of fnEntries) {
+    try {
+      // Build a closure that exposes all current globalScope values
+      const varDecls = Object.keys(result)
+        .map((k) => `var ${k} = __gs__[${JSON.stringify(k)}];`)
+        .join('\n')
+      result[key] = window.eval(
+        `(function(__gs__) { ${varDecls}\n return (${fnStr}); })`
+      )(result)
+    } catch (e) {
+      // Fallback: try plain eval
+      try {
+        result[key] = window.eval(`(${fnStr})`)
+      } catch (_) {
+        result[key] = fnStr
+      }
+    }
+  }
+
+  return result
+}
+
+export const stringToObject = (str, opts = { verbose: true }) => {
+  try {
+    return str ? window.eval('(' + str + ')') : {} // eslint-disable-line
+  } catch (e) {
+    if (opts.verbose) console.warn(e)
+  }
+}
+
+export const hasOwnProperty = (o, ...args) =>
+  Object.prototype.hasOwnProperty.call(o, ...args)
+
+export const isEmpty = (o) => {
+  for (const _ in o) return false // eslint-disable-line
+  return true
+}
+
+export const isEmptyObject = (o) => isObject(o) && isEmpty(o)
+
+export const makeObjectWithoutPrototype = () => Object.create(null)
+
+/**
+ * Overwrites object properties with another
+ */
+export const overwrite = (element, params, opts = {}) => {
+  const excl = opts.exclude || []
+  const allowDunder = opts.preventUnderscore
+
+  for (const e in params) {
+    if (excl.includes(e) || (!allowDunder && _startsWithDunder(e))) continue
+    // Block prototype-pollution writes (see _deepMerge for rationale).
+    if (e === 'constructor' || e === 'prototype') continue
+    if (params[e] !== undefined) {
+      element[e] = params[e]
+    }
+  }
+
+  return element
+}
+
+export const overwriteShallow = (obj, params, excludeFrom = []) => {
+  const useSet = excludeFrom instanceof Set
+  for (const e in params) {
+    if (_startsWithDunder(e)) continue
+    if (e === 'constructor' || e === 'prototype') continue
+    if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue
+    obj[e] = params[e]
+  }
+  return obj
+}
+
+/**
+ * Overwrites DEEPLY object properties with another
+ */
+export const overwriteDeep = (
+  obj,
+  params,
+  opts = {},
+  visited = new WeakMap()
+) => {
+  if (
+    !isObjectLike(obj) ||
+    !isObjectLike(params) ||
+    isDOMNode(obj) ||
+    isDOMNode(params)
+  ) {
+    return params
+  }
+
+  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.prototype.hasOwnProperty.call(params, e)) continue
+    if ((exclSet && exclSet.has(e)) || (forcedExclude && _startsWithDunder(e)))
+      continue
+    if (e === 'constructor' || e === 'prototype') continue
+
+    const objProp = obj[e]
+    const paramsProp = params[e]
+
+    if (isDOMNode(paramsProp)) {
+      obj[e] = paramsProp
+    } else if (isObjectLike(objProp) && isObjectLike(paramsProp)) {
+      obj[e] = overwriteDeep(objProp, paramsProp, opts, visited)
+    } else if (paramsProp !== undefined) {
+      obj[e] = paramsProp
+    }
+  }
+
+  return obj
+}
+
+/**
+ * Recursively compares two values to determine if they are deeply equal.
+ */
+export const isEqualDeep = (param, element, visited = new Set()) => {
+  if (
+    typeof param !== 'object' ||
+    typeof element !== 'object' ||
+    param === null ||
+    element === null
+  ) {
+    return param === element
+  }
+
+  if (visited.has(param) || visited.has(element)) {
+    return true
+  }
+
+  visited.add(param)
+  visited.add(element)
+
+  const keysParam = Object.keys(param)
+  const keysElement = Object.keys(element)
+
+  if (keysParam.length !== keysElement.length) {
+    return false
+  }
+
+  for (let i = 0; i < keysParam.length; i++) {
+    const key = keysParam[i]
+    if (!Object.prototype.hasOwnProperty.call(element, key)) {
+      return false
+    }
+    if (!isEqualDeep(param[key], element[key], visited)) {
+      return false
+    }
+  }
+
+  return true
+}
+
+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)
+
+    for (const key in source) {
+      if (!Object.prototype.hasOwnProperty.call(source, key)) continue
+      if (ignored.has(key)) continue
+      if (!Object.prototype.hasOwnProperty.call(target, key)) return false
+
+      const sourceValue = source[key]
+      const targetValue = target[key]
+
+      if (isDOMNode(sourceValue) || isDOMNode(targetValue)) {
+        if (sourceValue !== targetValue) return false
+      } else if (isObjectLike(sourceValue) && isObjectLike(targetValue)) {
+        if (!checkContains(targetValue, sourceValue)) return false
+      } else if (sourceValue !== targetValue) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  return checkContains(obj1, obj2)
+}
+
+export const removeFromObject = (obj, props) => {
+  if (props === undefined || props === null) return obj
+  if (is(props)('string', 'number')) {
+    delete obj[props]
+  } else if (isArray(props)) {
+    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'
+    )
+  }
+  return obj
+}
+
+export const createObjectWithoutPrototype = (obj) => {
+  if (obj === null || typeof obj !== 'object') {
+    return obj
+  }
+
+  const newObj = Object.create(null)
+
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      newObj[key] = createObjectWithoutPrototype(obj[key])
+    }
+  }
+
+  return newObj
+}
+
+export const createNestedObject = (arr, lastValue) => {
+  if (arr.length === 0) return lastValue
+
+  const nestedObject = {}
+  let current = nestedObject
+
+  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 nestedObject
+}
+
+export const removeNestedKeyByPath = (obj, path) => {
+  if (!Array.isArray(path)) {
+    throw new Error('Path must be an array.')
+  }
+
+  let current = obj
+
+  for (let i = 0; i < path.length - 1; i++) {
+    if (current[path[i]] === undefined) return
+    current = current[path[i]]
+  }
+
+  const lastKey = path[path.length - 1]
+  if (current && Object.prototype.hasOwnProperty.call(current, lastKey)) {
+    delete current[lastKey]
+  }
+}
+
+export const setInObjectByPath = (obj, path, value) => {
+  if (!Array.isArray(path)) {
+    throw new Error('Path must be an array.')
+  }
+
+  let current = obj
+
+  for (let i = 0; i < path.length - 1; i++) {
+    if (!current[path[i]] || typeof current[path[i]] !== 'object') {
+      current[path[i]] = {}
+    }
+    current = current[path[i]]
+  }
+
+  current[path[path.length - 1]] = value
+
+  return obj
+}
+
+export const getInObjectByPath = (obj, path) => {
+  if (!Array.isArray(path)) {
+    throw new Error('Path must be an array.')
+  }
+
+  let current = obj
+
+  for (let i = 0; i < path.length; i++) {
+    if (current === undefined || current === null) {
+      return undefined
+    }
+    current = current[path[i]]
+  }
+
+  return current
+}
+
+export const detectInfiniteLoop = (arr) => {
+  const maxRepeats = 10
+  let pattern = []
+  let repeatCount = 0
+
+  for (let i = 0; i < arr.length; i++) {
+    if (pattern.length < 2) {
+      pattern.push(arr[i])
+    } else {
+      if (arr[i] === pattern[i % 2]) {
+        repeatCount++
+      } else {
+        pattern = [arr[i - 1], arr[i]]
+        repeatCount = 1
+      }
+
+      if (repeatCount >= maxRepeats * 2) {
+        if (ENV === 'test' || ENV === 'development') {
+          console.warn(
+            'Warning: Potential infinite loop detected due to repeated sequence:',
+            pattern
+          )
+        }
+        return true
+      }
+    }
+  }
+}
+
+export const isCyclic = (obj) => {
+  const seen = new WeakSet()
+
+  function detect(obj) {
+    if (obj && typeof obj === 'object') {
+      if (seen.has(obj)) return true
+      seen.add(obj)
+      for (const key in obj) {
+        if (
+          Object.prototype.hasOwnProperty.call(obj, key) &&
+          detect(obj[key])
+        ) {
+          console.log(obj, 'cycle at ' + key)
+          return true
+        }
+      }
+    }
+    return false
+  }
+
+  return detect(obj)
+}
+
+export const excludeKeysFromObject = (obj, excludedKeys) => {
+  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
+}