@domql/element 2.5.200 → 3.0.1

package/dist/esm/utils/object.js

@@ -1,151 +0,0 @@
-import { isArray, isObject, isObjectLike, joinArrays, deepClone } from "@domql/utils";
-import { IGNORE_PROPS_PARAMS } from "../props/index.js";
-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"
-];
-const METHODS = [
-  "set",
-  "reset",
-  "update",
-  "remove",
-  "updateContent",
-  "removeContent",
-  "lookup",
-  "lookdown",
-  "lookdownAll",
-  "getRef",
-  "getPath",
-  "setNodeStyles",
-  "spotByPath",
-  "keys",
-  "parse",
-  "setProps",
-  "parseDeep",
-  "variables",
-  "if",
-  "log",
-  "nextElement",
-  "previousElement"
-];
-const METHODS_EXL = joinArrays(
-  ["node", "state", "context", "extend", "__element"],
-  METHODS,
-  IGNORE_STATE_PARAMS,
-  IGNORE_PROPS_PARAMS
-);
-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 === void 0) {
-      element[e] = extendProp;
-    } else if (isObjectLike(elementProp) && isObject(extendProp)) {
-      deepMerge(elementProp, extendProp);
-    }
-  }
-  return element;
-};
-const clone = (obj, exclude = METHODS_EXL) => {
-  const o = {};
-  for (const e in obj) {
-    if (exclude.includes(e)) continue;
-    o[e] = obj[e];
-  }
-  return o;
-};
-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 !== void 0) {
-      __cached[e] = changes[e] = elementProp;
-      element[e] = paramsProp;
-    }
-    if (options.cleanExec) delete __exec[e];
-  }
-  return changes;
-};
-const overwriteShallow = (obj, params, exclude = METHODS_EXL) => {
-  for (const e in params) {
-    if (exclude.includes(e)) continue;
-    obj[e] = params[e];
-  }
-  return obj;
-};
-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 !== void 0) {
-      obj[e] = paramsProp;
-    }
-  }
-  return obj;
-};
-const mergeIfExisted = (a, b) => {
-  if (isObjectLike(a) && isObjectLike(b)) return deepMerge(a, b);
-  return a || b;
-};
-const mergeArray = (arr, exclude = ["parent", "node", "__element", "state", "context", "__ref"]) => {
-  return arr.reduce((a, c) => deepMerge(a, deepClone(c, { exclude })), {});
-};
-const mergeAndCloneIfArray = (obj) => {
-  return isArray(obj) ? mergeArray(obj) : deepClone(obj);
-};
-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;
-};
-export {
-  METHODS,
-  METHODS_EXL,
-  clone,
-  deepMerge,
-  flattenRecursive,
-  mergeAndCloneIfArray,
-  mergeArray,
-  mergeIfExisted,
-  overwrite,
-  overwriteDeep,
-  overwriteShallow
-};

package/dist/esm/utils/propEvents.js

@@ -1,19 +0,0 @@
-import { isFunction, lowercaseFirstLetter } from "@domql/utils";
-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;
-  });
-};
-export {
-  propagateEventsFromProps
-};

package/extend.js

@@ -1,90 +0,0 @@
-'use strict'
-
-import { isFunction, exec } from '@domql/utils'
-import {
-  getExtendStack,
-  jointStacks,
-  cloneAndMergeArrayExtend,
-  deepMergeExtend,
-  fallbackStringExtend
-} from './utils/index.js'
-
-const ENV = process.env.NODE_ENV
-
-let mainExtend
-
-/**
- * Checks whether element has `extend` or is a part
- * of parent's `childExtend` extend
- */
-export const applyExtend = (element, parent, options = {}) => {
-  if (isFunction(element)) element = exec(element, parent)
-
-  const { props, __ref } = element
-  let extend = props?.extends || element.extends || element.extend
-  const variant = props?.variant
-  const context = element.context || parent.context
-
-  extend = fallbackStringExtend(extend, context, options, variant)
-
-  const extendStack = getExtendStack(extend, context)
-
-  if (ENV !== 'test' || ENV !== 'development') delete element.extend
-
-  let childExtendStack = []
-  if (parent) {
-    element.parent = parent
-    // Assign parent attr to the element
-    if (!options.ignoreChildExtend && !(props && props.ignoreChildExtend)) {
-      childExtendStack = getExtendStack(parent.childExtend, context)
-
-      // if (!options.ignoreChildExtend && !(props && exec(props, element).ignoreChildExtend)) {
-      //   const ignoreChildExtendRecursive = props && exec(props, element).ignoreChildExtendRecursive
-
-      const ignoreChildExtendRecursive = props && props.ignoreChildExtendRecursive
-      if (parent.childExtendRecursive && !ignoreChildExtendRecursive) {
-        const canExtendRecursive = element.key !== '__text'
-        if (canExtendRecursive) {
-          const childExtendRecursiveStack = getExtendStack(parent.childExtendRecursive, context)
-          // add error if childExtendRecursive contains element which goes to infinite loop
-          childExtendStack = childExtendStack.concat(childExtendRecursiveStack)
-          element.childExtendRecursive = parent.childExtendRecursive
-        }
-      }
-    }
-  }
-
-  const extendLength = extendStack.length
-  const childExtendLength = childExtendStack.length
-
-  let stack = []
-  if (extendLength && childExtendLength) {
-    stack = jointStacks(extendStack, childExtendStack)
-  } else if (extendLength) {
-    stack = extendStack
-  } else if (childExtendLength) {
-    stack = childExtendStack
-  } else if (!context.defaultExtends) return element
-
-  if (context.defaultExtends) {
-    if (!mainExtend) {
-      const defaultOptionsExtend = getExtendStack(context.defaultExtends, context)
-      mainExtend = cloneAndMergeArrayExtend(defaultOptionsExtend)
-      delete mainExtend.extend
-    }
-    stack = [].concat(stack, mainExtend)
-  }
-
-  if (__ref) __ref.__extend = stack
-  let mergedExtend = cloneAndMergeArrayExtend(stack)
-
-  const COMPONENTS = (context && context.components) || options.components
-  const component = exec(element.component || mergedExtend.component, element)
-  if (component && COMPONENTS && COMPONENTS[component]) {
-    const componentExtend = cloneAndMergeArrayExtend(getExtendStack(COMPONENTS[component]))
-    mergedExtend = deepMergeExtend(componentExtend, mergedExtend)
-  }
-
-  const merged = deepMergeExtend(element, mergedExtend)
-  return merged
-}

package/methods/index.js

@@ -1,317 +0,0 @@
-'use strict'
-
-import { triggerEventOn } from '@domql/event'
-import { isDefined, isObject, isFunction, isObjectLike, isProduction, removeValueFromArray, deepClone } from '@domql/utils'
-import { TREE } from '../tree.js'
-import { parseFilters, REGISTRY } from '../mixins/index.js'
-const ENV = process.env.NODE_ENV
-
-// TODO: update these files
-export function spotByPath (path) {
-  const element = this
-  const arr = [].concat(path)
-  let active = TREE[arr[0]]
-
-  if (!arr || !arr.length) return console.log(arr, 'on', element.key, 'is undefined')
-
-  while (active.key === arr[0]) {
-    arr.shift()
-    if (!arr.length) break
-    active = active[arr[0]]
-    if (!active) return
-  }
-
-  return active
-}
-
-// TODO: update these files
-export function lookup (param) {
-  const el = this
-  let { parent } = el
-
-  if (isFunction(param)) {
-    if (parent.state && param(parent, parent.state, parent.context)) return parent
-    else if (parent.parent) return parent.lookup(param)
-    else return
-  }
-
-  if (el[param]) return el[param]
-
-  while (parent.param !== param) {
-    if (parent[param]) return parent[param]
-    parent = parent.parent
-    if (!parent) return
-  }
-
-  return parent
-}
-
-export function lookdown (param) {
-  const el = this
-  const { __ref: ref } = el
-  const children = ref.__children
-
-  for (let i = 0; i < children.length; i++) {
-    const v = children[i]
-    const childElem = el[v]
-
-    if (v === param) return childElem
-    else if (isFunction(param)) {
-      const exec = param(childElem, childElem.state, childElem.context)
-      if (childElem.state && exec) {
-        return childElem
-      }
-    }
-    const lookdown = childElem?.lookdown?.(param)
-    if (lookdown) return lookdown
-  }
-}
-
-export function lookdownAll (param, results = []) {
-  const el = this
-  const { __ref: ref } = el
-  const children = ref.__children
-
-  for (let i = 0; i < children.length; i++) {
-    const v = children[i]
-    const childElem = el[v]
-
-    if (v === param) results.push(childElem)
-    else if (isFunction(param)) {
-      const exec = param(childElem, childElem.state, childElem.context)
-      if (childElem.state && exec) results.push(childElem)
-    }
-    childElem?.lookdownAll?.(param, results)
-  }
-
-  return results.length ? results : undefined
-}
-
-export function setNodeStyles (params = {}) {
-  const el = this
-  if (!el.node?.style) return
-
-  for (const param in params) {
-    const value = params[param]
-    const childElem = el[param]
-    if (isObject(value) && childElem) setNodeStyles.call(childElem, value)
-    else el.node.style[param] = value
-  }
-
-  return el
-}
-
-export function remove (opts) {
-  const element = this
-  const beforeRemoveReturns = triggerEventOn('beforeRemove', element, opts)
-  if (beforeRemoveReturns === false) return element
-  if (isFunction(element.node.remove)) element.node.remove()
-  else if (!isProduction()) {
-    console.warn('This item cant be removed')
-    element.log()
-  }
-  delete element.parent[element.key]
-  if (element.parent.__ref) element.parent.__ref.__children = removeValueFromArray(element.parent.__ref.__children, element.key)
-  triggerEventOn('remove', element, opts)
-}
-
-export function get (param) {
-  const element = this
-  return element[param]
-}
-
-export function setProps (param, options) {
-  const element = this
-  if (!param || !element.props) return
-  element.update({ props: param }, options)
-  return element
-}
-
-export function getRef () {
-  return this.__ref
-}
-
-export function getPath () {
-  return this.getRef().path
-}
-
-// export function set () {
-// }
-
-// export function update () {
-// }
-
-export const defineSetter = (element, key, get, set) =>
-  Object.defineProperty(element, key, { get, set })
-
-export function keys () {
-  const element = this
-  const keys = []
-  for (const param in element) {
-    if ((REGISTRY[param] && !parseFilters.elementKeys.includes(param)) || !Object.hasOwnProperty.call(element, param)) { continue }
-    keys.push(param)
-  }
-  return keys
-}
-
-export function parse (excl = []) {
-  const element = this
-  const obj = {}
-  const keyList = keys.call(element)
-  keyList.forEach(v => {
-    if (excl.includes(v)) return
-    const val = element[v]
-    if (v === 'state') {
-      if (element.__ref && !element.__ref.__hasRootState) return
-      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
-      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)) obj[v] = val
-  })
-  return obj
-}
-
-export function parseDeep (excl = []) {
-  const element = this
-  const obj = parse.call(element, excl)
-  for (const v in obj) {
-    if (excl.includes(v)) return
-    if (isObjectLike(obj[v])) { obj[v] = parseDeep.call(obj[v], excl) }
-  }
-  return obj
-}
-
-export function verbose (...args) {
-  if (ENV !== 'test' && ENV !== 'development') return
-
-  const element = this
-  const { __ref: ref } = element
-  console.groupCollapsed(element.key)
-  if (args.length) {
-    args.forEach(v => console.log(`%c${v}:\n`, 'font-weight: bold', element[v]))
-  } else {
-    console.log(ref.path)
-    const keys = element.keys()
-    keys.forEach(v => console.log(`%c${v}:`, 'font-weight: bold', element[v]))
-  }
-  console.log(element)
-  console.groupEnd(element.key)
-  return element
-}
-
-export function log (...params) {
-  if (ENV === 'test' || ENV === 'development') {
-    console.log(...params)
-  }
-}
-
-export function warn (...params) {
-  if (ENV === 'test' || ENV === 'development') {
-    console.warn(...params)
-  }
-}
-
-export function error (...params) {
-  if (ENV === 'test' || ENV === 'development') {
-    if (params[params.length - 1]?.debugger) debugger // eslint-disable-line
-    if (params[params.length - 1]?.verbose) verbose.call(this)
-    throw new Error(...params)
-  }
-}
-
-export function nextElement () {
-  const element = this
-  const { key, parent } = element
-  const { __children } = parent.__ref
-
-  const currentIndex = __children.indexOf(key)
-  const nextChild = __children[currentIndex + 1]
-
-  return parent[nextChild]
-}
-
-export function previousElement (el) {
-  const element = el || this
-  const { key, parent } = element
-  const { __children } = parent.__ref
-
-  if (!__children) return
-
-  const currentIndex = __children.indexOf(key)
-  return parent[__children[currentIndex - 1]]
-}
-
-export function variables (obj = {}) {
-  const element = this
-  if (!element.data) element.data = {}
-  if (!element.data.varCaches) element.data.varCaches = {}
-  const varCaches = element.data.varCaches
-  const changes = {}
-  let changed
-  for (const key in obj) {
-    if (obj[key] !== varCaches[key]) {
-      changed = true
-      changes[key] = obj[key]
-    }
-  }
-  return {
-    changed: (cb) => {
-      if (!changed) return
-      const returns = cb(changes, deepClone(varCaches))
-      for (const key in changes) {
-        varCaches[key] = changes[key]
-      }
-      return returns
-    },
-    timeout: (cb, timeout) => {
-      if (!changed) return
-      const t = setTimeout(() => {
-        cb(changes)
-        clearTimeout(t)
-      }, timeout)
-    }
-  }
-}
-
-export function call (fnKey, ...args) {
-  const context = this.context
-  return (context.utils[fnKey] || context.functions[fnKey] || context.methods[fnKey] || context.snippets[fnKey])?.call(this, ...args)
-}
-
-export const METHODS = [
-  'set',
-  'reset',
-  'update',
-  'remove',
-  'updateContent',
-  'removeContent',
-  'lookup',
-  'lookdown',
-  'lookdownAll',
-  'getRef',
-  'getPath',
-  'setNodeStyles',
-  'spotByPath',
-  'keys',
-  'parse',
-  'setProps',
-  'parseDeep',
-  'variables',
-  'if',
-  'log',
-  'verbose',
-  'warn',
-  'error',
-  'call',
-  'nextElement',
-  'previousElement'
-]
-
-export function isMethod (param, element) {
-  return METHODS.includes(param) || element?.context?.methods?.[param]
-}

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