import { Actions, HandlerContext, Maybe, Model, Props } from '../types/index.js'; import { Env } from '../boundary/components/env/types.js'; /** * Non-nullable primitive leaves that {@link Paths} can terminate on. Used * internally to stop the recursive walk at scalar boundaries; consumers * shouldn't reach for this directly. * * @internal */ export type Primitive = Maybe; /** * Decrement table used to cap {@link Paths} / {@link BooleanPaths} * recursion depth. Indexing `Depth[N]` produces `N - 1` (or `never` * once the budget is exhausted), keeping the type-checker tractable * on deeply nested models. * * @internal */ export type Depth = [never, 0, 1, 2, 3, 4, 5]; /** * Lodash-style dotted paths reachable from `T`. Yields `"a"`, `"a.b"`, * `"items.0"`, `"items.0.name"`, etc. Recursion is capped at depth 5 to * keep the type-checker tractable on deeply nested models. * * @template T The object type to enumerate paths from. * @template D Recursion budget (internal). */ export type Paths = [D] extends [never] ? never : T extends Primitive ? never : T extends ReadonlyArray ? `${number}` | (U extends Primitive ? never : `${number}.${Paths}`) : T extends object ? { [K in Extract]: T[K] extends Primitive ? K : K | `${K}.${Paths}`; }[Extract] : never; /** * Subset of {@link Paths} whose leaf type is `boolean`. Used by * `context.with.invert` (and the legacy {@link With.Invert}) to restrict the * key to togglable fields only. * * @template T The object type to enumerate boolean leaves from. * @template D Recursion budget (internal). */ export type BooleanPaths = [D] extends [never] ? never : T extends Primitive ? never : T extends ReadonlyArray ? (U extends boolean ? `${number}` : never) | (U extends Primitive ? never : `${number}.${BooleanPaths}`) : T extends object ? { [K in Extract]: T[K] extends boolean ? K : T[K] extends Primitive ? never : `${K}.${BooleanPaths}`; }[Extract] : never; /** * Resolves the leaf type at a dotted path on `T`. `Get<{a:{b:number}},"a.b">` * is `number`; `Get<{items: string[]},"items.0">` is `string`. * * @template T The object type to walk. * @template P The dotted path string. */ export type Get = P extends `${infer Head}.${infer Tail}` ? T extends ReadonlyArray ? Head extends `${number}` ? Get : never : Head extends keyof T ? Get : never : T extends ReadonlyArray ? P extends `${number}` ? U : never : P extends keyof T ? T[P] : never; /** * Returned by `context.with` — a typed bag of handler factories * bound to the model `M` declared in `useContext()`. Methods accept * lodash-style dotted paths (`"a.b.c"`) with array indices (`"items.0.id"`). * * - `update(key)` — assigns the dispatched payload to `model[key]`. * - `invert(key)` — flips a boolean leaf at `model[key]`. * - `always(key, value)` — assigns a fixed `value` to `model[key]`, * ignoring any dispatched payload. * * @template M The model type to bind keys against. */ export type WithHandle = M extends Model ? { update>(key: K): (context: HandlerContext, payload: Get) => void; invert>(key: K): (context: HandlerContext) => void; always>(key: K, value: Get): (context: HandlerContext) => void; } : Record;