@pyreon/ui-core 0.24.4 → 0.24.6

package/src/__tests__/config.test.ts

@@ -1,102 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest'
-import config, { init } from '../config'
-
-describe('Configuration', () => {
-  it('has default component as div', () => {
-    expect(config.component).toBe('div')
-  })
-
-  it('has default textComponent as span', () => {
-    expect(config.textComponent).toBe('span')
-  })
-
-  it('has css function', () => {
-    expect(config.css).toBeDefined()
-    expect(typeof config.css).toBe('function')
-  })
-
-  it('has styled function', () => {
-    expect(config.styled).toBeDefined()
-    expect(typeof config.styled).toBe('function')
-  })
-
-  it('has keyframes function', () => {
-    expect(config.keyframes).toBeDefined()
-    expect(typeof config.keyframes).toBe('function')
-  })
-
-  describe('init', () => {
-    const originalCss = config.css
-    const originalStyled = config.styled
-    const originalKeyframes = config.keyframes
-    const originalComponent = config.component
-    const originalTextComponent = config.textComponent
-    const originalCreateMediaQueries = config.createMediaQueries
-
-    afterEach(() => {
-      // restore defaults
-      config.css = originalCss
-      config.styled = originalStyled
-      config.keyframes = originalKeyframes
-      config.component = originalComponent
-      config.textComponent = originalTextComponent
-      config.createMediaQueries = originalCreateMediaQueries
-    })
-
-    it('updates css engine', () => {
-      const mockCss = (() => '') as any
-      init({ css: mockCss })
-      expect(config.css).toBe(mockCss)
-    })
-
-    it('updates styled engine', () => {
-      const mockStyled = (() => '') as any
-      init({ styled: mockStyled })
-      expect(config.styled).toBe(mockStyled)
-    })
-
-    it('updates component', () => {
-      init({ component: 'section' })
-      expect(config.component).toBe('section')
-    })
-
-    it('updates textComponent', () => {
-      init({ textComponent: 'p' })
-      expect(config.textComponent).toBe('p')
-    })
-
-    it('updates keyframes', () => {
-      const mockKeyframes = (() => 'anim') as any
-      init({ keyframes: mockKeyframes })
-      expect(config.keyframes).toBe(mockKeyframes)
-    })
-
-    it('updates createMediaQueries', () => {
-      const mockCreateMQ = (() => ({})) as any
-      init({ createMediaQueries: mockCreateMQ })
-      expect(config.createMediaQueries).toBe(mockCreateMQ)
-    })
-
-    it('only updates provided fields', () => {
-      init({ component: 'article' })
-      expect(config.component).toBe('article')
-      expect(config.textComponent).toBe('span')
-      expect(config.css).toBe(originalCss)
-    })
-
-    it('does nothing with empty object', () => {
-      init({})
-      expect(config.component).toBe('div')
-      expect(config.textComponent).toBe('span')
-    })
-
-    it('can be called multiple times to swap engine', () => {
-      const first = (() => 'first') as any
-      const second = (() => 'second') as any
-      init({ css: first })
-      expect(config.css).toBe(first)
-      init({ css: second })
-      expect(config.css).toBe(second)
-    })
-  })
-})

package/src/__tests__/context.test.tsx

@@ -1,71 +0,0 @@
-import { popContext, useContext } from '@pyreon/core'
-import { afterEach, describe, expect, it } from 'vitest'
-import Provider, { context } from '../context'
-
-describe('Provider', () => {
-  afterEach(() => {
-    // Clean up any pushed context frames
-    try {
-      popContext()
-    } catch {
-      // Ignore if no context was pushed
-    }
-  })
-
-  it('returns children when no theme is provided', () => {
-    const children = 'Hello'
-    const result = Provider({ children })
-    expect(result).toBe('Hello')
-  })
-
-  it('returns children with empty theme', () => {
-    const children = 'Hello'
-    const result = Provider({ theme: {}, children })
-    expect(result).toBe('Hello')
-  })
-
-  it('returns children with null theme', () => {
-    const children = 'Hello'
-    // @ts-expect-error testing null theme
-    const result = Provider({ theme: null, children })
-    expect(result).toBe('Hello')
-  })
-
-  it('returns children when theme is provided and pushes context', () => {
-    const theme = { rootSize: 16, breakpoints: { xs: 0 } }
-    const children = 'Styled'
-    const result = Provider({ theme, children })
-    expect(result).toBe('Styled')
-  })
-
-  it('pushes context with theme and extra props', () => {
-    const theme = { rootSize: 16 }
-    const children = 'Content'
-    Provider({ theme, children, custom: 'value' })
-    // After Provider runs, context should have been pushed
-    // Context is ReactiveContext — useContext returns () => value
-    const getCtx = useContext(context)
-    const ctx = getCtx() as any
-    expect(ctx.theme).toEqual({ rootSize: 16 })
-    expect(ctx.custom).toBe('value')
-  })
-
-  it('returns null when no children and no theme', () => {
-    const result = Provider({})
-    expect(result).toBeNull()
-  })
-
-  it('returns null when theme is provided but no children', () => {
-    const theme = { rootSize: 16 }
-    const result = Provider({ theme })
-    expect(result).toBeNull()
-  })
-})
-
-describe('context', () => {
-  it('exports context object with an id', () => {
-    expect(context).toBeDefined()
-    expect(context.id).toBeDefined()
-    expect(typeof context.id).toBe('symbol')
-  })
-})

package/src/__tests__/hoistNonReactStatics.test.tsx

@@ -1,166 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import hoistNonReactStatics from '../hoistNonReactStatics'
-
-describe('hoistNonReactStatics', () => {
-  it('copies custom static properties from source to target', () => {
-    const Source = () => null
-    ;(Source as any).customStatic = 'hello'
-    ;(Source as any).anotherStatic = 42
-
-    const Target = () => null
-
-    hoistNonReactStatics(Target, Source)
-
-    expect((Target as any).customStatic).toBe('hello')
-    expect((Target as any).anotherStatic).toBe(42)
-  })
-
-  it('does not copy component statics (displayName, defaultProps)', () => {
-    const Source = () => null
-    Source.displayName = 'SourceComponent'
-    ;(Source as any).defaultProps = { bar: 1 }
-    ;(Source as any).customProp = 'should copy'
-
-    const Target = () => null
-    Target.displayName = 'TargetComponent'
-
-    hoistNonReactStatics(Target, Source)
-
-    expect(Target.displayName).toBe('TargetComponent')
-    expect((Target as any).defaultProps).toBeUndefined()
-    expect((Target as any).customProp).toBe('should copy')
-  })
-
-  it('does not copy known JS statics (name, length, prototype)', () => {
-    const Source = () => null
-    ;(Source as any).customProp = 'value'
-
-    const Target = () => null
-    const originalName = Target.name
-
-    hoistNonReactStatics(Target, Source)
-
-    expect(Target.name).toBe(originalName)
-    expect((Target as any).customProp).toBe('value')
-  })
-
-  it('respects the excludeList', () => {
-    const Source = () => null
-    ;(Source as any).foo = 'included'
-    ;(Source as any).bar = 'excluded'
-    ;(Source as any).baz = 'included'
-
-    const Target = () => null
-
-    hoistNonReactStatics(Target, Source, { bar: true })
-
-    expect((Target as any).foo).toBe('included')
-    expect((Target as any).bar).toBeUndefined()
-    expect((Target as any).baz).toBe('included')
-  })
-
-  it('returns the target component', () => {
-    const Source = () => null
-    const Target = () => null
-
-    const result = hoistNonReactStatics(Target, Source)
-    expect(result).toBe(Target)
-  })
-
-  it('handles string source (HTML tag) gracefully', () => {
-    const Target = () => null
-
-    const result = hoistNonReactStatics(Target, 'div' as any)
-    expect(result).toBe(Target)
-  })
-
-  it('copies symbol-keyed properties', () => {
-    const sym = Symbol('custom')
-    const Source = () => null
-    ;(Source as any)[sym] = 'symbol value'
-
-    const Target = () => null
-
-    hoistNonReactStatics(Target, Source)
-
-    expect((Target as any)[sym]).toBe('symbol value')
-  })
-
-  it('copies getters and setters via property descriptors', () => {
-    const Source = () => null
-    let value = 0
-    Object.defineProperty(Source, 'counter', {
-      get: () => value,
-      set: (v) => {
-        value = v
-      },
-      enumerable: true,
-      configurable: true,
-    })
-
-    const Target = () => null
-
-    hoistNonReactStatics(Target, Source)
-
-    expect((Target as any).counter).toBe(0)
-    ;(Target as any).counter = 5
-    expect((Target as any).counter).toBe(5)
-    // shares the same backing variable
-    expect((Source as any).counter).toBe(5)
-  })
-
-  it('does not throw on non-configurable target properties', () => {
-    const Source = () => null
-    ;(Source as any).locked = 'source value'
-
-    const Target = () => null
-    Object.defineProperty(Target, 'locked', {
-      value: 'target value',
-      writable: false,
-      configurable: false,
-    })
-
-    expect(() => hoistNonReactStatics(Target, Source)).not.toThrow()
-    expect((Target as any).locked).toBe('target value')
-  })
-
-  it('hoists statics from prototype chain', () => {
-    function Base() {
-      // constructor stub
-    }
-    Base.prototype = Object.create(null)
-    ;(Base as any).inheritedStatic = 'from base'
-
-    function Source() {
-      // constructor stub
-    }
-    Source.prototype = Object.create(null)
-    Object.setPrototypeOf(Source, Base)
-    ;(Source as any).ownStatic = 'from source'
-
-    const Target = () => null
-
-    hoistNonReactStatics(Target, Source as any)
-
-    expect((Target as any).ownStatic).toBe('from source')
-    expect((Target as any).inheritedStatic).toBe('from base')
-  })
-
-  it('works with components that have no custom statics', () => {
-    const Source = () => null
-    const Target = () => null
-
-    expect(() => hoistNonReactStatics(Target, Source)).not.toThrow()
-  })
-
-  it('stops prototype recursion at Object.prototype', () => {
-    const Source = () => null
-    ;(Source as any).custom = 'value'
-    // Source's prototype is Function.prototype which has proto Object.prototype
-    // The recursion should walk up and stop at Object.prototype
-
-    const Target = () => null
-    expect(() => hoistNonReactStatics(Target, Source)).not.toThrow()
-    expect((Target as any).custom).toBe('value')
-  })
-})

package/src/__tests__/isEmpty.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import isEmpty from '../isEmpty'
-
-describe('isEmpty', () => {
-  it('should return true for null', () => {
-    expect(isEmpty(null)).toBe(true)
-  })
-
-  it('should return true for undefined', () => {
-    expect(isEmpty(undefined)).toBe(true)
-  })
-
-  it('should return true for empty object', () => {
-    expect(isEmpty({})).toBe(true)
-  })
-
-  it('should return true for empty array', () => {
-    expect(isEmpty([])).toBe(true)
-  })
-
-  it('should return false for non-empty object', () => {
-    expect(isEmpty({ a: 1 })).toBe(false)
-  })
-
-  it('should return false for non-empty array', () => {
-    expect(isEmpty([1])).toBe(false)
-  })
-
-  it('should return false for array with falsy values', () => {
-    expect(isEmpty([0, null, undefined])).toBe(false)
-  })
-
-  it('should return false for object with falsy values', () => {
-    expect(isEmpty({ a: 0, b: null })).toBe(false)
-  })
-
-  it('should return true for Object.create(null) with no properties', () => {
-    expect(isEmpty(Object.create(null))).toBe(true)
-  })
-
-  it('should return false for Object.create(null) with properties', () => {
-    const obj = Object.create(null)
-    obj.a = 1
-    expect(isEmpty(obj)).toBe(false)
-  })
-
-  it('should return true for non-object truthy primitives', () => {
-    // Covers typeof param !== 'object' branch
-    expect(isEmpty(42 as any)).toBe(true)
-    expect(isEmpty('hello' as any)).toBe(true)
-    expect(isEmpty(true as any)).toBe(true)
-  })
-})

package/src/__tests__/isEqual.test.ts

@@ -1,114 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import isEqual from '../isEqual'
-
-describe('isEqual', () => {
-  // Primitives
-  it('should return true for identical primitives', () => {
-    expect(isEqual(1, 1)).toBe(true)
-    expect(isEqual('a', 'a')).toBe(true)
-    expect(isEqual(true, true)).toBe(true)
-  })
-
-  it('should return false for different primitives', () => {
-    expect(isEqual(1, 2)).toBe(false)
-    expect(isEqual('a', 'b')).toBe(false)
-    expect(isEqual(true, false)).toBe(false)
-  })
-
-  it('should handle NaN', () => {
-    expect(isEqual(NaN, NaN)).toBe(true)
-  })
-
-  it('should distinguish 0 and -0', () => {
-    expect(isEqual(0, -0)).toBe(false)
-  })
-
-  // Null / undefined
-  it('should return true for null === null and undefined === undefined', () => {
-    expect(isEqual(null, null)).toBe(true)
-    expect(isEqual(undefined, undefined)).toBe(true)
-  })
-
-  it('should return false for null vs undefined', () => {
-    expect(isEqual(null, undefined)).toBe(false)
-  })
-
-  it('should return false for null vs object', () => {
-    expect(isEqual(null, {})).toBe(false)
-    expect(isEqual({}, null)).toBe(false)
-  })
-
-  // Objects
-  it('should return true for deeply equal objects', () => {
-    expect(isEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true)
-  })
-
-  it('should return true regardless of key order', () => {
-    expect(isEqual({ a: 1, b: 2 }, { b: 2, a: 1 })).toBe(true)
-  })
-
-  it('should return false for objects with different values', () => {
-    expect(isEqual({ a: 1 }, { a: 2 })).toBe(false)
-  })
-
-  it('should return false for objects with different keys', () => {
-    expect(isEqual({ a: 1 }, { b: 1 })).toBe(false)
-  })
-
-  it('should return false for objects with different key counts', () => {
-    expect(isEqual({ a: 1 }, { a: 1, b: 2 })).toBe(false)
-  })
-
-  // Nested objects
-  it('should deeply compare nested objects', () => {
-    const a = { a: { b: { c: 1 } } }
-    expect(isEqual(a, { a: { b: { c: 1 } } })).toBe(true)
-    expect(isEqual(a, { a: { b: { c: 2 } } })).toBe(false)
-  })
-
-  it('should handle nested key order differences', () => {
-    expect(isEqual({ x: { b: 2, a: 1 }, y: 3 }, { y: 3, x: { a: 1, b: 2 } })).toBe(true)
-  })
-
-  // Arrays
-  it('should return true for identical arrays', () => {
-    expect(isEqual([1, 2, 3], [1, 2, 3])).toBe(true)
-  })
-
-  it('should return false for arrays with different values', () => {
-    expect(isEqual([1, 2], [1, 3])).toBe(false)
-  })
-
-  it('should return false for arrays with different lengths', () => {
-    expect(isEqual([1, 2], [1, 2, 3])).toBe(false)
-  })
-
-  it('should not treat array and object as equal', () => {
-    expect(isEqual([1], { 0: 1 })).toBe(false)
-    expect(isEqual({ 0: 1 }, [1])).toBe(false)
-  })
-
-  // Mixed nested
-  it('should deeply compare arrays of objects', () => {
-    expect(isEqual([{ a: 1 }, { b: 2 }], [{ a: 1 }, { b: 2 }])).toBe(true)
-    expect(isEqual([{ a: 1 }], [{ a: 2 }])).toBe(false)
-  })
-
-  it('should deeply compare objects with array values', () => {
-    expect(isEqual({ a: [1, 2] }, { a: [1, 2] })).toBe(true)
-    expect(isEqual({ a: [1, 2] }, { a: [1, 3] })).toBe(false)
-  })
-
-  // Same reference
-  it('should return true for the same reference', () => {
-    const obj = { a: 1 }
-    expect(isEqual(obj, obj)).toBe(true)
-  })
-
-  // Type mismatches
-  it('should return false for different types', () => {
-    expect(isEqual(1, '1')).toBe(false)
-    expect(isEqual([], {})).toBe(false)
-    expect(isEqual(0, false)).toBe(false)
-  })
-})

package/src/__tests__/manifest-snapshot.test.ts

@@ -1,27 +0,0 @@
-import {
-  renderApiReferenceEntries,
-  renderLlmsFullSection,
-  renderLlmsTxtLine,
-} from '@pyreon/manifest'
-import manifest from '../manifest'
-
-describe('gen-docs — ui-core snapshot', () => {
-  it('renders a llms.txt bullet starting with the package prefix', () => {
-    const line = renderLlmsTxtLine(manifest)
-    expect(line.startsWith('- @pyreon/ui-core —')).toBe(true)
-  })
-
-  it('renders a llms-full.txt section with the right header', () => {
-    const section = renderLlmsFullSection(manifest)
-    expect(section.startsWith('## @pyreon/ui-core —')).toBe(true)
-    expect(section).toContain('```typescript')
-  })
-
-  it('renders MCP api-reference entries for every api[] item', () => {
-    const record = renderApiReferenceEntries(manifest)
-    expect(Object.keys(record).sort()).toEqual([
-      'ui-core/PyreonUI',
-      'ui-core/useMode',
-    ])
-  })
-})

package/src/__tests__/native-markers.test.ts

@@ -1,13 +0,0 @@
-import { isNativeCompat } from '@pyreon/core'
-import { describe, expect, it } from 'vitest'
-import CoreProvider from '../context'
-import { PyreonUI } from '../PyreonUI'
-
-describe('native-compat markers — @pyreon/ui-core', () => {
-  it('PyreonUI is marked native', () => {
-    expect(isNativeCompat(PyreonUI)).toBe(true)
-  })
-  it('CoreProvider is marked native', () => {
-    expect(isNativeCompat(CoreProvider)).toBe(true)
-  })
-})

package/src/__tests__/render.test.tsx

@@ -1,72 +0,0 @@
-import type { VNode } from '@pyreon/core'
-import { Fragment, h } from '@pyreon/core'
-import { describe, expect, it } from 'vitest'
-import renderFn from '../render'
-
-const TestComponent = (props: { label?: string }) => {
-  return h('span', { 'data-testid': 'test' }, props.label ?? 'default')
-}
-
-describe('render', () => {
-  it('should return null for falsy content', () => {
-    expect(renderFn(null)).toBeNull()
-    expect(renderFn(undefined)).toBeNull()
-    expect(renderFn(false as any)).toBeNull()
-    expect(renderFn('' as any)).toBeNull()
-  })
-
-  it('should render a component with props', () => {
-    const result = renderFn(TestComponent, { label: 'hello' }) as VNode
-    expect(result).toBeDefined()
-    expect(result.type).toBe(TestComponent)
-    expect(result.props.label).toBe('hello')
-  })
-
-  it('should render a component without props', () => {
-    const result = renderFn(TestComponent) as VNode
-    expect(result).toBeDefined()
-    expect(result.type).toBe(TestComponent)
-  })
-
-  it('should return string content as-is (treated as text)', () => {
-    expect(renderFn('div' as any)).toBe('div')
-    expect(renderFn('hello' as any)).toBe('hello')
-  })
-
-  it('should return primitive values as-is', () => {
-    expect(renderFn(42 as any)).toBe(42)
-    expect(renderFn(true as any)).toBe(true)
-    expect(renderFn('text' as any)).toBe('text')
-  })
-
-  it('should return arrays as-is', () => {
-    const arr = [h('span', { key: '1' }, 'a'), h('span', { key: '2' }, 'b')]
-    expect(renderFn(arr as any)).toBe(arr)
-  })
-
-  it('should return a VNode object without modification when no props', () => {
-    const vnode = h(TestComponent, { label: 'original' })
-    const result = renderFn(vnode as any)
-    // VNode objects are returned as-is
-    expect(result).toBe(vnode)
-  })
-
-  it('should return a VNode object as-is even with props (VNode path does not merge)', () => {
-    const vnode = h(TestComponent, { label: 'original' })
-    const result = renderFn(vnode as any, { label: 'cloned' })
-    // In Pyreon's render, VNode objects hit the object branch and are returned as-is
-    expect(result).toBe(vnode)
-  })
-
-  it('should return fragment as-is', () => {
-    const frag = h(Fragment, null, h('span', null, 'a'), h('span', null, 'b'))
-    const result = renderFn(frag as any)
-    expect(result).toBe(frag)
-  })
-
-  it('should return plain object as-is (fallback branch)', () => {
-    // Plain objects are not valid elements, not primitives, not arrays
-    const obj = { foo: 'bar' }
-    expect(renderFn(obj as any)).toBe(obj)
-  })
-})