@domql/element 3.4.5 → 3.4.6

package/render/cache.js

@@ -0,0 +1,68 @@
+'use strict'
+
+import { report } from '@domql/report'
+import { canRenderTag } from '../event/index.js'
+import { exec, isObject, isString, isValidHtmlTag, SVG_TAGS, document } from '@domql/utils'
+
+const SVG_NS = 'http://www.w3.org/2000/svg'
+
+export const createHTMLNode = (element) => {
+  const { tag, context } = element
+  const doc = context.document || document
+  if (tag) {
+    if (tag === 'string') return doc.createTextNode(element.text)
+    else if (tag === 'fragment') {
+      return doc.createDocumentFragment()
+    } else if (SVG_TAGS.has(tag)) {
+      if (tag === 'svg' || element.parent?.node?.namespaceURI === SVG_NS) {
+        return doc.createElementNS(SVG_NS, tag)
+      }
+      return doc.createElement(tag)
+    } else return doc.createElement(tag)
+  } else {
+    return doc.createElement('div')
+  }
+}
+
+export const detectTag = element => {
+  let { tag, key, props } = element
+  tag = exec(tag, element)
+
+  if (tag === true) tag = key
+
+  if (isObject(props) && isString(props.tag)) {
+    const tagExists = isValidHtmlTag(props.tag)
+    if (tagExists) return props.tag
+  }
+
+  if (isString(tag)) {
+    if (isValidHtmlTag(tag)) return tag
+  } else {
+    let keyAsTag = key.toLowerCase()
+    if (keyAsTag.includes('.')) keyAsTag = keyAsTag.split('.')[0]
+    if (keyAsTag.includes('_')) keyAsTag = keyAsTag.split('_')[0]
+    if (isValidHtmlTag(keyAsTag)) return keyAsTag
+  }
+
+  return 'div'
+}
+
+export const cacheNode = (element) => {
+  const { context } = element
+  const win = context.window || window
+  const tag = element.tag = detectTag(element)
+
+  if (!canRenderTag(tag)) {
+    return report('HTMLInvalidTag', element.tag, element)
+  }
+
+  if (!win.nodeCaches) win.nodeCaches = {}
+  const isSvgContext = SVG_TAGS.has(tag) && (tag === 'svg' || element.parent?.node?.namespaceURI === SVG_NS)
+  const cacheKey = isSvgContext ? 'svg:' + tag : tag
+  let cachedTag = win.nodeCaches[cacheKey]
+  if (!cachedTag) cachedTag = win.nodeCaches[cacheKey] = createHTMLNode(element)
+
+  const clonedNode = cachedTag.cloneNode(true)
+  if (tag === 'string') clonedNode.nodeValue = element.text
+  return clonedNode
+}

package/render/create.js

@@ -0,0 +1,3 @@
+'use strict'
+
+export const createNode = (element) => {}

package/render/index.js

@@ -0,0 +1,5 @@
+'use strict'
+
+export * from './create.js'
+export * from './cache.js'
+export * from './append.js'

package/utils/applyParam.js

@@ -0,0 +1,33 @@
+'use strict'
+
+import { exec, isFunction } from '@domql/utils'
+import { REGISTRY } from '../mixins/index.js'
+
+export const applyParam = (param, element, options) => {
+  const { node, context, __ref: ref } = element
+  const prop = exec(element[param], element)
+
+  const { onlyUpdate } = options
+
+  const DOMQLProperty = REGISTRY[param]
+  const DOMQLPropertyFromContext = context?.registry?.[param]
+  const isGlobalTransformer = DOMQLPropertyFromContext || DOMQLProperty
+
+  const hasDefine = element.define?.[param]
+  const hasContextDefine = context?.define?.[param]
+
+  if (!ref.__if) return
+
+  const hasOnlyUpdate = onlyUpdate
+    ? onlyUpdate === param || element.lookup(onlyUpdate)
+    : true
+
+  if (isGlobalTransformer && !hasContextDefine && hasOnlyUpdate) {
+    if (isFunction(isGlobalTransformer)) {
+      isGlobalTransformer(prop, element, node, options)
+    }
+    return
+  }
+
+  return { hasDefine, hasContextDefine }
+}

package/utils/extendUtils.js

@@ -0,0 +1,135 @@
+'use strict'
+
+import {
+  isArray,
+  isFunction,
+  isObject,
+  isString,
+  deepClone,
+  isNotProduction
+} from '@domql/utils'
+
+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
+  }
+  extendStackRegistry[hash] = stack
+  return stack
+}
+
+export const getExtendStackRegistry = (extend, stack) => {
+  if (extend.__hash) {
+    return stack.concat(getHashedExtend(extend))
+  }
+  return setHashedExtend(extend, stack) // stack .concat(hashedExtend)
+}
+
+// stacking
+export const extractArrayExtend = (extend, stack, context) => {
+  for (let i = 0; i < extend.length; i++) flattenExtend(extend[i], stack, context)
+  return stack
+}
+
+export const deepExtend = (extend, stack, context) => {
+  const extendOflattenExtend = extend.extend
+  if (extendOflattenExtend) {
+    flattenExtend(extendOflattenExtend, stack, context)
+  }
+  return stack
+}
+
+export const flattenExtend = (extend, stack, context) => {
+  if (!extend) return stack
+  if (isArray(extend)) return extractArrayExtend(extend, stack, context)
+  if (isString(extend)) extend = fallbackStringExtend(extend, context)
+  stack.push(extend)
+  if (extend.extend) deepExtend(extend, stack, context)
+  return stack
+}
+
+export const deepMergeExtend = (element, extend) => {
+  for (const e in extend) {
+    if (e === 'parent' || e === 'node' || e === '__element') continue
+    const elementProp = element[e]
+    const extendProp = extend[e]
+    if (elementProp === undefined) {
+      element[e] = extendProp
+    } else if (isObject(elementProp) && isObject(extendProp)) {
+      deepMergeExtend(elementProp, extendProp)
+    } else if (isArray(elementProp) && isArray(extendProp)) {
+      element[e] = elementProp.concat(extendProp)
+    } else if (isArray(elementProp) && isObject(extendProp)) {
+      const obj = deepMergeExtend({}, elementProp)
+      element[e] = deepMergeExtend(obj, extendProp)
+    } else if (elementProp === undefined && isFunction(extendProp)) {
+      element[e] = extendProp
+    }
+  }
+  return element
+}
+
+export const cloneAndMergeArrayExtend = stack => {
+  return stack.reduce((a, c) => {
+    return deepMergeExtend(a, deepClone(c))
+  }, {})
+}
+
+export const fallbackStringExtend = (
+  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 && isNotProduction()) {
+        console.warn('Extend is string but component was not found:', extend)
+      }
+      return {}
+    }
+  }
+  return extend
+}
+
+// joint stacks
+export const jointStacks = (extendStack, childExtendStack) => {
+  return []
+    .concat(extendStack.slice(0, 1))
+    .concat(childExtendStack.slice(0, 1))
+    .concat(extendStack.slice(1))
+    .concat(childExtendStack.slice(1))
+}
+
+// init
+export const getExtendStack = (extend, context) => {
+  if (!extend) return []
+  if (extend.__hash) return getHashedExtend(extend) || []
+  const stack = flattenExtend(extend, [], context)
+  return getExtendStackRegistry(extend, stack)
+}
+
+export const getExtendMerged = extend => {
+  const stack = getExtendStack(extend)
+  return cloneAndMergeArrayExtend(stack)
+}

package/utils/index.js

@@ -0,0 +1,4 @@
+'use strict'
+
+export * from './extendUtils.js'
+export const METHODS_EXL = [] // this is needed because of unit tests

package/utils/propEvents.js

@@ -0,0 +1,36 @@
+'use strict'
+
+import { isFunction, lowercaseFirstLetter } from '@domql/utils'
+
+export const propagateEventsFromProps = (element) => {
+  const { props, on } = element
+  for (const v in props) {
+    if (v.charCodeAt(0) !== 111 || v.charCodeAt(1) !== 110) continue // 'on'
+    const eventName = lowercaseFirstLetter(v.slice(2))
+    const origEvent = on[eventName]
+    const funcFromProps = props[v]
+    if (isFunction(origEvent)) {
+      on[eventName] = (...args) => {
+        const originalEventRetunrs = origEvent(...args)
+        if (originalEventRetunrs !== false) return funcFromProps(...args)
+      }
+    } else on[eventName] = funcFromProps
+  }
+}
+
+export const propagateEventsFromElement = (element) => {
+  const { on } = element
+  for (const param in element) {
+    if (param.charCodeAt(0) !== 111 || param.charCodeAt(1) !== 110 || !Object.prototype.hasOwnProperty.call(element, param)) continue
+    const fn = element[param]
+    if (!isFunction(fn)) continue
+    const eventName = lowercaseFirstLetter(param.slice(2))
+    const origEvent = on[eventName]
+    if (isFunction(origEvent)) {
+      on[eventName] = (...args) => {
+        const ret = origEvent(...args)
+        if (ret !== false) return fn(...args)
+      }
+    } else on[eventName] = fn
+  }
+}