@pyreon/rocketstyle 0.24.4 → 0.24.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/rocketstyle",
-  "version": "0.24.4",
+  "version": "0.24.6",
   "description": "Multi-dimensional style composition for Pyreon components",
   "license": "MIT",
   "repository": {
@@ -13,8 +13,7 @@
     "!lib/**/*.map",
     "!lib/analysis",
     "README.md",
-    "LICENSE",
-    "src"
+    "LICENSE"
   ],
   "type": "module",
   "sideEffects": false,
@@ -22,7 +21,6 @@
   "types": "./lib/index.d.ts",
   "exports": {
     ".": {
-      "bun": "./src/index.ts",
       "import": "./lib/index.js",
       "types": "./lib/index.d.ts"
     }
@@ -43,8 +41,8 @@
   },
   "devDependencies": {
     "@pyreon/test-utils": "^0.13.11",
-    "@pyreon/typescript": "^0.24.4",
-    "@pyreon/ui-core": "^0.24.4",
+    "@pyreon/typescript": "^0.24.6",
+    "@pyreon/ui-core": "^0.24.6",
     "@vitest/browser-playwright": "^4.1.4",
     "@vitus-labs/tools-rolldown": "^2.4.0"
   },
@@ -52,9 +50,9 @@
     "node": ">= 22"
   },
   "dependencies": {
-    "@pyreon/core": "^0.24.4",
-    "@pyreon/reactivity": "^0.24.4",
-    "@pyreon/styler": "^0.24.4",
-    "@pyreon/ui-core": "^0.24.4"
+    "@pyreon/core": "^0.24.6",
+    "@pyreon/reactivity": "^0.24.6",
+    "@pyreon/styler": "^0.24.6",
+    "@pyreon/ui-core": "^0.24.6"
   }
 }

package/src/__tests__/attrs-overloads.test.ts

@@ -1,97 +0,0 @@
-import type { ComponentFn } from '@pyreon/core'
-import rocketstyle from '../init'
-
-// Type-level regression tests for the post-#225/#227 `.attrs()` overload
-// split: (a) DFP widening makes `.attrs(obj)` keys optional at JSX call site,
-// (b) callback overload preserves Pyreon's loose-return convention so
-// `_documentProps` / `tag: 'a'` runtime extras still typecheck without
-// per-callsite `as any` casts.
-//
-// These are not bisect-load-bearing at runtime — they're type-level
-// assertions exercised by `tsc --noEmit`. Including them in the suite
-// makes failures show up in the test report (vitest treats type errors
-// as compile failures).
-describe('attrs overloads — type-level contract', () => {
-  // A minimal base component standing in for Text / Button / etc.
-  // We only care about the type-level surface here.
-  type BaseProps = {
-    tag?: 'div' | 'span' | 'p' | 'h1' | 'h2' | 'h3'
-    role?: string
-  }
-  const Base: ComponentFn<BaseProps> = () => null
-
-  describe('object overload — keys become optional at JSX site (PR #225)', () => {
-    it('accepts object with default values', () => {
-      const Comp = rocketstyle()({ name: 'Comp', component: Base }).attrs({
-        tag: 'div',
-      })
-      // The component is callable — at the JSX call site, `tag` is now
-      // optional because `.attrs({ tag: 'div' })` provides a default.
-      // Pre-#225 the type would have required `tag` at the JSX site.
-      // We can't directly assert via `expectTypeOf` without the dep, but
-      // the smoke is: the chain compiles without errors.
-      expect(typeof Comp).toBe('function')
-    })
-
-    it('accepts new keys in attrs object', () => {
-      // The attrs object can introduce new keys beyond the base component's
-      // props (here: `customField`). The keys flow into the returned
-      // component's extended-attrs `EA` and become typed props.
-      const Comp = rocketstyle()({ name: 'Comp', component: Base }).attrs({
-        customField: 'hello',
-      })
-      expect(typeof Comp).toBe('function')
-    })
-  })
-
-  describe('callback overload — Pyreon convention for runtime extras', () => {
-    it('accepts callback returning fields outside the base prop union (no as-cast needed)', () => {
-      // This is the canonical document-primitive pattern: a Text-based
-      // rocketstyle that overrides `tag` to a value outside Text's strict
-      // `tag` union AND adds a runtime-only `_documentProps` marker. The
-      // callback's return type intentionally allows `Record<string, unknown>`
-      // for keys outside the user's explicit `<P>` generic, matching
-      // Pyreon's pre-#225 convention.
-      const Comp = rocketstyle()({ name: 'DocLink', component: Base }).attrs<{
-        href?: string
-      }>((props) => ({
-        tag: 'a', // 'a' is NOT in BaseProps['tag'] — falls through Record<string, unknown>
-        _documentProps: { href: props.href ?? '#' },
-      }))
-      expect(typeof Comp).toBe('function')
-    })
-
-    it('accepts callback returning literal values (contextual narrowing via <P>)', () => {
-      // When the user passes an explicit `<P>` generic, the callback's
-      // return is contextually typed against `Partial<P>`. Writing
-      // `tag: 'h1'` stays narrow at literal `'h1'` — no `as const` needed.
-      // Note: tag is in BaseProps['tag'] union so this typechecks against
-      // BOTH the wildcard arm AND the explicit P-key arm.
-      const Comp = rocketstyle()({ name: 'Heading', component: Base }).attrs<{
-        level?: number
-      }>((props) => ({
-        tag: `h${props.level ?? 1}` as 'h1' | 'h2' | 'h3',
-      }))
-      expect(typeof Comp).toBe('function')
-    })
-
-    it('callback receives full DFP-typed props for narrow reads', () => {
-      // The `props` arg passed to the callback IS strictly typed as
-      // `Partial<DFP & P>` — so reading `props.tag` narrows against the
-      // wrapped component's full surface. This is the "props narrow,
-      // return loose" asymmetry Pyreon settled on.
-      const Comp = rocketstyle()({ name: 'Probe', component: Base }).attrs<{
-        scale?: number
-      }>((props) => {
-        // Type check: `props.scale` is `number | undefined`, `props.tag`
-        // is the narrow BaseProps['tag'] union | undefined.
-        const _scale: number | undefined = props.scale
-        const _tag: 'div' | 'span' | 'p' | 'h1' | 'h2' | 'h3' | undefined = props.tag
-        expect(_scale).toBeUndefined()
-        expect(_tag).toBeUndefined()
-        return { scale: 1 }
-      })
-      expect(typeof Comp).toBe('function')
-    })
-  })
-})

package/src/__tests__/attrs.test.ts

@@ -1,190 +0,0 @@
-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__/cache-key-boolean-collision.test.ts

@@ -1,54 +0,0 @@
-/**
- * Bug reproduction: under `useBooleans: true`, `_resolveRsEntry`'s cache
- * key reads `propsRec[dimName]` directly (e.g. `propsRec.state`). Boolean
- * shorthand props like `<X primary />` populate `propsRec.primary` (NOT
- * `propsRec.state`), so the cache key for the `state` slot is `undefined`
- * → `''` regardless of which boolean variant was passed.
- *
- * Result: `<X primary />` and `<X secondary />` produce identical cache
- * keys and share the cached entry. The first-resolved variant's
- * `$rocketstyle` wins for all subsequent renders.
- */
-import { initTestConfig, withThemeContext } from '@pyreon/test-utils'
-import rocketstyle from '../init'
-
-let cleanup: () => void
-beforeAll(() => {
-  cleanup = initTestConfig()
-})
-afterAll(() => cleanup())
-
-const ThemeCapture: any = ({ $rocketstyle, $rocketstate, ...rest }: any) => ({
-  type: 'div',
-  props: rest,
-  $rocketstyle: typeof $rocketstyle === 'function' ? $rocketstyle() : $rocketstyle,
-  $rocketstate: typeof $rocketstate === 'function' ? $rocketstate() : $rocketstate,
-})
-ThemeCapture.displayName = 'ThemeCapture'
-
-describe('rocketstyle — cache-key collision under useBooleans:true', () => {
-  it('different boolean variants produce different $rocketstyle (NOT collide)', () => {
-    const Button: any = rocketstyle({ useBooleans: true })({
-      name: 'BoolButton',
-      component: ThemeCapture,
-    }).states(() => ({
-      primary: { color: 'red' },
-      secondary: { color: 'blue' },
-    }))
-
-    // Render with primary=true. Captures the $rocketstyle resolved
-    // for state='primary'.
-    const a = withThemeContext(() => Button({ primary: true }))
-
-    // Render with secondary=true. Should resolve to state='secondary'
-    // and produce DIFFERENT $rocketstyle.
-    const b = withThemeContext(() => Button({ secondary: true }))
-
-    // Bug: a.$rocketstyle === b.$rocketstyle (same cached entry).
-    // Fix: a.$rocketstyle.color === 'red', b.$rocketstyle.color === 'blue'.
-    expect(a.$rocketstate.state).toBe('primary')
-    expect(b.$rocketstate.state).toBe('secondary')
-    expect(a.$rocketstyle.color).toBe('red')
-    expect(b.$rocketstyle.color).toBe('blue')
-  })
-})

package/src/__tests__/chaining.test.ts

@@ -1,86 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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([])
-  })
-})