@domql/utils 3.1.2 → 3.2.7

package/element.js

@@ -12,7 +12,7 @@ const ENV = process.env.NODE_ENV
 export const returnValueAsText = (element, parent, key) => {
   const childExtendsTag = parent.childExtends && parent.childExtends.tag
   const childPropsTag = parent.props.childProps && parent.props.childProps.tag
-  const isKeyValidHTMLTag = HTML_TAGS.body.indexOf(key) > -1 && key
+  const isKeyValidHTMLTag = HTML_TAGS.body.has(key) && key
   return {
     text: element,
     tag: childExtendsTag || childPropsTag || isKeyValidHTMLTag || 'string'
@@ -26,7 +26,7 @@ export const createBasedOnType = (element, parent, key) => {
       console.warn(
         key,
         'element is undefined in',
-        parent && parent.__ref && parent.__ref.path
+        parent?.__ref?.path
       )
     }
     return {}

package/events.js

@@ -9,9 +9,9 @@ export function addEventFromProps (key, obj) {
   const origEvent = on[eventName]
   const funcFromProps = props[key]
   if (isFunction(origEvent)) {
-    on[eventName] = async (...args) => {
-      const originalEventRetunrs = await origEvent(...args)
-      if (originalEventRetunrs !== false) await funcFromProps(...args)
+    on[eventName] = (...args) => {
+      const originalEventRetunrs = origEvent(...args)
+      if (originalEventRetunrs !== false) funcFromProps(...args)
     }
   } else on[eventName] = funcFromProps
 }

package/extends.js

@@ -94,7 +94,7 @@ export const setHashedExtend = (extend, stack) => {
   if (!isString(extend)) {
     extend.__hash = hash
   }
-  if (!['__proto__', 'constructor', 'prototype'].includes(hash)) {
+  if (hash !== '__proto__' && hash !== 'constructor' && hash !== 'prototype') {
     extendStackRegistry[hash] = stack
   }
   return stack
@@ -125,11 +125,14 @@ export const extractArrayExtend = (
 }
 
 export const deepExtend = (extend, stack, context, processed = new Set()) => {
-  const extendOflattenExtend = extend.extends
-  // Remove extends property before adding to stack
+  const extendOflattenExtend = extend.extends || extend.extend
+  // Remove extends/extend properties before adding to stack
   const cleanExtend = { ...extend }
   delete cleanExtend.extends
-  if (Object.keys(cleanExtend).length > 0) {
+  delete cleanExtend.extend
+  let hasKeys = false
+  for (const _k in cleanExtend) { hasKeys = true; break } // eslint-disable-line
+  if (hasKeys) {
     stack.push(cleanExtend)
   }
   if (extendOflattenExtend) {
@@ -157,7 +160,7 @@ export const flattenExtend = (
 
   processed.add(extend)
 
-  if (extend?.extends) {
+  if (extend?.extends || extend?.extend) {
     deepExtend(extend, stack, context, processed)
   } else if (extend) {
     stack.push(extend)
@@ -166,12 +169,16 @@ export const flattenExtend = (
   return stack
 }
 
+const MERGE_EXTENDS_SKIP = new Set([
+  'parent', 'node', '__ref', '__proto__', 'extend', 'childExtend', 'childExtendRecursive'
+])
+
 export const deepMergeExtends = (element, extend) => {
   // Clone extend to prevent mutations
   extend = deepClone(extend)
 
   for (const e in extend) {
-    if (['parent', 'node', '__ref', '__proto__'].indexOf(e) > -1) continue
+    if (MERGE_EXTENDS_SKIP.has(e)) continue
 
     const elementProp = element[e]
     const extendProp = extend[e]
@@ -182,7 +189,7 @@ export const deepMergeExtends = (element, extend) => {
     // Handle only properties that exist in the extend object
     if (
       Object.prototype.hasOwnProperty.call(extend, e) &&
-      !['__proto__', 'constructor', 'prototype'].includes(e)
+      e !== '__proto__' && e !== 'constructor' && e !== 'prototype'
     ) {
       if (elementProp === undefined) {
         // For undefined properties in element, copy from extend
@@ -233,15 +240,15 @@ export const mapStringsWithContextComponents = (
   options = {},
   variant
 ) => {
-  const COMPONENTS = (context && context.components) || options.components
-  const PAGES = (context && context.pages) || options.pages
+  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.startsWith('/') && PAGES[extend]
+    const pageExists = PAGES && extend.charCodeAt(0) === 47 && PAGES[extend]
     if (componentExists) return componentExists
     else if (pageExists) return pageExists
     else {
@@ -283,7 +290,7 @@ export const getExtendsInElement = obj => {
 
   function traverse (o) {
     for (const key in o) {
-      if (Object.hasOwnProperty.call(o, key)) {
+      if (Object.prototype.hasOwnProperty.call(o, key)) {
         // Check if the key starts with a capital letter and exclude keys like @mobileL, $propsCollection
         if (matchesComponentNaming(key)) {
           result.push(key)
@@ -316,7 +323,10 @@ export const createElementExtends = (element, parent, options = {}) => {
   const context = element.context || parent.context
   const variant = element.props?.variant
 
-  // Add the extends property from element if it exists
+  // Add the extends property from element if it exists (supports v2 `extend` fallback)
+  if (element.extend && !element.extends) element.extends = element.extend
+  delete element.extend
+  if (!element.extends && element.props?.extends) element.extends = element.props.extends
   if (element.extends) {
     if (Array.isArray(element.extends) && element.extends.length > 0) {
       // Handle first item in array specially for variant
@@ -379,16 +389,18 @@ export const inheritChildExtends = (element, parent, options = {}) => {
   const ignoreChildExtends =
     options.ignoreChildExtends || props?.ignoreChildExtends
 
-  if (!ignoreChildExtends && parent.childExtends) {
-    // Use else if to avoid double-adding
-    addExtends(parent.childExtends, element)
+  // Supports v2 `childExtend` fallback
+  const childExtends = parent.childExtends || parent.childExtend
+  if (!ignoreChildExtends && childExtends) {
+    addExtends(childExtends, element)
   }
   return ref.__extends
 }
 
 export const inheritRecursiveChildExtends = (element, parent, options = {}) => {
   const { props, __ref: ref } = element
-  const childExtendsRecursive = parent.childExtendsRecursive
+  // Supports v2 `childExtendRecursive` fallback
+  const childExtendsRecursive = parent.childExtendsRecursive || parent.childExtendRecursive
   const ignoreChildExtendsRecursive =
     options.ignoreChildExtendsRecursive || props?.ignoreChildExtendsRecursive
   const isText = element.key === '__text'
@@ -402,7 +414,6 @@ export const createExtendsStack = (element, parent, options = {}) => {
   const { props, __ref: ref } = element
   const context = element.context || parent.context
 
-  // if (ENV !== 'test' && ENV !== 'development') delete element.extends
   const variant = element.variant || props?.variant
 
   const __extends = removeDuplicatesInArray(

package/function.js

@@ -16,7 +16,8 @@
 export function debounce (func, wait, immediate) {
   let timeout
   return function () {
-    const context = this; const args = arguments
+    const context = this
+    const args = arguments
     const later = function () {
       timeout = null
       if (!immediate) func.apply(context, args)
@@ -46,11 +47,13 @@ export const debounceOnContext = (element, func, timeout = 300) => {
   let timer
   return (...args) => {
     clearTimeout(timer)
-    timer = setTimeout(() => { func.apply(element, args) }, timeout)
+    timer = setTimeout(() => {
+      func.apply(element, args)
+    }, timeout)
   }
 }
 
-export const memoize = (fn) => {
+export const memoize = fn => {
   const cache = {}
   return (...args) => {
     const n = args[0]
@@ -64,12 +67,10 @@ export const memoize = (fn) => {
   }
 }
 
-export const isStringFunction = inputString => {
-  // Regular expression to match both regular and arrow function declarations
-  const functionRegex = /^((function\s*\([^)]*\)\s*\{[^}]*\})|(\([^)]*\)\s*=>))/
+const RE_STRING_FUNCTION = /^((function\s*\([^)]*\)\s*\{[^}]*\})|(\([^)]*\)\s*=>))/
 
-  // Use the regex to test if the inputString matches the function pattern
-  return functionRegex.test(inputString)
+export const isStringFunction = inputString => {
+  return RE_STRING_FUNCTION.test(inputString)
 }
 
 export function cloneFunction (fn, win = window) {
@@ -79,7 +80,7 @@ export function cloneFunction (fn, win = window) {
 
   // Copy properties from original function
   for (const key in fn) {
-    if (Object.hasOwnProperty.call(fn, key)) {
+    if (Object.prototype.hasOwnProperty.call(fn, key)) {
       temp[key] = fn[key]
     }
   }

package/index.js

@@ -23,3 +23,4 @@ export * from './scope.js'
 export * from './methods.js'
 export * from './cache.js'
 export * from './update.js'
+export * from './triggerEvent.js'

package/keys.js

@@ -1,6 +1,6 @@
 'use strict'
 
-export const DOMQ_PROPERTIES = [
+export const DOMQ_PROPERTIES = new Set([
   'attr',
   'style',
   'text',
@@ -10,12 +10,16 @@ export const DOMQ_PROPERTIES = [
   'classlist',
   'state',
   'scope',
+  'root',
   'deps',
+  'extend',
   'extends',
   '$router',
   'routes',
   'children',
+  'childExtend',
   'childExtends',
+  'childExtendRecursive',
   'childExtendsRecursive',
   'props',
   'if',
@@ -33,9 +37,9 @@ export const DOMQ_PROPERTIES = [
   'on',
   'component',
   'context'
-]
+])
 
-export const PARSED_DOMQ_PROPERTIES = [
+export const PARSED_DOMQ_PROPERTIES = new Set([
   'attr',
   'style',
   'text',
@@ -53,7 +57,7 @@ export const PARSED_DOMQ_PROPERTIES = [
   'query',
   'on',
   'context'
-]
+])
 
 export const STATE_PROPERTIES = [
   'ref',
@@ -65,7 +69,7 @@ export const STATE_PROPERTIES = [
   'root'
 ]
 
-export const STATE_METHODS = [
+export const STATE_METHODS = new Set([
   'update',
   'parse',
   'clean',
@@ -98,11 +102,11 @@ export const STATE_METHODS = [
   'removeByPath',
   'removePathCollection',
   'getByPath'
-]
+])
 
-export const PROPS_METHODS = ['update', '__element']
+export const PROPS_METHODS = new Set(['update', '__element'])
 
-export const METHODS = [
+export const METHODS = new Set([
   'set',
   'reset',
   'update',
@@ -128,17 +132,23 @@ export const METHODS = [
   'error',
   'call',
   'nextElement',
-  'previousElement'
-]
+  'previousElement',
+  'getRootState',
+  'getRoot',
+  'getRootData',
+  'getRootContext',
+  'getContext',
+  'getChildren'
+])
 
-export const METHODS_EXL = [
-  ...['node', 'context', 'extends', '__element', '__ref'],
+export const METHODS_EXL = new Set([
+  'node', 'context', 'extends', '__element', '__ref',
   ...METHODS,
   ...STATE_METHODS,
   ...PROPS_METHODS
-]
+])
 
-export const DOMQL_EVENTS = [
+export const DOMQL_EVENTS = new Set([
   'init',
   'beforeClassAssign',
   'render',
@@ -154,4 +164,4 @@ export const DOMQL_EVENTS = [
   'complete',
   'frame',
   'update'
-]
+])

package/log.js

@@ -3,7 +3,6 @@
 export const logIf = (bool, ...arg) => {
   if (bool) arg.map(v => console.log(v))
 }
-
 export const logGroupIf = (bool, key, ...arg) => {
   if (bool) {
     console.group(key)

package/methods.js

@@ -1,6 +1,6 @@
 'use strict'
 
-import { triggerEventOn } from '@domql/event'
+import { triggerEventOn } from './triggerEvent.js'
 import { DOMQ_PROPERTIES, METHODS, PARSED_DOMQ_PROPERTIES } from './keys.js'
 import { isDefined, isFunction, isObject, isObjectLike } from './types.js'
 import { deepClone } from './object.js'
@@ -55,7 +55,9 @@ export function lookup (param) {
 export function lookdown (param) {
   const el = this
   const { __ref: ref } = el
-  const children = ref.__children
+  const children = ref?.__children
+
+  if (!children) return
 
   for (let i = 0; i < children.length; i++) {
     const v = children[i]
@@ -76,7 +78,9 @@ export function lookdown (param) {
 export function lookdownAll (param, results = []) {
   const el = this
   const { __ref: ref } = el
-  const children = ref.__children
+  const children = ref?.__children
+
+  if (!children) return
 
   for (let i = 0; i < children.length; i++) {
     const v = children[i]
@@ -138,19 +142,67 @@ export function setProps (param, options) {
   return element
 }
 
-export function getRef () {
+export function getRef (key) {
+  if (key) return this.__ref && this.__ref[key]
   return this.__ref
 }
 
+export function getChildren () {
+  const __children = this.getRef('__children')
+  return __children.map(k => this[k])
+}
+
 export function getPath () {
   return this.getRef().path
 }
 
-// export function set () {
-// }
+export function getRootState (param) {
+  let state = null
+  const hasRootState = (obj) => obj.__element && obj.root?.isRootState
+  if (!this) {
+    state = window.platformState || window.smblsApp?.state
+  } else if (hasRootState(this)) {
+    state = this.root
+  } else if (this.__ref && this.__ref.path) {
+    const hasPlatformState = this.state && hasRootState(this.state)
+    const hasPlatformStateOnParent =
+      isFunction(this.state) &&
+      this.parent.state &&
+      hasRootState(this.parent.state)
+    if (hasPlatformState || hasPlatformStateOnParent) {
+      state = this.state.root || this.parent.state.root
+    }
+  }
+  if (!state) {
+    state = window.platformState || window.smblsApp?.state
+  }
+  return param ? state?.[param] : state
+}
 
-// export function update () {
-// }
+export function getRoot (key) {
+  const rootElem = this.getRootState()?.__element
+  return rootElem && Object.keys(rootElem).length > 0 && key
+    ? rootElem[key]
+    : rootElem
+}
+
+export function getRootData (key) {
+  return this.getRoot('data') &&
+    Object.keys(this.getRoot('data')).length > 0 &&
+    key
+    ? this.getRoot('data')[key]
+    : this.getRoot('data')
+}
+
+export function getRootContext (key) {
+  const ctx = this.getRoot()?.context
+  return key ? ctx[key] : ctx
+}
+
+export function getContext (key) {
+  const ctx = this.context
+  return key ? ctx[key] : ctx
+}
 
 export const defineSetter = (element, key, get, set) =>
   Object.defineProperty(element, key, { get, set })
@@ -160,10 +212,10 @@ export function keys () {
   const keys = []
   for (const param in element) {
     if (
-      // (REGISTRY[param] && !DOMQ_PROPERTIES.includes(param)) ||
-      !Object.hasOwnProperty.call(element, param) ||
-      (DOMQ_PROPERTIES.includes(param) &&
-        !PARSED_DOMQ_PROPERTIES.includes(param))
+      // (REGISTRY[param] && !DOMQ_PROPERTIES.has(param)) ||
+      !Object.prototype.hasOwnProperty.call(element, param) ||
+      (DOMQ_PROPERTIES.has(param) &&
+        !PARSED_DOMQ_PROPERTIES.has(param))
     ) {
       continue
     }
@@ -174,35 +226,49 @@ export function keys () {
 
 export function parse (excl = []) {
   const element = this
-  const { __ref: ref } = element
   const obj = {}
   const keyList = keys.call(element)
-  keyList.forEach(v => {
-    if (excl.includes(v)) return
+  const hasChildren = keyList.includes('children')
+  const exclSet = excl.length ? new Set(excl) : null
+  for (let i = 0; i < keyList.length; i++) {
+    const v = keyList[i]
+    if ((exclSet && exclSet.has(v)) || !Object.prototype.hasOwnProperty.call(element, v)) continue
+    if (hasChildren && v === 'content') continue
     const val = element[v]
     if (v === 'state') {
-      if (!ref?.__hasRootState) return
+      if (element.__ref && !element.__ref.__hasRootState) continue
       const parsedVal = isFunction(val && val.parse) ? val.parse() : val
       obj[v] = isFunction(parsedVal)
         ? parsedVal
         : JSON.parse(JSON.stringify(parsedVal || {}))
     } else if (v === 'scope') {
-      if (!ref?.__hasRootScope) return
+      if (element.__ref && !element.__ref.__hasRootScope) continue
       obj[v] = JSON.parse(JSON.stringify(val || {}))
-    } else if (isDefined(val) && Object.hasOwnProperty.call(element, v)) {
+    } else if (v === 'props') {
+      const { __element, update, ...props } = element[v]
+      obj[v] = props
+    } else if (isDefined(val) && Object.prototype.hasOwnProperty.call(element, v)) {
       obj[v] = val
     }
-  })
+  }
   return obj
 }
 
-export function parseDeep (excl = []) {
+export function parseDeep (excl = [], visited = new WeakSet()) {
   const element = this
+  if (visited.has(element)) return undefined
+  visited.add(element)
   const obj = parse.call(element, excl)
+  const exclSet = excl.length ? new Set(excl) : null
   for (const v in obj) {
-    if (excl.includes(v)) return
-    if (isObjectLike(obj[v])) {
-      obj[v] = parseDeep.call(obj[v], excl)
+    if ((exclSet && exclSet.has(v)) || !Object.prototype.hasOwnProperty.call(element, v)) continue
+    const val = obj[v]
+    if (Array.isArray(val)) {
+      obj[v] = val.map(item =>
+        isObjectLike(item) ? parseDeep.call(item, excl, visited) : item
+      )
+    } else if (isObjectLike(val)) {
+      obj[v] = parseDeep.call(val, excl, visited)
     }
   }
   return obj
@@ -300,6 +366,15 @@ export function variables (obj = {}) {
   }
 }
 
+/**
+ * A unified call function that detects the calling context and adapts accordingly.
+ * - When called in an async context (with await), it fully resolves promises
+ * - When called in a sync context, it returns sync results directly and handles promises appropriately
+ *
+ * @param {string} fnKey - The name of the function to call
+ * @param {...any} args - Arguments to pass to the function
+ * @returns {any|Promise} - The result or a Promise to the result
+ */
 export function call (fnKey, ...args) {
   const context = this.context
   return (
@@ -311,5 +386,5 @@ export function call (fnKey, ...args) {
 }
 
 export function isMethod (param, element) {
-  return Boolean(METHODS.includes(param) || element?.context?.methods?.[param])
+  return Boolean(METHODS.has(param) || element?.context?.methods?.[param])
 }