@domql/element 3.1.2 → 3.2.7

package/__tests__/define.test.js

@@ -1,75 +0,0 @@
-import define from '../define'
-import { REGISTRY } from '../mixins'
-
-describe('default function (registry updater)', () => {
-  let originalRegistry
-
-  beforeEach(() => {
-    // Save the original REGISTRY to restore after each test
-    originalRegistry = { ...REGISTRY }
-  })
-
-  afterEach(() => {
-    // Restore the original REGISTRY after each test
-    Object.keys(REGISTRY).forEach(key => {
-      REGISTRY[key] = originalRegistry[key]
-    })
-  })
-
-  it('should add new params to REGISTRY when overwrite is true', () => {
-    const params = { newKey: 'newValue', anotherKey: 'anotherValue' }
-    const options = { overwrite: true }
-
-    define(params, options)
-
-    expect(REGISTRY.newKey).toBe('newValue')
-    expect(REGISTRY.anotherKey).toBe('anotherValue')
-  })
-
-  it('should not modify REGISTRY when trying to overwrite existing keys without overwrite option', () => {
-    const params = { attr: 'newValue', text: 'newText' }
-
-    try {
-      define(params)
-    } catch (e) {
-      // Ignore the error
-    }
-
-    expect(REGISTRY.attr).toBe(originalRegistry.attr)
-    expect(REGISTRY.text).toBe(originalRegistry.text)
-  })
-
-  it('should overwrite existing keys when overwrite is true', () => {
-    const params = { attr: 'newValue', text: 'newText' }
-    const options = { overwrite: true }
-
-    define(params, options)
-
-    expect(REGISTRY.attr).toBe('newValue')
-    expect(REGISTRY.text).toBe('newText')
-  })
-
-  it('should handle empty params object without errors', () => {
-    const params = {}
-    const options = { overwrite: true }
-
-    expect(() => define(params, options)).not.toThrow()
-    expect(REGISTRY).toEqual(originalRegistry)
-  })
-
-  it('should handle empty options object without errors', () => {
-    const params = { newKey: 'newValue' }
-
-    expect(() => define(params, {})).not.toThrow()
-    expect(REGISTRY.newKey).toBe('newValue')
-  })
-
-  it('should not add new keys when params is empty', () => {
-    const params = {}
-    const options = { overwrite: true }
-
-    define(params, options)
-
-    expect(REGISTRY).toEqual(originalRegistry)
-  })
-})

package/__tests__/inheritStateUpdates.test.js

@@ -1,79 +0,0 @@
-import { update } from '../update'
-
-describe('update() with inheritStateUpdates', () => {
-  let element, options
-
-  beforeEach(() => {
-    element = {
-      __ref: {
-        __state: null,
-        __hasRootState: false,
-        __execProps: {},
-        __props: []
-      },
-      state: {
-        calculated: 42,
-        set: () => {
-          return true
-        }
-      },
-      parent: {
-        state: { baseState: true },
-        props: {}
-      },
-      props: {},
-      key: 'testKey'
-    }
-    options = {}
-  })
-
-  // 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)
-    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 () => {
-    options.preventInheritedStateUpdate = true
-    element.state = { existing: 'state' }
-
-    await update.call(element, {}, options)
-    expect(element.state).toEqual({ baseState: true })
-  })
-
-  // Test 3: Execute state functions when forced
-  it('overwrites state with function result', async () => {
-    element.__ref.__state = () => ({ calculated: 42 })
-    options.execStateFunction = true
-    options.stateFunctionOverwrite = true
-
-    await update.call(element, {}, options)
-    expect(element.state.calculated).toEqual(42)
-  })
-
-  // Test 4: Block updates via beforeStateUpdate event
-  it('preserves state when beforeStateUpdate rejects', async () => {
-    element.onBeforeStateUpdate = () => false
-    await 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 () => {
-    element.parent.state = { updatedParentState: true }
-    await 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 () => {
-    element.__ref.__hasRootState = true
-    element.state = { local: 'data' }
-
-    await update.call(element, {}, options)
-    expect(element.state.local).toBe('data')
-  })
-})

package/__tests__/renderElement.test.js

@@ -1,131 +0,0 @@
-import { jest } from '@jest/globals'
-
-describe('create()', () => {
-  let props
-  let parent
-
-  const OLD_ENV = process.env
-
-  beforeEach(() => {
-    props = {
-      __ref: { __if: false, path: [], __skipCreate: true },
-      key: 'testKey',
-      context: {
-        defaultExtends: {},
-        define: ['test']
-      },
-      scope: 'props',
-      define: ['test']
-    }
-    parent = {
-      testKey: 'parentTestKey',
-      key: 'parentKey'
-    }
-    jest.resetModules()
-    process.env = { ...OLD_ENV }
-  })
-
-  afterAll(() => {
-    process.env = OLD_ENV
-  })
-
-  test('should execute onlyResolveExtends when __skipCreate is true', async () => {
-    props.__ref.__skipCreate = true
-    props.scope = undefined
-    const { create } = await import('../create')
-    await create(props, parent, 'passedKey', {
-      onlyResolveExtends: true,
-      define: ['test']
-    })
-    expect(parent.__ref).toBeUndefined()
-    expect(parent.passedKey).toBe(props.__ref.parent.passedKey)
-  })
-
-  test('should execute onlyResolveExtends when __ref.__if is true', async () => {
-    props.__ref.__if = true
-    props.scope = 'state'
-    const { create } = await import('../create')
-    await create(props, parent, 'passedKey', {
-      onlyResolveExtends: true,
-      define: ['test']
-    })
-    expect(parent.__ref).toBeUndefined()
-    expect(parent.passedKey).toBe(props.__ref.parent.passedKey)
-  })
-
-  test('should execute onlyResolveExtends when scope is not state', async () => {
-    process.env.NODE_ENV = 'prod'
-    props.__ref = undefined
-    const { create } = await import('../create')
-    await create(props, parent, 'passedKey', { onlyResolveExtends: true })
-    expect(parent.__ref).toBeUndefined()
-    expect(parent.passedKey).toBe(props.__ref.parent.passedKey)
-  })
-
-  test('should execute catch statement when __ref is undefined', async () => {
-    process.env.NODE_ENV = 'prod'
-    props.__ref = undefined
-    const { create } = await import('../create')
-    await create(props, parent, 'passedKey')
-    expect(parent.__ref).toBeUndefined()
-    expect(parent.passedKey).toBe(props.__ref.parent.passedKey)
-  })
-
-  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')
-    expect(parent.__ref).toBeUndefined()
-    expect(parent.passedKey).toBe(props.__ref.parent.passedKey)
-  })
-
-  test('should attach element to parent when ref.__if is true', async () => {
-    process.env.NODE_ENV = 'prod'
-    props.__if = true
-    const { create } = await import('../create')
-    await create(props, parent, 'passedKey')
-    expect(parent.testKey).toBe('parentTestKey')
-    expect(parent.passedKey).toBe(props.__ref.parent.passedKey)
-  })
-
-  test('skips createNestedChild when __uniqId exists', async () => {
-    process.env.NODE_ENV = 'prod'
-    props.__ref = { __uniqId: 'existing-id', path: [] }
-    const { create } = await import('../create')
-    await create(props, {}, 'passedKey')
-    expect(props.__ref.__uniqId).toBeDefined()
-  })
-
-  test('skips createNestedChild when infinite loop detected', async () => {
-    process.env.NODE_ENV = 'prod'
-    props.__ref = { path: ['loop-path'], __uniqId: undefined }
-    const { create } = await import('../create')
-    await create(props, {}, 'passedKey')
-    expect(props.__ref.__uniqId).toBeDefined()
-  })
-
-  test('should modifies path containing ComponentsGrid', async () => {
-    process.env.NODE_ENV = 'prod'
-    props.__ref = { path: ['ComponentsGrid', 'x', 'y', 'z'] }
-    const { create } = await import('../create')
-    await create(props, {}, ['ComponentsGrid', 'x', 'y', 'z'])
-    expect(props.__ref.path).toEqual(['ComponentsGrid,x,y,z'])
-  })
-
-  test('should modifies path containing demoComponent', async () => {
-    process.env.NODE_ENV = 'prod'
-    props.__ref = { path: ['demoComponent', 'a', 'b', 'c'] }
-    const { create } = await import('../create')
-    await create(props, {}, ['demoComponent', 'a', 'b', 'c'])
-    expect(props.__ref.path).toEqual(['demoComponent,a,b,c'])
-  })
-
-  test('uses element.key when key property is missing', async () => {
-    process.env.NODE_ENV = 'prod'
-    props.__ref = { __if: false, path: [] }
-    props.key = 'fallbackKey'
-    const { create } = await import('../create')
-    await create(props, parent, null)
-    expect(props.__ref.parent.fallbackKey).toBeDefined()
-  })
-})

package/__tests__/resetElement.test.js

@@ -1,44 +0,0 @@
-import { resetContent } from '../set'
-
-describe('resetContent', () => {
-  let element, ref
-
-  beforeEach(() => {
-    ref = {
-      contentElementKey: 'content'
-    }
-    element = {
-      __ref: ref,
-      content: { node: document.createElement('div') },
-      node: document.createElement('div'),
-      context: {}
-    }
-  })
-
-  it('should update contentElementKey from options', async () => {
-    await resetContent({}, element, { contentElementKey: 'mainContent' })
-
-    expect(ref.contentElementKey).toBe('mainContent')
-    expect(element.mainContent).toBeDefined()
-  })
-
-  it('should merge options correctly', async () => {
-    await resetContent({}, element, { customOption: true })
-
-    expect(element.content).toEqual(
-      expect.objectContaining({
-        // Verify options merging through observable behavior
-        // (this assertion pattern would need actual create() implementation details)
-      })
-    )
-  })
-
-  it('should maintain context through reset', async () => {
-    const originalContext = element.context
-
-    await resetContent({}, element, {})
-
-    expect(element.context).toBe(originalContext)
-    expect(element.content.context).toBe(originalContext)
-  })
-})

package/__tests__/set.test.js

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