@domql/element 3.1.2 → 3.2.7

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

package/__tests__/throughUpdatedExec.test.js

@@ -1,110 +0,0 @@
-import { throughUpdatedExec } from '../iterate'
-
-describe('throughUpdatedExec', () => {
-  let element, ref
-
-  beforeEach(() => {
-    ref = {
-      __exec: {},
-      __defineCache: {}
-    }
-    element = {
-      __ref: ref,
-      state: { testState: true },
-      context: { testContext: true }
-    }
-  })
-
-  it('should skip execution for params in __defineCache', () => {
-    ref.__defineCache.cachedParam = true
-    ref.__exec.cachedParam = () => 'should not execute'
-    element.cachedParam = 'original'
-
-    const changes = throughUpdatedExec(element)
-
-    expect(element.cachedParam).toBe('original')
-    expect(changes).toEqual({})
-  })
-
-  it('should update element properties when newExec differs from current value', () => {
-    ref.__exec.testParam = () => 'new value'
-    element.testParam = 'old value'
-
-    const changes = 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', () => {
-    const node = { node: true, text: 'old text' }
-    ref.__exec.testParam = () => 'new text'
-    element.testParam = node
-
-    const changes = throughUpdatedExec(element)
-
-    expect(element.testParam.text).toBe('new text')
-    expect(changes).toEqual({})
-  })
-
-  it('should handle component naming matches and overwrite with context component', () => {
-    const contextComponent = { extends: 'Component', prop: 'value' }
-    element.context.components = { TestComponent: contextComponent }
-    ref.__exec.TestComponent = () => contextComponent
-    element.TestComponent = { oldProp: 'oldValue' }
-
-    const changes = throughUpdatedExec(element)
-
-    expect(element.TestComponent).toEqual({
-      oldProp: 'oldValue',
-      prop: 'value'
-    })
-    expect(changes).toEqual({})
-  })
-
-  it('should not update element properties when newExec matches current value', () => {
-    ref.__exec.testParam = () => 'same value'
-    element.testParam = 'same value'
-
-    const changes = throughUpdatedExec(element)
-
-    expect(element.testParam).toBe('same value')
-    expect(changes).toEqual({})
-  })
-
-  it('should handle non-string/non-number exec returns for non-node properties', () => {
-    const newValue = { complex: 'object' }
-    ref.__exec.testParam = () => newValue
-    element.testParam = 'old value'
-
-    const changes = throughUpdatedExec(element)
-
-    expect(element.testParam).toBe(newValue)
-    expect(changes).toEqual({ testParam: 'old value' })
-  })
-
-  it('should return an empty changes object when no updates occur', () => {
-    ref.__exec.testParam = () => 'same value'
-    element.testParam = 'same value'
-
-    const changes = throughUpdatedExec(element)
-
-    expect(changes).toEqual({})
-  })
-
-  it('should handle multiple properties and return correct changes', () => {
-    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)
-
-    expect(element.param1).toBe('new value 1')
-    expect(element.param2).toBe('new value 2')
-    expect(changes).toEqual({
-      param1: 'old value 1',
-      param2: 'old value 2'
-    })
-  })
-})

package/__tests__/tree.test.js

@@ -1,15 +0,0 @@
-import { ROOT, TREE } from '../tree'
-
-describe('ROOT/TREE initialization and report()', () => {
-  // Test 1: ROOT object structure
-  it('initializes ROOT with :root key and document.body node', () => {
-    expect(ROOT.key).toBe(':root')
-    expect(ROOT.node).toBe(document.body) // Works in JSDOM
-  })
-
-  // Test 2: TREE === ROOT
-  it('assigns TREE to reference ROOT', () => {
-    expect(TREE).toBe(ROOT)
-    expect(TREE.node).toBe(document.body)
-  })
-})