@domql/element 3.2.3 → 3.2.7

package/__tests__/children.test.js

@@ -1,209 +0,0 @@
-import { jest } from '@jest/globals'
-import { setChildren } from '../children'
-
-describe('children', () => {
-  let element, node
-
-  beforeEach(() => {
-    element = {
-      __ref: {},
-      state: {},
-      props: {},
-      call: jest.fn(),
-      removeContent: jest.fn(),
-      content: null
-    }
-    node = {}
-  })
-
-  it('handles null/undefined params', () => {
-    const result = setChildren(null, element, node)
-    expect(result).toBeUndefined()
-  })
-
-  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', () => {
-    const result = setChildren(42, element, node)
-    expect(result).toEqual({ tag: 'fragment', 0: { text: 42 } })
-  })
-
-  it('handles array of primitive values with childrenAs prop', () => {
-    const result = setChildren(['one', 'two'], element, node)
-
-    expect(result).toEqual({
-      tag: 'fragment',
-      0: { text: 'one' },
-      1: { text: 'two' }
-    })
-  })
-
-  it('handles array of primitive values with childrenAs state', () => {
-    element.props.childrenAs = 'state'
-    const result = setChildren(['one', 'two'], element, node)
-
-    expect(result).toEqual({
-      tag: 'fragment',
-      0: { state: { value: 'one' } },
-      1: { state: { value: 'two' } }
-    })
-  })
-
-  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
-    setChildren(children1, element, node)
-    expect(element.__ref.__childrenCache).toEqual(children1)
-    expect(element.__ref.__noChildrenDifference).toBeUndefined()
-
-    // Same content, different reference
-    setChildren(children2, element, node)
-    expect(element.__ref.__noChildrenDifference).toBe(true)
-
-    // Different content
-    setChildren(children3, element, node)
-    expect(element.__ref.__noChildrenDifference).toBeUndefined()
-    expect(element.__ref.__childrenCache).toEqual(children3)
-  })
-
-  it('handles mixed React and normal components', () => {
-    const mixedChildren = [
-      { type: 'div', text: 'Normal' },
-      { $$typeof: Symbol('react') },
-      { type: 'span', text: 'Another' }
-    ]
-
-    setChildren(mixedChildren, element, node)
-
-    expect(element.call).toHaveBeenCalledWith(
-      'renderReact',
-      [mixedChildren[1]],
-      element
-    )
-  })
-
-  it('handles state-based children', () => {
-    element.state = {
-      items: ['a', 'b'],
-      parse: () => ['parsed a', 'parsed b']
-    }
-
-    const result = setChildren('state', element, node)
-    expect(result).toEqual({
-      tag: 'fragment',
-      0: { text: 'parsed a' },
-      1: { text: 'parsed b' }
-    })
-  })
-
-  it('handles async function parameters', () => {
-    const asyncParam = () => ['async1', 'async2']
-    const result = setChildren(asyncParam, element, node)
-
-    expect(result).toEqual({
-      tag: 'fragment',
-      0: { text: 'async1' },
-      1: { text: 'async2' }
-    })
-  })
-
-  it('handles nested object structures', () => {
-    const nestedChildren = {
-      header: { text: 'Title' },
-      content: {
-        nested: { text: 'Content' }
-      }
-    }
-
-    const result = setChildren(nestedChildren, element, node)
-    expect(result).toEqual({
-      tag: 'fragment',
-      0: { text: 'Title' },
-      1: { nested: { text: 'Content' } }
-    })
-  })
-
-  it('handles empty arrays and objects', () => {
-    let result = setChildren([], element, node)
-    expect(result).toEqual({
-      tag: 'fragment'
-    })
-
-    result = setChildren({}, element, node)
-    expect(result).toEqual({
-      tag: 'fragment'
-    })
-  })
-
-  it('handles falsy values in arrays', () => {
-    const result = setChildren([null, undefined, false, 0, ''], element, node)
-    expect(result).toEqual({
-      tag: 'fragment',
-      3: { text: 0 },
-      4: { text: '' }
-    })
-  })
-
-  it('handles React components with falsy values in array', () => {
-    const mixedChildren = [
-      null,
-      { $$typeof: Symbol('react') },
-      undefined,
-      { $$typeof: Symbol('react') },
-      false
-    ]
-
-    setChildren(mixedChildren, element, node)
-
-    expect(element.call).toHaveBeenCalledWith(
-      'renderReact',
-      [mixedChildren[1], mixedChildren[3]],
-      element
-    )
-  })
-
-  it('handles nested state parsing', () => {
-    element.state = {
-      nested: {
-        items: ['c', 'd']
-      }
-    }
-    element.state.nested.__proto__.parse = () => ['parsed c', 'parsed d']
-
-    const result = setChildren('nested', element, node)
-    expect(result).toEqual({
-      tag: 'fragment',
-      0: { state: ['c', 'd'] }
-    })
-  })
-
-  it('handles mixed state and regular objects', () => {
-    element.state = {
-      header: { parse: () => 'Header' },
-      footer: { parse: () => 'Footer' }
-    }
-
-    const result = setChildren(
-      {
-        header: 'header',
-        content: { text: 'Content' },
-        footer: 'footer'
-      },
-      element,
-      node
-    )
-
-    expect(result).toEqual({
-      tag: 'fragment',
-      0: { text: 'header' },
-      1: { text: 'Content' },
-      2: { text: 'footer' }
-    })
-  })
-})

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', () => {
-    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', () => {
-    options.preventInheritedStateUpdate = true
-    element.state = { existing: 'state' }
-
-    update.call(element, {}, options)
-    expect(element.state).toEqual({ baseState: true })
-  })
-
-  // Test 3: Execute state functions when forced
-  it('overwrites state with function result', () => {
-    element.__ref.__state = () => ({ calculated: 42 })
-    options.execStateFunction = true
-    options.stateFunctionOverwrite = true
-
-    update.call(element, {}, options)
-    expect(element.state.calculated).toEqual(42)
-  })
-
-  // Test 4: Block updates via beforeStateUpdate event
-  it('preserves state when beforeStateUpdate rejects', () => {
-    element.onBeforeStateUpdate = () => false
-    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', () => {
-    element.parent.state = { updatedParentState: true }
-    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', () => {
-    element.__ref.__hasRootState = true
-    element.state = { local: 'data' }
-
-    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')
-    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')
-    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')
-    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')
-    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')
-    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')
-    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')
-    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')
-    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')
-    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')
-    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')
-    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', () => {
-    resetContent({}, element, { contentElementKey: 'mainContent' })
-
-    expect(ref.contentElementKey).toBe('mainContent')
-    expect(element.mainContent).toBeDefined()
-  })
-
-  it('should merge options correctly', () => {
-    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', () => {
-    const originalContext = element.context
-
-    resetContent({}, element, {})
-
-    expect(element.context).toBe(originalContext)
-    expect(element.content.context).toBe(originalContext)
-  })
-})