tmu
4ebe18adb1
Rename `MatcherStrict` / `MatcherWidening` to `PrimitiveUnionMatcherStrict` / `PrimitiveUnionMatcherWidening`, matching the exported `getPrimitiveUnionMatcher(W)` names and the `TaggedUnionMatcher*` pair. Folds in the working-tree lint cleanups: drop the now-unneeded `typescript/unified-signatures` disables and turn the tagged-union factory interfaces into type aliases.
104 lines
4.1 KiB
TypeScript
104 lines
4.1 KiB
TypeScript
import type { Exact } from "type-fest";
|
|
|
|
import type {
|
|
HandlerMap,
|
|
Matchable,
|
|
PatternKey,
|
|
PatternParam,
|
|
PatternReturns,
|
|
RedundantFallback,
|
|
UnaryFn,
|
|
} from "./matcher-shared.ts";
|
|
|
|
type Handlers<T extends Matchable, R> = {
|
|
[K in PatternKey<T>]: UnaryFn<PatternParam<K>, R>;
|
|
};
|
|
|
|
// The fallback is a *second argument*, not a property of the handler map,
|
|
// because its parameter is the remainder `Exclude<T, keyof Handled>` and TypeScript
|
|
// fixes a property's contextual type before it infers its sibling keys. A later
|
|
// argument, by contrast, is contextually typed from inference on an earlier
|
|
// one, so the split is what makes the remainder expressible at all.
|
|
// See development/library.md.
|
|
type Fallback<T extends Matchable, Handled, R> = UnaryFn<
|
|
Exclude<T, PatternParam<keyof Handled>>,
|
|
R
|
|
>;
|
|
|
|
// A fallback is redundant once the handler map covers `T`. The guard is folded
|
|
// into `Handled`'s own (self-referential) constraint so it is checked *after*
|
|
// inference; a conditional in the fallback's parameter type is evaluated while
|
|
// `Handled` is still its constraint and would reject context-sensitive partial
|
|
// maps. That placement also fixes where the diagnostic lands: the constraint
|
|
// failure is reported on the argument that inferred `Handled` (the handler
|
|
// map), so the required property is spelled as the message instead of relying
|
|
// on its position. See development/library.md.
|
|
type MustBePartial<T extends Matchable, Handled> =
|
|
PatternKey<T> extends keyof Handled ? RedundantFallback : unknown;
|
|
|
|
// TypeScript does not apply the excess-property check to a generic constraint,
|
|
// so `Exact` restores it for the generic forms: a handler map can otherwise
|
|
// carry keys outside `T`.
|
|
|
|
// Strict returns: one common `R`. Overload order is load-bearing:
|
|
// #1 Handlers (first) -> the exhaustive form and the autocomplete popup
|
|
// #2 Fallback (last) -> accepts a partial handler map plus a fallback
|
|
interface PrimitiveUnionMatcherStrict<T extends Matchable> {
|
|
<R>(handlers: Handlers<T, R>): UnaryFn<T, R>;
|
|
<
|
|
R,
|
|
Handled extends Exact<Partial<Handlers<T, R>>, Handled> &
|
|
MustBePartial<T, Handled>,
|
|
>(
|
|
handlers: Handled & Partial<Handlers<T, R>>,
|
|
fallback: Fallback<T, Handled, R>,
|
|
): UnaryFn<T, R>;
|
|
}
|
|
|
|
// Widened returns: the union of every handler's return type. `P` is inferred
|
|
// from the whole handler map, whose closed constraint supplies the
|
|
// contextual/autocomplete type.
|
|
interface PrimitiveUnionMatcherWidening<T extends Matchable> {
|
|
<P extends Exact<Handlers<T, unknown>, P>>(
|
|
handlers: P,
|
|
): UnaryFn<T, PatternReturns<P>>;
|
|
<
|
|
R,
|
|
Handled extends Exact<Partial<Handlers<T, unknown>>, Handled> &
|
|
MustBePartial<T, Handled>,
|
|
>(
|
|
handlers: Handled,
|
|
fallback: Fallback<T, Handled, R>,
|
|
): UnaryFn<T, PatternReturns<Handled> | R>;
|
|
}
|
|
|
|
const dispatch =
|
|
(handlers: HandlerMap, fallback?: UnaryFn<never, unknown>) =>
|
|
(shape: Matchable): unknown =>
|
|
// `handlers[true]` already coerces to the `"true"` property at runtime,
|
|
// identical to `handlers[String(shape)]`, so indexing with `shape`
|
|
// directly is sound: `shape` is a facade-checked universe member and
|
|
// `PatternKey` only ever produces valid property keys. The assertion is
|
|
// needed solely because TypeScript forbids indexing with
|
|
// `boolean`/`null`/`undefined` (TS2538); it buys the number fast path.
|
|
(
|
|
handlers[
|
|
// oxlint-disable-next-line typescript/no-unsafe-type-assertion
|
|
shape as string | number
|
|
] ??
|
|
fallback ??
|
|
(() => {
|
|
throw new Error(`Unhandled shape: ${String(shape)}`);
|
|
})
|
|
)(
|
|
// oxlint-disable-next-line typescript/no-unsafe-type-assertion
|
|
shape as never,
|
|
);
|
|
|
|
export const getPrimitiveUnionMatcher = <
|
|
T extends Matchable,
|
|
>(): PrimitiveUnionMatcherStrict<T> => dispatch;
|
|
export const getPrimitiveUnionMatcherW = <
|
|
T extends Matchable,
|
|
>(): PrimitiveUnionMatcherWidening<T> => dispatch;
|