@pyreon/rocketstyle 0.24.5 → 0.24.6

package/src/types/config.ts

@@ -1,48 +0,0 @@
-import type { DimensionBooleanAttrs, Dimensions, ExtractDimensions, TDKP } from './dimensions'
-import type { PseudoState } from './pseudo'
-import type { ElementType, TObj } from './utils'
-
-// --------------------------------------------------------
-// CONFIG
-// --------------------------------------------------------
-export type RocketComponentType = ElementType & {
-  IS_ROCKETSTYLE: true
-  $$rocketstyle: Record<string, unknown>
-}
-
-export type RocketProviderState<T extends RocketComponentType | TObj | unknown = unknown> =
-  T extends RocketComponentType ? Partial<T['$$rocketstyle']> & { pseudo: PseudoState } : T
-
-export type ConsumerCtxCBValue<
-  T extends RocketComponentType,
-  D extends Dimensions,
-  DKP extends TDKP,
-> = (
-  attrs: RocketProviderState<T>,
-) => DKP extends TDKP ? Partial<ExtractDimensions<D, DKP> & { pseudo: PseudoState }> : TObj
-
-export type ConsumerCtxCb<D extends Dimensions, DKP extends TDKP = TDKP> = <
-  T extends RocketComponentType,
->(
-  attrs: ConsumerCtxCBValue<T, D, DKP>,
-) => ReturnType<ConsumerCtxCBValue<T, D, DKP>>
-
-export type ConsumerCb<D extends Dimensions, DKP extends TDKP = TDKP> = (
-  ctx: ConsumerCtxCb<D, DKP>,
-) => ReturnType<ConsumerCtxCb<D, DKP>>
-
-export type ConfigAttrs<
-  C extends ElementType | unknown,
-  D extends Dimensions,
-  DKP extends TDKP,
-  UB extends boolean,
-> = Partial<{
-  name: string
-  component: C
-  provider: boolean
-  consumer: ConsumerCb<D, DKP>
-  DEBUG: boolean
-  inversed: boolean
-  passProps: UB extends true ? keyof DimensionBooleanAttrs<D, DKP>[] : never
-  styled: boolean
-}>

package/src/types/configuration.ts

@@ -1,69 +0,0 @@
-import type { ConsumerCb } from './config'
-import type { Dimensions, MultiKeys } from './dimensions'
-import type { PseudoProps } from './pseudo'
-import type { StylesCbArray } from './styles'
-import type { ArrayOfKeys, ArrayOfValues, ElementType, TFn } from './utils'
-
-export type __ROCKETSTYLE__ = {
-  dimensions: Record<string, string>
-  reservedPropNames: Record<string, true>
-  baseTheme: Record<string, unknown>
-  themes: Record<string, unknown>
-}
-
-export type OptionFunc = (...arg: unknown[]) => Record<string, unknown>
-
-export type InitConfiguration<C, D> = {
-  name?: string | undefined
-  component: C
-  useBooleans: boolean
-  dimensions: D
-  dimensionKeys: ArrayOfKeys<D>
-  dimensionValues: ArrayOfValues<D>
-  multiKeys: MultiKeys
-  transformKeys: Partial<Record<string, true>>
-}
-
-export type Configuration<
-  C = ElementType | unknown,
-  D extends Dimensions = Dimensions,
-> = InitConfiguration<C, D> & {
-  provider?: boolean | undefined
-  consumer?: ConsumerCb<D> | undefined
-  DEBUG?: boolean | undefined
-  inversed?: boolean | undefined
-  passProps?: string[] | undefined
-  styled?: boolean | undefined
-
-  // array chaining options
-  attrs: OptionFunc[]
-  priorityAttrs: OptionFunc[]
-  filterAttrs: string[]
-  theme: OptionFunc[]
-  styles: StylesCbArray
-  compose: Record<string, TFn | null | undefined | false>
-  statics: Record<string, any>
-} & Record<string, any>
-
-export type ExtendedConfiguration<
-  C = ElementType | unknown,
-  D extends Dimensions = Dimensions,
-> = InitConfiguration<C, D> & {
-  provider?: boolean | undefined
-  consumer?: ConsumerCb<D> | undefined
-  DEBUG?: boolean | undefined
-  inversed?: boolean | undefined
-  passProps?: string[] | undefined
-  styled?: boolean | undefined
-
-  // array chaining options
-  attrs: OptionFunc
-  priorityAttrs: OptionFunc
-  filterAttrs: string[]
-  theme: OptionFunc
-  styles: StylesCbArray
-  compose: Record<string, TFn | null | undefined | false>
-  statics: Record<string, any>
-} & Record<string, any>
-
-export type DefaultProps = Partial<PseudoProps> & { children?: import('@pyreon/core').VNodeChild }

package/src/types/dimensions.ts

@@ -1,109 +0,0 @@
-import type { DefaultDimensions } from '../constants/defaultDimensions'
-import type { Css } from './styles'
-import type { ThemeModeCallback } from './theme'
-import type { CallBackParam, NullableKeys, ReturnCbParam, Spread, TObj, ValueOf } from './utils'
-
-export type { DefaultDimensions }
-
-export type ExtractNullableDimensionKeys<T> = {
-  [P in keyof T as T[P] extends false ? never : P]: T[P]
-}
-
-export type ExtractDimensionKey<T extends DimensionValue> = T extends DimensionValueObj
-  ? T['propName']
-  : T
-
-export type ExtractDimensionMulti<T extends DimensionValue> = T extends DimensionValueObj
-  ? true
-  : false
-
-export type ExtractDimensionAttrsKeys<D extends Dimensions> = {
-  [I in keyof D]: ExtractDimensionKey<D[I]>
-}[keyof D]
-
-export type DimensionValuePrimitive = string
-export type DimensionValueObj = {
-  propName: string
-  multi?: boolean
-  /** When true, this dimension is evaluated last and its values receive the accumulated theme as argument. */
-  transform?: boolean
-}
-
-export type DimensionValue = DimensionValuePrimitive | DimensionValueObj
-export type Dimensions = Record<string, DimensionValue>
-
-export type MultiKeys<T extends Dimensions = Dimensions> = Partial<
-  Record<ExtractDimensionKey<T[keyof T]>, true>
->
-
-/** Mode-aware value — either the value directly or a m(light, dark) callback. */
-type ModeAware<T> = T | ((mode: 'light' | 'dark') => T)
-
-type DeepPartial<T> = {
-  [K in keyof T]?: T[K] extends (...args: any[]) => any
-    ? T[K]
-    : NonNullable<T[K]> extends Record<string, any>
-      ? DeepPartial<NonNullable<T[K]>> | ModeAware<DeepPartial<NonNullable<T[K]>>> | Extract<T[K], null>
-      : ModeAware<T[K]>
-}
-
-export type DimensionResult<CT, T = any> = Record<
-  string,
-  | boolean
-  | null
-  | DeepPartial<CT>
-  | ((theme: CT, appTheme: T, mode: ThemeModeCallback, css: Css) => DeepPartial<CT>)
->
-export type DimensionObj<CT, T = any> = DimensionResult<CT, T>
-
-export type DimensionCb<T, CT> = (
-  theme: T,
-  mode: ThemeModeCallback,
-  css: Css,
-) => DimensionResult<CT, T>
-
-export type DimensionCallbackParam<T, CT> = DimensionObj<CT, T> | DimensionCb<T, CT>
-
-export type DimensionReturn<P, A> = P extends TObj ? A & P : A
-
-export type TDKP = Record<string, unknown>
-
-export type DimensionProps<
-  K extends DimensionValue,
-  D extends Dimensions,
-  P extends CallBackParam,
-  DKP extends TDKP,
-> = {
-  [I in ExtractDimensionKey<D[keyof D]>]: I extends ExtractDimensionKey<K>
-    ? ExtractNullableDimensionKeys<Spread<[DKP[I], NullableKeys<ReturnCbParam<P>>]>>
-    : DKP[I]
-}
-
-type DimensionTypesHelper<D extends Dimensions, DKP extends TDKP> = {
-  [I in ExtractDimensionKey<D[keyof D]> & keyof DKP]: keyof DKP[I]
-}
-
-export type DimensionObjAttrs<D extends Dimensions, DKP extends TDKP> = {
-  [I in ExtractDimensionKey<D[keyof D]> & keyof DKP]: ExtractDimensionMulti<
-    D[I & keyof D]
-  > extends true
-    ? keyof DKP[I] | Array<keyof DKP[I]>
-    : keyof DKP[I]
-}
-
-export type DimensionBooleanAttrs<D extends Dimensions, DKP extends TDKP> = Partial<
-  Record<ValueOf<DimensionTypesHelper<D, DKP>>, boolean>
->
-
-export type ExtractDimensionProps<
-  D extends Dimensions,
-  DKP extends TDKP,
-  UB extends boolean,
-> = UB extends true
-  ? Partial<ExtractNullableDimensionKeys<DimensionObjAttrs<D, DKP> & DimensionBooleanAttrs<D, DKP>>>
-  : Partial<ExtractNullableDimensionKeys<DimensionObjAttrs<D, DKP>>>
-
-export type ExtractDimensions<
-  D extends Dimensions,
-  DKP extends TDKP,
-> = ExtractNullableDimensionKeys<DimensionObjAttrs<D, DKP>>

package/src/types/hoc.ts

@@ -1,5 +0,0 @@
-import type { ElementType } from './utils'
-
-export type GenericHoc = (component: ElementType) => ElementType
-
-export type ComposeParam = Record<string, GenericHoc | null | undefined | false>

package/src/types/pseudo.ts

@@ -1,19 +0,0 @@
-export type PseudoActions = {
-  onMouseEnter: (e: MouseEvent) => void
-  onMouseLeave: (e: MouseEvent) => void
-  onMouseDown: (e: MouseEvent) => void
-  onMouseUp: (e: MouseEvent) => void
-  onFocus: (e: FocusEvent) => void
-  onBlur: (e: FocusEvent) => void
-}
-
-export type PseudoState = {
-  active: boolean
-  hover: boolean
-  focus: boolean
-  pressed: boolean
-  disabled: boolean
-  readOnly: boolean
-}
-
-export type PseudoProps = Partial<PseudoState & PseudoActions>

package/src/types/rocketComponent.ts

@@ -1,24 +0,0 @@
-import type { Configuration } from './configuration'
-import type { DefaultDimensions, Dimensions } from './dimensions'
-import type { RocketStyleComponent } from './rocketstyle'
-import type { ElementType, ExtractProps, TObj } from './utils'
-
-export type RocketComponent<
-  C extends ElementType = ElementType,
-  T extends TObj = {},
-  CSS extends TObj = {},
-  D extends Dimensions = DefaultDimensions,
-  UB extends boolean = boolean,
-> = (props: Configuration<C, D>) => RocketStyleComponent<
-  // keep original component props + extract dimension props
-  ExtractProps<C>,
-  // set default extending props
-  {},
-  T,
-  CSS,
-  {},
-  {},
-  D,
-  UB,
-  {}
->

package/src/types/rocketstyle.ts

@@ -1,220 +0,0 @@
-import type { VNodeChild } from '@pyreon/core'
-import type { AttrsHelpers } from './attrs'
-import type { ConfigAttrs } from './config'
-import type { DefaultProps } from './configuration'
-import type {
-  DimensionCallbackParam,
-  DimensionProps,
-  Dimensions,
-  DimensionValue,
-  ExtractDimensionProps,
-  ExtractDimensions,
-  MultiKeys,
-  TDKP,
-} from './dimensions'
-import type { ComposeParam } from './hoc'
-import type { Styles, StylesCb } from './styles'
-import type { Theme, ThemeCb, ThemeModeKeys } from './theme'
-import type { ElementType, ExtractProps, MergeTypes, TObj } from './utils'
-
-export type InnerComponentProps = {
-  'data-rocketstyle'?: string | undefined
-} & Record<string, any>
-
-export type RocketStyleComponent<
-  OA extends TObj = {},
-  EA extends TObj = {},
-  T extends TObj = {},
-  CSS extends TObj = {},
-  S extends TObj = {},
-  HOC extends TObj = {},
-  D extends Dimensions = Dimensions,
-  UB extends boolean = boolean,
-  DKP extends TDKP = TDKP,
-> = IRocketStyleComponent<OA, EA, T, CSS, S, HOC, D, UB, DKP> & {
-  [I in keyof D]: <
-    K extends DimensionValue = D[I],
-    P extends DimensionCallbackParam<Theme<T>, Styles<CSS>> = DimensionCallbackParam<
-      Theme<T>,
-      Styles<CSS>
-    >,
-  >(
-    param: P,
-  ) => P extends DimensionCallbackParam<Theme<T>, Styles<CSS>>
-    ? RocketStyleComponent<OA, EA, T, CSS, S, HOC, D, UB, DimensionProps<K, D, P, DKP>>
-    : RocketStyleComponent<OA, EA, T, CSS, S, HOC, D, UB, DKP>
-}
-
-/**
- * @param OA   Origin component props params.
- * @param EA   Extended prop types
- * @param T    Theme passed via context.
- * @param CSS  Custom theme accepted by styles.
- * @param S    Defined statics
- * @param D    Dimensions to be used for defining component states.
- * @param UB   Use booleans value
- * @param DKP  Dimensions key props.
- * @param DFP  Calculated final component props
- */
-export interface IRocketStyleComponent<
-  // original component props
-  OA extends TObj = {},
-  // extended component props
-  EA extends TObj = {},
-  // theme
-  T extends TObj = {},
-  // custom style properties
-  CSS extends TObj = {},
-  // statics
-  S extends TObj = {},
-  // hocs
-  HOC extends TObj = {},
-  // dimensions
-  D extends Dimensions = Dimensions,
-  // use booleans
-  UB extends boolean = boolean,
-  // dimension key props
-  DKP extends TDKP = TDKP,
-  // calculated final props
-  //
-  // `OA extends infer O` distributes over OA's union branches — future-proofs
-  // against the overload-aware `ExtractProps` (follow-up PR); for today's
-  // single-typed OA the distribution collapses to a single branch.
-  //
-  // **OA-overlapping EA keys are widened**. When `.attrs({ tag: 'a' })` sets
-  // a default for `tag` on a wrapper whose OA has `tag: HTMLTags`, we strip
-  // `tag` from OA and re-add it as `Partial<Pick<O, 'tag'>>` — taking O's
-  // WIDER type (`HTMLTags`), not EA's narrow literal `'a'`. The runtime
-  // default is `'a'`; the JSX call site still accepts any `HTMLTags` value
-  // (so `<Btn tag="span" />` is valid). `Partial<Omit<EA, keyof O>>` handles
-  // net-new EA-only keys (no OA conflict) and marks them optional too —
-  // every `.attrs()` value is semantically a default, never required of the
-  // consumer. Mirrors vitus-labs/ui-system PR #225.
-  DFP = OA extends infer O
-    ? Omit<O, keyof EA & keyof O> &
-        Partial<Pick<O, keyof EA & keyof O>> &
-        MergeTypes<
-          [Partial<Omit<EA, keyof O>>, DefaultProps, ExtractDimensionProps<D, DKP, UB>]
-        >
-    : never,
-> {
-  // The component is callable — Pyreon components are plain functions
-  (props: DFP): VNodeChild
-
-  // CONFIG chaining method
-  config: <NC extends ElementType | unknown = unknown>({
-    name,
-    component: NC,
-    provider,
-    consumer,
-    DEBUG,
-    inversed,
-    passProps,
-  }: ConfigAttrs<NC, D, DKP, UB>) => NC extends ElementType
-    ? RocketStyleComponent<ExtractProps<NC>, EA, T, CSS, S, HOC, D, UB, DKP>
-    : RocketStyleComponent<OA, EA, T, CSS, S, HOC, D, UB, DKP>
-
-  // ATTRS chaining method
-  //
-  // Two overloads. TS resolves in declaration order; the callback form is
-  // listed FIRST so a function argument matches it before falling through to
-  // the object form. Mirrors vitus-labs/ui-system PR #227 Issue 2 (callback
-  // overload split).
-  //
-  // **Callback overload — asymmetric props/return**: the `props` arg is
-  // typed strictly as `Partial<DFP & P>` (so reading `props.x` narrows
-  // against the wrapped component's full surface), while the RETURN is
-  // `Partial<P> & Record<string, unknown>` — only the user's explicit `<P>`
-  // generic is checked, with a wildcard for runtime extras. This preserves
-  // Pyreon's documented convention where `.attrs(callback)` returns can
-  // carry runtime-only fields (`_documentProps` markers for the document-
-  // export pipeline, `tag: 'a'` overrides on Text-based components where
-  // the rendered DOM tag is outside the component's narrow `tag` union,
-  // etc.). The runtime is loose by design — `.attrs(cb, { filter })`
-  // strips keys before forwarding to the DOM. Consumers wanting strict
-  // typed extras pass `<P>` with the precise keys they expect.
-  //
-  // **Object overload — `P & Partial<NoInfer<DFP>>`**: TS infers P from
-  // the param's keys. `NoInfer<DFP>` (TS 5.4+) prevents DFP from
-  // contributing to P inference. Combined with DFP widening above, this
-  // makes `.attrs({ tag: 'a' })` keys optional at the JSX call site —
-  // every `.attrs()` value is a default, not a required prop. Mirrors
-  // vitus-labs PR #225.
-  attrs: {
-    <P extends TObj = {}>(
-      param: (
-        props: Partial<DFP & P>,
-        theme: Theme<T>,
-        helpers: AttrsHelpers,
-      ) => Partial<P> & Record<string, unknown>,
-      config?: Partial<{
-        priority: boolean
-        filter: (keyof MergeTypes<[EA, P]>)[]
-      }>,
-    ): RocketStyleComponent<OA, MergeTypes<[EA, P]>, T, CSS, S, HOC, D, UB, DKP>
-
-    <P extends TObj = {}>(
-      param: P & Partial<NoInfer<DFP>>,
-      config?: Partial<{
-        priority: boolean
-        filter: (keyof MergeTypes<[EA, P]>)[]
-      }>,
-    ): RocketStyleComponent<OA, MergeTypes<[EA, P]>, T, CSS, S, HOC, D, UB, DKP>
-  }
-
-  // THEME chaining method
-  theme: <P extends TObj = TObj>(
-    param: Partial<P> | Partial<Styles<CSS>> | ThemeCb<P, Theme<T>>,
-  ) => RocketStyleComponent<OA, EA, T, MergeTypes<[CSS, P]>, S, HOC, D, UB, DKP>
-
-  // STYLES chaining method
-  styles: (param: StylesCb<CSS>) => RocketStyleComponent<OA, EA, T, CSS, S, HOC, D, UB, DKP>
-
-  // COMPOSE chaining method
-  compose: <P extends ComposeParam>(
-    param: P,
-  ) => P extends TObj
-    ? RocketStyleComponent<OA, EA, T, CSS, S, MergeTypes<[HOC, P]>, D, UB, DKP>
-    : RocketStyleComponent<OA, EA, T, CSS, S, HOC, D, UB, DKP>
-
-  // STATICS chaining method
-  statics: <P extends TObj | unknown = unknown>(
-    param: P,
-  ) => P extends TObj
-    ? RocketStyleComponent<OA, EA, T, CSS, MergeTypes<[S, P]>, HOC, D, UB, DKP>
-    : RocketStyleComponent<OA, EA, T, CSS, S, HOC, D, UB, DKP>
-
-  /** Access to all defined statics on the component. */
-  meta: S
-
-  getStaticDimensions: (theme: TObj) => {
-    dimensions: DKP
-    useBooleans: UB
-    multiKeys: MultiKeys<D>
-  }
-
-  getDefaultAttrs: (props: TObj, theme: TObj, mode: ThemeModeKeys) => TObj
-
-  readonly $$rocketstyle: ExtractDimensions<D, DKP>
-  readonly $$originTypes: OA
-  readonly $$extendedTypes: EA
-  readonly $$types: DFP
-
-  IS_ROCKETSTYLE: true
-  displayName: string
-
-  /**
-   * The accumulated `.attrs()` callback chain — hoisted at component-creation
-   * time so external inspectors (notably `extractDocumentTree` from
-   * `@pyreon/connector-document`) can compute post-attrs props without
-   * invoking the full styled wrapper. Each callback maps user props to a
-   * partial props object; `chain.reduce(Object.assign, {})` produces the
-   * post-attrs result.
-   *
-   * Stable contract — consumers can rely on this property being present on
-   * every rocketstyle-wrapped component. Empty array when no `.attrs()`
-   * was ever called on the chain. Treat as read-only; mutating breaks
-   * `extractDocumentTree` and any other inspector consuming the hoist.
-   */
-  readonly __rs_attrs: ReadonlyArray<(props: Record<string, unknown>) => Record<string, unknown>>
-}

package/src/types/styles.ts

@@ -1,61 +0,0 @@
-import type { config } from '@pyreon/ui-core'
-import type { PseudoState } from './pseudo'
-import type { TObj } from './utils'
-
-export interface StylesDefault {}
-
-export type Styles<_S = unknown> = StylesDefault
-
-export type Css = typeof config.css
-export type Style = ReturnType<Css>
-export type OptionStyles = ((css: Css) => ReturnType<Css>)[]
-
-/**
- * Props available inside `.styles()` interpolation functions.
- *
- * - `$rocketstyle` — resolved theme object (the styled() runtime resolves
- *   the reactive accessor before calling interpolation functions)
- * - `$rocketstate` — active dimension values + pseudo state
- *
- * Note: internally, rocketstyle passes $rocketstyle as a `() => CSS` accessor
- * to DynamicStyled for reactive class swapping. But by the time interpolation
- * functions run, it's always been resolved to a plain CSS object.
- */
-/** Pseudo-state style overrides — always present (default to {}). */
-type PseudoStyleOverrides = {
-  hover: Record<string, unknown>
-  focus: Record<string, unknown>
-  active: Record<string, unknown>
-  disabled: Record<string, unknown>
-  pressed: Record<string, unknown>
-  readOnly: Record<string, unknown>
-}
-
-export type RocketStyleInterpolationProps<CSS extends TObj = TObj> = {
-  /** Resolved theme object — merged from .theme(), .states(), .sizes(), .variants(). */
-  $rocketstyle: CSS & PseudoStyleOverrides & Record<string, unknown>
-  /** Active dimension values + pseudo state (hover, focus, pressed, etc.). */
-  $rocketstate: Record<string, string | string[]> & {
-    pseudo: Partial<PseudoState>
-  }
-} & Record<string, any>
-
-/**
- * A tagged-template css function whose interpolation functions
- * receive typed props including `$rocketstyle` and `$rocketstate`.
- */
-export type RocketCss<CSS extends TObj = TObj> = (
-  strings: TemplateStringsArray,
-  ...values: Array<
-    | string
-    | number
-    | boolean
-    | null
-    | undefined
-    | ((props: RocketStyleInterpolationProps<CSS>) => any)
-    | any[]
-  >
-) => any
-
-export type StylesCb<CSS extends TObj = TObj> = (css: RocketCss<CSS>) => ReturnType<Css>
-export type StylesCbArray = StylesCb[]

package/src/types/theme.ts

@@ -1,18 +0,0 @@
-import type { THEME_MODES } from '../constants'
-import type { Css } from './styles'
-import type { MergeTypes } from './utils'
-
-export interface ThemeDefault {}
-
-export type Theme<T> = T extends unknown ? ThemeDefault : MergeTypes<[ThemeDefault, T]>
-
-export type ThemeModeKeys = keyof typeof THEME_MODES
-
-export type ThemeModeCallback = <A = any, B = any>(
-  light: A,
-  dark: B,
-) => (mode: 'light' | 'dark') => A | B
-
-export type ThemeMode = <A = any, B = any>(light: A, dark: B) => A | B
-
-export type ThemeCb<CSS, T> = (theme: T, mode: ThemeModeCallback, css: Css) => Partial<CSS>

package/src/types/utils.ts

@@ -1,98 +0,0 @@
-import type { VNodeChild } from '@pyreon/core'
-
-export type TObj = Record<string, unknown>
-export type TFn = (...args: any) => any
-export type CallBackParam = TObj | TFn
-export type DisplayName = string
-
-/** In Pyreon, components are plain functions — no forwardRef needed. */
-export type ComponentFn<P = any> = ((props: P) => VNodeChild) & Partial<Record<string, any>>
-
-export type ElementType<T extends TObj | unknown = any> = ComponentFn<T>
-
-export type ValueOf<T> = T[keyof T]
-
-export type ArrayOfValues<T> = T[keyof T][]
-
-export type ArrayOfKeys<T> = Array<keyof T>
-
-export type SimpleHoc<P extends Record<string, unknown> = Record<string, unknown>> = <
-  T extends ComponentFn<any>,
->(
-  WrappedComponent: T,
-) => ComponentFn<MergeTypes<[P, ExtractProps<T>]>>
-
-type IsFalseOrNullable<T> = T extends null | undefined | false ? never : true
-export type NullableKeys<T> = { [K in keyof T]: IsFalseOrNullable<T[K]> }
-
-export type ReturnCbParam<P extends TFn | TObj> = P extends TFn ? ReturnType<P> : P
-
-// ─── MergeTypes ───────────────────────────────────────────────
-type Id<T> = T extends infer U ? { [K in keyof U]: U[K] } : never
-
-type IsAny<T> = 0 extends 1 & T ? true : false
-
-type ExtractNullableKeys<T> = {
-  [P in keyof T as IsAny<T[P]> extends true
-    ? P
-    : [T[P]] extends [never]
-      ? never
-      : [T[P]] extends [null | undefined]
-        ? never
-        : P]: T[P]
-}
-
-type SpreadTwo<L, R> = Id<Pick<L, Exclude<keyof L, keyof R>> & R>
-
-export type Spread<A extends readonly [...any]> = A extends [infer L, ...infer R]
-  ? SpreadTwo<L, Spread<R>>
-  : unknown
-
-export type MergeTypes<A extends readonly [...any]> = ExtractNullableKeys<Spread<A>>
-
-// ─── ExtractProps ─────────────────────────────────────────────
-/**
- * Extracts the props type from a Pyreon component function — or passes
- * through the input unchanged when it's 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. Iterator / List / Element
- * are 3-overload primitives where the LAST overload (`ChildrenProps`) is the
- * loosest; without overload-aware extraction, `ExtractProps<Iterator>`
- * returned just `ChildrenProps` and lost both `SimpleProps<T>` and
- * `ObjectProps<T>` — wrapping Iterator through `rocketstyle()` /
- * `attrs()` silently downgraded the public prop surface.
- *
- * The pattern-match shape `T extends { (props: infer P1, ...args: any): any;
- * (props: infer P2, ...args: any): any; ... }` is the canonical TS trick
- * for extracting overload sets — see also `Parameters<T>` semantics.
- *
- * Mirrors vitus-labs PR #222.
- */
-export type ExtractProps<TComponentOrTProps> = TComponentOrTProps 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
-  : TComponentOrTProps extends {
-        (props: infer P1, ...args: any): any
-        (props: infer P2, ...args: any): any
-        (props: infer P3, ...args: any): any
-      }
-    ? P1 | P2 | P3
-    : TComponentOrTProps extends {
-          (props: infer P1, ...args: any): any
-          (props: infer P2, ...args: any): any
-        }
-      ? P1 | P2
-      : TComponentOrTProps extends ComponentFn<infer TProps>
-        ? TProps
-        : TComponentOrTProps