@pyreon/ui-core 0.11.5 → 0.11.6

package/src/__tests__/config.test.ts

@@ -1,31 +1,31 @@
-import { afterEach, describe, expect, it } from "vitest"
-import config, { init } from "../config"
+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")
+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 default textComponent as span', () => {
+    expect(config.textComponent).toBe('span')
   })
 
-  it("has css function", () => {
+  it('has css function', () => {
     expect(config.css).toBeDefined()
-    expect(typeof config.css).toBe("function")
+    expect(typeof config.css).toBe('function')
   })
 
-  it("has styled function", () => {
+  it('has styled function', () => {
     expect(config.styled).toBeDefined()
-    expect(typeof config.styled).toBe("function")
+    expect(typeof config.styled).toBe('function')
   })
 
-  it("has keyframes function", () => {
+  it('has keyframes function', () => {
     expect(config.keyframes).toBeDefined()
-    expect(typeof config.keyframes).toBe("function")
+    expect(typeof config.keyframes).toBe('function')
   })
 
-  describe("init", () => {
+  describe('init', () => {
     const originalCss = config.css
     const originalStyled = config.styled
     const originalKeyframes = config.keyframes
@@ -43,56 +43,56 @@ describe("Configuration", () => {
       config.createMediaQueries = originalCreateMediaQueries
     })
 
-    it("updates css engine", () => {
-      const mockCss = (() => "") as any
+    it('updates css engine', () => {
+      const mockCss = (() => '') as any
       init({ css: mockCss })
       expect(config.css).toBe(mockCss)
     })
 
-    it("updates styled engine", () => {
-      const mockStyled = (() => "") as any
+    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 component', () => {
+      init({ component: 'section' })
+      expect(config.component).toBe('section')
     })
 
-    it("updates textComponent", () => {
-      init({ textComponent: "p" })
-      expect(config.textComponent).toBe("p")
+    it('updates textComponent', () => {
+      init({ textComponent: 'p' })
+      expect(config.textComponent).toBe('p')
     })
 
-    it("updates keyframes", () => {
-      const mockKeyframes = (() => "anim") as any
+    it('updates keyframes', () => {
+      const mockKeyframes = (() => 'anim') as any
       init({ keyframes: mockKeyframes })
       expect(config.keyframes).toBe(mockKeyframes)
     })
 
-    it("updates createMediaQueries", () => {
+    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")
+    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", () => {
+    it('does nothing with empty object', () => {
       init({})
-      expect(config.component).toBe("div")
-      expect(config.textComponent).toBe("span")
+      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
+    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 })

package/src/__tests__/context.test.tsx

@@ -1,8 +1,8 @@
-import { popContext, useContext } from "@pyreon/core"
-import { afterEach, describe, expect, it } from "vitest"
-import Provider, { context } from "../context"
+import { popContext, useContext } from '@pyreon/core'
+import { afterEach, describe, expect, it } from 'vitest'
+import Provider, { context } from '../context'
 
-describe("Provider", () => {
+describe('Provider', () => {
   afterEach(() => {
     // Clean up any pushed context frames
     try {
@@ -12,59 +12,60 @@ describe("Provider", () => {
     }
   })
 
-  it("returns children when no theme is provided", () => {
-    const children = "Hello"
+  it('returns children when no theme is provided', () => {
+    const children = 'Hello'
     const result = Provider({ children })
-    expect(result).toBe("Hello")
+    expect(result).toBe('Hello')
   })
 
-  it("returns children with empty theme", () => {
-    const children = "Hello"
+  it('returns children with empty theme', () => {
+    const children = 'Hello'
     const result = Provider({ theme: {}, children })
-    expect(result).toBe("Hello")
+    expect(result).toBe('Hello')
   })
 
-  it("returns children with null theme", () => {
-    const children = "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")
+    expect(result).toBe('Hello')
   })
 
-  it("returns children when theme is provided and pushes context", () => {
+  it('returns children when theme is provided and pushes context', () => {
     const theme = { rootSize: 16, breakpoints: { xs: 0 } }
-    const children = "Styled"
+    const children = 'Styled'
     const result = Provider({ theme, children })
-    expect(result).toBe("Styled")
+    expect(result).toBe('Styled')
   })
 
-  it("pushes context with theme and extra props", () => {
+  it('pushes context with theme and extra props', () => {
     const theme = { rootSize: 16 }
-    const children = "Content"
-    Provider({ theme, children, custom: "value" })
+    const children = 'Content'
+    Provider({ theme, children, custom: 'value' })
     // After Provider runs, context should have been pushed
-    // We can verify by reading the context value
-    const ctx = useContext(context)
+    // 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")
+    expect(ctx.custom).toBe('value')
   })
 
-  it("returns null when no children and no theme", () => {
+  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", () => {
+  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", () => {
+describe('context', () => {
+  it('exports context object with an id', () => {
     expect(context).toBeDefined()
     expect(context.id).toBeDefined()
-    expect(typeof context.id).toBe("symbol")
+    expect(typeof context.id).toBe('symbol')
   })
 })

package/src/__tests__/hoistNonReactStatics.test.tsx

@@ -1,39 +1,39 @@
-import { describe, expect, it } from "vitest"
-import hoistNonReactStatics from "../hoistNonReactStatics"
+import { describe, expect, it } from 'vitest'
+import hoistNonReactStatics from '../hoistNonReactStatics'
 
-describe("hoistNonReactStatics", () => {
-  it("copies custom static properties from source to target", () => {
+describe('hoistNonReactStatics', () => {
+  it('copies custom static properties from source to target', () => {
     const Source = () => null
-    ;(Source as any).customStatic = "hello"
+    ;(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).customStatic).toBe('hello')
     expect((Target as any).anotherStatic).toBe(42)
   })
 
-  it("does not copy component statics (displayName, defaultProps)", () => {
+  it('does not copy component statics (displayName, defaultProps)', () => {
     const Source = () => null
-    Source.displayName = "SourceComponent"
+    Source.displayName = 'SourceComponent'
     ;(Source as any).defaultProps = { bar: 1 }
-    ;(Source as any).customProp = "should copy"
+    ;(Source as any).customProp = 'should copy'
 
     const Target = () => null
-    Target.displayName = "TargetComponent"
+    Target.displayName = 'TargetComponent'
 
     hoistNonReactStatics(Target, Source)
 
-    expect(Target.displayName).toBe("TargetComponent")
+    expect(Target.displayName).toBe('TargetComponent')
     expect((Target as any).defaultProps).toBeUndefined()
-    expect((Target as any).customProp).toBe("should copy")
+    expect((Target as any).customProp).toBe('should copy')
   })
 
-  it("does not copy known JS statics (name, length, prototype)", () => {
+  it('does not copy known JS statics (name, length, prototype)', () => {
     const Source = () => null
-    ;(Source as any).customProp = "value"
+    ;(Source as any).customProp = 'value'
 
     const Target = () => null
     const originalName = Target.name
@@ -41,25 +41,25 @@ describe("hoistNonReactStatics", () => {
     hoistNonReactStatics(Target, Source)
 
     expect(Target.name).toBe(originalName)
-    expect((Target as any).customProp).toBe("value")
+    expect((Target as any).customProp).toBe('value')
   })
 
-  it("respects the excludeList", () => {
+  it('respects the excludeList', () => {
     const Source = () => null
-    ;(Source as any).foo = "included"
-    ;(Source as any).bar = "excluded"
-    ;(Source as any).baz = "included"
+    ;(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).foo).toBe('included')
     expect((Target as any).bar).toBeUndefined()
-    expect((Target as any).baz).toBe("included")
+    expect((Target as any).baz).toBe('included')
   })
 
-  it("returns the target component", () => {
+  it('returns the target component', () => {
     const Source = () => null
     const Target = () => null
 
@@ -67,29 +67,29 @@ describe("hoistNonReactStatics", () => {
     expect(result).toBe(Target)
   })
 
-  it("handles string source (HTML tag) gracefully", () => {
+  it('handles string source (HTML tag) gracefully', () => {
     const Target = () => null
 
-    const result = hoistNonReactStatics(Target, "div" as any)
+    const result = hoistNonReactStatics(Target, 'div' as any)
     expect(result).toBe(Target)
   })
 
-  it("copies symbol-keyed properties", () => {
-    const sym = Symbol("custom")
+  it('copies symbol-keyed properties', () => {
+    const sym = Symbol('custom')
     const Source = () => null
-    ;(Source as any)[sym] = "symbol value"
+    ;(Source as any)[sym] = 'symbol value'
 
     const Target = () => null
 
     hoistNonReactStatics(Target, Source)
 
-    expect((Target as any)[sym]).toBe("symbol value")
+    expect((Target as any)[sym]).toBe('symbol value')
   })
 
-  it("copies getters and setters via property descriptors", () => {
+  it('copies getters and setters via property descriptors', () => {
     const Source = () => null
     let value = 0
-    Object.defineProperty(Source, "counter", {
+    Object.defineProperty(Source, 'counter', {
       get: () => value,
       set: (v) => {
         value = v
@@ -109,58 +109,58 @@ describe("hoistNonReactStatics", () => {
     expect((Source as any).counter).toBe(5)
   })
 
-  it("does not throw on non-configurable target properties", () => {
+  it('does not throw on non-configurable target properties', () => {
     const Source = () => null
-    ;(Source as any).locked = "source value"
+    ;(Source as any).locked = 'source value'
 
     const Target = () => null
-    Object.defineProperty(Target, "locked", {
-      value: "target value",
+    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")
+    expect((Target as any).locked).toBe('target value')
   })
 
-  it("hoists statics from prototype chain", () => {
+  it('hoists statics from prototype chain', () => {
     function Base() {
       // constructor stub
     }
     Base.prototype = Object.create(null)
-    ;(Base as any).inheritedStatic = "from base"
+    ;(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"
+    ;(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")
+    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", () => {
+  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", () => {
+  it('stops prototype recursion at Object.prototype', () => {
     const Source = () => null
-    ;(Source as any).custom = "value"
+    ;(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")
+    expect((Target as any).custom).toBe('value')
   })
 })

package/src/__tests__/isEmpty.test.ts

@@ -1,53 +1,53 @@
-import { describe, expect, it } from "vitest"
-import isEmpty from "../isEmpty"
+import { describe, expect, it } from 'vitest'
+import isEmpty from '../isEmpty'
 
-describe("isEmpty", () => {
-  it("should return true for null", () => {
+describe('isEmpty', () => {
+  it('should return true for null', () => {
     expect(isEmpty(null)).toBe(true)
   })
 
-  it("should return true for undefined", () => {
+  it('should return true for undefined', () => {
     expect(isEmpty(undefined)).toBe(true)
   })
 
-  it("should return true for empty object", () => {
+  it('should return true for empty object', () => {
     expect(isEmpty({})).toBe(true)
   })
 
-  it("should return true for empty array", () => {
+  it('should return true for empty array', () => {
     expect(isEmpty([])).toBe(true)
   })
 
-  it("should return false for non-empty object", () => {
+  it('should return false for non-empty object', () => {
     expect(isEmpty({ a: 1 })).toBe(false)
   })
 
-  it("should return false for non-empty array", () => {
+  it('should return false for non-empty array', () => {
     expect(isEmpty([1])).toBe(false)
   })
 
-  it("should return false for array with falsy values", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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('hello' as any)).toBe(true)
     expect(isEmpty(true as any)).toBe(true)
   })
 })

package/src/__tests__/isEqual.test.ts

@@ -1,113 +1,113 @@
-import { describe, expect, it } from "vitest"
-import isEqual from "../isEqual"
+import { describe, expect, it } from 'vitest'
+import isEqual from '../isEqual'
 
-describe("isEqual", () => {
+describe('isEqual', () => {
   // Primitives
-  it("should return true for identical primitives", () => {
+  it('should return true for identical primitives', () => {
     expect(isEqual(1, 1)).toBe(true)
-    expect(isEqual("a", "a")).toBe(true)
+    expect(isEqual('a', 'a')).toBe(true)
     expect(isEqual(true, true)).toBe(true)
   })
 
-  it("should return false for different primitives", () => {
+  it('should return false for different primitives', () => {
     expect(isEqual(1, 2)).toBe(false)
-    expect(isEqual("a", "b")).toBe(false)
+    expect(isEqual('a', 'b')).toBe(false)
     expect(isEqual(true, false)).toBe(false)
   })
 
-  it("should handle NaN", () => {
+  it('should handle NaN', () => {
     expect(isEqual(NaN, NaN)).toBe(true)
   })
 
-  it("should distinguish 0 and -0", () => {
+  it('should distinguish 0 and -0', () => {
     expect(isEqual(0, -0)).toBe(false)
   })
 
   // Null / undefined
-  it("should return true for null === null and undefined === 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", () => {
+  it('should return false for null vs undefined', () => {
     expect(isEqual(null, undefined)).toBe(false)
   })
 
-  it("should return false for null vs object", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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)
+  it('should return false for different types', () => {
+    expect(isEqual(1, '1')).toBe(false)
     expect(isEqual([], {})).toBe(false)
     expect(isEqual(0, false)).toBe(false)
   })