@domql/element 3.2.3 → 3.2.7

package/__tests__/set.test.js

@@ -1,312 +0,0 @@
-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', () => {
-    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', () => {
-    ref.__noChildrenDifference = true
-    const originalProps = { ...element.props }
-    set.call(element, { props: { id: 'same' } })
-    expect(element.props).toEqual(originalProps)
-  })
-
-  // 3. ChildExtends Inheritance
-  it('merges element.childExtends into params when missing', () => {
-    element.childExtends = { button: 'PrimaryButton' }
-    const params = { tag: 'fragment', props: {} }
-    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', () => {
-    const originalContent = element[ref.contentElementKey]
-    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', () => {
-    element.props.childProps = { size: 'large' }
-    const params = { tag: 'fragment', props: {} }
-    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', () => {
-    ref.__noChildrenDifference = true
-    const originalState = { ...element.state }
-
-    // Simulate beforeUpdate rejection by not changing state
-    set.call(element, { state: { shouldChange: true } })
-    expect(element.state).toEqual(originalState)
-  })
-
-  // 9. DOM Node Handling
-  it('updates node reference when provided in params', () => {
-    const newNode = document.createElement('section')
-    set.call(element, { node: newNode })
-    expect(element.node.tagName).toBe('DIV')
-  })
-
-  // 11. Context Component Resolution
-  it('resolves context components in params', () => {
-    element.context.components = { Header: {} }
-    set.call(element, { Header: {} })
-    expect(element.Header).toBeUndefined()
-  })
-
-  // 12. Nested Property Updates
-  it('updates nested props without mutating original', () => {
-    const originalProps = { nested: { value: 1 } }
-    element.props = originalProps
-    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', () => {
-    element.props = { preserveMe: true }
-    set.call(element, null)
-    expect(element.props.preserveMe).toBe(true)
-  })
-
-  // 14. Content Removal
-  it('removes content correctly when calling removeContent', () => {
-    const content = document.createElement('div')
-    element.content = {
-      node: content,
-      tag: 'div',
-      remove: jest.fn()
-    }
-    element.node.appendChild(content)
-    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', () => {
-    jest.useFakeTimers()
-    element.props = { lazyLoad: true }
-    const params = { props: { test: true } }
-
-    set.call(element, params)
-    jest.runAllTimers()
-
-    setTimeout(() => {
-      expect(element.content).toBeDefined()
-    }, 35)
-    jest.useRealTimers()
-  })
-
-  // 17. Fragment Content
-  it('handles fragment content removal correctly', () => {
-    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)
-
-    set.call(element, { props: { new: true } })
-
-    expect(remove1).toHaveBeenCalled()
-    expect(remove2).toHaveBeenCalled()
-  })
-
-  it('handles fragment content removal with children', () => {
-    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)
-
-    set.call(element, { props: { new: true } })
-
-    expect(remove1).toHaveBeenCalled()
-    expect(remove2).toHaveBeenCalled()
-  })
-
-  it('merges element.childExtends into params when tag is fragment', () => {
-    element.tag = 'fragment'
-    element.childExtends = { button: 'PrimaryButton' }
-    const params = { tag: 'fragment', props: {} }
-    set.call(element, params)
-    expect(params.childExtends).toEqual(element.childExtends)
-  })
-
-  it('copies element.props.childProps into params for fragments', () => {
-    element.tag = 'fragment'
-    element.props.childProps = { size: 'large' }
-    const params = { tag: 'fragment', props: {} }
-    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

@@ -1,86 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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({})
-  })
-})