@pyreon/rocketstyle 0.11.1 → 0.11.3

package/src/__tests__/createLocalProvider.test.ts

@@ -0,0 +1,248 @@
+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")>()
+  return {
+    ...original,
+    provide: vi.fn(),
+  }
+})
+
+const mockedProvide = vi.mocked(provide)
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+/** Simple base component that returns its received props as a VNode for inspection. */
+const BaseComponent: any = vi.fn((props: Record<string, unknown>) => ({
+  type: "div",
+  props,
+  children: props.children,
+  key: null,
+}))
+
+describe("createLocalProvider", () => {
+  it("returns a component function", () => {
+    const HOC = createLocalProvider(BaseComponent)
+    expect(typeof HOC).toBe("function")
+  })
+
+  it("calls the wrapped component with forwarded props", () => {
+    const HOC = createLocalProvider(BaseComponent)
+
+    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")
+  })
+
+  it("provides local context via provide()", () => {
+    const HOC = createLocalProvider(BaseComponent)
+
+    HOC({} as any)
+
+    expect(mockedProvide).toHaveBeenCalledTimes(1)
+  })
+
+  it("initial pseudo state is all false", () => {
+    const HOC = createLocalProvider(BaseComponent)
+
+    HOC({} as any)
+
+    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
+    const rocketstate = callProps.$rocketstate as Record<string, unknown>
+    const pseudo = rocketstate?.pseudo as Record<string, boolean>
+
+    expect(pseudo.hover).toBe(false)
+    expect(pseudo.focus).toBe(false)
+    expect(pseudo.pressed).toBe(false)
+  })
+
+  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")
+  })
+
+  it("forwards original onMouseEnter handler", () => {
+    const HOC = createLocalProvider(BaseComponent)
+    const originalHandler = vi.fn()
+    const mockEvent = new MouseEvent("mouseenter")
+
+    HOC({ onMouseEnter: originalHandler } as any)
+
+    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
+    ;(callProps.onMouseEnter as (e: MouseEvent) => void)(mockEvent)
+
+    expect(originalHandler).toHaveBeenCalledWith(mockEvent)
+  })
+
+  it("forwards original onMouseLeave handler", () => {
+    const HOC = createLocalProvider(BaseComponent)
+    const originalHandler = vi.fn()
+    const mockEvent = new MouseEvent("mouseleave")
+
+    HOC({ onMouseLeave: originalHandler } as any)
+
+    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
+    ;(callProps.onMouseLeave as (e: MouseEvent) => void)(mockEvent)
+
+    expect(originalHandler).toHaveBeenCalledWith(mockEvent)
+  })
+
+  it("forwards original onMouseDown handler", () => {
+    const HOC = createLocalProvider(BaseComponent)
+    const originalHandler = vi.fn()
+    const mockEvent = new MouseEvent("mousedown")
+
+    HOC({ onMouseDown: originalHandler } as any)
+
+    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
+    ;(callProps.onMouseDown as (e: MouseEvent) => void)(mockEvent)
+
+    expect(originalHandler).toHaveBeenCalledWith(mockEvent)
+  })
+
+  it("forwards original onMouseUp handler", () => {
+    const HOC = createLocalProvider(BaseComponent)
+    const originalHandler = vi.fn()
+    const mockEvent = new MouseEvent("mouseup")
+
+    HOC({ onMouseUp: originalHandler } as any)
+
+    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
+    ;(callProps.onMouseUp as (e: MouseEvent) => void)(mockEvent)
+
+    expect(originalHandler).toHaveBeenCalledWith(mockEvent)
+  })
+
+  it("forwards original onFocus handler", () => {
+    const HOC = createLocalProvider(BaseComponent)
+    const originalHandler = vi.fn()
+    const mockEvent = new FocusEvent("focus")
+
+    HOC({ onFocus: originalHandler } as any)
+
+    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
+    ;(callProps.onFocus as (e: FocusEvent) => void)(mockEvent)
+
+    expect(originalHandler).toHaveBeenCalledWith(mockEvent)
+  })
+
+  it("forwards original onBlur handler", () => {
+    const HOC = createLocalProvider(BaseComponent)
+    const originalHandler = vi.fn()
+    const mockEvent = new FocusEvent("blur")
+
+    HOC({ onBlur: originalHandler } as any)
+
+    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
+    ;(callProps.onBlur as (e: FocusEvent) => void)(mockEvent)
+
+    expect(originalHandler).toHaveBeenCalledWith(mockEvent)
+  })
+
+  it("does not forward event handlers that were not provided", () => {
+    const HOC = createLocalProvider(BaseComponent)
+
+    HOC({} as any)
+
+    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"))
+    }).not.toThrow()
+  })
+
+  it("merges existing $rocketstate with pseudo state", () => {
+    const HOC = createLocalProvider(BaseComponent)
+
+    HOC({
+      $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")
+    const pseudo = rocketstate.pseudo as Record<string, unknown>
+    expect(pseudo.disabled).toBe(true)
+    expect(pseudo.hover).toBe(false)
+    expect(pseudo.focus).toBe(false)
+    expect(pseudo.pressed).toBe(false)
+  })
+
+  it("provides updated state to local context", () => {
+    const HOC = createLocalProvider(BaseComponent)
+
+    HOC({} as any)
+
+    expect(mockedProvide).toHaveBeenCalledTimes(1)
+    const [, providedValue] = mockedProvide.mock.calls[0] as [unknown, Record<string, unknown>]
+    const pseudo = providedValue.pseudo as Record<string, boolean>
+    expect(pseudo.hover).toBe(false)
+    expect(pseudo.focus).toBe(false)
+    expect(pseudo.pressed).toBe(false)
+  })
+
+  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)
+
+    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")
+    // 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", () => {
+    const HOC = createLocalProvider(BaseComponent)
+    const originalState = { existing: true }
+
+    HOC({ $rocketstate: originalState } as any)
+
+    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
+    const rocketstate = callProps.$rocketstate as Record<string, unknown>
+    // Should have merged pseudo state
+    expect(rocketstate.pseudo).toBeDefined()
+    // Original state is preserved
+    expect(rocketstate.existing).toBe(true)
+  })
+
+  it("returns the result of the wrapped component", () => {
+    const expectedResult = {
+      type: "div",
+      props: { "data-result": "yes" },
+      children: ["Result"],
+      key: null,
+    }
+    const MockComponent = vi.fn(() => expectedResult)
+    const HOC = createLocalProvider(MockComponent as any)
+
+    const result = HOC({} as any)
+
+    expect(result).toBe(expectedResult)
+  })
+})

package/src/__tests__/dimensions.test.ts

@@ -0,0 +1,183 @@
+import {
+  getDimensionsMap,
+  getDimensionsValues,
+  getKeys,
+  getMultipleDimensions,
+  getTransformDimensions,
+  getValues,
+  isMultiKey,
+  isValidKey,
+} from "../utils/dimensions"
+
+describe("isValidKey", () => {
+  it("returns true for truthy values", () => {
+    expect(isValidKey("a")).toBe(true)
+    expect(isValidKey(1)).toBe(true)
+    expect(isValidKey(true)).toBe(true)
+    expect(isValidKey(0)).toBe(true)
+    expect(isValidKey("")).toBe(true)
+  })
+
+  it("returns false for undefined, null, false", () => {
+    expect(isValidKey(undefined)).toBe(false)
+    expect(isValidKey(null)).toBe(false)
+    expect(isValidKey(false)).toBe(false)
+  })
+})
+
+describe("isMultiKey", () => {
+  it("returns [true, propName] for object with propName", () => {
+    expect(isMultiKey({ propName: "tags", multi: true })).toEqual([true, "tags"])
+  })
+
+  it("returns [false, value] for string", () => {
+    expect(isMultiKey("variant")).toEqual([false, "variant"])
+  })
+})
+
+describe("getKeys", () => {
+  it("returns object keys", () => {
+    expect(getKeys({ a: 1, b: 2 })).toEqual(["a", "b"])
+  })
+
+  it("returns empty array for empty object", () => {
+    expect(getKeys({})).toEqual([])
+  })
+})
+
+describe("getValues", () => {
+  it("returns object values", () => {
+    expect(getValues({ a: 1, b: 2 })).toEqual([1, 2])
+  })
+})
+
+describe("getDimensionsValues", () => {
+  it("extracts string dimension values", () => {
+    const dimensions = { size: "size", variant: "variant" }
+    expect(getDimensionsValues(dimensions)).toEqual(["size", "variant"])
+  })
+
+  it("extracts propName from object dimensions", () => {
+    const dimensions = {
+      size: "size",
+      tags: { propName: "tags", multi: true },
+    }
+    expect(getDimensionsValues(dimensions)).toEqual(["size", "tags"])
+  })
+})
+
+describe("getMultipleDimensions", () => {
+  it("identifies multi-key dimensions", () => {
+    const dimensions = {
+      size: "size",
+      tags: { propName: "tags", multi: true },
+    }
+    expect(getMultipleDimensions(dimensions)).toEqual({ tags: true })
+  })
+
+  it("returns empty for no multi dimensions", () => {
+    const dimensions = { size: "size", variant: "variant" }
+    expect(getMultipleDimensions(dimensions)).toEqual({})
+  })
+
+  it("skips multi=false", () => {
+    const dimensions = {
+      tags: { propName: "tags", multi: false },
+    }
+    expect(getMultipleDimensions(dimensions)).toEqual({})
+  })
+})
+
+describe("getDimensionsMap", () => {
+  it("builds keysMap and keywords from themes", () => {
+    const themes = {
+      size: { small: { fontSize: 12 }, large: { fontSize: 18 } },
+    }
+    const result = getDimensionsMap({ themes })
+    expect(result.keysMap).toEqual({
+      size: { small: true, large: true },
+    })
+    expect(result.keywords.size).toBe(true)
+  })
+
+  it("adds dimension keys to keywords when useBooleans", () => {
+    const themes = {
+      size: { small: { fontSize: 12 }, large: { fontSize: 18 } },
+    }
+    const result = getDimensionsMap({ themes, useBooleans: true })
+    expect(result.keywords.small).toBe(true)
+    expect(result.keywords.large).toBe(true)
+  })
+
+  it("skips invalid values (false, null, undefined)", () => {
+    const themes = {
+      size: { small: { fontSize: 12 }, disabled: false, hidden: null },
+    }
+    const result = getDimensionsMap({ themes })
+    expect(result.keysMap.size).toEqual({ small: true })
+  })
+
+  it("returns empty for empty themes", () => {
+    const result = getDimensionsMap({ themes: {} })
+    expect(result.keysMap).toEqual({})
+    expect(result.keywords).toEqual({})
+  })
+
+  it("includes function values (transform modifiers) as valid keys", () => {
+    const themes = {
+      modifier: {
+        outlined: (theme: any) => ({ color: theme.bg }),
+        ghost: () => ({ bg: "transparent" }),
+      },
+    }
+    const result = getDimensionsMap({ themes })
+    expect(result.keysMap).toEqual({
+      modifier: { outlined: true, ghost: true },
+    })
+    expect(result.keywords.modifier).toBe(true)
+  })
+
+  it("includes function values as boolean keywords when useBooleans", () => {
+    const themes = {
+      modifier: {
+        outlined: (theme: any) => ({ color: theme.bg }),
+      },
+    }
+    const result = getDimensionsMap({ themes, useBooleans: true })
+    expect(result.keywords.outlined).toBe(true)
+  })
+})
+
+describe("getTransformDimensions", () => {
+  it("identifies transform dimensions", () => {
+    const dimensions = {
+      states: "state",
+      modifiers: { propName: "modifier", multi: true, transform: true },
+    }
+    expect(getTransformDimensions(dimensions)).toEqual({ modifier: true })
+  })
+
+  it("returns empty when no transform dimensions exist", () => {
+    const dimensions = {
+      states: "state",
+      sizes: "size",
+      multiple: { propName: "multiple", multi: true },
+    }
+    expect(getTransformDimensions(dimensions)).toEqual({})
+  })
+
+  it("skips dimensions without transform flag", () => {
+    const dimensions = {
+      states: "state",
+      tags: { propName: "tags", multi: true },
+    }
+    expect(getTransformDimensions(dimensions)).toEqual({})
+  })
+
+  it("skips transform=false", () => {
+    const dimensions = {
+      modifiers: { propName: "modifier", multi: true, transform: false },
+    }
+    expect(getTransformDimensions(dimensions)).toEqual({})
+  })
+})