@symbo.ls/utils 3.14.2 → 3.14.4

package/extends.js

@@ -1,519 +0,0 @@
-'use strict'
-
-import { joinArrays, removeDuplicatesInArray } from './array.js'
-import { matchesComponentNaming } from './component.js'
-import { deepClone, exec } from './object.js'
-import { isArray, isObject, isString } from './types.js'
-const ENV = process.env.NODE_ENV
-const isSourcemapEnabled = (options) => options.sourcemap !== false && ENV !== 'production'
-
-export const createExtendsFromKeys = key => {
-  if (key.includes('+')) {
-    return key.split('+').filter(matchesComponentNaming)
-  }
-
-  if (key.includes('_')) {
-    const [first] = key.split('_')
-    return [first]
-  }
-
-  if (key.includes('.') && !matchesComponentNaming(key.split('.')[1])) {
-    const [first] = key.split('.')
-    return [first]
-  }
-
-  return [key]
-}
-
-// Initial extend creation
-export const createExtends = (element, parent, key) => {
-  let __extends = []
-  const keyExtends = createExtendsFromKeys(key)
-  if (keyExtends) __extends = [...keyExtends]
-  const elementExtends = element.extends
-  if (elementExtends) {
-    __extends = isArray(elementExtends)
-      ? [...__extends, ...elementExtends]
-      : [...__extends, elementExtends]
-  }
-  return __extends
-}
-
-export const addExtends = (newExtends, element) => {
-  const { __ref: ref } = element
-  let { __extends } = ref
-
-  if (!newExtends) return __extends
-
-  // Check if the first extend has a variant in components
-  const variant = element.variant
-  const context = element.context
-  if (
-    variant &&
-    context?.components &&
-    !Array.isArray(newExtends) &&
-    typeof newExtends === 'string'
-  ) {
-    const variantKey = `${newExtends}.${variant}`
-    if (context.components[variantKey]) {
-      newExtends = variantKey
-    }
-  }
-
-  if (!__extends.includes(newExtends)) {
-    __extends = Array.isArray(newExtends)
-      ? [...__extends, ...newExtends]
-      : [...__extends, newExtends]
-    ref.__extends = __extends
-  }
-  return __extends
-}
-
-export const concatAddExtends = (newExtend, element) => {
-  if (!newExtend) return element
-  const { extends: elementExtend } = element
-  const originalArray = isArray(elementExtend) ? elementExtend : [elementExtend]
-  const receivedArray = isArray(newExtend) ? newExtend : [newExtend]
-  return {
-    ...element,
-    extends: joinArrays(receivedArray, originalArray)
-  }
-}
-
-export const generateHash = () => Math.random().toString(36).substring(2)
-
-// hashing
-export const extendStackRegistry = {}
-export const extendCachedRegistry = {}
-
-export const getHashedExtend = extend => {
-  return extendStackRegistry[extend.__hash]
-}
-
-export const setHashedExtend = (extend, stack) => {
-  const hash = generateHash()
-  if (!isString(extend)) {
-    extend.__hash = hash
-  }
-  if (hash !== '__proto__' && hash !== 'constructor' && hash !== 'prototype') {
-    extendStackRegistry[hash] = stack
-  }
-  return stack
-}
-
-export const getExtendsStackRegistry = (extend, stack) => {
-  if (extend.__hash) {
-    return stack.concat(getHashedExtend(extend))
-  }
-  return setHashedExtend(extend, stack) // stack .concat(hashedExtend)
-}
-
-// stacking
-export const extractArrayExtend = (
-  extend,
-  stack,
-  context,
-  processed = new Set(),
-  nameStack,
-  componentNameMap
-) => {
-  for (const each of extend) {
-    if (isArray(each)) {
-      extractArrayExtend(each, stack, context, processed, nameStack, componentNameMap)
-    } else {
-      flattenExtend(each, stack, context, processed, nameStack, undefined, componentNameMap)
-    }
-  }
-  return stack
-}
-
-export const deepExtend = (extend, stack, context, processed = new Set(), nameStack, currentName, componentNameMap) => {
-  const extendOflattenExtend = extend.extends
-  const cleanExtend = { ...extend }
-  delete cleanExtend.extends
-  let hasKeys = false
-  for (const _k in cleanExtend) { hasKeys = true; break } // eslint-disable-line
-  if (hasKeys) {
-    stack.push(cleanExtend)
-    if (nameStack) nameStack.push(currentName)
-  }
-  if (extendOflattenExtend) {
-    flattenExtend(extendOflattenExtend, stack, context, processed, nameStack, currentName, componentNameMap)
-  }
-  return stack
-}
-
-export const flattenExtend = (
-  extend,
-  stack,
-  context,
-  processed = new Set(),
-  nameStack,
-  parentName,
-  componentNameMap
-) => {
-  if (!extend) return stack
-  if (processed.has(extend)) return stack
-
-  if (isArray(extend)) {
-    return extractArrayExtend(extend, stack, context, processed, nameStack, componentNameMap)
-  }
-
-  let currentName = parentName
-  if (isString(extend)) {
-    currentName = extend
-    extend = mapStringsWithContextComponents(extend, context)
-  } else if (componentNameMap && isObject(extend) && componentNameMap.has(extend)) {
-    // Resolve name from pre-built map (top-level resolved extends)
-    currentName = componentNameMap.get(extend)
-  }
-
-  processed.add(extend)
-
-  if (extend?.extends) {
-    deepExtend(extend, stack, context, processed, nameStack, currentName, componentNameMap)
-  } else if (extend) {
-    stack.push(extend)
-    if (nameStack) nameStack.push(currentName)
-  }
-
-  return stack
-}
-
-const MERGE_EXTENDS_SKIP = new Set([
-  'parent', 'node', '__ref', '__proto__', 'extends', 'childExtends', 'childExtendsRecursive'
-])
-
-export const deepMergeExtends = (element, extend, sourcemap, sourceName, preBuiltSourcemap) => {
-  // Clone extend to prevent mutations
-  extend = deepClone(extend)
-
-  for (const e in extend) {
-    if (MERGE_EXTENDS_SKIP.has(e)) continue
-
-    const elementProp = element[e]
-    const extendProp = extend[e]
-
-    // Skip if the property is undefined in the extend object
-    if (extendProp === undefined) continue
-
-    // Handle only properties that exist in the extend object
-    if (
-      Object.prototype.hasOwnProperty.call(extend, e) &&
-      e !== '__proto__' && e !== 'constructor' && e !== 'prototype'
-    ) {
-      if (elementProp === undefined) {
-        // For undefined properties in element, copy from extend
-        element[e] = extendProp
-        // Track sourcemap for this property
-        if (sourcemap && sourceName) {
-          if (isObject(extendProp) && !isArray(extendProp)) {
-            sourcemap[e] = sourcemap[e] || {}
-            trackSourcemapDeep(sourcemap[e], extendProp, sourceName)
-          } else {
-            sourcemap[e] = sourceName
-          }
-        } else if (sourcemap && preBuiltSourcemap?.[e]) {
-          // Copy sourcemap entry from pre-built sourcemap (used in finalizeExtends)
-          sourcemap[e] = preBuiltSourcemap[e]
-        }
-      } else if (isObject(elementProp) && isObject(extendProp)) {
-        // For objects, merge based on type
-        const nestedSourcemap = sourcemap ? (sourcemap[e] = sourcemap[e] || {}) : undefined
-        const nestedPreBuilt = preBuiltSourcemap?.[e]
-        if (matchesComponentNaming(e)) {
-          // For components, override base properties with extended ones
-          element[e] = deepMergeExtends(elementProp, extendProp, nestedSourcemap, sourceName, nestedPreBuilt)
-        } else {
-          // For other objects, merge normally
-          deepMergeExtends(elementProp, extendProp, nestedSourcemap, sourceName, nestedPreBuilt)
-        }
-      }
-
-      if (
-        e === 'extends' ||
-        e === 'childExtends' ||
-        e === 'childExtendsRecursive'
-      ) {
-        if (isArray(elementProp) && isArray(extendProp)) {
-          element[e] = elementProp.concat(extendProp)
-        } else if (isArray(elementProp) && isObject(extendProp)) {
-          const obj = deepMergeExtends({}, elementProp)
-          element[e] = deepMergeExtends(obj, extendProp)
-        }
-      }
-      // If elementProp is defined and not an object, keep it (don't override)
-      // This preserves properties from earlier in the extend chain
-    }
-  }
-
-  return element
-}
-
-const trackSourcemapDeep = (sourcemap, obj, sourceName, seen) => {
-  if (!seen) seen = new WeakSet()
-  if (seen.has(obj)) return
-  seen.add(obj)
-  for (const key in obj) {
-    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue
-    if (key === '__proto__' || key === 'constructor' || key === 'prototype') continue
-    const val = obj[key]
-    if (isObject(val) && !isArray(val)) {
-      sourcemap[key] = sourcemap[key] || {}
-      trackSourcemapDeep(sourcemap[key], val, sourceName, seen)
-    } else {
-      sourcemap[key] = sourceName
-    }
-  }
-}
-
-export const cloneAndMergeArrayExtend = (stack, sourcemap, extendNames) => {
-  return stack.reduce((acc, current, i) => {
-    // Clone current extend to avoid mutations
-    const cloned = deepClone(current)
-    const sourceName = extendNames ? extendNames[i] : undefined
-    // Merge into accumulator, giving priority to current extend
-    return deepMergeExtends(acc, cloned, sourcemap, sourceName)
-  }, {})
-}
-
-export const mapStringsWithContextComponents = (
-  extend,
-  context,
-  options = {},
-  variant
-) => {
-  const COMPONENTS = context?.components || options.components
-  const PAGES = context?.pages || options.pages
-  if (isString(extend)) {
-    const componentExists =
-      COMPONENTS &&
-      (COMPONENTS[extend + '.' + variant] ||
-        COMPONENTS[extend] ||
-        COMPONENTS['smbls.' + extend])
-    const pageExists = PAGES && extend.charCodeAt(0) === 47 && PAGES[extend]
-    if (componentExists) return componentExists
-    else if (pageExists) return pageExists
-    else {
-      if (options.verbose && (ENV === 'test' || ENV === 'development')) {
-        console.warn('Extend is string but component was not found:', extend)
-      }
-      return
-    }
-  }
-  return extend
-}
-
-// joint stacks
-export const jointStacks = (extendStack, childExtendsStack) => {
-  return []
-    .concat(extendStack.slice(0, 1))
-    .concat(childExtendsStack.slice(0, 1))
-    .concat(extendStack.slice(1))
-    .concat(childExtendsStack.slice(1))
-}
-
-// init
-export const getExtendsStack = (extend, context, nameStack, componentNameMap) => {
-  if (!extend) return []
-  if (extend.__hash) return getHashedExtend(extend) || []
-  const processed = new Set()
-  const stack = flattenExtend(extend, [], context, processed, nameStack, undefined, componentNameMap)
-  if (nameStack) return stack
-  return getExtendsStackRegistry(extend, stack)
-}
-
-export const addExtend = (newExtends, elementExtends) => {
-  if (!newExtends) return elementExtends
-  const receivedArray = isArray(newExtends) ? newExtends : [newExtends]
-  return joinArrays(receivedArray, elementExtends)
-}
-
-export const getExtendsInElement = obj => {
-  let result = []
-
-  function traverse (o) {
-    for (const key in o) {
-      if (Object.prototype.hasOwnProperty.call(o, key)) {
-        // Check if the key starts with a capital letter and exclude keys like @mobileL, $router
-        if (matchesComponentNaming(key)) {
-          result.push(key)
-        }
-
-        // Check if the key is "extend" and it's either a string or an array
-        if (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 const createElementExtends = (element, parent, options = {}) => {
-  const { __ref: ref } = element
-  const context = element.context || parent.context
-  const variant = element.variant
-
-  if (element.extends) {
-    if (Array.isArray(element.extends) && element.extends.length > 0) {
-      // Handle first item in array specially for variant
-      const [firstExtend, ...restExtends] = element.extends
-      if (typeof firstExtend === 'string' && variant && context?.components) {
-        const variantKey = `${firstExtend}.${variant}`
-        if (context.components[variantKey]) {
-          addExtends([variantKey, ...restExtends], element)
-        } else {
-          addExtends(element.extends, element)
-        }
-      } else {
-        addExtends(element.extends, element)
-      }
-    } else if (
-      typeof element.extends === 'string' &&
-      variant &&
-      context?.components
-    ) {
-      const variantKey = `${element.extends}.${variant}`
-      if (context.components[variantKey]) {
-        addExtends(variantKey, element)
-      } else {
-        addExtends(element.extends, element)
-      }
-    } else {
-      addExtends(element.extends, element)
-    }
-  }
-
-  inheritChildPropsExtends(element, parent, options)
-  inheritChildExtends(element, parent, options)
-  inheritRecursiveChildExtends(element, parent, options)
-
-  if (element.component) {
-    addExtends(exec(element.component, element), element)
-  }
-
-  if (context.defaultExtends) {
-    addExtends(context.defaultExtends, element)
-  }
-
-  return removeDuplicatesInArray(ref.__extends)
-}
-
-export const inheritChildPropsExtends = (element, parent, options = {}) => {
-  const { __ref: ref } = element
-  const ignoreChildExtends =
-    options.ignoreChildExtends || element.ignoreChildExtends
-  if (!ignoreChildExtends) {
-    if (parent.childProps?.extends) {
-      addExtends(parent.childProps.extends, element)
-    }
-  }
-  return ref.__extends
-}
-
-export const inheritChildExtends = (element, parent, options = {}) => {
-  const { __ref: ref } = element
-  const ignoreChildExtends =
-    options.ignoreChildExtends || element.ignoreChildExtends
-
-  const childExtends = parent.childExtends
-  if (!ignoreChildExtends && childExtends) {
-    addExtends(childExtends, element)
-  }
-  return ref.__extends
-}
-
-export const inheritRecursiveChildExtends = (element, parent, options = {}) => {
-  const { __ref: ref } = element
-  const childExtendsRecursive = parent.childExtendsRecursive
-  const ignoreChildExtendsRecursive =
-    options.ignoreChildExtendsRecursive || element.ignoreChildExtendsRecursive
-  const isText = element.key === '__text'
-  if (childExtendsRecursive && !isText && !ignoreChildExtendsRecursive) {
-    addExtends(childExtendsRecursive, element)
-  }
-  return ref.__extends
-}
-
-export const createExtendsStack = (element, parent, options = {}) => {
-  const { __ref: ref } = element
-  const context = element.context || parent.context
-
-  const variant = element.variant
-
-  // Keep original string names before resolution for sourcemap tracking
-  const sourcemap = isSourcemapEnabled(options)
-  const originalExtendNames = sourcemap ? [...ref.__extends] : null
-
-  const __extends = removeDuplicatesInArray(
-    ref.__extends.map((val, i) => {
-      return mapStringsWithContextComponents(
-        val,
-        context,
-        options,
-        i === 0 && variant
-      )
-    })
-  )
-
-  if (sourcemap) {
-    // Build a map from resolved component objects to their original string names
-    const componentNameMap = new WeakMap()
-    for (let i = 0; i < __extends.length; i++) {
-      const resolved = __extends[i]
-      const originalName = originalExtendNames[i]
-      if (resolved && isObject(resolved) && isString(originalName)) {
-        componentNameMap.set(resolved, originalName)
-      }
-    }
-    const nameStack = []
-    const stack = getExtendsStack(__extends, context, nameStack, componentNameMap)
-    ref.__extendsStack = stack
-    ref.__extendsNames = nameStack
-  } else {
-    const stack = getExtendsStack(__extends, context)
-    ref.__extendsStack = stack
-  }
-
-  return ref.__extendsStack
-}
-
-export const finalizeExtends = (element, parent, options = {}) => {
-  const { __ref: ref } = element
-  const { __extendsStack } = ref
-
-  if (isSourcemapEnabled(options)) {
-    const sourcemapAcc = {}
-    const extendNames = ref.__extendsNames || []
-    const flattenExtends = cloneAndMergeArrayExtend(__extendsStack, sourcemapAcc, extendNames)
-    // Only keep sourcemap entries for properties actually merged into element
-    const appliedSourcemap = {}
-    deepMergeExtends(element, flattenExtends, appliedSourcemap, undefined, sourcemapAcc)
-    ref.__sourcemap = appliedSourcemap
-  } else {
-    const flattenExtends = cloneAndMergeArrayExtend(__extendsStack)
-    deepMergeExtends(element, flattenExtends)
-  }
-
-  return element
-}
-
-export const applyExtends = (element, parent, options = {}) => {
-  createElementExtends(element, parent, options)
-  createExtendsStack(element, parent, options)
-  finalizeExtends(element, parent, options)
-  return element
-}

package/fibonacci.js

@@ -1,9 +0,0 @@
-'use strict'
-
-export const fibonacciNumberByIndex = function fibonacciNumberByIndex (n) {
-  const fib = [0, 1]
-  for (let i = 2; i <= n; i++) {
-    fib[i] = fib[i - 1] + fib[i - 2]
-  }
-  return fib[n]
-}

package/files.js

@@ -1,3 +0,0 @@
-'use strict'
-
-export const isPhoto = format => ['jpeg', 'gif', 'jpg', 'png', 'tiff', 'woff'].includes(format)

package/function.js

@@ -1,145 +0,0 @@
-'use strict'
-
-/**
- * Debounces a function, ensuring that it is only executed after a specified timeout
- * period has elapsed since the last invocation.
- *
- * @param {function} func - The function to be debounced.
- * @param {number} [timeout=300] - The time (in milliseconds) to wait after the last call to
- *     `debounce` before executing the `func`.
- * @returns {function} - A debounced version of the input function `func`.
- * @example
- * // Usage example:
- * const debouncedFunction = debounce(this, myFunction, 500);
- * window.addEventListener('resize', debouncedFunction);
- */
-export 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)
-  }
-}
-
-/**
- * Debounces a function, ensuring that it is only executed after a specified timeout
- * period has elapsed since the last invocation.
- *
- * @param {Object} element - The context (this) to which the debounced function will be applied.
- * @param {function} func - The function to be debounced.
- * @param {number} [timeout=300] - The time (in milliseconds) to wait after the last call to
- *     `debounce` before executing the `func`.
- * @returns {function} - A debounced version of the input function `func`.
- * @example
- * // Usage example:
- * const debouncedFunction = debounce(this, myFunction, 500);
- * window.addEventListener('resize', debouncedFunction);
- */
-export const debounceOnContext = (element, func, timeout = 300) => {
-  let timer
-  return (...args) => {
-    clearTimeout(timer)
-    timer = setTimeout(() => {
-      func.apply(element, args)
-    }, timeout)
-  }
-}
-
-export 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 RE_STRING_FUNCTION = /^((function\s*\([^)]*\)\s*\{[^}]*\})|(\([^)]*\)\s*=>))/
-
-export const isStringFunction = inputString => {
-  return RE_STRING_FUNCTION.test(inputString)
-}
-
-/**
- * Resolve an event handler through context plugins.
- *
- * If `handler` is already a function it is returned as-is.
- * Otherwise, iterates `context.plugins` looking for a plugin
- * with a `resolveHandler` method that can compile the handler
- * (e.g. a funcql schema) into a callable function.
- *
- * @param {*} handler - event handler (function, object, array, string)
- * @param {object} element - domql element
- * @returns {function|*} resolved handler
- */
-/**
- * Check if context has any plugin that can resolve non-function handlers.
- */
-export const hasHandlerPlugin = (ctx) => {
-  const plugins = ctx?.plugins
-  if (!plugins || !plugins.length) return false
-  for (const plugin of plugins) {
-    if (plugin.resolveHandler) return true
-  }
-  return false
-}
-
-export const resolveHandler = (handler, element) => {
-  if (typeof handler === 'function') return handler
-  const plugins = element?.context?.plugins
-  if (!plugins) return handler
-  for (const plugin of plugins) {
-    if (plugin.resolveHandler) {
-      const resolved = plugin.resolveHandler(handler, element)
-      if (typeof resolved === 'function') return resolved
-    }
-  }
-  return handler
-}
-
-/**
- * Run a named hook across all context plugins.
- *
- * @param {string} hookName - lifecycle hook name
- * @param {object} element - domql element
- * @param {*[]} args - additional arguments forwarded to each plugin hook
- */
-export const runPluginHook = (hookName, element, ...args) => {
-  const plugins = element?.context?.plugins
-  if (!plugins) return false
-  let handled = false
-  for (const plugin of plugins) {
-    if (typeof plugin[hookName] === 'function') {
-      plugin[hookName](element, ...args)
-      handled = true
-    }
-  }
-  return handled
-}
-
-export function cloneFunction (fn, win = window) {
-  const temp = function () {
-    return fn.apply(win, arguments)
-  }
-
-  // Copy properties from original function
-  for (const key in fn) {
-    if (Object.prototype.hasOwnProperty.call(fn, key)) {
-      temp[key] = fn[key]
-    }
-  }
-  return temp
-}

package/globals.js

@@ -1,8 +0,0 @@
-'use strict'
-
-const global = globalThis
-const self = globalThis
-const window = globalThis
-const document = (this || window).document // eslint-disable-line
-
-export { global, self, window, document }