@symbo.ls/utils 3.2.3 → 3.14.0

package/element.js

@@ -0,0 +1,148 @@
+'use strict'
+
+import { createExtends } from './extends.js'
+import { createKey } from './key.js'
+import { isNode } from './node.js'
+import { createProps } from './props.js'
+import { HTML_TAGS } from './tags.js'
+import { is, isFunction } from './types.js'
+
+const ENV = process.env.NODE_ENV
+
+export const returnValueAsText = (element, parent, key) => {
+  const childExtendsTag = parent.childExtends && parent.childExtends.tag
+  const childPropsTag = parent.childProps && parent.childProps.tag
+  const isKeyValidHTMLTag = HTML_TAGS.body.has(key) && key
+  return {
+    text: element,
+    tag: childExtendsTag || childPropsTag || isKeyValidHTMLTag || 'string'
+  }
+}
+
+export const createBasedOnType = (element, parent, key) => {
+  // if ELEMENT is not given
+  if (element === undefined) {
+    if (ENV === 'test' || ENV === 'development') {
+      console.warn(
+        key,
+        'element is undefined in',
+        parent?.__ref?.path
+      )
+    }
+    return {}
+  }
+
+  if (element === null) return
+  if (element === true) return {}
+
+  if (is(element)('string', 'number')) {
+    return returnValueAsText(element, parent, key)
+  }
+
+  if (isFunction(element)) {
+    return { props: element }
+  }
+
+  return element
+}
+
+export const addRef = (element, parent) => {
+  const ref = {}
+  ref.origin = element
+  ref.parent = parent
+  return ref
+}
+
+export const createParent = (element, parent, key, options, root) => {
+  if (!parent) return root
+  if (isNode(parent)) {
+    const parentNodeWrapper = { key: ':root', node: parent }
+    root[`${key}_parent`] = parentNodeWrapper
+    return parentNodeWrapper
+  }
+  return parent
+}
+
+export const createRoot = (element, parent) => {
+  const { __ref: ref } = element
+  const { __ref: parentRef } = parent
+
+  const hasRoot = parent && parent.key === ':root'
+  if (!ref?.root) {
+    ref.root = hasRoot ? element : parentRef?.root
+  }
+}
+
+export const createPath = (element, parent, key) => {
+  let { __ref: parentRef } = parent
+  // set the PATH array
+  if (!parentRef) parentRef = parent.ref = {}
+  if (!parentRef.path) parentRef.path = []
+  return parentRef.path.concat(key)
+}
+
+export const addContext = (element, parent, key, options, root) => {
+  const forcedOptionsContext =
+    options.context && !root.context && !element.context
+  if (forcedOptionsContext) root.context = options.context
+
+  // inherit from parent or root
+  return options.context || parent.context || root.context || element.context
+}
+
+export const addCaching = (element, parent, key) => {
+  const ref = addRef(element, parent)
+
+  element.__ref = ref
+
+  // enable CACHING
+  if (!ref.__defineCache) ref.__defineCache = {}
+
+  // enable EXEC
+  if (!ref.__exec) ref.__exec = {}
+  if (!ref.__execProps) ref.__execProps = {}
+
+  // enable CLASS CACHING
+  if (!ref.__class) ref.__class = {}
+  if (!ref.__classNames) ref.__classNames = {}
+
+  // enable CLASS CACHING
+  if (!ref.__attr) ref.__attr = {}
+
+  // enable CHANGES storing
+  if (!ref.__changes) ref.__changes = []
+
+  // enable CHANGES storing
+  if (!ref.__children) ref.__children = []
+
+  ref.__extends = createExtends(element, parent, key)
+  ref.path = createPath(element, parent, key)
+
+  return ref
+}
+
+export const createElement = (passedProps, parentEl, passedKey, opts, root) => {
+  const hashed = passedProps?.__hash
+  const element = hashed
+    ? { extends: [passedProps] }
+    : createBasedOnType(passedProps, parentEl, passedKey)
+  if (!element) return
+
+  const parent = createParent(element, parentEl, passedKey, opts, root)
+  const key = createKey(element, parent, passedKey)
+
+  addCaching(element, parent, key)
+
+  const props = createProps(element, parent, key)
+  const context = addContext(element, parent, key, opts, root)
+  const on = element.on || {}
+
+  return {
+    ...element,
+    key,
+    props,
+    parent,
+    context,
+    on
+  }
+}

package/env.js

@@ -0,0 +1,15 @@
+'use strict'
+
+// @preserve-env
+export const NODE_ENV = process.env.NODE_ENV
+export const ENV = NODE_ENV
+
+export const isProduction = (env = NODE_ENV) => env === 'production'
+export const isTest = (env = NODE_ENV) => env === 'testing' || env === 'test'
+export const isTesting = isTest
+export const isStaging = (env = NODE_ENV) => env === 'staging'
+export const isLocal = (env = NODE_ENV) => env === 'local'
+export const isDevelopment = (env = NODE_ENV) =>
+  env === 'development' || env === 'dev' || env === 'local'
+export const getNev = (key, env = NODE_ENV) => env[key]
+export const isNotProduction = (env = NODE_ENV) => !isProduction(env)

package/events.js

@@ -0,0 +1,19 @@
+'use strict'
+
+import { lowercaseFirstLetter } from './string.js'
+import { isFunction } from './types.js'
+
+export function addEventFromProps (key, obj) {
+  const { props, on } = obj
+  const eventName = lowercaseFirstLetter(key.split('on')[1])
+  const origEvent = on[eventName]
+  const funcFromProps = props[key]
+  if (isFunction(origEvent)) {
+    on[eventName] = (...args) => {
+      const originalEventRetunrs = origEvent(...args)
+      if (originalEventRetunrs !== false) {
+        if (isFunction(funcFromProps)) return funcFromProps(...args)
+      }
+    }
+  } else on[eventName] = funcFromProps
+}

package/extends.js

@@ -0,0 +1,519 @@
+'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
+}