@domql/element 3.1.2 → 3.2.3

package/README.md

@@ -9,12 +9,10 @@ import DOM from 'domql'
 
 const Poster = {
   extends: [Link, Img],
-  props: {
-    boxSize: [100, 200],
-    borderRadius: 12,
-    padding: 16,
-    background: '#fff'
-  }
+  boxSize: [100, 200],
+  borderRadius: 12,
+  padding: 16,
+  background: '#fff'
 }
 
 DOM.create(Poster, document.body)

package/__tests__/checkIfOnUpdate.test.js

@@ -44,60 +44,60 @@ describe('checkIfOnUpdate via update()', () => {
     options = {}
   })
 
-  it('uses props.if when element.if missing', async () => {
+  it('uses props.if when element.if missing', () => {
     delete element.if
     element.props.if = () => false
-    await update.call(element, {}, options)
+    update.call(element, {}, options)
     expect(element.node).toEqual(document.createElement('div'))
   })
 
-  it('retains state when __hasRootState=true', async () => {
+  it('retains state when __hasRootState=true', () => {
     element.__ref.__hasRootState = true
     element.state.critical = true
     element.__ref.__if = false
 
-    await update.call(element, {}, options)
+    update.call(element, {}, options)
 
     expect(element.state.critical).toBe(true)
     expect(element.state.preserved).toBeUndefined()
   })
 
-  it('processes nested content with parseDeep', async () => {
+  it('processes nested content with parseDeep', () => {
     element.content = {
       parseDeep: () => ({ parsed: true }),
       existing: 'data'
     }
 
-    await update.call(element, {}, options)
+    update.call(element, {}, options)
 
     expect(element.content.parsed).toBe(true)
     expect(element.content.existing).toBeUndefined()
   })
 
-  it('reattaches after previous sibling', async () => {
+  it('reattaches after previous sibling', () => {
     const prevNode = document.createElement('span')
     parent.node.appendChild(prevNode)
 
-    await update.call(element, {}, options)
+    update.call(element, {}, options)
 
     const newElement = parent.node.children[0]
     expect(newElement).toEqual(document.createElement('span'))
     expect(newElement.previousSibling).toBe(null)
   })
 
-  // it('reattaches before next sibling', async () => {
+  // it('reattaches before next sibling', () => {
   //   const nextNode = document.createElement('p')
   //   parent.node.appendChild(nextNode)
 
-  //   await update.call(element, {}, options)
+  //   update.call(element, {}, options)
 
   //   const newElement = parent.node.children[0]
   //   expect(newElement).toEqual(document.createElement('p'))
   //   expect(newElement.nextSibling).toBe(null)
   // })
 
-  // it('appends to parent when no siblings exist', async () => {
-  //   await update.call(element, {}, options)
+  // it('appends to parent when no siblings exist', () => {
+  //   update.call(element, {}, options)
   //   expect(parent.node.children).toHaveLength(0)
   // })
 })

package/__tests__/children.test.js

@@ -16,23 +16,23 @@ describe('children', () => {
     node = {}
   })
 
-  it('handles null/undefined params', async () => {
-    const result = await setChildren(null, element, node)
+  it('handles null/undefined params', () => {
+    const result = setChildren(null, element, node)
     expect(result).toBeUndefined()
   })
 
-  it('handles direct string children', async () => {
-    const result = await setChildren('Hello World', element, node)
+  it('handles direct string children', () => {
+    const result = setChildren('Hello World', element, node)
     expect(result).toEqual({ tag: 'fragment', 0: { text: 'Hello World' } })
   })
 
-  it('handles numeric children', async () => {
-    const result = await setChildren(42, element, node)
+  it('handles numeric children', () => {
+    const result = setChildren(42, element, node)
     expect(result).toEqual({ tag: 'fragment', 0: { text: 42 } })
   })
 
-  it('handles array of primitive values with childrenAs prop', async () => {
-    const result = await setChildren(['one', 'two'], element, node)
+  it('handles array of primitive values with childrenAs prop', () => {
+    const result = setChildren(['one', 'two'], element, node)
 
     expect(result).toEqual({
       tag: 'fragment',
@@ -41,9 +41,9 @@ describe('children', () => {
     })
   })
 
-  it('handles array of primitive values with childrenAs state', async () => {
+  it('handles array of primitive values with childrenAs state', () => {
     element.props.childrenAs = 'state'
-    const result = await setChildren(['one', 'two'], element, node)
+    const result = setChildren(['one', 'two'], element, node)
 
     expect(result).toEqual({
       tag: 'fragment',
@@ -52,34 +52,34 @@ describe('children', () => {
     })
   })
 
-  it('caches children and detects changes', async () => {
+  it('caches children and detects changes', () => {
     const children1 = [{ id: 1 }, { id: 2 }]
     const children2 = [{ id: 1 }, { id: 2 }]
     const children3 = [{ id: 1 }, { id: 3 }]
 
     // First call
-    await setChildren(children1, element, node)
+    setChildren(children1, element, node)
     expect(element.__ref.__childrenCache).toEqual(children1)
     expect(element.__ref.__noChildrenDifference).toBeUndefined()
 
     // Same content, different reference
-    await setChildren(children2, element, node)
+    setChildren(children2, element, node)
     expect(element.__ref.__noChildrenDifference).toBe(true)
 
     // Different content
-    await setChildren(children3, element, node)
+    setChildren(children3, element, node)
     expect(element.__ref.__noChildrenDifference).toBeUndefined()
     expect(element.__ref.__childrenCache).toEqual(children3)
   })
 
-  it('handles mixed React and normal components', async () => {
+  it('handles mixed React and normal components', () => {
     const mixedChildren = [
       { type: 'div', text: 'Normal' },
       { $$typeof: Symbol('react') },
       { type: 'span', text: 'Another' }
     ]
 
-    await setChildren(mixedChildren, element, node)
+    setChildren(mixedChildren, element, node)
 
     expect(element.call).toHaveBeenCalledWith(
       'renderReact',
@@ -88,13 +88,13 @@ describe('children', () => {
     )
   })
 
-  it('handles state-based children', async () => {
+  it('handles state-based children', () => {
     element.state = {
       items: ['a', 'b'],
       parse: () => ['parsed a', 'parsed b']
     }
 
-    const result = await setChildren('state', element, node)
+    const result = setChildren('state', element, node)
     expect(result).toEqual({
       tag: 'fragment',
       0: { text: 'parsed a' },
@@ -102,9 +102,9 @@ describe('children', () => {
     })
   })
 
-  it('handles async function parameters', async () => {
-    const asyncParam = async () => ['async1', 'async2']
-    const result = await setChildren(asyncParam, element, node)
+  it('handles async function parameters', () => {
+    const asyncParam = () => ['async1', 'async2']
+    const result = setChildren(asyncParam, element, node)
 
     expect(result).toEqual({
       tag: 'fragment',
@@ -113,7 +113,7 @@ describe('children', () => {
     })
   })
 
-  it('handles nested object structures', async () => {
+  it('handles nested object structures', () => {
     const nestedChildren = {
       header: { text: 'Title' },
       content: {
@@ -121,7 +121,7 @@ describe('children', () => {
       }
     }
 
-    const result = await setChildren(nestedChildren, element, node)
+    const result = setChildren(nestedChildren, element, node)
     expect(result).toEqual({
       tag: 'fragment',
       0: { text: 'Title' },
@@ -129,24 +129,20 @@ describe('children', () => {
     })
   })
 
-  it('handles empty arrays and objects', async () => {
-    let result = await setChildren([], element, node)
+  it('handles empty arrays and objects', () => {
+    let result = setChildren([], element, node)
     expect(result).toEqual({
       tag: 'fragment'
     })
 
-    result = await setChildren({}, element, node)
+    result = setChildren({}, element, node)
     expect(result).toEqual({
       tag: 'fragment'
     })
   })
 
-  it('handles falsy values in arrays', async () => {
-    const result = await setChildren(
-      [null, undefined, false, 0, ''],
-      element,
-      node
-    )
+  it('handles falsy values in arrays', () => {
+    const result = setChildren([null, undefined, false, 0, ''], element, node)
     expect(result).toEqual({
       tag: 'fragment',
       3: { text: 0 },
@@ -154,7 +150,7 @@ describe('children', () => {
     })
   })
 
-  it('handles React components with falsy values in array', async () => {
+  it('handles React components with falsy values in array', () => {
     const mixedChildren = [
       null,
       { $$typeof: Symbol('react') },
@@ -163,7 +159,7 @@ describe('children', () => {
       false
     ]
 
-    await setChildren(mixedChildren, element, node)
+    setChildren(mixedChildren, element, node)
 
     expect(element.call).toHaveBeenCalledWith(
       'renderReact',
@@ -172,7 +168,7 @@ describe('children', () => {
     )
   })
 
-  it('handles nested state parsing', async () => {
+  it('handles nested state parsing', () => {
     element.state = {
       nested: {
         items: ['c', 'd']
@@ -180,20 +176,20 @@ describe('children', () => {
     }
     element.state.nested.__proto__.parse = () => ['parsed c', 'parsed d']
 
-    const result = await setChildren('nested', element, node)
+    const result = setChildren('nested', element, node)
     expect(result).toEqual({
       tag: 'fragment',
       0: { state: ['c', 'd'] }
     })
   })
 
-  it('handles mixed state and regular objects', async () => {
+  it('handles mixed state and regular objects', () => {
     element.state = {
       header: { parse: () => 'Header' },
       footer: { parse: () => 'Footer' }
     }
 
-    const result = await setChildren(
+    const result = setChildren(
       {
         header: 'header',
         content: { text: 'Content' },

package/__tests__/inheritStateUpdates.test.js

@@ -28,52 +28,52 @@ describe('update() with inheritStateUpdates', () => {
   })
 
   // Test 1: Continue update when state inheritance succeeds
-  it('processes full update flow when state is inherited', async () => {
-    await update.call(element, { props: { newProp: true } }, options)
+  it('processes full update flow when state is inherited', () => {
+    update.call(element, { props: { newProp: true } }, options)
     expect(element.props.newProp).toBe(true)
     expect(element.state.baseState).toBe(true) // Inherited from parent
   })
 
   // Test 2: Preserve existing state when inheritance blocked
-  it('maintains state when preventInheritedStateUpdate=true', async () => {
+  it('maintains state when preventInheritedStateUpdate=true', () => {
     options.preventInheritedStateUpdate = true
     element.state = { existing: 'state' }
 
-    await update.call(element, {}, options)
+    update.call(element, {}, options)
     expect(element.state).toEqual({ baseState: true })
   })
 
   // Test 3: Execute state functions when forced
-  it('overwrites state with function result', async () => {
+  it('overwrites state with function result', () => {
     element.__ref.__state = () => ({ calculated: 42 })
     options.execStateFunction = true
     options.stateFunctionOverwrite = true
 
-    await update.call(element, {}, options)
+    update.call(element, {}, options)
     expect(element.state.calculated).toEqual(42)
   })
 
   // Test 4: Block updates via beforeStateUpdate event
-  it('preserves state when beforeStateUpdate rejects', async () => {
+  it('preserves state when beforeStateUpdate rejects', () => {
     element.onBeforeStateUpdate = () => false
-    await update.call(element, { props: { shouldChange: true } }, options)
+    update.call(element, { props: { shouldChange: true } }, options)
     expect(element.state).toEqual({ baseState: true })
     expect(element.props.shouldChange).toBe(true)
   })
 
   // Test 5: Handle parent state changes
-  it('reflects parent state updates', async () => {
+  it('reflects parent state updates', () => {
     element.parent.state = { updatedParentState: true }
-    await update.call(element, {}, options)
+    update.call(element, {}, options)
     expect(element.state.updatedParentState).toBe(true)
   })
 
   // Test 6: Maintain local state when root state exists
-  it('preserves local state when __hasRootState=true', async () => {
+  it('preserves local state when __hasRootState=true', () => {
     element.__ref.__hasRootState = true
     element.state = { local: 'data' }
 
-    await update.call(element, {}, options)
+    update.call(element, {}, options)
     expect(element.state.local).toBe('data')
   })
 })

package/__tests__/renderElement.test.js

@@ -33,7 +33,7 @@ describe('create()', () => {
     props.__ref.__skipCreate = true
     props.scope = undefined
     const { create } = await import('../create')
-    await create(props, parent, 'passedKey', {
+    create(props, parent, 'passedKey', {
       onlyResolveExtends: true,
       define: ['test']
     })
@@ -45,7 +45,7 @@ describe('create()', () => {
     props.__ref.__if = true
     props.scope = 'state'
     const { create } = await import('../create')
-    await create(props, parent, 'passedKey', {
+    create(props, parent, 'passedKey', {
       onlyResolveExtends: true,
       define: ['test']
     })
@@ -57,7 +57,7 @@ describe('create()', () => {
     process.env.NODE_ENV = 'prod'
     props.__ref = undefined
     const { create } = await import('../create')
-    await create(props, parent, 'passedKey', { onlyResolveExtends: true })
+    create(props, parent, 'passedKey', { onlyResolveExtends: true })
     expect(parent.__ref).toBeUndefined()
     expect(parent.passedKey).toBe(props.__ref.parent.passedKey)
   })
@@ -66,7 +66,7 @@ describe('create()', () => {
     process.env.NODE_ENV = 'prod'
     props.__ref = undefined
     const { create } = await import('../create')
-    await create(props, parent, 'passedKey')
+    create(props, parent, 'passedKey')
     expect(parent.__ref).toBeUndefined()
     expect(parent.passedKey).toBe(props.__ref.parent.passedKey)
   })
@@ -74,7 +74,7 @@ describe('create()', () => {
   test('should attaches element to parent when ref.__if is false', async () => {
     process.env.NODE_ENV = 'prod'
     const { create } = await import('../create')
-    await create(props, parent, 'passedKey')
+    create(props, parent, 'passedKey')
     expect(parent.__ref).toBeUndefined()
     expect(parent.passedKey).toBe(props.__ref.parent.passedKey)
   })
@@ -83,7 +83,7 @@ describe('create()', () => {
     process.env.NODE_ENV = 'prod'
     props.__if = true
     const { create } = await import('../create')
-    await create(props, parent, 'passedKey')
+    create(props, parent, 'passedKey')
     expect(parent.testKey).toBe('parentTestKey')
     expect(parent.passedKey).toBe(props.__ref.parent.passedKey)
   })
@@ -92,7 +92,7 @@ describe('create()', () => {
     process.env.NODE_ENV = 'prod'
     props.__ref = { __uniqId: 'existing-id', path: [] }
     const { create } = await import('../create')
-    await create(props, {}, 'passedKey')
+    create(props, {}, 'passedKey')
     expect(props.__ref.__uniqId).toBeDefined()
   })
 
@@ -100,7 +100,7 @@ describe('create()', () => {
     process.env.NODE_ENV = 'prod'
     props.__ref = { path: ['loop-path'], __uniqId: undefined }
     const { create } = await import('../create')
-    await create(props, {}, 'passedKey')
+    create(props, {}, 'passedKey')
     expect(props.__ref.__uniqId).toBeDefined()
   })
 
@@ -108,7 +108,7 @@ describe('create()', () => {
     process.env.NODE_ENV = 'prod'
     props.__ref = { path: ['ComponentsGrid', 'x', 'y', 'z'] }
     const { create } = await import('../create')
-    await create(props, {}, ['ComponentsGrid', 'x', 'y', 'z'])
+    create(props, {}, ['ComponentsGrid', 'x', 'y', 'z'])
     expect(props.__ref.path).toEqual(['ComponentsGrid,x,y,z'])
   })
 
@@ -116,7 +116,7 @@ describe('create()', () => {
     process.env.NODE_ENV = 'prod'
     props.__ref = { path: ['demoComponent', 'a', 'b', 'c'] }
     const { create } = await import('../create')
-    await create(props, {}, ['demoComponent', 'a', 'b', 'c'])
+    create(props, {}, ['demoComponent', 'a', 'b', 'c'])
     expect(props.__ref.path).toEqual(['demoComponent,a,b,c'])
   })
 
@@ -125,7 +125,7 @@ describe('create()', () => {
     props.__ref = { __if: false, path: [] }
     props.key = 'fallbackKey'
     const { create } = await import('../create')
-    await create(props, parent, null)
+    create(props, parent, null)
     expect(props.__ref.parent.fallbackKey).toBeDefined()
   })
 })

package/__tests__/resetElement.test.js

@@ -15,15 +15,15 @@ describe('resetContent', () => {
     }
   })
 
-  it('should update contentElementKey from options', async () => {
-    await resetContent({}, element, { contentElementKey: 'mainContent' })
+  it('should update contentElementKey from options', () => {
+    resetContent({}, element, { contentElementKey: 'mainContent' })
 
     expect(ref.contentElementKey).toBe('mainContent')
     expect(element.mainContent).toBeDefined()
   })
 
-  it('should merge options correctly', async () => {
-    await resetContent({}, element, { customOption: true })
+  it('should merge options correctly', () => {
+    resetContent({}, element, { customOption: true })
 
     expect(element.content).toEqual(
       expect.objectContaining({
@@ -33,10 +33,10 @@ describe('resetContent', () => {
     )
   })
 
-  it('should maintain context through reset', async () => {
+  it('should maintain context through reset', () => {
     const originalContext = element.context
 
-    await resetContent({}, element, {})
+    resetContent({}, element, {})
 
     expect(element.context).toBe(originalContext)
     expect(element.content.context).toBe(originalContext)