@domql/element 3.1.1 → 3.2.3

package/__tests__/set.test.js

@@ -22,91 +22,87 @@ describe('set', () => {
   })
 
   // 1. Basic Content Updates
-  it('updates element.props when params.props are provided', async () => {
-    await set.call(element, { props: { title: 'New Title' } })
+  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', async () => {
+  it('skips update when deepContains matches existing content', () => {
     ref.__noChildrenDifference = true
     const originalProps = { ...element.props }
-    await set.call(element, { props: { id: 'same' } })
+    set.call(element, { props: { id: 'same' } })
     expect(element.props).toEqual(originalProps)
   })
 
   // 3. ChildExtends Inheritance
-  it('merges element.childExtends into params when missing', async () => {
+  it('merges element.childExtends into params when missing', () => {
     element.childExtends = { button: 'PrimaryButton' }
     const params = { tag: 'fragment', props: {} }
-    await set.call(element, params)
+    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 () => {
+  it('preserves content when preventContentUpdate=true and no children', () => {
     const originalContent = element[ref.contentElementKey]
-    await set.call(
-      element,
-      { props: { new: true } },
-      { preventContentUpdate: true }
-    )
+    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 () => {
+  it('copies element.props.childProps into params when missing', () => {
     element.props.childProps = { size: 'large' }
     const params = { tag: 'fragment', props: {} }
-    await set.call(element, params)
+    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 () => {
+  it('preserves state when beforeUpdate returns false', () => {
     ref.__noChildrenDifference = true
     const originalState = { ...element.state }
 
     // Simulate beforeUpdate rejection by not changing state
-    await set.call(element, { state: { shouldChange: true } })
+    set.call(element, { state: { shouldChange: true } })
     expect(element.state).toEqual(originalState)
   })
 
   // 9. DOM Node Handling
-  it('updates node reference when provided in params', async () => {
+  it('updates node reference when provided in params', () => {
     const newNode = document.createElement('section')
-    await set.call(element, { node: newNode })
+    set.call(element, { node: newNode })
     expect(element.node.tagName).toBe('DIV')
   })
 
   // 11. Context Component Resolution
-  it('resolves context components in params', async () => {
+  it('resolves context components in params', () => {
     element.context.components = { Header: {} }
-    await set.call(element, { Header: {} })
+    set.call(element, { Header: {} })
     expect(element.Header).toBeUndefined()
   })
 
   // 12. Nested Property Updates
-  it('updates nested props without mutating original', async () => {
+  it('updates nested props without mutating original', () => {
     const originalProps = { nested: { value: 1 } }
     element.props = originalProps
-    await set.call(element, { props: { nested: { value: 2 } } })
+    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 () => {
+  it('preserves existing props when params=null', () => {
     element.props = { preserveMe: true }
-    await set.call(element, null)
+    set.call(element, null)
     expect(element.props.preserveMe).toBe(true)
   })
 
   // 14. Content Removal
-  it('removes content correctly when calling removeContent', async () => {
+  it('removes content correctly when calling removeContent', () => {
     const content = document.createElement('div')
     element.content = {
       node: content,
@@ -114,18 +110,18 @@ describe('set', () => {
       remove: jest.fn()
     }
     element.node.appendChild(content)
-    await set.call(element, { props: { new: true } })
+    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 () => {
+  it('handles lazy loading with requestAnimationFrame', () => {
     jest.useFakeTimers()
     element.props = { lazyLoad: true }
     const params = { props: { test: true } }
 
-    await set.call(element, params)
+    set.call(element, params)
     jest.runAllTimers()
 
     setTimeout(() => {
@@ -135,7 +131,7 @@ describe('set', () => {
   })
 
   // 17. Fragment Content
-  it('handles fragment content removal correctly', async () => {
+  it('handles fragment content removal correctly', () => {
     const remove1 = jest.fn(() => Promise.resolve())
     const remove2 = jest.fn(() => Promise.resolve())
     const node1 = document.createElement('div')
@@ -155,13 +151,13 @@ describe('set', () => {
     element.node.appendChild(node1)
     element.node.appendChild(node2)
 
-    await set.call(element, { props: { new: true } })
+    set.call(element, { props: { new: true } })
 
     expect(remove1).toHaveBeenCalled()
     expect(remove2).toHaveBeenCalled()
   })
 
-  it('handles fragment content removal with children', async () => {
+  it('handles fragment content removal with children', () => {
     const remove1 = jest.fn()
     const remove2 = jest.fn()
     const node1 = document.createElement('div')
@@ -180,25 +176,25 @@ describe('set', () => {
     element.node.appendChild(node1)
     element.node.appendChild(node2)
 
-    await set.call(element, { props: { new: true } })
+    set.call(element, { props: { new: true } })
 
     expect(remove1).toHaveBeenCalled()
     expect(remove2).toHaveBeenCalled()
   })
 
-  it('merges element.childExtends into params when tag is fragment', async () => {
+  it('merges element.childExtends into params when tag is fragment', () => {
     element.tag = 'fragment'
     element.childExtends = { button: 'PrimaryButton' }
     const params = { tag: 'fragment', props: {} }
-    await set.call(element, params)
+    set.call(element, params)
     expect(params.childExtends).toEqual(element.childExtends)
   })
 
-  it('copies element.props.childProps into params for fragments', async () => {
+  it('copies element.props.childProps into params for fragments', () => {
     element.tag = 'fragment'
     element.props.childProps = { size: 'large' }
     const params = { tag: 'fragment', props: {} }
-    await set.call(element, params)
+    set.call(element, params)
     expect(params.props.childProps).toEqual(element.props.childProps)
   })
 })

package/__tests__/throughExecProps.test.js

@@ -15,11 +15,11 @@ describe('throughExecProps', () => {
     }
   })
 
-  it('should cache and execute define-prefixed function props', async () => {
+  it('should cache and execute define-prefixed function props', () => {
     element.props.isActive = () => true
     element.props.hasFeature = (el, state) => state.test === 'state'
 
-    await throughExecProps(element)
+    throughExecProps(element)
 
     expect(element.props.isActive).toBe(true)
     expect(element.props.hasFeature).toBe(true)
@@ -29,48 +29,48 @@ describe('throughExecProps', () => {
     })
   })
 
-  it('should execute cached functions from previous runs', async () => {
+  it('should execute cached functions from previous runs', () => {
     ref.__execProps.value = () => 'cached'
     element.props.value = 'current'
 
-    await throughExecProps(element)
+    throughExecProps(element)
 
     expect(element.props.value).toBe('cached')
   })
 
-  it('should leave non-function props unchanged', async () => {
+  it('should leave non-function props unchanged', () => {
     element.props.title = 'static text'
     element.props.disabled = false
 
-    await throughExecProps(element)
+    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', async () => {
+  it('should handle mixed define-prefixed and regular props', () => {
     element.props.useHelper = () => 'helper'
     element.props.color = 'blue'
 
-    await throughExecProps(element)
+    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', async () => {
+  it('should preserve existing cache entries', () => {
     ref.__execProps.existing = () => 'prior'
     element.props.existing = 'new'
 
-    await throughExecProps(element)
+    throughExecProps(element)
 
     expect(element.props.existing).toBe('prior')
     expect(ref.__execProps.existing).toBeInstanceOf(Function)
   })
 
-  it('should pass correct execution context', async () => {
+  it('should pass correct execution context', () => {
     element.props.checkContext = function (el, state, context) {
       return (
         this === element &&
@@ -79,7 +79,7 @@ describe('throughExecProps', () => {
       )
     }
 
-    await throughExecProps(element)
+    throughExecProps(element)
 
     expect(typeof element.props.checkContext).toBe('function')
   })

package/__tests__/throughInitialDefine.test.js

@@ -16,47 +16,47 @@ describe('throughInitialDefine', () => {
     }
   })
 
-  it('should merge local and global define objects', async () => {
+  it('should merge local and global define objects', () => {
     element.define = { localProp: () => 'local' }
     element.context.define = { globalProp: () => 'global' }
 
-    await throughInitialDefine(element)
+    throughInitialDefine(element)
 
     expect(element.localProp).toBe('local')
     expect(element.globalProp).toBe('global')
   })
 
-  it('should cache and execute define functions', async () => {
+  it('should cache and execute define functions', () => {
     element.define.testProp = value => 'defined value'
     element.testProp = () => 'initial value'
 
-    await throughInitialDefine(element)
+    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', async () => {
+  it('should skip execution for method properties', () => {
     element.define.update = value => 'should not execute'
     element.update = () => 'built-in method'
 
-    await throughInitialDefine(element)
+    throughInitialDefine(element)
 
     expect(ref.__exec).not.toHaveProperty('update')
     expect(ref.__defineCache).not.toHaveProperty('update')
   })
 
-  it('should handle parse method in execution result', async () => {
+  it('should handle parse method in execution result', () => {
     element.define.testProp = () => ({ parse: () => 'parsed value' })
     element.testProp = () => 'initial value'
 
-    await throughInitialDefine(element)
+    throughInitialDefine(element)
 
     expect(ref.__defineCache.testProp).toBe('initial value')
   })
 
-  it('should pass correct arguments to define functions', async () => {
+  it('should pass correct arguments to define functions', () => {
     element.define.testProp = (value, el, state, context) => ({
       valueMatch: value === 'initial value',
       elMatch: el === element,
@@ -65,7 +65,7 @@ describe('throughInitialDefine', () => {
     })
     element.testProp = 'initial value'
 
-    await throughInitialDefine(element)
+    throughInitialDefine(element)
 
     expect(element.testProp).toEqual({
       valueMatch: true,
@@ -75,17 +75,17 @@ describe('throughInitialDefine', () => {
     })
   })
 
-  it('should handle non-function element properties', async () => {
+  it('should handle non-function element properties', () => {
     element.define.testProp = value => 'defined value'
     element.testProp = 'non-function value'
 
-    await throughInitialDefine(element)
+    throughInitialDefine(element)
 
     expect(element.testProp).toBe('defined value')
   })
 
-  it('should handle empty define objects', async () => {
-    await throughInitialDefine(element)
+  it('should handle empty define objects', () => {
+    throughInitialDefine(element)
 
     expect(element).toEqual({
       ...element,
@@ -93,11 +93,11 @@ describe('throughInitialDefine', () => {
     })
   })
 
-  it('should handle null or undefined define properties', async () => {
+  it('should handle null or undefined define properties', () => {
     element.define.testProp = () => null
     element.testProp = 'initial value'
 
-    await throughInitialDefine(element)
+    throughInitialDefine(element)
 
     expect(element.testProp).toBe('initial value')
   })

package/__tests__/throughInitialExec.test.js

@@ -14,63 +14,63 @@ describe('throughInitialExec', () => {
     }
   })
 
-  it('should process non-method functions and update element properties', async () => {
-    await throughInitialExec(element)
+  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', async () => {
+  it('should skip excluded parameters', () => {
     element.excludedFn = () => 'should not execute'
-    await throughInitialExec(element, { excludedFn: true })
+    throughInitialExec(element, { excludedFn: true })
 
     expect(element.excludedFn).toBeInstanceOf(Function)
     expect(ref.__exec).not.toHaveProperty('excludedFn')
   })
 
-  it('should skip methods from METHODS array', async () => {
+  it('should skip methods from METHODS array', () => {
     element.update = () => 'built-in method'
-    await throughInitialExec(element)
+    throughInitialExec(element)
 
     expect(element.update).toBeInstanceOf(Function)
     expect(ref.__exec).not.toHaveProperty('update')
   })
 
-  it('should skip methods from context.methods', async () => {
+  it('should skip methods from context.methods', () => {
     element.context.methods = { contextMethod: true }
     element.contextMethod = () => 'context method'
-    await throughInitialExec(element)
+    throughInitialExec(element)
 
     expect(element.contextMethod).toBeInstanceOf(Function)
     expect(ref.__exec).not.toHaveProperty('contextMethod')
   })
 
-  it('should leave non-function properties unchanged', async () => {
+  it('should leave non-function properties unchanged', () => {
     element.stringProp = 'text'
-    await throughInitialExec(element)
+    throughInitialExec(element)
 
     expect(element.stringProp).toBe('text')
     expect(ref.__exec).not.toHaveProperty('stringProp')
   })
 
-  it('should store original functions in __exec', async () => {
+  it('should store original functions in __exec', () => {
     const originalFn = () => 'original'
     element.testFn = originalFn
-    await throughInitialExec(element)
+    throughInitialExec(element)
 
     expect(ref.__exec.testFn).toBe(originalFn)
     expect(element.testFn).toBe('original')
   })
 
-  it('should execute functions with correct arguments', async () => {
+  it('should execute functions with correct arguments', () => {
     element.argChecker = (el, state, context) => ({
       elIsElement: el === element,
       stateMatch: state === element.state,
       contextMatch: context === element.context
     })
 
-    await throughInitialExec(element)
+    throughInitialExec(element)
 
     expect(element.argChecker).toEqual({
       elIsElement: true,
@@ -79,10 +79,10 @@ describe('throughInitialExec', () => {
     })
   })
 
-  it('should handle empty exclude object', async () => {
+  it('should handle empty exclude object', () => {
     element.fn1 = () => 'one'
     element.fn2 = () => 'two'
-    await throughInitialExec(element, {})
+    throughInitialExec(element, {})
 
     expect(element.fn1).toBe('one')
     expect(element.fn2).toBe('two')

package/__tests__/throughUpdatedDefine.test.js

@@ -16,54 +16,54 @@ describe('throughUpdatedDefine', () => {
     }
   })
 
-  it('should merge local and global define objects', async () => {
+  it('should merge local and global define objects', () => {
     element.define = { localProp: () => 'local' }
     element.context.define = { globalProp: () => 'global' }
 
-    await throughUpdatedDefine(element)
+    throughUpdatedDefine(element)
 
     expect(element.localProp).toBe('local')
     expect(element.globalProp).toBe('global')
   })
 
-  it('should update element properties using cached exec functions', async () => {
+  it('should update element properties using cached exec functions', () => {
     ref.__exec.testProp = () => 'cached value'
     element.define.testProp = cached => `updated ${cached}`
 
-    await throughUpdatedDefine(element)
+    throughUpdatedDefine(element)
 
     expect(element.testProp).toBe('updated cached value')
     expect(ref.__defineCache.testProp).toBe('cached value')
   })
 
-  it('should handle non-function cached values', async () => {
+  it('should handle non-function cached values', () => {
     ref.__defineCache.testProp = 'static value'
     element.define.testProp = cached => `updated ${cached}`
 
-    await throughUpdatedDefine(element)
+    throughUpdatedDefine(element)
 
     expect(element.testProp).toBe('updated static value')
   })
 
-  it('should skip updates for undefined or null results', async () => {
+  it('should skip updates for undefined or null results', () => {
     ref.__exec.testProp = () => 'cached value'
     element.define.testProp = () => null
     element.testProp = 'original value'
 
-    await throughUpdatedDefine(element)
+    throughUpdatedDefine(element)
 
     expect(element.testProp).toBe('original value')
   })
 
-  it('should handle empty define objects', async () => {
+  it('should handle empty define objects', () => {
     const originalElement = { ...element }
 
-    await throughUpdatedDefine(element)
+    throughUpdatedDefine(element)
 
     expect(element).toEqual(originalElement)
   })
 
-  it('should pass correct arguments to define functions', async () => {
+  it('should pass correct arguments to define functions', () => {
     element.define.testProp = (cached, el, state, context) => ({
       cachedMatch: cached === 'cached value',
       elMatch: el === element,
@@ -72,7 +72,7 @@ describe('throughUpdatedDefine', () => {
     })
     ref.__defineCache.testProp = 'cached value'
 
-    await throughUpdatedDefine(element)
+    throughUpdatedDefine(element)
 
     expect(element.testProp).toEqual({
       cachedMatch: true,
@@ -82,10 +82,10 @@ describe('throughUpdatedDefine', () => {
     })
   })
 
-  it('should return an empty changes object', async () => {
+  it('should return an empty changes object', () => {
     element.define.testProp = () => 'updated value'
 
-    const changes = await throughUpdatedDefine(element)
+    const changes = throughUpdatedDefine(element)
 
     expect(changes).toEqual({})
   })

package/__tests__/throughUpdatedExec.test.js

@@ -15,45 +15,45 @@ describe('throughUpdatedExec', () => {
     }
   })
 
-  it('should skip execution for params in __defineCache', () => {
+  it('should skip execution for params in __defineCache', async () => {
     ref.__defineCache.cachedParam = true
     ref.__exec.cachedParam = () => 'should not execute'
     element.cachedParam = 'original'
 
-    const changes = throughUpdatedExec(element)
+    const changes = await throughUpdatedExec(element)
 
     expect(element.cachedParam).toBe('original')
     expect(changes).toEqual({})
   })
 
-  it('should update element properties when newExec differs from current value', () => {
+  it('should update element properties when newExec differs from current value', async () => {
     ref.__exec.testParam = () => 'new value'
     element.testParam = 'old value'
 
-    const changes = throughUpdatedExec(element)
+    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', () => {
+  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 = throughUpdatedExec(element)
+    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', () => {
+  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 = throughUpdatedExec(element)
+    const changes = await throughUpdatedExec(element)
 
     expect(element.TestComponent).toEqual({
       oldProp: 'oldValue',
@@ -62,44 +62,45 @@ describe('throughUpdatedExec', () => {
     expect(changes).toEqual({})
   })
 
-  it('should not update element properties when newExec matches current value', () => {
+  it('should not update element properties when newExec matches current value', async () => {
     ref.__exec.testParam = () => 'same value'
     element.testParam = 'same value'
 
-    const changes = throughUpdatedExec(element)
+    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', () => {
+  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 = throughUpdatedExec(element)
+    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', () => {
+  it('should return an empty changes object when no updates occur', async () => {
     ref.__exec.testParam = () => 'same value'
     element.testParam = 'same value'
 
-    const changes = throughUpdatedExec(element)
+    const changes = await throughUpdatedExec(element)
 
     expect(changes).toEqual({})
   })
 
-  it('should handle multiple properties and return correct changes', () => {
+  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 = throughUpdatedExec(element)
+    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({