@pyreon/rocketstyle 0.11.0 → 0.11.2

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@pyreon/rocketstyle",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "repository": {
     "type": "git",
-    "url": "https://github.com/pyreon/ui-system",
+    "url": "https://github.com/pyreon/pyreon",
     "directory": "packages/ui-system/rocketstyle"
   },
   "description": "Multi-dimensional style composition for Pyreon components",
@@ -11,10 +11,11 @@
   "type": "module",
   "sideEffects": false,
   "exports": {
-    "bun": "./src/index.ts",
-    "source": "./src/index.ts",
-    "import": "./lib/index.js",
-    "types": "./lib/index.d.ts"
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    }
   },
   "types": "./lib/index.d.ts",
   "main": "./lib/index.js",
@@ -23,7 +24,8 @@
     "!lib/**/*.map",
     "!lib/analysis",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "src"
   ],
   "engines": {
     "node": ">= 22"
@@ -42,13 +44,13 @@
     "typecheck": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@pyreon/core": "^0.11.0",
-    "@pyreon/reactivity": "^0.11.0",
-    "@pyreon/ui-core": "^0.11.0",
-    "@pyreon/styler": "^0.11.0"
+    "@pyreon/core": "^0.11.2",
+    "@pyreon/reactivity": "^0.11.2",
+    "@pyreon/ui-core": "^0.11.2",
+    "@pyreon/styler": "^0.11.2"
   },
   "devDependencies": {
     "@vitus-labs/tools-rolldown": "^1.15.3",
-    "@pyreon/typescript": "^0.11.0"
+    "@pyreon/typescript": "^0.11.2"
   }
 }

package/src/__tests__/attrs.test.ts

@@ -0,0 +1,190 @@
+import {
+  calculateChainOptions,
+  calculateStylingAttrs,
+  pickStyledAttrs,
+  removeUndefinedProps,
+} from "../utils/attrs"
+
+describe("removeUndefinedProps", () => {
+  it("removes keys with undefined values", () => {
+    const result = removeUndefinedProps({ a: 1, b: undefined, c: "hello" })
+    expect(result).toEqual({ a: 1, c: "hello" })
+  })
+
+  it("keeps null values", () => {
+    const result = removeUndefinedProps({ a: null, b: 0 })
+    expect(result).toEqual({ a: null, b: 0 })
+  })
+
+  it("keeps all falsy non-undefined values", () => {
+    const result = removeUndefinedProps({ a: 0, b: "", c: false, d: null })
+    expect(result).toEqual({ a: 0, b: "", c: false, d: null })
+  })
+
+  it("returns empty for all undefined", () => {
+    expect(removeUndefinedProps({ a: undefined, b: undefined })).toEqual({})
+  })
+
+  it("returns empty for empty input", () => {
+    expect(removeUndefinedProps({})).toEqual({})
+  })
+})
+
+describe("pickStyledAttrs", () => {
+  it("picks keys that exist in keywords with truthy values", () => {
+    const result = pickStyledAttrs(
+      { state: "primary", size: "large", label: "hello" },
+      { state: true, size: true },
+    )
+    expect(result).toEqual({ state: "primary", size: "large" })
+  })
+
+  it("ignores falsy prop values", () => {
+    const result = pickStyledAttrs({ state: "", size: "large" }, { state: true, size: true })
+    expect(result).toEqual({ size: "large" })
+  })
+
+  it("returns empty when no keywords match", () => {
+    const result = pickStyledAttrs({ label: "hello" } as any, { state: true })
+    expect(result).toEqual({})
+  })
+
+  it("returns empty for empty props", () => {
+    const result = pickStyledAttrs({}, { state: true })
+    expect(result).toEqual({})
+  })
+})
+
+describe("calculateChainOptions", () => {
+  it("returns empty object when options is empty array", () => {
+    const calc = calculateChainOptions([])
+    expect(calc([])).toEqual({})
+  })
+
+  it("returns empty object when options is undefined", () => {
+    const calc = calculateChainOptions(undefined)
+    expect(calc([])).toEqual({})
+  })
+
+  it("evaluates chain of functions and merges via Object.assign", () => {
+    const fn1 = (props: any) => ({ a: 1, ...props })
+    const fn2 = (_props: any) => ({ b: 2 })
+    const calc = calculateChainOptions([fn1, fn2])
+    expect(calc([{ c: 3 }])).toEqual({ a: 1, b: 2, c: 3 })
+  })
+
+  it("later functions override earlier ones (shallow)", () => {
+    const fn1 = () => ({ a: 1 })
+    const fn2 = () => ({ a: 2 })
+    const calc = calculateChainOptions([fn1, fn2])
+    expect(calc([])).toEqual({ a: 2 })
+  })
+
+  it("passes all args to each function", () => {
+    const fn = vi.fn(() => ({}))
+    const calc = calculateChainOptions([fn])
+    calc(["arg1", "arg2"] as any)
+    expect(fn).toHaveBeenCalledWith("arg1", "arg2")
+  })
+})
+
+describe("calculateStylingAttrs", () => {
+  it("picks string values from props for dimensions", () => {
+    const calc = calculateStylingAttrs({ useBooleans: false, multiKeys: {} })
+    const result = calc({
+      props: { state: "primary", size: "large" },
+      dimensions: { state: {}, size: {} },
+    })
+    expect(result).toEqual({ state: "primary", size: "large" })
+  })
+
+  it("picks number values from props", () => {
+    const calc = calculateStylingAttrs({ useBooleans: false, multiKeys: {} })
+    const result = calc({
+      props: { state: 0 },
+      dimensions: { state: {} },
+    })
+    expect(result).toEqual({ state: 0 })
+  })
+
+  it("sets undefined for non-string/non-number values when booleans disabled", () => {
+    const calc = calculateStylingAttrs({ useBooleans: false, multiKeys: {} })
+    const result = calc({
+      props: { state: true },
+      dimensions: { state: {} },
+    })
+    expect(result).toEqual({ state: undefined })
+  })
+
+  it("allows arrays for multi-key dimensions", () => {
+    const calc = calculateStylingAttrs({
+      useBooleans: false,
+      multiKeys: { multiple: true },
+    })
+    const result = calc({
+      props: { multiple: ["a", "b"] },
+      dimensions: { multiple: {} },
+    })
+    expect(result).toEqual({ multiple: ["a", "b"] })
+  })
+
+  it("resolves boolean props when useBooleans is true (single key)", () => {
+    const calc = calculateStylingAttrs({
+      useBooleans: true,
+      multiKeys: {},
+    })
+    const result = calc({
+      props: { primary: true },
+      dimensions: { state: { primary: true, secondary: true } },
+    })
+    expect(result).toEqual({ state: "primary" })
+  })
+
+  it("resolves multi-key boolean props as array", () => {
+    const calc = calculateStylingAttrs({
+      useBooleans: true,
+      multiKeys: { multiple: true },
+    })
+    const result = calc({
+      props: { a: true, b: true },
+      dimensions: { multiple: { a: true, b: true, c: true } },
+    })
+    expect(result.multiple).toEqual(expect.arrayContaining(["a", "b"]))
+  })
+
+  it("prefers explicit string prop over boolean shorthand", () => {
+    const calc = calculateStylingAttrs({
+      useBooleans: true,
+      multiKeys: {},
+    })
+    const result = calc({
+      props: { state: "secondary", primary: true },
+      dimensions: { state: { primary: true, secondary: true } },
+    })
+    expect(result).toEqual({ state: "secondary" })
+  })
+
+  it("skips boolean keyword when prop value is falsy", () => {
+    const calc = calculateStylingAttrs({
+      useBooleans: true,
+      multiKeys: {},
+    })
+    const result = calc({
+      props: { primary: false },
+      dimensions: { state: { primary: true, secondary: true } },
+    })
+    expect(result.state).toBeUndefined()
+  })
+
+  it("skips boolean resolution when value is already set", () => {
+    const calc = calculateStylingAttrs({
+      useBooleans: true,
+      multiKeys: {},
+    })
+    const result = calc({
+      props: { state: "primary", secondary: true },
+      dimensions: { state: { primary: true, secondary: true } },
+    })
+    expect(result.state).toBe("primary")
+  })
+})

package/src/__tests__/chaining.test.ts

@@ -0,0 +1,86 @@
+import { chainOptions, chainOrOptions, chainReservedKeyOptions } from "../utils/chaining"
+
+describe("chainOptions", () => {
+  it("appends function to defaults", () => {
+    const fn1 = () => ({ a: 1 })
+    const fn2 = () => ({ b: 2 })
+    const result = chainOptions(fn2, [fn1])
+    expect(result).toHaveLength(2)
+    expect(result[0]).toBe(fn1)
+    expect(result[1]).toBe(fn2)
+  })
+
+  it("wraps object in function and appends", () => {
+    const obj = { a: 1 }
+    const result = chainOptions(obj, [])
+    expect(result).toHaveLength(1)
+    expect(result[0]?.()).toEqual({ a: 1 })
+  })
+
+  it("returns defaults when opts is undefined", () => {
+    const fn1 = () => ({ a: 1 })
+    const result = chainOptions(undefined, [fn1])
+    expect(result).toEqual([fn1])
+  })
+
+  it("handles empty defaults", () => {
+    const fn = () => ({ a: 1 })
+    const result = chainOptions(fn, [])
+    expect(result).toHaveLength(1)
+  })
+
+  it("defaults to empty array when defaultOpts missing", () => {
+    const fn = () => ({ a: 1 })
+    // @ts-expect-error testing with undefined defaults
+    const result = chainOptions(fn, undefined)
+    expect(result).toHaveLength(1)
+  })
+})
+
+describe("chainOrOptions", () => {
+  it("merges opts with defaults using keys", () => {
+    const keys = ["a", "b", "c"] as const
+    const opts = { a: "new", c: "also" }
+    const defaults = { a: "old", b: "default", c: "orig" }
+    const result = chainOrOptions(keys, opts, defaults)
+    expect(result).toEqual({ a: "new", b: "default", c: "also" })
+  })
+
+  it("uses default when opt is falsy", () => {
+    const keys = ["a"] as const
+    const opts = { a: "" }
+    const defaults = { a: "default" }
+    const result = chainOrOptions(keys, opts, defaults)
+    expect(result).toEqual({ a: "default" })
+  })
+
+  it("handles missing keys in both", () => {
+    const keys = ["x"] as const
+    const result = chainOrOptions(keys, {}, {})
+    expect(result).toEqual({ x: undefined })
+  })
+})
+
+describe("chainReservedKeyOptions", () => {
+  it("chains options for each reserved key", () => {
+    const keys = ["theme", "styles"] as const
+    const fn1 = () => ({ a: 1 })
+    const fn2 = () => ({ b: 2 })
+    const opts = { theme: fn2 }
+    const defaults = { theme: [fn1], styles: [] }
+
+    const result = chainReservedKeyOptions(keys, opts, defaults)
+    expect(result.theme).toHaveLength(2)
+    expect(result.styles).toHaveLength(0)
+  })
+
+  it("wraps object opts into functions", () => {
+    const keys = ["theme"] as const
+    const opts = { theme: { color: "red" } }
+    const defaults = { theme: [] }
+
+    const result = chainReservedKeyOptions(keys, opts, defaults)
+    expect(result.theme).toHaveLength(1)
+    expect(result.theme?.[0]?.()).toEqual({ color: "red" })
+  })
+})

package/src/__tests__/collection.test.ts

@@ -0,0 +1,35 @@
+import { removeNullableValues } from "../utils/collection"
+
+describe("removeNullableValues", () => {
+  it("removes null values", () => {
+    expect(removeNullableValues({ a: 1, b: null })).toEqual({ a: 1 })
+  })
+
+  it("removes undefined values", () => {
+    expect(removeNullableValues({ a: 1, b: undefined })).toEqual({ a: 1 })
+  })
+
+  it("removes false values", () => {
+    expect(removeNullableValues({ a: 1, b: false })).toEqual({ a: 1 })
+  })
+
+  it("keeps truthy values", () => {
+    expect(removeNullableValues({ a: 1, b: "hello", c: true })).toEqual({
+      a: 1,
+      b: "hello",
+      c: true,
+    })
+  })
+
+  it("keeps zero and empty string", () => {
+    expect(removeNullableValues({ a: 0, b: "" })).toEqual({ a: 0, b: "" })
+  })
+
+  it("returns empty object for all nullable", () => {
+    expect(removeNullableValues({ a: null, b: undefined, c: false })).toEqual({})
+  })
+
+  it("handles empty object", () => {
+    expect(removeNullableValues({})).toEqual({})
+  })
+})

package/src/__tests__/compose.test.ts

@@ -0,0 +1,36 @@
+import { calculateHocsFuncs } from "../utils/compose"
+
+describe("calculateHocsFuncs", () => {
+  it("extracts functions from object values", () => {
+    const fn1 = (x: any) => x
+    const fn2 = (x: any) => x
+    const options = { a: fn1, b: fn2 }
+    const result = calculateHocsFuncs(options)
+    expect(result).toHaveLength(2)
+  })
+
+  it("filters out non-function values", () => {
+    const fn = (x: any) => x
+    const options = { a: fn, b: "string", c: 42, d: null }
+    const result = calculateHocsFuncs(options)
+    expect(result).toHaveLength(1)
+    expect(result[0]).toBe(fn)
+  })
+
+  it("reverses the order", () => {
+    const fn1 = () => "first"
+    const fn2 = () => "second"
+    const options = { a: fn1, b: fn2 }
+    const result = calculateHocsFuncs(options)
+    expect(result[0]).toBe(fn2)
+    expect(result[1]).toBe(fn1)
+  })
+
+  it("returns empty array for empty options", () => {
+    expect(calculateHocsFuncs({})).toEqual([])
+  })
+
+  it("handles undefined options", () => {
+    expect(calculateHocsFuncs(undefined as any)).toEqual([])
+  })
+})

package/src/__tests__/context.test.ts

@@ -0,0 +1,200 @@
+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")>()
+  return {
+    ...original,
+    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")>()
+  return {
+    ...original,
+    Provider: vi.fn(((props: Record<string, unknown>) => ({
+      type: "div",
+      props: { ...props, "data-provider": "core" },
+      children: props.children,
+      key: null,
+    })) as any),
+    context: original.context,
+  }
+})
+
+const mockedUseContext = vi.mocked(useContext)
+const mockedCoreProvider = vi.mocked(CoreProvider)
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  // Default: empty context
+  mockedUseContext.mockReturnValue({} as any)
+  mockedCoreProvider.mockImplementation(((props: Record<string, unknown>) => ({
+    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)
+
+    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.isLight).toBe(true)
+    expect(callArgs.isDark).toBe(false)
+  })
+
+  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 callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
+    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" })
+
+    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
+    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 })
+
+    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
+    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 })
+
+    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
+    expect(callArgs.mode).toBe("light")
+    expect(callArgs.isLight).toBe(true)
+    expect(callArgs.isDark).toBe(false)
+  })
+
+  it("passes theme to provider when provided", () => {
+    const theme = { rootSize: 16, breakpoints: { sm: 576 } }
+    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 }
+    Provider({ children })
+
+    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
+    expect("theme" in callArgs).toBe(false)
+  })
+
+  it("uses custom provider when specified", () => {
+    const customProvider = vi.fn((props: Record<string, unknown>) => ({
+      type: "section",
+      props,
+      children: props.children as VNodeChild,
+      key: null,
+    }))
+
+    const children = { type: "span", props: {}, children: ["Hello"], key: null }
+    Provider({ children, provider: customProvider as any })
+
+    expect(customProvider).toHaveBeenCalledTimes(1)
+    // CoreProvider should NOT have been called
+    expect(mockedCoreProvider).not.toHaveBeenCalled()
+  })
+
+  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 }
+    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 }
+    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", () => {
+    mockedCoreProvider.mockReturnValue(null as any)
+
+    const children = { type: "span", props: {}, children: ["Hello"], key: null }
+    const result = Provider({ children })
+
+    expect(result).toBeNull()
+  })
+
+  it("returns null when provider returns undefined", () => {
+    mockedCoreProvider.mockReturnValue(undefined as any)
+
+    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",
+      theme: { rootSize: 12 },
+    } as any)
+
+    const overrideTheme = { rootSize: 20 }
+    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.theme).toEqual(overrideTheme)
+  })
+
+  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 }
+    Provider({ children })
+
+    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
+    expect(callArgs.mode).toBe("dark")
+    expect(callArgs.isDark).toBe(true)
+  })
+})