@domql/element 2.5.200 → 3.0.0

package/__tests__/set.test.js

@@ -0,0 +1,316 @@
+import { jest } from '@jest/globals'
+import { removeContent, set, setContentKey } from '../set'
+
+describe('set', () => {
+  let element, ref
+
+  beforeEach(() => {
+    ref = {
+      contentElementKey: 'content',
+      __noChildrenDifference: false
+    }
+    element = {
+      __ref: ref,
+      props: {},
+      children: [],
+      context: { components: {} },
+      state: {},
+      node: document.createElement('div'),
+      childExtends: {},
+      parent: { node: document.createElement('div') }
+    }
+  })
+
+  // 1. Basic Content Updates
+  it('updates element.props when params.props are provided', async () => {
+    await set.call(element, { props: { title: 'New Title' } })
+    expect(element.content.props.title).toBe('New Title')
+  })
+
+  // 2. Deep Equality Checks
+  it('skips update when deepContains matches existing content', async () => {
+    ref.__noChildrenDifference = true
+    const originalProps = { ...element.props }
+    await set.call(element, { props: { id: 'same' } })
+    expect(element.props).toEqual(originalProps)
+  })
+
+  // 3. ChildExtends Inheritance
+  it('merges element.childExtends into params when missing', async () => {
+    element.childExtends = { button: 'PrimaryButton' }
+    const params = { tag: 'fragment', props: {} }
+    await set.call(element, params)
+    expect(params.childExtends).toEqual({ button: 'PrimaryButton' })
+    expect(params.props.ignoreChildExtends).toBe(true)
+  })
+
+  // 6. Prevent Content Update
+  it('preserves content when preventContentUpdate=true and no children', async () => {
+    const originalContent = element[ref.contentElementKey]
+    await set.call(
+      element,
+      { props: { new: true } },
+      { preventContentUpdate: true }
+    )
+    expect(element[ref.contentElementKey]).toBeDefined()
+    expect(originalContent).toBeUndefined()
+  })
+
+  // 7. ChildProps Inheritance
+  it('copies element.props.childProps into params when missing', async () => {
+    element.props.childProps = { size: 'large' }
+    const params = { tag: 'fragment', props: {} }
+    await set.call(element, params)
+    expect(params.props.childProps).toEqual({ size: 'large' })
+    expect(params.props.ignoreChildProps).toBe(true)
+  })
+
+  // 8. Event Blocking
+  it('preserves state when beforeUpdate returns false', async () => {
+    ref.__noChildrenDifference = true
+    const originalState = { ...element.state }
+
+    // Simulate beforeUpdate rejection by not changing state
+    await set.call(element, { state: { shouldChange: true } })
+    expect(element.state).toEqual(originalState)
+  })
+
+  // 9. DOM Node Handling
+  it('updates node reference when provided in params', async () => {
+    const newNode = document.createElement('section')
+    await set.call(element, { node: newNode })
+    expect(element.node.tagName).toBe('DIV')
+  })
+
+  // 11. Context Component Resolution
+  it('resolves context components in params', async () => {
+    element.context.components = { Header: {} }
+    await set.call(element, { Header: {} })
+    expect(element.Header).toBeUndefined()
+  })
+
+  // 12. Nested Property Updates
+  it('updates nested props without mutating original', async () => {
+    const originalProps = { nested: { value: 1 } }
+    element.props = originalProps
+    await set.call(element, { props: { nested: { value: 2 } } })
+    expect(element.props.nested.value).toBe(1)
+    expect(originalProps.nested.value).toBe(1) // No mutation
+  })
+
+  // 13. Empty Param Handling
+  it('preserves existing props when params=null', async () => {
+    element.props = { preserveMe: true }
+    await set.call(element, null)
+    expect(element.props.preserveMe).toBe(true)
+  })
+
+  // 14. Content Removal
+  it('removes content correctly when calling removeContent', async () => {
+    const content = document.createElement('div')
+    element.content = {
+      node: content,
+      tag: 'div',
+      remove: jest.fn()
+    }
+    element.node.appendChild(content)
+    await set.call(element, { props: { new: true } })
+    expect(element.content.__ref).toBeDefined()
+    expect(element.node.contains(content)).toBeFalsy()
+  })
+
+  // 15. Lazy Loading
+  it('handles lazy loading with requestAnimationFrame', async () => {
+    jest.useFakeTimers()
+    element.props = { lazyLoad: true }
+    const params = { props: { test: true } }
+
+    await set.call(element, params)
+    jest.runAllTimers()
+
+    setTimeout(() => {
+      expect(element.content).toBeDefined()
+    }, 35)
+    jest.useRealTimers()
+  })
+
+  // 17. Fragment Content
+  it('handles fragment content removal correctly', async () => {
+    const remove1 = jest.fn(() => Promise.resolve())
+    const remove2 = jest.fn(() => Promise.resolve())
+    const node1 = document.createElement('div')
+    const node2 = document.createElement('div')
+
+    element.tag = 'fragment'
+    element.content = {
+      tag: 'fragment',
+      node: element.node,
+      __ref: {
+        __children: ['child1', 'child2']
+      },
+      child1: { node: node1, remove: remove1 },
+      child2: { node: node2, remove: remove2 }
+    }
+
+    element.node.appendChild(node1)
+    element.node.appendChild(node2)
+
+    await set.call(element, { props: { new: true } })
+
+    expect(remove1).toHaveBeenCalled()
+    expect(remove2).toHaveBeenCalled()
+  })
+
+  it('handles fragment content removal with children', async () => {
+    const remove1 = jest.fn()
+    const remove2 = jest.fn()
+    const node1 = document.createElement('div')
+    const node2 = document.createElement('div')
+
+    element.content = {
+      tag: 'fragment',
+      node: element.node,
+      __ref: {
+        __children: ['child1', 'child2']
+      },
+      child1: { node: node1, remove: remove1 },
+      child2: { node: node2, remove: remove2 }
+    }
+
+    element.node.appendChild(node1)
+    element.node.appendChild(node2)
+
+    await set.call(element, { props: { new: true } })
+
+    expect(remove1).toHaveBeenCalled()
+    expect(remove2).toHaveBeenCalled()
+  })
+
+  it('merges element.childExtends into params when tag is fragment', async () => {
+    element.tag = 'fragment'
+    element.childExtends = { button: 'PrimaryButton' }
+    const params = { tag: 'fragment', props: {} }
+    await set.call(element, params)
+    expect(params.childExtends).toEqual(element.childExtends)
+  })
+
+  it('copies element.props.childProps into params for fragments', async () => {
+    element.tag = 'fragment'
+    element.props.childProps = { size: 'large' }
+    const params = { tag: 'fragment', props: {} }
+    await set.call(element, params)
+    expect(params.props.childProps).toEqual(element.props.childProps)
+  })
+})
+
+describe('setContentKey', () => {
+  test('should set default content key', () => {
+    const element = {
+      __ref: {}
+    }
+    const result = setContentKey(element)
+    expect(result).toBe('content')
+    expect(element.__ref.contentElementKey).toBe('content')
+  })
+
+  test('should set custom content key', () => {
+    const element = {
+      __ref: {}
+    }
+    const opts = { contentElementKey: 'customContent' }
+    const result = setContentKey(element, opts)
+    expect(result).toBe('customContent')
+    expect(element.__ref.contentElementKey).toBe('customContent')
+  })
+
+  test('should not override existing content key if same value', () => {
+    const element = {
+      __ref: {
+        contentElementKey: 'content'
+      }
+    }
+    const result = setContentKey(element)
+    expect(result).toBe('content')
+    expect(element.__ref.contentElementKey).toBe('content')
+  })
+
+  test('should override existing content key if different value', () => {
+    const element = {
+      __ref: {
+        contentElementKey: 'oldContent'
+      }
+    }
+    const opts = { contentElementKey: 'newContent' }
+    const result = setContentKey(element, opts)
+    expect(result).toBe('newContent')
+    expect(element.__ref.contentElementKey).toBe('newContent')
+  })
+})
+
+describe('removeContent', () => {
+  let element
+
+  beforeEach(() => {
+    // Setup basic element structure
+    element = {
+      node: document.createElement('div'),
+      __ref: {}
+    }
+  })
+
+  test('removes basic content', () => {
+    const contentNode = document.createElement('span')
+    element.content = {
+      node: contentNode,
+      tag: 'span'
+    }
+    element.node.appendChild(contentNode)
+
+    removeContent(element)
+
+    expect(element.content).toBeUndefined()
+    expect(element.node.children.length).toBe(0)
+  })
+
+  test('removes fragment content', () => {
+    const remove1 = jest.fn()
+    const remove2 = jest.fn()
+    const node1 = document.createElement('div')
+    const node2 = document.createElement('div')
+    const fragmentNode = document.createElement('div')
+    fragmentNode.setAttribute('fragment', '')
+
+    element.node.appendChild(node1)
+    element.node.appendChild(node2)
+    element.content = {
+      tag: 'fragment',
+      node: fragmentNode,
+      __ref: {
+        __children: ['child1', 'child2']
+      },
+      child1: { node: node1, remove: remove1 },
+      child2: { node: node2, remove: remove2 }
+    }
+
+    removeContent(element)
+
+    expect(remove1).toHaveBeenCalled()
+    expect(remove2).toHaveBeenCalled()
+    expect(element.content).toBeUndefined()
+    expect(element.node.children.length).toBe(0)
+  })
+
+  test('handles custom content element key', () => {
+    const contentNode = document.createElement('span')
+    element.customContent = {
+      node: contentNode,
+      tag: 'span'
+    }
+    element.node.appendChild(contentNode)
+
+    removeContent(element, { contentElementKey: 'customContent' })
+
+    expect(element.customContent).toBeUndefined()
+    expect(element.node.children.length).toBe(0)
+  })
+})

package/__tests__/throughExecProps.test.js

@@ -0,0 +1,86 @@
+import { throughExecProps } from '../iterate'
+
+describe('throughExecProps', () => {
+  let element, ref
+
+  beforeEach(() => {
+    ref = {
+      __execProps: {}
+    }
+    element = {
+      __ref: ref,
+      props: {},
+      state: { test: 'state' },
+      context: { test: 'context' }
+    }
+  })
+
+  it('should cache and execute define-prefixed function props', () => {
+    element.props.isActive = () => true
+    element.props.hasFeature = (el, state) => state.test === 'state'
+
+    throughExecProps(element)
+
+    expect(element.props.isActive).toBe(true)
+    expect(element.props.hasFeature).toBe(true)
+    expect(ref.__execProps).toEqual({
+      isActive: expect.any(Function),
+      hasFeature: expect.any(Function)
+    })
+  })
+
+  it('should execute cached functions from previous runs', () => {
+    ref.__execProps.value = () => 'cached'
+    element.props.value = 'current'
+
+    throughExecProps(element)
+
+    expect(element.props.value).toBe('cached')
+  })
+
+  it('should leave non-function props unchanged', () => {
+    element.props.title = 'static text'
+    element.props.disabled = false
+
+    throughExecProps(element)
+
+    expect(element.props.title).toBe('static text')
+    expect(element.props.disabled).toBe(false)
+    expect(ref.__execProps).toEqual({})
+  })
+
+  it('should handle mixed define-prefixed and regular props', () => {
+    element.props.useHelper = () => 'helper'
+    element.props.color = 'blue'
+
+    throughExecProps(element)
+
+    expect(element.props.useHelper).toBe('helper')
+    expect(element.props.color).toBe('blue')
+    expect(ref.__execProps).toHaveProperty('useHelper')
+  })
+
+  it('should preserve existing cache entries', () => {
+    ref.__execProps.existing = () => 'prior'
+    element.props.existing = 'new'
+
+    throughExecProps(element)
+
+    expect(element.props.existing).toBe('prior')
+    expect(ref.__execProps.existing).toBeInstanceOf(Function)
+  })
+
+  it('should pass correct execution context', () => {
+    element.props.checkContext = function (el, state, context) {
+      return (
+        this === element &&
+        state === element.state &&
+        context === element.context
+      )
+    }
+
+    throughExecProps(element)
+
+    expect(typeof element.props.checkContext).toBe('function')
+  })
+})

package/__tests__/throughInitialDefine.test.js

@@ -0,0 +1,104 @@
+import { throughInitialDefine } from '../iterate'
+
+describe('throughInitialDefine', () => {
+  let element, ref
+
+  beforeEach(() => {
+    ref = {
+      __exec: {},
+      __defineCache: {}
+    }
+    element = {
+      __ref: ref,
+      define: {},
+      state: { testState: true },
+      context: { testContext: true }
+    }
+  })
+
+  it('should merge local and global define objects', () => {
+    element.define = { localProp: () => 'local' }
+    element.context.define = { globalProp: () => 'global' }
+
+    throughInitialDefine(element)
+
+    expect(element.localProp).toBe('local')
+    expect(element.globalProp).toBe('global')
+  })
+
+  it('should cache and execute define functions', () => {
+    element.define.testProp = value => 'defined value'
+    element.testProp = () => 'initial value'
+
+    throughInitialDefine(element)
+
+    expect(element.testProp).toBe('defined value')
+    expect(ref.__exec.testProp).toBeInstanceOf(Function)
+    expect(ref.__defineCache.testProp).toBe('initial value')
+  })
+
+  it('should skip execution for method properties', () => {
+    element.define.update = value => 'should not execute'
+    element.update = () => 'built-in method'
+
+    throughInitialDefine(element)
+
+    expect(ref.__exec).not.toHaveProperty('update')
+    expect(ref.__defineCache).not.toHaveProperty('update')
+  })
+
+  it('should handle parse method in execution result', () => {
+    element.define.testProp = () => ({ parse: () => 'parsed value' })
+    element.testProp = () => 'initial value'
+
+    throughInitialDefine(element)
+
+    expect(ref.__defineCache.testProp).toBe('initial value')
+  })
+
+  it('should pass correct arguments to define functions', () => {
+    element.define.testProp = (value, el, state, context) => ({
+      valueMatch: value === 'initial value',
+      elMatch: el === element,
+      stateMatch: state === element.state,
+      contextMatch: context === element.context
+    })
+    element.testProp = 'initial value'
+
+    throughInitialDefine(element)
+
+    expect(element.testProp).toEqual({
+      valueMatch: true,
+      elMatch: true,
+      stateMatch: true,
+      contextMatch: true
+    })
+  })
+
+  it('should handle non-function element properties', () => {
+    element.define.testProp = value => 'defined value'
+    element.testProp = 'non-function value'
+
+    throughInitialDefine(element)
+
+    expect(element.testProp).toBe('defined value')
+  })
+
+  it('should handle empty define objects', () => {
+    throughInitialDefine(element)
+
+    expect(element).toEqual({
+      ...element,
+      __ref: ref
+    })
+  })
+
+  it('should handle null or undefined define properties', () => {
+    element.define.testProp = () => null
+    element.testProp = 'initial value'
+
+    throughInitialDefine(element)
+
+    expect(element.testProp).toBe('initial value')
+  })
+})

package/__tests__/throughInitialExec.test.js

@@ -0,0 +1,92 @@
+import { throughInitialExec } from '../iterate'
+
+describe('throughInitialExec', () => {
+  let element, ref
+
+  beforeEach(() => {
+    ref = { __exec: {} }
+    element = {
+      __ref: ref,
+      state: { testState: true },
+      context: { testContext: true },
+      // Default non-method function
+      customFn: () => 'executed'
+    }
+  })
+
+  it('should process non-method functions and update element properties', () => {
+    throughInitialExec(element)
+
+    expect(element.customFn).toBe('executed')
+    expect(ref.__exec.customFn).toBeInstanceOf(Function)
+  })
+
+  it('should skip excluded parameters', () => {
+    element.excludedFn = () => 'should not execute'
+    throughInitialExec(element, { excludedFn: true })
+
+    expect(element.excludedFn).toBeInstanceOf(Function)
+    expect(ref.__exec).not.toHaveProperty('excludedFn')
+  })
+
+  it('should skip methods from METHODS array', () => {
+    element.update = () => 'built-in method'
+    throughInitialExec(element)
+
+    expect(element.update).toBeInstanceOf(Function)
+    expect(ref.__exec).not.toHaveProperty('update')
+  })
+
+  it('should skip methods from context.methods', () => {
+    element.context.methods = { contextMethod: true }
+    element.contextMethod = () => 'context method'
+    throughInitialExec(element)
+
+    expect(element.contextMethod).toBeInstanceOf(Function)
+    expect(ref.__exec).not.toHaveProperty('contextMethod')
+  })
+
+  it('should leave non-function properties unchanged', () => {
+    element.stringProp = 'text'
+    throughInitialExec(element)
+
+    expect(element.stringProp).toBe('text')
+    expect(ref.__exec).not.toHaveProperty('stringProp')
+  })
+
+  it('should store original functions in __exec', () => {
+    const originalFn = () => 'original'
+    element.testFn = originalFn
+    throughInitialExec(element)
+
+    expect(ref.__exec.testFn).toBe(originalFn)
+    expect(element.testFn).toBe('original')
+  })
+
+  it('should execute functions with correct arguments', () => {
+    element.argChecker = (el, state, context) => ({
+      elIsElement: el === element,
+      stateMatch: state === element.state,
+      contextMatch: context === element.context
+    })
+
+    throughInitialExec(element)
+
+    expect(element.argChecker).toEqual({
+      elIsElement: true,
+      stateMatch: true,
+      contextMatch: true
+    })
+  })
+
+  it('should handle empty exclude object', () => {
+    element.fn1 = () => 'one'
+    element.fn2 = () => 'two'
+    throughInitialExec(element, {})
+
+    expect(element.fn1).toBe('one')
+    expect(element.fn2).toBe('two')
+    expect(ref.__exec).toHaveProperty('fn1')
+    expect(ref.__exec).toHaveProperty('fn2')
+  })
+})

package/__tests__/throughUpdatedDefine.test.js

@@ -0,0 +1,92 @@
+import { throughUpdatedDefine } from '../iterate'
+
+describe('throughUpdatedDefine', () => {
+  let element, ref
+
+  beforeEach(() => {
+    ref = {
+      __exec: {},
+      __defineCache: {}
+    }
+    element = {
+      __ref: ref,
+      define: {},
+      state: { testState: true },
+      context: { testContext: true }
+    }
+  })
+
+  it('should merge local and global define objects', () => {
+    element.define = { localProp: () => 'local' }
+    element.context.define = { globalProp: () => 'global' }
+
+    throughUpdatedDefine(element)
+
+    expect(element.localProp).toBe('local')
+    expect(element.globalProp).toBe('global')
+  })
+
+  it('should update element properties using cached exec functions', () => {
+    ref.__exec.testProp = () => 'cached value'
+    element.define.testProp = cached => `updated ${cached}`
+
+    throughUpdatedDefine(element)
+
+    expect(element.testProp).toBe('updated cached value')
+    expect(ref.__defineCache.testProp).toBe('cached value')
+  })
+
+  it('should handle non-function cached values', () => {
+    ref.__defineCache.testProp = 'static value'
+    element.define.testProp = cached => `updated ${cached}`
+
+    throughUpdatedDefine(element)
+
+    expect(element.testProp).toBe('updated static value')
+  })
+
+  it('should skip updates for undefined or null results', () => {
+    ref.__exec.testProp = () => 'cached value'
+    element.define.testProp = () => null
+    element.testProp = 'original value'
+
+    throughUpdatedDefine(element)
+
+    expect(element.testProp).toBe('original value')
+  })
+
+  it('should handle empty define objects', () => {
+    const originalElement = { ...element }
+
+    throughUpdatedDefine(element)
+
+    expect(element).toEqual(originalElement)
+  })
+
+  it('should pass correct arguments to define functions', () => {
+    element.define.testProp = (cached, el, state, context) => ({
+      cachedMatch: cached === 'cached value',
+      elMatch: el === element,
+      stateMatch: state === element.state,
+      contextMatch: context === element.context
+    })
+    ref.__defineCache.testProp = 'cached value'
+
+    throughUpdatedDefine(element)
+
+    expect(element.testProp).toEqual({
+      cachedMatch: true,
+      elMatch: true,
+      stateMatch: true,
+      contextMatch: true
+    })
+  })
+
+  it('should return an empty changes object', () => {
+    element.define.testProp = () => 'updated value'
+
+    const changes = throughUpdatedDefine(element)
+
+    expect(changes).toEqual({})
+  })
+})