@domql/element 2.5.198 → 3.0.0

package/mixins/content.js

@@ -1,55 +0,0 @@
-'use strict'
-
-import { isFunction, setContentKey } from '@domql/utils'
-import { set } from '../set.js'
-
-export const updateContent = function (params, options) {
-  const element = this
-  const ref = element.__ref
-
-  const contentKey = ref.contentElementKey
-
-  if (!element[contentKey]) return
-  if (element[contentKey].update) element[contentKey].update(params, options)
-}
-
-export const removeContent = function (el, opts = {}) {
-  const element = el || this
-  const { __ref: ref } = element
-  const contentElementKey = setContentKey(element, opts)
-  if (opts.contentElementKey !== 'content') opts.contentElementKey = 'content'
-  if (element[contentElementKey]) {
-    if (element[contentElementKey].node && element.node) {
-      if (element[contentElementKey].tag === 'fragment') element.node.innerHTML = ''
-      else {
-        const contentNode = element[contentElementKey].node
-        if (contentNode.parentNode === element.node) element.node.removeChild(element[contentElementKey].node)
-      }
-    }
-
-    const { __cached } = ref
-    if (__cached && __cached[contentElementKey]) {
-      if (__cached[contentElementKey].tag === 'fragment') __cached[contentElementKey].parent.node.innerHTML = ''
-      else if (__cached[contentElementKey] && isFunction(__cached[contentElementKey].remove)) __cached[contentElementKey].remove()
-    }
-
-    delete element[contentElementKey]
-  }
-}
-
-/**
- * Appends anything as content
- * an original one as a child
- */
-export function setContent (param, element, node, opts) {
-  const contentElementKey = setContentKey(element, opts)
-  if (param && element) {
-    if (element[contentElementKey].update) {
-      element[contentElementKey].update({}, opts)
-    } else {
-      set.call(element, param, opts)
-    }
-  }
-}
-
-export default setContent

package/props/create.js

@@ -1,87 +0,0 @@
-'use strict'
-
-import { exec, isArray, isObject, deepClone, deepMerge } from '@domql/utils'
-import { IGNORE_PROPS_PARAMS } from './ignore.js'
-
-import { inheritParentProps } from './inherit.js'
-
-const createPropsStack = (element, parent) => {
-  const { props, __ref: ref } = element
-  const propsStack = ref.__props = inheritParentProps(element, parent)
-
-  if (isObject(props)) propsStack.push(props)
-  else if (props === 'inherit' && parent.props) propsStack.push(parent.props)
-  else if (props) propsStack.push(props)
-
-  if (isArray(ref.__extend)) {
-    ref.__extend.forEach(extend => {
-      if (extend.props && extend.props !== props) propsStack.push(extend.props)
-    })
-  }
-
-  ref.__props = propsStack
-
-  return propsStack
-}
-
-export const syncProps = (props, element, opts) => {
-  element.props = {}
-  const mergedProps = {}
-
-  props.forEach(v => {
-    if (IGNORE_PROPS_PARAMS.includes(v)) return
-    let execProps
-    try {
-      execProps = exec(v, element)
-    } catch (e) { element.error(e, opts) }
-    // TODO: check if this failing the function props merge
-    // if (isObject(execProps) && execProps.__element) return
-    // it was causing infinite loop at early days
-    element.props = deepMerge(
-      mergedProps,
-      deepClone(execProps, { ignore: IGNORE_PROPS_PARAMS }),
-      IGNORE_PROPS_PARAMS
-    )
-  })
-  element.props = mergedProps
-
-  const methods = { update: update.bind(element.props), __element: element }
-  Object.setPrototypeOf(element.props, methods)
-
-  return element.props
-}
-
-export const createProps = function (element, parent, options) {
-  const { __ref: ref } = element
-
-  const applyProps = () => {
-    const propsStack = options.cachedProps || createPropsStack(element, parent)
-    if (propsStack.length) {
-      ref.__props = propsStack
-      syncProps(propsStack, element)
-    } else {
-      ref.__props = options.cachedProps || []
-      element.props = {}
-    }
-  }
-
-  if (ref.__if) applyProps()
-  else {
-    try {
-      applyProps()
-    } catch {
-      element.props = {}
-      ref.__props = options.cachedProps || []
-    }
-  }
-
-  const methods = { update: update.bind(element.props), __element: element }
-  Object.setPrototypeOf(element.props, methods)
-
-  return element
-}
-
-function update (props, options) {
-  const element = this.__element
-  element.update({ props }, options)
-}

package/props/ignore.js

@@ -1,3 +0,0 @@
-'use strict'
-
-export const IGNORE_PROPS_PARAMS = ['update', '__element']

package/props/index.js

@@ -1,6 +0,0 @@
-'use strict'
-
-export * from './ignore.js'
-export * from './create.js'
-export * from './inherit.js'
-export * from './update.js'

package/props/inherit.js

@@ -1,35 +0,0 @@
-'use strict'
-
-import { exec, is, isString } from '@domql/utils'
-
-const objectizeStringProperty = propValue => {
-  if (is(propValue)('string', 'number')) {
-    return { inheritedString: propValue }
-  }
-  return propValue
-}
-
-export const inheritParentProps = (element, parent) => {
-  let propsStack = []
-  const parentProps = exec(parent, parent.state).props
-
-  const matchParent = parent.props && parentProps[element.key]
-  const matchParentIsString = isString(matchParent)
-  const matchParentChildProps = parentProps && parentProps.childProps
-
-  if (matchParent) {
-    if (matchParentIsString) {
-      const inheritedStringExists = propsStack.filter(v => v.inheritedString)[0]
-      if (inheritedStringExists) inheritedStringExists.inheritedString = matchParent
-      else {
-        propsStack = [].concat(objectizeStringProperty(matchParent), propsStack)
-      }
-    } else {
-      propsStack.push(objectizeStringProperty(matchParent))
-    }
-  }
-
-  if (matchParentChildProps && !element?.props?.ignoreChildProps) propsStack.push(matchParentChildProps)
-
-  return propsStack
-}

package/props/update.js

@@ -1,17 +0,0 @@
-'use strict'
-
-import { syncProps } from './create.js'
-import { inheritParentProps } from './inherit.js'
-
-export const updateProps = (newProps, element, parent) => {
-  const { __ref } = element
-  let propsStack = __ref.__props
-
-  const parentProps = inheritParentProps(element, parent)
-  if (parentProps.length) propsStack = __ref.__props = [].concat(parentProps, propsStack)
-  if (newProps) propsStack = __ref.__props = [].concat(newProps, propsStack)
-
-  if (propsStack) syncProps(propsStack, element)
-
-  return element
-}

package/utils/component.js

@@ -1,68 +0,0 @@
-'use strict'
-
-import {
-  isObject,
-  isString,
-  overwriteDeep,
-  checkIfKeyIsComponent,
-  addAdditionalExtend,
-  hasVariantProp,
-  isVariant
-} from '@domql/utils'
-
-import { applyExtend } from '../extend.js'
-import { REGISTRY } from '../mixins/index.js'
-
-export const createValidDomqlObjectFromSugar = (el, parent, key, options) => {
-  const newElem = {
-    props: {},
-    define: {}
-  }
-
-  const allowedKeys = ['data', 'state', 'attr', 'if']
-
-  for (const k in el) {
-    const value = el[k]
-    const isComponent = checkIfKeyIsComponent(k)
-    const isRegistry = REGISTRY[k]
-    if (isComponent || isRegistry || allowedKeys.includes(k)) {
-      newElem[k] = value
-    } else {
-      newElem.props[k] = value
-    }
-  }
-  return newElem
-}
-
-export const overwriteVariant = (element, variant, variantProps) => {
-  let variantElement = element[variant]
-  if (!variantElement) return
-  const props = isObject(variantProps) ? variantProps : {}
-  if (isString(variantElement)) {
-    variantElement = {
-      extend: [{ props }, variantElement]
-    }
-  } else if (variantElement.extend) {
-    variantElement = addAdditionalExtend({ props }, variantElement)
-  }
-  const extendedVariant = applyExtend(variantElement, element.parent)
-  const { parent, ...rest } = extendedVariant
-  return overwriteDeep(element, rest) // TODO: check why string is not working
-  // return overwriteDeep(element, applyExtend(variantElement, element.parent)) // TODO: check why string is not working
-}
-
-export const applyVariant = (element) => {
-  const { props } = element
-  if (!hasVariantProp(element)) return element
-  const { variant } = props
-  overwriteVariant(element, `.${variant}`)
-
-  const elKeys = Object.keys(element).filter((key) => isVariant(key))
-  elKeys.forEach((variant) => {
-    const slicedVariantElementKey = variant.slice(1)
-    const variantElementProps = props[slicedVariantElementKey]
-    if (variantElementProps) overwriteVariant(element, variant, variantElementProps)
-  })
-
-  return element
-}

package/utils/extendUtils.js

@@ -1,134 +0,0 @@
-'use strict'
-
-import { isArray, isFunction, isObject, isString, deepClone } from '@domql/utils'
-const ENV = process.env.NODE_ENV
-
-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 && (ENV === 'test' || ENV === 'development')) {
-        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/object.js

@@ -1,172 +0,0 @@
-'use strict'
-
-import { isArray, isObject, isObjectLike, joinArrays, deepClone } from '@domql/utils'
-import { IGNORE_PROPS_PARAMS } from '../props/index.js'
-
-// breaks server build
-// import { IGNORE_STATE_PARAMS } from '@domql/state'
-// import { METHODS } from '../methods'
-
-const IGNORE_STATE_PARAMS = [
-  'update', 'parse', 'clean', 'create', 'destroy', 'add', 'toggle', 'remove', 'apply', 'set', 'reset',
-  'replace', 'quietReplace', 'quietUpdate', 'applyReplace', 'applyFunction',
-  'rootUpdate', 'parentUpdate', 'parent', '__element', '__depends', '__ref', '__children', 'root',
-  'setByPath', 'setPathCollection', 'removeByPath', 'removePathCollection', 'getByPath'
-]
-
-export const METHODS = [
-  'set',
-  'reset',
-  'update',
-  'remove',
-  'updateContent',
-  'removeContent',
-  'lookup',
-  'lookdown',
-  'lookdownAll',
-  'getRef',
-  'getPath',
-  'setNodeStyles',
-  'spotByPath',
-  'keys',
-  'parse',
-  'setProps',
-  'parseDeep',
-  'variables',
-  'if',
-  'log',
-  'nextElement',
-  'previousElement'
-]
-
-export const METHODS_EXL = joinArrays(
-  ['node', 'state', 'context', 'extend', '__element'],
-  METHODS,
-  IGNORE_STATE_PARAMS,
-  IGNORE_PROPS_PARAMS
-)
-
-export const deepMerge = (element, extend, exclude = METHODS_EXL) => {
-  for (const e in extend) {
-    if (exclude.includes(e)) continue
-    const elementProp = element[e]
-    const extendProp = extend[e]
-    if (elementProp === undefined) {
-      element[e] = extendProp
-    } else if (isObjectLike(elementProp) && isObject(extendProp)) {
-      deepMerge(elementProp, extendProp)
-    }
-  }
-  return element
-}
-
-export const clone = (obj, exclude = METHODS_EXL) => {
-  const o = {}
-  for (const e in obj) {
-    if (exclude.includes(e)) continue
-    o[e] = obj[e]
-  }
-  return o
-}
-
-// export const deepClone = (obj, exclude = METHODS_EXL) => {
-//   const o = isArray(obj) ? [] : {}
-//   for (const e in obj) {
-//     if (exclude.includes(e)) continue
-//     let objProp = obj[e]
-//     if (e === 'extend' && isArray(objProp)) {
-//       objProp = mergeArray(objProp, exclude)
-//     }
-//     if (isObjectLike(objProp)) {
-//       o[e] = deepClone(objProp, exclude)
-//     } else o[e] = objProp
-//   }
-//   return o
-// }
-
-/**
- * Overwrites object properties with another
- */
-export const overwrite = (element, params, options) => {
-  const changes = {}
-  const { __ref } = element
-  const { __exec, __cached } = __ref
-
-  for (const e in params) {
-    if (e === 'props' || e === 'state' || e === '__ref') continue
-
-    const elementProp = element[e]
-    const paramsProp = params[e]
-
-    if (paramsProp !== undefined) {
-      __cached[e] = changes[e] = elementProp
-      element[e] = paramsProp
-    }
-
-    if (options.cleanExec) delete __exec[e]
-  }
-
-  return changes
-}
-
-export const overwriteShallow = (obj, params, exclude = METHODS_EXL) => {
-  for (const e in params) {
-    if (exclude.includes(e)) continue
-    obj[e] = params[e]
-  }
-  return obj
-}
-
-/**
- * Overwrites DEEPly object properties with another
- */
-export const overwriteDeep = (obj, params, exclude = METHODS_EXL) => {
-  for (const e in params) {
-    if (exclude.includes(e)) continue
-    const objProp = obj[e]
-    const paramsProp = params[e]
-    if (isObjectLike(objProp) && isObjectLike(paramsProp)) {
-      overwriteDeep(objProp, paramsProp)
-    } else if (paramsProp !== undefined) {
-      obj[e] = paramsProp
-    }
-  }
-  return obj
-}
-
-/**
- * Overwrites object properties with another
- */
-export const mergeIfExisted = (a, b) => {
-  if (isObjectLike(a) && isObjectLike(b)) return deepMerge(a, b)
-  return a || b
-}
-
-/**
- * Merges array extends
- */
-export const mergeArray = (arr, exclude = ['parent', 'node', '__element', 'state', 'context', '__ref']) => {
-  return arr.reduce((a, c) => deepMerge(a, deepClone(c, { exclude })), {})
-}
-
-/**
- * Merges array extends
- */
-export const mergeAndCloneIfArray = obj => {
-  return isArray(obj) ? mergeArray(obj) : deepClone(obj)
-}
-
-/**
- * Overwrites object properties with another
- */
-export const flattenRecursive = (param, prop, stack = []) => {
-  const objectized = mergeAndCloneIfArray(param)
-  stack.push(objectized)
-
-  const extendOfExtend = objectized[prop]
-  if (extendOfExtend) flattenRecursive(extendOfExtend, prop, stack)
-
-  delete objectized[prop]
-
-  return stack
-}

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) funcFromProps(...args)
-      }
-    } else on[eventName] = funcFromProps
-  })
-}