@domql/element 3.0.7 → 3.1.1

package/__tests__/inheritStateUpdates.test.js

@@ -55,7 +55,7 @@ describe('update() with inheritStateUpdates', () => {
 
   // Test 4: Block updates via beforeStateUpdate event
   it('preserves state when beforeStateUpdate rejects', async () => {
-    element.props.onBeforeStateUpdate = () => false
+    element.onBeforeStateUpdate = () => false
     await update.call(element, { props: { shouldChange: true } }, options)
     expect(element.state).toEqual({ baseState: true })
     expect(element.props.shouldChange).toBe(true)

package/__tests__/throughExecProps.test.js

@@ -15,11 +15,11 @@ describe('throughExecProps', () => {
     }
   })
 
-  it('should cache and execute define-prefixed function props', () => {
+  it('should cache and execute define-prefixed function props', async () => {
     element.props.isActive = () => true
     element.props.hasFeature = (el, state) => state.test === 'state'
 
-    throughExecProps(element)
+    await 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', () => {
+  it('should execute cached functions from previous runs', async () => {
     ref.__execProps.value = () => 'cached'
     element.props.value = 'current'
 
-    throughExecProps(element)
+    await throughExecProps(element)
 
     expect(element.props.value).toBe('cached')
   })
 
-  it('should leave non-function props unchanged', () => {
+  it('should leave non-function props unchanged', async () => {
     element.props.title = 'static text'
     element.props.disabled = false
 
-    throughExecProps(element)
+    await 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', () => {
+  it('should handle mixed define-prefixed and regular props', async () => {
     element.props.useHelper = () => 'helper'
     element.props.color = 'blue'
 
-    throughExecProps(element)
+    await 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', () => {
+  it('should preserve existing cache entries', async () => {
     ref.__execProps.existing = () => 'prior'
     element.props.existing = 'new'
 
-    throughExecProps(element)
+    await throughExecProps(element)
 
     expect(element.props.existing).toBe('prior')
     expect(ref.__execProps.existing).toBeInstanceOf(Function)
   })
 
-  it('should pass correct execution context', () => {
+  it('should pass correct execution context', async () => {
     element.props.checkContext = function (el, state, context) {
       return (
         this === element &&
@@ -79,7 +79,7 @@ describe('throughExecProps', () => {
       )
     }
 
-    throughExecProps(element)
+    await 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', () => {
+  it('should merge local and global define objects', async () => {
     element.define = { localProp: () => 'local' }
     element.context.define = { globalProp: () => 'global' }
 
-    throughInitialDefine(element)
+    await throughInitialDefine(element)
 
     expect(element.localProp).toBe('local')
     expect(element.globalProp).toBe('global')
   })
 
-  it('should cache and execute define functions', () => {
+  it('should cache and execute define functions', async () => {
     element.define.testProp = value => 'defined value'
     element.testProp = () => 'initial value'
 
-    throughInitialDefine(element)
+    await 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', () => {
+  it('should skip execution for method properties', async () => {
     element.define.update = value => 'should not execute'
     element.update = () => 'built-in method'
 
-    throughInitialDefine(element)
+    await throughInitialDefine(element)
 
     expect(ref.__exec).not.toHaveProperty('update')
     expect(ref.__defineCache).not.toHaveProperty('update')
   })
 
-  it('should handle parse method in execution result', () => {
+  it('should handle parse method in execution result', async () => {
     element.define.testProp = () => ({ parse: () => 'parsed value' })
     element.testProp = () => 'initial value'
 
-    throughInitialDefine(element)
+    await throughInitialDefine(element)
 
     expect(ref.__defineCache.testProp).toBe('initial value')
   })
 
-  it('should pass correct arguments to define functions', () => {
+  it('should pass correct arguments to define functions', async () => {
     element.define.testProp = (value, el, state, context) => ({
       valueMatch: value === 'initial value',
       elMatch: el === element,
@@ -65,7 +65,7 @@ describe('throughInitialDefine', () => {
     })
     element.testProp = 'initial value'
 
-    throughInitialDefine(element)
+    await throughInitialDefine(element)
 
     expect(element.testProp).toEqual({
       valueMatch: true,
@@ -75,17 +75,17 @@ describe('throughInitialDefine', () => {
     })
   })
 
-  it('should handle non-function element properties', () => {
+  it('should handle non-function element properties', async () => {
     element.define.testProp = value => 'defined value'
     element.testProp = 'non-function value'
 
-    throughInitialDefine(element)
+    await throughInitialDefine(element)
 
     expect(element.testProp).toBe('defined value')
   })
 
-  it('should handle empty define objects', () => {
-    throughInitialDefine(element)
+  it('should handle empty define objects', async () => {
+    await throughInitialDefine(element)
 
     expect(element).toEqual({
       ...element,
@@ -93,11 +93,11 @@ describe('throughInitialDefine', () => {
     })
   })
 
-  it('should handle null or undefined define properties', () => {
+  it('should handle null or undefined define properties', async () => {
     element.define.testProp = () => null
     element.testProp = 'initial value'
 
-    throughInitialDefine(element)
+    await 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', () => {
-    throughInitialExec(element)
+  it('should process non-method functions and update element properties', async () => {
+    await throughInitialExec(element)
 
     expect(element.customFn).toBe('executed')
     expect(ref.__exec.customFn).toBeInstanceOf(Function)
   })
 
-  it('should skip excluded parameters', () => {
+  it('should skip excluded parameters', async () => {
     element.excludedFn = () => 'should not execute'
-    throughInitialExec(element, { excludedFn: true })
+    await throughInitialExec(element, { excludedFn: true })
 
     expect(element.excludedFn).toBeInstanceOf(Function)
     expect(ref.__exec).not.toHaveProperty('excludedFn')
   })
 
-  it('should skip methods from METHODS array', () => {
+  it('should skip methods from METHODS array', async () => {
     element.update = () => 'built-in method'
-    throughInitialExec(element)
+    await throughInitialExec(element)
 
     expect(element.update).toBeInstanceOf(Function)
     expect(ref.__exec).not.toHaveProperty('update')
   })
 
-  it('should skip methods from context.methods', () => {
+  it('should skip methods from context.methods', async () => {
     element.context.methods = { contextMethod: true }
     element.contextMethod = () => 'context method'
-    throughInitialExec(element)
+    await throughInitialExec(element)
 
     expect(element.contextMethod).toBeInstanceOf(Function)
     expect(ref.__exec).not.toHaveProperty('contextMethod')
   })
 
-  it('should leave non-function properties unchanged', () => {
+  it('should leave non-function properties unchanged', async () => {
     element.stringProp = 'text'
-    throughInitialExec(element)
+    await throughInitialExec(element)
 
     expect(element.stringProp).toBe('text')
     expect(ref.__exec).not.toHaveProperty('stringProp')
   })
 
-  it('should store original functions in __exec', () => {
+  it('should store original functions in __exec', async () => {
     const originalFn = () => 'original'
     element.testFn = originalFn
-    throughInitialExec(element)
+    await throughInitialExec(element)
 
     expect(ref.__exec.testFn).toBe(originalFn)
     expect(element.testFn).toBe('original')
   })
 
-  it('should execute functions with correct arguments', () => {
+  it('should execute functions with correct arguments', async () => {
     element.argChecker = (el, state, context) => ({
       elIsElement: el === element,
       stateMatch: state === element.state,
       contextMatch: context === element.context
     })
 
-    throughInitialExec(element)
+    await throughInitialExec(element)
 
     expect(element.argChecker).toEqual({
       elIsElement: true,
@@ -79,10 +79,10 @@ describe('throughInitialExec', () => {
     })
   })
 
-  it('should handle empty exclude object', () => {
+  it('should handle empty exclude object', async () => {
     element.fn1 = () => 'one'
     element.fn2 = () => 'two'
-    throughInitialExec(element, {})
+    await 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', () => {
+  it('should merge local and global define objects', async () => {
     element.define = { localProp: () => 'local' }
     element.context.define = { globalProp: () => 'global' }
 
-    throughUpdatedDefine(element)
+    await throughUpdatedDefine(element)
 
     expect(element.localProp).toBe('local')
     expect(element.globalProp).toBe('global')
   })
 
-  it('should update element properties using cached exec functions', () => {
+  it('should update element properties using cached exec functions', async () => {
     ref.__exec.testProp = () => 'cached value'
     element.define.testProp = cached => `updated ${cached}`
 
-    throughUpdatedDefine(element)
+    await throughUpdatedDefine(element)
 
     expect(element.testProp).toBe('updated cached value')
     expect(ref.__defineCache.testProp).toBe('cached value')
   })
 
-  it('should handle non-function cached values', () => {
+  it('should handle non-function cached values', async () => {
     ref.__defineCache.testProp = 'static value'
     element.define.testProp = cached => `updated ${cached}`
 
-    throughUpdatedDefine(element)
+    await throughUpdatedDefine(element)
 
     expect(element.testProp).toBe('updated static value')
   })
 
-  it('should skip updates for undefined or null results', () => {
+  it('should skip updates for undefined or null results', async () => {
     ref.__exec.testProp = () => 'cached value'
     element.define.testProp = () => null
     element.testProp = 'original value'
 
-    throughUpdatedDefine(element)
+    await throughUpdatedDefine(element)
 
     expect(element.testProp).toBe('original value')
   })
 
-  it('should handle empty define objects', () => {
+  it('should handle empty define objects', async () => {
     const originalElement = { ...element }
 
-    throughUpdatedDefine(element)
+    await throughUpdatedDefine(element)
 
     expect(element).toEqual(originalElement)
   })
 
-  it('should pass correct arguments to define functions', () => {
+  it('should pass correct arguments to define functions', async () => {
     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'
 
-    throughUpdatedDefine(element)
+    await throughUpdatedDefine(element)
 
     expect(element.testProp).toEqual({
       cachedMatch: true,
@@ -82,10 +82,10 @@ describe('throughUpdatedDefine', () => {
     })
   })
 
-  it('should return an empty changes object', () => {
+  it('should return an empty changes object', async () => {
     element.define.testProp = () => 'updated value'
 
-    const changes = throughUpdatedDefine(element)
+    const changes = await throughUpdatedDefine(element)
 
     expect(changes).toEqual({})
   })

package/__tests__/update.test.js

@@ -6,9 +6,11 @@ describe('update()', () => {
   beforeEach(() => {
     element = {
       __ref: {
+        __if: true,
         __execProps: {},
         __exec: {},
         __defineCache: {},
+        __propsStack: [],
         __props: [],
         __state: 'state'
       },
@@ -17,6 +19,7 @@ describe('update()', () => {
       parent: {
         props: {}
       },
+      context: {},
       define: {},
       node: document.createElement('div'),
       key: 'testElement',
@@ -233,21 +236,21 @@ describe('update()', () => {
     expect(element.props.shouldExist).toBeUndefined()
   })
 
-  it('returns element when beforeUpdate rejects', async () => {
-    // Simulate beforeUpdate rejection
-    element.props.onBeforeUpdate = () => false
-    const result = await element.update({}, opts)
-    expect(result).toBe(element)
-  })
-
   it('processes parent.childProps', async () => {
     element.parent.props.childProps = { global: true }
     await element.update({}, opts)
-    expect(element.props.global).toBeUndefined()
+    expect(element.props.global).toBe(true)
   })
 
   it('processes function props', async () => {
     await element.update({ props: { calc: () => 42 } }, opts)
     expect(element.props.calc()).toBe(42)
   })
+
+  it('returns element when beforeUpdate rejects', async () => {
+    // Simulate beforeUpdate rejection
+    element.on.beforeUpdate = () => false
+    const result = await element.update({}, opts)
+    expect(result).toBe(element)
+  })
 })

package/create.js

@@ -51,7 +51,7 @@ export const create = async (
 
   applyExtends(element, parent, options)
 
-  propertizeElement(element, parent)
+  propertizeElement.call(element, element)
 
   await triggerEventOn('start', element, options)
 
@@ -167,15 +167,6 @@ const renderElement = async (element, parent, options, attachOptions) => {
       if (element.on?.error) {
         element.on.error(e, element, element.state, element.context, options)
       }
-      if (element.props?.onError) {
-        element.props.onError(
-          e,
-          element,
-          element.state,
-          element.context,
-          options
-        )
-      }
     }
   }
 

package/dist/cjs/__tests__/checkIfOnUpdate.test.js

@@ -0,0 +1,73 @@
+var import_update = require("../update");
+describe("checkIfOnUpdate via update()", () => {
+  let element, parent, options;
+  beforeEach(() => {
+    parent = {
+      node: document.createElement("div"),
+      props: {},
+      state: {}
+    };
+    element = {
+      __ref: {
+        __if: void 0,
+        __state: null,
+        __hasRootState: false,
+        __execProps: {},
+        contentElementKey: "content"
+      },
+      parent,
+      props: {},
+      state: {
+        update: (el, st) => {
+          return st;
+        }
+      },
+      context: {
+        defaultExtends: {}
+      },
+      node: document.createElement("div"),
+      if: () => true,
+      previousElement: () => {
+        return {};
+      },
+      nextElement: () => {
+        return {};
+      },
+      removeContent: () => {
+        return true;
+      }
+    };
+    options = {};
+  });
+  it("uses props.if when element.if missing", async () => {
+    delete element.if;
+    element.props.if = () => false;
+    await import_update.update.call(element, {}, options);
+    expect(element.node).toEqual(document.createElement("div"));
+  });
+  it("retains state when __hasRootState=true", async () => {
+    element.__ref.__hasRootState = true;
+    element.state.critical = true;
+    element.__ref.__if = false;
+    await import_update.update.call(element, {}, options);
+    expect(element.state.critical).toBe(true);
+    expect(element.state.preserved).toBeUndefined();
+  });
+  it("processes nested content with parseDeep", async () => {
+    element.content = {
+      parseDeep: () => ({ parsed: true }),
+      existing: "data"
+    };
+    await import_update.update.call(element, {}, options);
+    expect(element.content.parsed).toBe(true);
+    expect(element.content.existing).toBeUndefined();
+  });
+  it("reattaches after previous sibling", async () => {
+    const prevNode = document.createElement("span");
+    parent.node.appendChild(prevNode);
+    await import_update.update.call(element, {}, options);
+    const newElement = parent.node.children[0];
+    expect(newElement).toEqual(document.createElement("span"));
+    expect(newElement.previousSibling).toBe(null);
+  });
+});