@domql/utils 3.2.3 → 3.2.10

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/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

@@ -67,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) {
@@ -82,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',
@@ -12,11 +12,14 @@ export const DOMQ_PROPERTIES = [
   'scope',
   'root',
   'deps',
+  'extend',
   'extends',
   '$router',
   'routes',
   'children',
+  'childExtend',
   'childExtends',
+  'childExtendRecursive',
   'childExtendsRecursive',
   'props',
   'if',
@@ -34,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',
@@ -52,8 +55,9 @@ export const PARSED_DOMQ_PROPERTIES = [
   'key',
   'tag',
   'query',
-  'on'
-]
+  '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/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'
@@ -156,11 +156,53 @@ 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 getRoot (key) {
+  const rootElem = this.getRootState()?.__element
+  return rootElem && Object.keys(rootElem).length > 0 && key
+    ? rootElem[key]
+    : rootElem
+}
 
-// export function update () {
-// }
+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 })
@@ -170,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
     }
@@ -187,26 +229,28 @@ export function parse (excl = []) {
   const obj = {}
   const keyList = keys.call(element)
   const hasChildren = keyList.includes('children')
-  keyList.forEach(v => {
-    if (excl.includes(v) || !Object.hasOwnProperty.call(element, v)) return
-    if (hasChildren && v === 'content') return
+  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 (element.__ref && !element.__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 (element.__ref && !element.__ref.__hasRootScope) return
+      if (element.__ref && !element.__ref.__hasRootScope) continue
       obj[v] = JSON.parse(JSON.stringify(val || {}))
     } else if (v === 'props') {
       const { __element, update, ...props } = element[v]
       obj[v] = props
-    } else if (isDefined(val) && Object.hasOwnProperty.call(element, v)) {
+    } else if (isDefined(val) && Object.prototype.hasOwnProperty.call(element, v)) {
       obj[v] = val
     }
-  })
+  }
   return obj
 }
 
@@ -215,8 +259,9 @@ export function parseDeep (excl = [], visited = new WeakSet()) {
   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) || !Object.hasOwnProperty.call(element, v)) continue
+    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 =>
@@ -341,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])
 }