@domql/element 3.2.3 → 3.2.8

package/mixins/data.js

@@ -1,26 +0,0 @@
-'use strict'
-
-import { isObject, deepMerge, exec } from '@domql/utils'
-import { report } from '@domql/report'
-
-/**
- * Apply data parameters on the DOM nodes
- * this should only work if `showOnNode: true` is passed
- */
-export function data (params, element, node) {
-  if (params) {
-    if (element.props.data) deepMerge(params, element.props.data)
-    if (params.showOnNode) {
-      if (!isObject(params)) report('HTMLInvalidData', params)
-
-      // Apply data params on node
-      for (const dataset in params) {
-        if (dataset !== 'showOnNode') {
-          node.dataset[dataset] = exec(params[dataset], element)
-        }
-      }
-    }
-  }
-}
-
-export default data

package/mixins/html.js

@@ -1,21 +0,0 @@
-'use strict'
-
-import { exec } from '@domql/utils'
-
-/**
- * Appends raw HTML as content
- * an original one as a child
- */
-export function html (param, element, node) {
-  const prop = exec(element?.props?.html || param, element)
-  const { __ref } = element
-  if (prop !== __ref.__html) {
-    // const parser = new window.DOMParser()
-    // param = parser.parseFromString(param, 'text/html')
-    if (node.nodeName === 'SVG') node.textContent = prop
-    else node.innerHTML = prop
-    __ref.__html = prop
-  }
-}
-
-export default html

package/mixins/index.js

@@ -1,23 +0,0 @@
-'use strict'
-
-import { attr } from './attr.js'
-import { applyClasslist } from './classList.js'
-import { data } from './data.js'
-import { html } from './html.js'
-import { style } from './style.js'
-import { text } from './text.js'
-import { state } from './state.js'
-import { scope } from './scope.js'
-
-export {
-  applyClasslist as classList,
-  attr,
-  data,
-  style,
-  text,
-  html,
-  state,
-  scope
-}
-
-export * from './registry.js'

package/mixins/registry.js

@@ -1,46 +0,0 @@
-'use strict'
-
-import { attr } from './attr.js'
-import { classList } from './classList.js'
-import data from './data.js'
-import html from './html.js'
-import scope from './scope.js'
-import state from './state.js'
-import style from './style.js'
-import text from './text.js'
-
-export const REGISTRY = {
-  attr,
-  style,
-  text,
-  html,
-  data,
-  classlist: classList,
-  state,
-  scope,
-  deps: (param, el) => param || el.parent.deps,
-
-  extends: {},
-  children: {},
-  content: {},
-  childExtends: {},
-  childExtendsRecursive: {},
-  props: {},
-  if: {},
-  define: {},
-  __name: {},
-  __ref: {},
-  __hash: {},
-  __text: {},
-  key: {},
-  tag: {},
-  query: {},
-  parent: {},
-  node: {},
-  variables: {},
-  on: {},
-  component: {},
-  context: {}
-}
-
-export default REGISTRY

package/mixins/scope.js

@@ -1,23 +0,0 @@
-'use strict'
-
-import { isFunction, isObject } from '@domql/utils'
-
-/**
- * Apply data parameters on the DOM nodes
- * this should only work if `showOnNode: true` is passed
- */
-export function scope (params, element, node) {
-  if (!isObject(params)) return
-
-  // Apply data params on node
-  for (const scopeItem in params) {
-    const value = params[scopeItem]
-    if (isFunction(value)) {
-      element.scope[scopeItem] = value.bind(element)
-    } else {
-      element.scope[scopeItem] = value
-    }
-  }
-}
-
-export default scope

package/mixins/state.js

@@ -1,19 +0,0 @@
-'use strict'
-
-import { exec, isObject, STATE_METHODS } from '@domql/utils'
-
-export function state (params, element, node) {
-  const state = exec(params, element)
-
-  if (isObject(state)) {
-    for (const param in state) {
-      if (STATE_METHODS.includes(param)) continue
-      if (!Object.hasOwnProperty.call(state, param)) continue
-      // element.state[param] = exec(state[param], element)
-    }
-  }
-
-  return element
-}
-
-export default state

package/mixins/style.js

@@ -1,16 +0,0 @@
-'use strict'
-
-import { isObject, map } from '@domql/utils'
-import { report } from '@domql/report'
-
-/**
- * Recursively add styles to a DOM node
- */
-export function style (params, element, node) {
-  if (params) {
-    if (isObject(params)) map(node.style, params, element)
-    else report('HTMLInvalidStyles', params)
-  }
-}
-
-export default style

package/mixins/text.js

@@ -1,26 +0,0 @@
-'use strict'
-
-import { create } from '../create.js'
-import { exec, isString } from '@domql/utils'
-
-/**
- * Creates a text node and appends into
- * an original one as a child
- */
-export function text (param, element, node) {
-  let prop = exec(element.props.text || param, element)
-  if (isString(prop) && prop.includes('{{')) {
-    prop = element.call('replaceLiteralsWithObjectFields', prop, element.state)
-  }
-  if (element.tag === 'string') {
-    node.nodeValue = prop
-  } else if (param !== undefined || param !== null) {
-    if (element.__text) {
-      if (element.__text.text === prop) return
-      element.__text.text = prop
-      if (element.__text.node) element.__text.node.nodeValue = prop
-    } else create({ tag: 'string', text: prop }, element, '__text')
-  }
-}
-
-export default text

package/utils/applyParam.js

@@ -1,34 +0,0 @@
-'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 && context.registry && context.registry[param]
-  const isGlobalTransformer = DOMQLPropertyFromContext || DOMQLProperty
-
-  const hasDefine = element.define && element.define[param]
-  const hasContextDefine = context && context.define && 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

@@ -1,149 +0,0 @@
-'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) => {
-  extend.forEach(each => flattenExtend(each, 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 (['parent', 'node', '__element'].indexOf(e) > -1) 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 && context.components) || options.components
-  const PAGES = (context && 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]
-    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)
-}
-
-// export const replaceStringsWithComponents = (stack, context, options) => {
-//   const COMPONENTS = (context && context.components) || options.components
-//   return stack.map(v => {
-//     if (isString(v)) {
-//       const component = COMPONENTS[v]
-//       return component
-//     }
-//     if (isString(v.extend)) {
-//       v.extend = getExtendMerged(COMPONENTS[v.extend])
-//     }
-//     return v
-//   })
-// }

package/utils/index.js

@@ -1,3 +0,0 @@
-'use strict'
-
-export const METHODS_EXL = [] // this is needed because of unit tests

package/utils/propEvents.js

@@ -1,19 +0,0 @@
-'use strict'
-
-import { isFunction, lowercaseFirstLetter } from '@domql/utils'
-
-export const propagateEventsFromProps = (element) => {
-  const { props, on } = element
-  const eventKeysFromProps = Object.keys(props).filter(key => key.startsWith('on'))
-  eventKeysFromProps.forEach(v => {
-    const eventName = lowercaseFirstLetter(v.split('on')[1])
-    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
-  })
-}