@pyreon/rocketstyle 0.11.5 → 0.11.7

package/src/__tests__/context.test.ts

@@ -1,25 +1,25 @@
-import type { VNodeChild } from "@pyreon/core"
-import { useContext } from "@pyreon/core"
-import { Provider as CoreProvider } from "@pyreon/ui-core"
-import Provider from "../context/context"
+import type { VNodeChild } from '@pyreon/core'
+import { useContext } from '@pyreon/core'
+import { Provider as CoreProvider } from '@pyreon/ui-core'
+import Provider from '../context/context'
 
 // Mock @pyreon/core useContext to return controlled values
-vi.mock("@pyreon/core", async (importOriginal) => {
-  const original = await importOriginal<typeof import("@pyreon/core")>()
+vi.mock('@pyreon/core', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@pyreon/core')>()
   return {
     ...original,
-    useContext: vi.fn(() => ({})),
+    useContext: vi.fn(() => (() => ({}))),
   }
 })
 
 // Mock @pyreon/ui-core Provider and context
-vi.mock("@pyreon/ui-core", async (importOriginal) => {
-  const original = await importOriginal<typeof import("@pyreon/ui-core")>()
+vi.mock('@pyreon/ui-core', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@pyreon/ui-core')>()
   return {
     ...original,
     Provider: vi.fn(((props: Record<string, unknown>) => ({
-      type: "div",
-      props: { ...props, "data-provider": "core" },
+      type: 'div',
+      props: { ...props, 'data-provider': 'core' },
       children: props.children,
       key: null,
     })) as any),
@@ -33,97 +33,97 @@ const mockedCoreProvider = vi.mocked(CoreProvider)
 beforeEach(() => {
   vi.clearAllMocks()
   // Default: empty context
-  mockedUseContext.mockReturnValue({} as any)
+  mockedUseContext.mockReturnValue((() => ({})) as any)
   mockedCoreProvider.mockImplementation(((props: Record<string, unknown>) => ({
-    type: "div",
-    props: { ...props, "data-provider": "core" },
+    type: 'div',
+    props: { ...props, 'data-provider': 'core' },
     children: props.children as VNodeChild,
     key: null,
   })) as any)
 })
 
-describe("Provider (context)", () => {
-  it("uses MODE_DEFAULT (light) when no mode is provided", () => {
-    mockedUseContext.mockReturnValue({} as any)
+describe('Provider (context)', () => {
+  it('uses MODE_DEFAULT (light) when no mode is provided', () => {
+    mockedUseContext.mockReturnValue((() => ({})) as any)
 
-    const children = { type: "span", props: {}, children: ["Hello"], key: null }
+    const children = { type: 'span', props: {}, children: ['Hello'], key: null }
     Provider({ children })
 
     expect(mockedCoreProvider).toHaveBeenCalledTimes(1)
     const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.mode).toBe("light")
+    expect(callArgs.mode).toBe('light')
     expect(callArgs.isLight).toBe(true)
     expect(callArgs.isDark).toBe(false)
   })
 
-  it("passes mode directly when inversed is false", () => {
-    mockedUseContext.mockReturnValue({ mode: "dark" } as any)
+  it('passes mode directly when inversed is false', () => {
+    mockedUseContext.mockReturnValue((() => ({ mode: 'dark' })) as any)
 
-    const children = { type: "span", props: {}, children: ["Hello"], key: null }
-    Provider({ children, mode: "dark", inversed: false })
+    const children = { type: 'span', props: {}, children: ['Hello'], key: null }
+    Provider({ children, mode: 'dark', inversed: false })
 
     const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.mode).toBe("dark")
+    expect(callArgs.mode).toBe('dark')
     expect(callArgs.isDark).toBe(true)
     expect(callArgs.isLight).toBe(false)
   })
 
-  it("passes mode directly when inversed is undefined", () => {
-    const children = { type: "span", props: {}, children: ["Hello"], key: null }
-    Provider({ children, mode: "dark" })
+  it('passes mode directly when inversed is undefined', () => {
+    const children = { type: 'span', props: {}, children: ['Hello'], key: null }
+    Provider({ children, mode: 'dark' })
 
     const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.mode).toBe("dark")
+    expect(callArgs.mode).toBe('dark')
     expect(callArgs.isDark).toBe(true)
     expect(callArgs.isLight).toBe(false)
   })
 
-  it("inverts light to dark when inversed is true", () => {
-    const children = { type: "span", props: {}, children: ["Hello"], key: null }
-    Provider({ children, mode: "light", inversed: true })
+  it('inverts light to dark when inversed is true', () => {
+    const children = { type: 'span', props: {}, children: ['Hello'], key: null }
+    Provider({ children, mode: 'light', inversed: true })
 
     const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.mode).toBe("dark")
+    expect(callArgs.mode).toBe('dark')
     expect(callArgs.isDark).toBe(true)
     expect(callArgs.isLight).toBe(false)
   })
 
-  it("inverts dark to light when inversed is true", () => {
-    const children = { type: "span", props: {}, children: ["Hello"], key: null }
-    Provider({ children, mode: "dark", inversed: true })
+  it('inverts dark to light when inversed is true', () => {
+    const children = { type: 'span', props: {}, children: ['Hello'], key: null }
+    Provider({ children, mode: 'dark', inversed: true })
 
     const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.mode).toBe("light")
+    expect(callArgs.mode).toBe('light')
     expect(callArgs.isLight).toBe(true)
     expect(callArgs.isDark).toBe(false)
   })
 
-  it("passes theme to provider when provided", () => {
+  it('passes theme to provider when provided', () => {
     const theme = { rootSize: 16, breakpoints: { sm: 576 } }
-    const children = { type: "span", props: {}, children: ["Hello"], key: null }
+    const children = { type: 'span', props: {}, children: ['Hello'], key: null }
     Provider({ children, theme })
 
     const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
     expect(callArgs.theme).toEqual(theme)
   })
 
-  it("does not pass theme key when theme is undefined", () => {
-    const children = { type: "span", props: {}, children: ["Hello"], key: null }
+  it('does not pass theme key when theme is undefined', () => {
+    const children = { type: 'span', props: {}, children: ['Hello'], key: null }
     Provider({ children })
 
     const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect("theme" in callArgs).toBe(false)
+    expect('theme' in callArgs).toBe(false)
   })
 
-  it("uses custom provider when specified", () => {
+  it('uses custom provider when specified', () => {
     const customProvider = vi.fn((props: Record<string, unknown>) => ({
-      type: "section",
+      type: 'section',
       props,
       children: props.children as VNodeChild,
       key: null,
     }))
 
-    const children = { type: "span", props: {}, children: ["Hello"], key: null }
+    const children = { type: 'span', props: {}, children: ['Hello'], key: null }
     Provider({ children, provider: customProvider as any })
 
     expect(customProvider).toHaveBeenCalledTimes(1)
@@ -131,70 +131,70 @@ describe("Provider (context)", () => {
     expect(mockedCoreProvider).not.toHaveBeenCalled()
   })
 
-  it("defaults to CoreProvider when no provider prop is given", () => {
-    const children = { type: "span", props: {}, children: ["Hello"], key: null }
+  it('defaults to CoreProvider when no provider prop is given', () => {
+    const children = { type: 'span', props: {}, children: ['Hello'], key: null }
     Provider({ children })
 
     expect(mockedCoreProvider).toHaveBeenCalledTimes(1)
   })
 
-  it("passes children through to the provider", () => {
-    const children = { type: "span", props: {}, children: ["Hello World"], key: null }
+  it('passes children through to the provider', () => {
+    const children = { type: 'span', props: {}, children: ['Hello World'], key: null }
     Provider({ children })
 
     const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
     expect(callArgs.children).toBe(children)
   })
 
-  it("passes provider reference to the provider call", () => {
-    const children = { type: "span", props: {}, children: ["Hello"], key: null }
+  it('passes provider reference to the provider call', () => {
+    const children = { type: 'span', props: {}, children: ['Hello'], key: null }
     Provider({ children })
 
     const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
     expect(callArgs.provider).toBe(CoreProvider)
   })
 
-  it("returns null when provider returns null", () => {
+  it('returns null when provider returns null', () => {
     mockedCoreProvider.mockReturnValue(null as any)
 
-    const children = { type: "span", props: {}, children: ["Hello"], key: null }
+    const children = { type: 'span', props: {}, children: ['Hello'], key: null }
     const result = Provider({ children })
 
     expect(result).toBeNull()
   })
 
-  it("returns null when provider returns undefined", () => {
+  it('returns null when provider returns undefined', () => {
     mockedCoreProvider.mockReturnValue(undefined as any)
 
-    const children = { type: "span", props: {}, children: ["Hello"], key: null }
+    const children = { type: 'span', props: {}, children: ['Hello'], key: null }
     const result = Provider({ children })
 
     expect(result).toBeNull()
   })
 
-  it("merges context values with incoming props (props take precedence)", () => {
-    mockedUseContext.mockReturnValue({
-      mode: "light",
+  it('merges context values with incoming props (props take precedence)', () => {
+    mockedUseContext.mockReturnValue((() => ({
+      mode: 'light',
       theme: { rootSize: 12 },
-    } as any)
+    })) as any)
 
     const overrideTheme = { rootSize: 20 }
-    const children = { type: "span", props: {}, children: ["Hello"], key: null }
-    Provider({ children, theme: overrideTheme, mode: "dark" })
+    const children = { type: 'span', props: {}, children: ['Hello'], key: null }
+    Provider({ children, theme: overrideTheme, mode: 'dark' })
 
     const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.mode).toBe("dark")
+    expect(callArgs.mode).toBe('dark')
     expect(callArgs.theme).toEqual(overrideTheme)
   })
 
-  it("uses context mode when no mode prop is given", () => {
-    mockedUseContext.mockReturnValue({ mode: "dark" } as any)
+  it('uses context mode when no mode prop is given', () => {
+    mockedUseContext.mockReturnValue((() => ({ mode: 'dark' })) as any)
 
-    const children = { type: "span", props: {}, children: ["Hello"], key: null }
+    const children = { type: 'span', props: {}, children: ['Hello'], key: null }
     Provider({ children })
 
     const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.mode).toBe("dark")
+    expect(callArgs.mode).toBe('dark')
     expect(callArgs.isDark).toBe(true)
   })
 })

package/src/__tests__/createLocalProvider.test.ts

@@ -1,9 +1,9 @@
-import { provide } from "@pyreon/core"
-import createLocalProvider from "../context/createLocalProvider"
+import { provide } from '@pyreon/core'
+import createLocalProvider from '../context/createLocalProvider'
 
 // Mock @pyreon/core provide
-vi.mock("@pyreon/core", async (importOriginal) => {
-  const original = await importOriginal<typeof import("@pyreon/core")>()
+vi.mock('@pyreon/core', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@pyreon/core')>()
   return {
     ...original,
     provide: vi.fn(),
@@ -18,31 +18,31 @@ beforeEach(() => {
 
 /** Simple base component that returns its received props as a VNode for inspection. */
 const BaseComponent: any = vi.fn((props: Record<string, unknown>) => ({
-  type: "div",
+  type: 'div',
   props,
   children: props.children,
   key: null,
 }))
 
-describe("createLocalProvider", () => {
-  it("returns a component function", () => {
+describe('createLocalProvider', () => {
+  it('returns a component function', () => {
     const HOC = createLocalProvider(BaseComponent)
-    expect(typeof HOC).toBe("function")
+    expect(typeof HOC).toBe('function')
   })
 
-  it("calls the wrapped component with forwarded props", () => {
+  it('calls the wrapped component with forwarded props', () => {
     const HOC = createLocalProvider(BaseComponent)
 
-    HOC({ "data-testid": "test", title: "Hello", children: "Content" } as any)
+    HOC({ 'data-testid': 'test', title: 'Hello', children: 'Content' } as any)
 
     expect(BaseComponent).toHaveBeenCalledTimes(1)
     const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callProps["data-testid"]).toBe("test")
-    expect(callProps.title).toBe("Hello")
-    expect(callProps.children).toBe("Content")
+    expect(callProps['data-testid']).toBe('test')
+    expect(callProps.title).toBe('Hello')
+    expect(callProps.children).toBe('Content')
   })
 
-  it("provides local context via provide()", () => {
+  it('provides local context via provide()', () => {
     const HOC = createLocalProvider(BaseComponent)
 
     HOC({} as any)
@@ -50,7 +50,7 @@ describe("createLocalProvider", () => {
     expect(mockedProvide).toHaveBeenCalledTimes(1)
   })
 
-  it("initial pseudo state is all false", () => {
+  it('initial pseudo state is all false', () => {
     const HOC = createLocalProvider(BaseComponent)
 
     HOC({} as any)
@@ -64,24 +64,24 @@ describe("createLocalProvider", () => {
     expect(pseudo.pressed).toBe(false)
   })
 
-  it("injects mouse and focus event handlers", () => {
+  it('injects mouse and focus event handlers', () => {
     const HOC = createLocalProvider(BaseComponent)
 
     HOC({} as any)
 
     const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(typeof callProps.onMouseEnter).toBe("function")
-    expect(typeof callProps.onMouseLeave).toBe("function")
-    expect(typeof callProps.onMouseDown).toBe("function")
-    expect(typeof callProps.onMouseUp).toBe("function")
-    expect(typeof callProps.onFocus).toBe("function")
-    expect(typeof callProps.onBlur).toBe("function")
+    expect(typeof callProps.onMouseEnter).toBe('function')
+    expect(typeof callProps.onMouseLeave).toBe('function')
+    expect(typeof callProps.onMouseDown).toBe('function')
+    expect(typeof callProps.onMouseUp).toBe('function')
+    expect(typeof callProps.onFocus).toBe('function')
+    expect(typeof callProps.onBlur).toBe('function')
   })
 
-  it("forwards original onMouseEnter handler", () => {
+  it('forwards original onMouseEnter handler', () => {
     const HOC = createLocalProvider(BaseComponent)
     const originalHandler = vi.fn()
-    const mockEvent = new MouseEvent("mouseenter")
+    const mockEvent = new MouseEvent('mouseenter')
 
     HOC({ onMouseEnter: originalHandler } as any)
 
@@ -91,10 +91,10 @@ describe("createLocalProvider", () => {
     expect(originalHandler).toHaveBeenCalledWith(mockEvent)
   })
 
-  it("forwards original onMouseLeave handler", () => {
+  it('forwards original onMouseLeave handler', () => {
     const HOC = createLocalProvider(BaseComponent)
     const originalHandler = vi.fn()
-    const mockEvent = new MouseEvent("mouseleave")
+    const mockEvent = new MouseEvent('mouseleave')
 
     HOC({ onMouseLeave: originalHandler } as any)
 
@@ -104,10 +104,10 @@ describe("createLocalProvider", () => {
     expect(originalHandler).toHaveBeenCalledWith(mockEvent)
   })
 
-  it("forwards original onMouseDown handler", () => {
+  it('forwards original onMouseDown handler', () => {
     const HOC = createLocalProvider(BaseComponent)
     const originalHandler = vi.fn()
-    const mockEvent = new MouseEvent("mousedown")
+    const mockEvent = new MouseEvent('mousedown')
 
     HOC({ onMouseDown: originalHandler } as any)
 
@@ -117,10 +117,10 @@ describe("createLocalProvider", () => {
     expect(originalHandler).toHaveBeenCalledWith(mockEvent)
   })
 
-  it("forwards original onMouseUp handler", () => {
+  it('forwards original onMouseUp handler', () => {
     const HOC = createLocalProvider(BaseComponent)
     const originalHandler = vi.fn()
-    const mockEvent = new MouseEvent("mouseup")
+    const mockEvent = new MouseEvent('mouseup')
 
     HOC({ onMouseUp: originalHandler } as any)
 
@@ -130,10 +130,10 @@ describe("createLocalProvider", () => {
     expect(originalHandler).toHaveBeenCalledWith(mockEvent)
   })
 
-  it("forwards original onFocus handler", () => {
+  it('forwards original onFocus handler', () => {
     const HOC = createLocalProvider(BaseComponent)
     const originalHandler = vi.fn()
-    const mockEvent = new FocusEvent("focus")
+    const mockEvent = new FocusEvent('focus')
 
     HOC({ onFocus: originalHandler } as any)
 
@@ -143,10 +143,10 @@ describe("createLocalProvider", () => {
     expect(originalHandler).toHaveBeenCalledWith(mockEvent)
   })
 
-  it("forwards original onBlur handler", () => {
+  it('forwards original onBlur handler', () => {
     const HOC = createLocalProvider(BaseComponent)
     const originalHandler = vi.fn()
-    const mockEvent = new FocusEvent("blur")
+    const mockEvent = new FocusEvent('blur')
 
     HOC({ onBlur: originalHandler } as any)
 
@@ -156,7 +156,7 @@ describe("createLocalProvider", () => {
     expect(originalHandler).toHaveBeenCalledWith(mockEvent)
   })
 
-  it("does not forward event handlers that were not provided", () => {
+  it('does not forward event handlers that were not provided', () => {
     const HOC = createLocalProvider(BaseComponent)
 
     HOC({} as any)
@@ -164,26 +164,26 @@ describe("createLocalProvider", () => {
     const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
     // The HOC event handlers should not throw when no original handler exists
     expect(() => {
-      ;(callProps.onMouseEnter as (e: MouseEvent) => void)(new MouseEvent("mouseenter"))
-      ;(callProps.onMouseLeave as (e: MouseEvent) => void)(new MouseEvent("mouseleave"))
-      ;(callProps.onMouseDown as (e: MouseEvent) => void)(new MouseEvent("mousedown"))
-      ;(callProps.onMouseUp as (e: MouseEvent) => void)(new MouseEvent("mouseup"))
-      ;(callProps.onFocus as (e: FocusEvent) => void)(new FocusEvent("focus"))
-      ;(callProps.onBlur as (e: FocusEvent) => void)(new FocusEvent("blur"))
+      ;(callProps.onMouseEnter as (e: MouseEvent) => void)(new MouseEvent('mouseenter'))
+      ;(callProps.onMouseLeave as (e: MouseEvent) => void)(new MouseEvent('mouseleave'))
+      ;(callProps.onMouseDown as (e: MouseEvent) => void)(new MouseEvent('mousedown'))
+      ;(callProps.onMouseUp as (e: MouseEvent) => void)(new MouseEvent('mouseup'))
+      ;(callProps.onFocus as (e: FocusEvent) => void)(new FocusEvent('focus'))
+      ;(callProps.onBlur as (e: FocusEvent) => void)(new FocusEvent('blur'))
     }).not.toThrow()
   })
 
-  it("merges existing $rocketstate with pseudo state", () => {
+  it('merges existing $rocketstate with pseudo state', () => {
     const HOC = createLocalProvider(BaseComponent)
 
     HOC({
-      $rocketstate: { someExisting: "value", pseudo: { disabled: true } },
+      $rocketstate: { someExisting: 'value', pseudo: { disabled: true } },
     } as any)
 
     const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
     const rocketstate = callProps.$rocketstate as Record<string, unknown>
 
-    expect(rocketstate.someExisting).toBe("value")
+    expect(rocketstate.someExisting).toBe('value')
     const pseudo = rocketstate.pseudo as Record<string, unknown>
     expect(pseudo.disabled).toBe(true)
     expect(pseudo.hover).toBe(false)
@@ -191,7 +191,7 @@ describe("createLocalProvider", () => {
     expect(pseudo.pressed).toBe(false)
   })
 
-  it("provides updated state to local context", () => {
+  it('provides updated state to local context', () => {
     const HOC = createLocalProvider(BaseComponent)
 
     HOC({} as any)
@@ -204,20 +204,20 @@ describe("createLocalProvider", () => {
     expect(pseudo.pressed).toBe(false)
   })
 
-  it("does not pass event handler props to wrapped component as original handler names", () => {
+  it('does not pass event handler props to wrapped component as original handler names', () => {
     const HOC = createLocalProvider(BaseComponent)
     const originalMouseEnter = vi.fn()
 
-    HOC({ onMouseEnter: originalMouseEnter, customProp: "keep" } as any)
+    HOC({ onMouseEnter: originalMouseEnter, customProp: 'keep' } as any)
 
     const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
     // The wrapped component should receive the HOC event handlers, not the original ones
-    expect(callProps.customProp).toBe("keep")
+    expect(callProps.customProp).toBe('keep')
     // The onMouseEnter on the component should be the HOC wrapper, not the original
     expect(callProps.onMouseEnter).not.toBe(originalMouseEnter)
   })
 
-  it("strips $rocketstate from forwarded props and passes updated version", () => {
+  it('strips $rocketstate from forwarded props and passes updated version', () => {
     const HOC = createLocalProvider(BaseComponent)
     const originalState = { existing: true }
 
@@ -231,11 +231,11 @@ describe("createLocalProvider", () => {
     expect(rocketstate.existing).toBe(true)
   })
 
-  it("returns the result of the wrapped component", () => {
+  it('returns the result of the wrapped component', () => {
     const expectedResult = {
-      type: "div",
-      props: { "data-result": "yes" },
-      children: ["Result"],
+      type: 'div',
+      props: { 'data-result': 'yes' },
+      children: ['Result'],
       key: null,
     }
     const MockComponent = vi.fn(() => expectedResult)