@pyreon/core 0.15.0 → 0.18.0

package/src/tests/reactive-props.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { makeReactiveProps, REACTIVE_PROP, _rp } from '../props'
+import { makeReactiveProps, REACTIVE_PROP, _rp, _wrapSpread } from '../props'
 
 describe('makeReactiveProps', () => {
   it('returns raw object when no reactive props exist (fast path)', () => {
@@ -85,3 +85,73 @@ describe('_rp', () => {
     expect(branded()).toBe('hello')
   })
 })
+
+describe('_wrapSpread', () => {
+  it('returns null/undefined unchanged (primitive guard)', () => {
+    expect(_wrapSpread(null)).toBe(null)
+    expect(_wrapSpread(undefined)).toBe(undefined)
+  })
+
+  it('returns source unchanged when no getter descriptors exist (fast path)', () => {
+    const source = { a: 1, b: 'x', c: true }
+    expect(_wrapSpread(source)).toBe(source)
+  })
+
+  it('returns source unchanged for empty objects', () => {
+    const source = {}
+    expect(_wrapSpread(source)).toBe(source)
+  })
+
+  it('wraps getter-shaped reactive props as _rp-branded thunks', () => {
+    let liveValue = 'a'
+    const source = {} as Record<string, unknown>
+    Object.defineProperty(source, 'x', {
+      get: () => liveValue,
+      enumerable: true,
+      configurable: true,
+    })
+
+    const result = _wrapSpread(source) as Record<string, unknown>
+    expect(result).not.toBe(source) // new object allocated
+
+    const wrappedX = result.x as () => unknown
+    expect(typeof wrappedX).toBe('function')
+    expect((wrappedX as unknown as Record<symbol, unknown>)[REACTIVE_PROP]).toBe(true)
+
+    // Lazy read — each call reads the current source[x] getter value
+    expect(wrappedX()).toBe('a')
+    liveValue = 'b'
+    expect(wrappedX()).toBe('b') // live re-read, not captured
+  })
+
+  it('preserves data properties as-is when mixed with getters', () => {
+    const source = { plain: 'data' } as Record<string, unknown>
+    Object.defineProperty(source, 'reactive', {
+      get: () => 'live',
+      enumerable: true,
+      configurable: true,
+    })
+
+    const result = _wrapSpread(source) as Record<string, unknown>
+    expect(result.plain).toBe('data') // copied through
+    expect(typeof result.reactive).toBe('function') // wrapped as thunk
+  })
+
+  it('preserves Reflect.ownKeys symbol-keyed properties', () => {
+    const sym = Symbol('marker')
+    const source = { regular: 'x' } as Record<string | symbol, unknown>
+    Object.defineProperty(source, 'reactive', {
+      get: () => 'live',
+      enumerable: true,
+      configurable: true,
+    })
+    source[sym] = 'symbol-value'
+
+    const result = _wrapSpread(source) as Record<string | symbol, unknown>
+    expect(result.regular).toBe('x')
+    // Note: symbol keys go through Reflect.ownKeys; the wrap path indexes
+    // via `key as string` for type narrowing but the runtime carries them
+    // forward as data properties.
+    expect(typeof result.reactive).toBe('function')
+  })
+})

package/src/types.ts

@@ -30,8 +30,49 @@ export type ComponentFn<P extends Props = Props> = (props: P) => VNodeChild
 
 // ─── Utility types ───────────────────────────────────────────────────────────
 
-/** Extract the props type from a component function, or pass through if already a props type. */
-export type ExtractProps<T> = T extends ComponentFn<infer P> ? P : T
+/**
+ * Extract the props type from a component function, or pass through if already
+ * a props type. **Multi-overload aware** — matches up to 4 call signatures and
+ * produces the UNION of their first-argument types. A single-overload function
+ * still works (the union of 4 copies of the same props type dedupes back to
+ * the single shape).
+ *
+ * **Why this shape**. `T extends (props: infer P) => any ? P : never` only
+ * captures the LAST overload of a multi-overload function — TS's overload-
+ * resolution-against-conditional-types semantics. Multi-overload primitives
+ * (Iterator, List, Element, etc.) need the union of every overload's props
+ * to survive HOC wrapping (`rocketstyle()`, `attrs()`) without silently
+ * downgrading the public prop surface to the loosest overload. Mirrors
+ * vitus-labs PR #222.
+ *
+ * @example
+ * function Iterator<T extends SimpleValue>(p: { data: T[]; valueName?: string }): VNodeChild
+ * function Iterator<T extends ObjectValue>(p: { data: T[]; component: ComponentFn<T> }): VNodeChild
+ * type Props = ExtractProps<typeof Iterator>
+ * // → { data: SimpleValue[]; valueName?: string }
+ * //  | { data: ObjectValue[]; component: ComponentFn<ObjectValue> }
+ */
+export type ExtractProps<T> = T extends {
+  (props: infer P1, ...args: any): any
+  (props: infer P2, ...args: any): any
+  (props: infer P3, ...args: any): any
+  (props: infer P4, ...args: any): any
+}
+  ? P1 | P2 | P3 | P4
+  : T extends {
+        (props: infer P1, ...args: any): any
+        (props: infer P2, ...args: any): any
+        (props: infer P3, ...args: any): any
+      }
+    ? P1 | P2 | P3
+    : T extends {
+          (props: infer P1, ...args: any): any
+          (props: infer P2, ...args: any): any
+        }
+      ? P1 | P2
+      : T extends ComponentFn<infer P>
+        ? P
+        : T
 
 /** A higher-order component that wraps a component, optionally transforming its props. */
 export type HigherOrderComponent<HOP extends Props, P extends Props | undefined = undefined> = (