@domql/element 3.2.3 → 3.2.8

package/__tests__/throughUpdatedExec.test.js

@@ -1,111 +0,0 @@
-import { throughUpdatedExec } from '../iterate'
-
-describe('throughUpdatedExec', () => {
-  let element, ref
-
-  beforeEach(() => {
-    ref = {
-      __exec: {},
-      __defineCache: {}
-    }
-    element = {
-      __ref: ref,
-      state: { testState: true },
-      context: { testContext: true }
-    }
-  })
-
-  it('should skip execution for params in __defineCache', async () => {
-    ref.__defineCache.cachedParam = true
-    ref.__exec.cachedParam = () => 'should not execute'
-    element.cachedParam = 'original'
-
-    const changes = await throughUpdatedExec(element)
-
-    expect(element.cachedParam).toBe('original')
-    expect(changes).toEqual({})
-  })
-
-  it('should update element properties when newExec differs from current value', async () => {
-    ref.__exec.testParam = () => 'new value'
-    element.testParam = 'old value'
-
-    const changes = await throughUpdatedExec(element)
-
-    expect(element.testParam).toBe('new value')
-    expect(changes).toEqual({ testParam: 'old value' })
-  })
-
-  it('should overwrite text property for nodes when exec returns string or number', async () => {
-    const node = { node: true, text: 'old text' }
-    ref.__exec.testParam = () => 'new text'
-    element.testParam = node
-
-    const changes = await throughUpdatedExec(element)
-
-    expect(element.testParam.text).toBe('new text')
-    expect(changes).toEqual({})
-  })
-
-  it('should handle component naming matches and overwrite with context component', async () => {
-    const contextComponent = { extends: 'Component', prop: 'value' }
-    element.context.components = { TestComponent: contextComponent }
-    ref.__exec.TestComponent = () => contextComponent
-    element.TestComponent = { oldProp: 'oldValue' }
-
-    const changes = await throughUpdatedExec(element)
-
-    expect(element.TestComponent).toEqual({
-      oldProp: 'oldValue',
-      prop: 'value'
-    })
-    expect(changes).toEqual({})
-  })
-
-  it('should not update element properties when newExec matches current value', async () => {
-    ref.__exec.testParam = () => 'same value'
-    element.testParam = 'same value'
-
-    const changes = await throughUpdatedExec(element)
-
-    expect(element.testParam).toBe('same value')
-    expect(changes).toEqual({})
-  })
-
-  it('should handle non-string/non-number exec returns for non-node properties', async () => {
-    const newValue = { complex: 'object' }
-    ref.__exec.testParam = () => newValue
-    element.testParam = 'old value'
-
-    const changes = await throughUpdatedExec(element)
-
-    expect(element.testParam).toBe(newValue)
-    expect(changes).toEqual({ testParam: 'old value' })
-  })
-
-  it('should return an empty changes object when no updates occur', async () => {
-    ref.__exec.testParam = () => 'same value'
-    element.testParam = 'same value'
-
-    const changes = await throughUpdatedExec(element)
-
-    expect(changes).toEqual({})
-  })
-
-  it('should handle multiple properties and return correct changes', async () => {
-    ref.__exec.param1 = () => 'new value 1'
-    ref.__exec.param2 = () => 'new value 2'
-    element.param1 = 'old value 1'
-    element.param2 = 'old value 2'
-
-    const changes = await throughUpdatedExec(element)
-
-    console.log(element)
-    expect(element.param1).toBe('new value 1')
-    expect(element.param2).toBe('new value 2')
-    expect(changes).toEqual({
-      param1: 'old value 1',
-      param2: 'old value 2'
-    })
-  })
-})

package/__tests__/tree.test.js

@@ -1,15 +0,0 @@
-import { ROOT, TREE } from '../tree'
-
-describe('ROOT/TREE initialization and report()', () => {
-  // Test 1: ROOT object structure
-  it('initializes ROOT with :root key and document.body node', () => {
-    expect(ROOT.key).toBe(':root')
-    expect(ROOT.node).toBe(document.body) // Works in JSDOM
-  })
-
-  // Test 2: TREE === ROOT
-  it('assigns TREE to reference ROOT', () => {
-    expect(TREE).toBe(ROOT)
-    expect(TREE.node).toBe(document.body)
-  })
-})

package/__tests__/update.test.js

@@ -1,256 +0,0 @@
-import { update } from '../update'
-
-describe('update()', () => {
-  let element, params, opts
-
-  beforeEach(() => {
-    element = {
-      __ref: {
-        __if: true,
-        __execProps: {},
-        __exec: {},
-        __defineCache: {},
-        __propsStack: [],
-        __props: [],
-        __state: 'state'
-      },
-      state: 'string',
-      props: {},
-      parent: {
-        props: {}
-      },
-      context: {},
-      define: {},
-      node: document.createElement('div'),
-      key: 'testElement',
-      on: {},
-      update
-    }
-    opts = {
-      preventUpdate: [],
-      preventDefineUpdate: [],
-      preventBeforeStateUpdateListener: false,
-      preventListeners: false,
-      preventStateUpdateListener: false
-    }
-    params = {}
-  })
-
-  it('does not modify opts when params and opts are empty', () => {
-    element.update({}, opts)
-    expect(opts).toEqual({
-      calleeElement: false,
-      cleanExec: true,
-      currentSnapshot: false,
-      exclude: [],
-      preventRecursive: false,
-      stackChanges: false,
-      preventUpdate: [],
-      preventDefineUpdate: [],
-      preventBeforeStateUpdateListener: false,
-      preventListeners: false,
-      preventStateUpdateListener: false
-    })
-  })
-
-  it('initializes options with UPDATE_DEFAULT_OPTIONS when opts is empty', () => {
-    element.update({}, opts)
-    expect(opts.calleeElement).toBe(false) // Ensure opts is not mutated
-    expect(element.__ref).toBeDefined() // Ensure __ref is initialized
-  })
-
-  it('merges opts with UPDATE_DEFAULT_OPTIONS using deepMerge', () => {
-    opts.customOption = true
-    element.update({}, opts)
-    expect(opts.customOption).toBe(true) // Ensure custom options are preserved
-  })
-
-  it('converts string params to { text: params }', () => {
-    element.update('testString', opts)
-    expect(element.text).toBe('testString')
-  })
-
-  it('converts number params to { text: params }', () => {
-    element.update(123, opts)
-    expect(element.text).toBe(123)
-  })
-
-  it('returns early if preventInheritAtCurrentState matches element', () => {
-    opts.preventInheritAtCurrentState = { __element: element }
-    element.update({}, opts)
-    expect(element.__ref.__currentSnapshot).toBe(6) // No snapshot update
-  })
-
-  it('initializes __ref if not present', () => {
-    delete element.__ref
-    element.update({}, opts)
-    expect(element.__ref).toBeDefined()
-  })
-
-  it('merges options with UPDATE_DEFAULT_OPTIONS when exclude is missing', () => {
-    element.update({}, opts)
-    expect(opts.exclude).toBeDefined() // Ensure exclude is added
-  })
-
-  it('does not throw or modify opts when params is undefined', () => {
-    element.update(undefined, opts)
-    expect(opts).toEqual({
-      calleeElement: false,
-      cleanExec: true,
-      currentSnapshot: false,
-      exclude: [],
-      preventRecursive: false,
-      preventUpdate: [],
-      preventDefineUpdate: [],
-      stackChanges: false,
-      preventBeforeStateUpdateListener: false,
-      preventListeners: false,
-      preventStateUpdateListener: false
-    })
-  })
-
-  it('does not throw when opts is undefined', () => {
-    element.update({}, undefined)
-    expect(element.__ref).toBeDefined() // Ensure __ref is initialized
-  })
-
-  it('does not throw when opts is null', () => {
-    element.update({}, null)
-    expect(element.__ref).toBeDefined() // Ensure __ref is initialized
-  })
-
-  it('does not modify the params object', () => {
-    params = { key: 'value' }
-    element.update(params, opts)
-    expect(params).toEqual({ key: 'value' })
-  })
-
-  it('does modify opts when params is an empty object', () => {
-    element.update({}, opts)
-    expect(opts).toEqual({
-      calleeElement: false,
-      cleanExec: true,
-      currentSnapshot: false,
-      exclude: [],
-      preventRecursive: false,
-      stackChanges: false,
-      preventUpdate: [],
-      preventDefineUpdate: [],
-      preventBeforeStateUpdateListener: false,
-      preventListeners: false,
-      preventStateUpdateListener: false
-    })
-  })
-
-  it('moves regular properties to element.props', () => {
-    params = { props: { title: 'Test', description: 'Content' } }
-    element.update(params, opts)
-    expect(element.props).toEqual({
-      title: 'Test',
-      description: 'Content'
-    })
-    expect(element.title).toBeUndefined()
-  })
-
-  it('keeps element-rooted properties', () => {
-    params = { Header: {}, Footer: {}, 0: 'index' }
-    element.update(params, opts)
-    expect(element.Header).toBeDefined()
-    expect(element.Footer).toBeDefined()
-    expect(element['0']).toBe('index')
-    expect(element.props).toEqual({})
-  })
-
-  it('preserves built-in properties on element', () => {
-    params = { props: { className: 'container', hidden: true } }
-    element.update(params, opts)
-    expect(element.props.className).toBe('container')
-    expect(element.props.hidden).toBe(true)
-    expect(element.props).toEqual({ className: 'container', hidden: true })
-  })
-
-  it('moves element-like properties from props to root', () => {
-    params = { props: { Header: {} } }
-    element.update(params, opts)
-    expect(element.Header).toBeDefined()
-    expect(element.props.Header).toBeUndefined()
-  })
-
-  it('exits early when inheritStateUpdates returns false', () => {
-    // Simulate inheritStateUpdates failure
-    element.__ref.__stateBlocked = true
-    element.update({ props: { shouldChange: true } }, opts)
-
-    expect(element.props.shouldChange).toBe(true)
-    expect(element.__ref.__stateBlocked).toBe(true) // State remains blocked
-  })
-
-  it('exits early when checkIfOnUpdate fails', () => {
-    // Force checkIfOnUpdate failure
-    element.parent.props.ifCondition = false
-    element.update({ state: { newState: true } }, opts)
-
-    expect(element.state.newState).toBe(true)
-  })
-
-  it('updates props from parent key match', () => {
-    element.parent.props.testKey = { inherited: true }
-    element.update({}, opts)
-    expect(element.props.inherited).toBeUndefined()
-  })
-
-  it('updates props when functions exist in __props', () => {
-    element.__ref.__props.push(() => 'dynamic')
-    element.update({}, opts)
-    expect(element.props).toEqual(expect.any(Object)) // Props were processed
-  })
-
-  it('skips props update when preventPropsUpdate=true', () => {
-    opts.preventPropsUpdate = true
-    opts.preventUpdateAfter = true
-    element.parent.props.testKey = { shouldExist: true }
-    element.update({}, opts)
-    expect(element.props.shouldExist).toBeUndefined()
-  })
-
-  it('should not skips props update when preventPropsUpdate=false', () => {
-    opts.preventPropsUpdate = false
-    opts.lazyLoad = true
-    opts.onEachUpdate = () => {
-      return true
-    }
-    element.parent.props.testKey = { shouldExist: true }
-    element.__ref.__propsStack = []
-    element.__ref.__if = true
-    element.off = { text: 'off' }
-    element.update({}, opts)
-    expect(element.props.shouldExist).toBeUndefined()
-  })
-
-  it('should set preventUpdateAfterCount to 1 when is not a number', () => {
-    opts.preventPropsUpdate = true
-    opts.preventUpdateAfter = 2
-    opts.preventUpdateAfterCount = undefined
-    element.parent.props.testKey = { shouldExist: true }
-    element.update({}, opts)
-    expect(element.props.shouldExist).toBeUndefined()
-  })
-
-  it('processes parent.childProps', () => {
-    element.parent.props.childProps = { global: true }
-    element.update({}, opts)
-    expect(element.props.global).toBe(true)
-  })
-
-  it('processes function props', () => {
-    element.update({ props: { calc: () => 42 } }, opts)
-    expect(element.props.calc()).toBe(42)
-  })
-
-  it('returns element when beforeUpdate rejects', () => {
-    // Simulate beforeUpdate rejection
-    element.on.beforeUpdate = () => false
-    const result = element.update({}, opts)
-    expect(result).toBe(element)
-  })
-})

package/dist/cjs/package.json

@@ -1,4 +0,0 @@
-{
-  "type": "commonjs",
-  "main": "index.js"
-}

package/methods/set.js

@@ -1,63 +0,0 @@
-'use strict'
-
-import { merge, overwrite } from '@domql/utils'
-
-import { set, reset, updateContent, removeContent } from '../set.js'
-import { update } from '../update.js'
-
-import {
-  call,
-  error,
-  getPath,
-  getRef,
-  keys,
-  log,
-  lookdown,
-  lookdownAll,
-  lookup,
-  nextElement,
-  parse,
-  parseDeep,
-  previousElement,
-  remove,
-  setNodeStyles,
-  setProps,
-  spotByPath,
-  variables,
-  verbose,
-  warn
-} from '@domql/utils/methods'
-
-export const addMethods = (element, parent, options = {}) => {
-  const proto = {
-    set,
-    reset,
-    update,
-    variables,
-    remove,
-    updateContent,
-    removeContent,
-    setProps,
-    lookup,
-    lookdown,
-    lookdownAll,
-    getRef,
-    getPath,
-    setNodeStyles,
-    spotByPath,
-    parse,
-    parseDeep,
-    keys,
-    nextElement,
-    previousElement,
-    log,
-    verbose,
-    warn,
-    error,
-    call
-  }
-  if (element.context.methods) {
-    ;(options.strict ? merge : overwrite)(proto, element.context.methods)
-  }
-  Object.setPrototypeOf(element, proto)
-}

package/methods/v2.js

@@ -1,83 +0,0 @@
-'use strict'
-
-import { isDefined, isFunction, isObjectLike } from '@domql/utils'
-
-export const defineSetter = (element, key, get, set) =>
-  Object.defineProperty(element, key, { get, set })
-
-export const keys = function () {
-  const element = this
-  const keys = []
-  for (const param in element) {
-    // if (REGISTRY[param] && !parseFilters.elementKeys.includes(param)) { continue }
-    keys.push(param)
-  }
-  return keys
-}
-
-export const parse = function (excl = []) {
-  const element = this
-  const obj = {}
-  const keyList = keys.call(element)
-  keyList.forEach(v => {
-    if (excl.includes(v)) return
-    let val = element[v]
-    if (v === 'state') {
-      if (element.__ref && element.__ref.__hasRootState) return
-      if (isFunction(val && val.parse)) val = val.parse()
-    } else if (v === 'props') {
-      const { __element, update, ...props } = element[v]
-      obj[v] = props
-    } else if (isDefined(val)) obj[v] = val
-  })
-  return obj
-}
-
-export const parseDeep = function (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 const log = function (...args) {
-  const element = this
-  const { __ref } = element
-  console.group(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}:\n`, 'font-weight: bold', element[v]))
-  }
-  console.groupEnd(element.key)
-  return element
-}
-
-export const nextElement = function () {
-  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 const previousElement = function (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]]
-}

package/mixins/attr.js

@@ -1,32 +0,0 @@
-'use strict'
-
-import { deepMerge, exec, isNot, isNull, isUndefined } from '@domql/utils'
-import { report } from '@domql/report'
-
-/**
- * Recursively add attributes to a DOM node
- */
-export function attr (params, element, node) {
-  const { __ref: ref, props } = element
-  const { __attr } = ref
-  if (isNot('object')) report('HTMLInvalidAttr', params)
-  if (params) {
-    const attrs = exec(params, element)
-    if (props.attr) deepMerge(attrs, props.attr)
-    for (const attr in attrs) {
-      const val = exec(attrs[attr], element)
-      // if (__attr[attr] === val) return
-      if (
-        val !== false &&
-        !isUndefined(val) &&
-        !isNull(val) &&
-        node.setAttribute
-      ) {
-        node.setAttribute(attr, val)
-      } else if (node.removeAttribute) node.removeAttribute(attr)
-      __attr[attr] = val
-    }
-  }
-}
-
-export default attr

package/mixins/classList.js

@@ -1,54 +0,0 @@
-'use strict'
-
-import { exec, isObject, isString } from '@domql/utils'
-
-export const assignKeyAsClassname = element => {
-  const { key } = element
-  if (element.classlist === true) element.classlist = key
-  else if (
-    !element.classlist &&
-    typeof key === 'string' &&
-    key.charAt(0) === '_' &&
-    key.charAt(1) !== '_'
-  ) {
-    element.classlist = key.slice(1)
-  }
-}
-
-// stringifies class object
-export const classify = (obj, element) => {
-  let className = ''
-  for (const item in obj) {
-    const param = obj[item]
-    if (typeof param === 'boolean' && param) className += ` ${item}`
-    else if (typeof param === 'string') className += ` ${param}`
-    else if (typeof param === 'function') {
-      className += ` ${exec(param, element)}`
-    }
-  }
-  return className
-}
-
-export const classList = (params, element) => {
-  if (!params) return
-  const { key } = element
-  if (params === true) params = element.classlist = { key }
-  if (isString(params)) params = element.classlist = { default: params }
-  if (isObject(params)) params = classify(params, element)
-  // TODO: fails on string
-  const className = params.replace(/\s+/g, ' ').trim()
-  return className
-}
-
-// LEGACY (still needed in old domql)
-export const applyClassListOnNode = (params, element, node) => {
-  const className = classList(params, element)
-  node.classList = className
-  return className
-}
-
-export function applyClasslist (params, element, node) {
-  applyClassListOnNode(params, element, node)
-}
-
-export default applyClasslist

package/mixins/content.js

@@ -1,65 +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()
-    }
-
-    ref.__children.splice(ref.__children.indexOf(element[contentElementKey]), 1)
-
-    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