tmu
34e9b52ee8
Cleaner separation of concerns:
- options.typeAware: true in .oxlintrc.json activates type-aware
rules declaratively (equivalent to --type-aware CLI flag, but
the script command stays clean: just 'oxlint ...')
- Remove the 3 type-aware rule disables from .oxlintrc.json
- Add source-level oxlint-disable directives instead:
- 4x typescript/no-unsafe-type-assertion (pattern.ts: keysMatch
Object.keys() cast, candidate[] cast; structuralMatcher value
as S cast; match.ts: handler as ... cast in nextCases)
- 1x typescript/no-unnecessary-type-parameters (pattern.ts:
keysMatch <S extends object>)
- 1x file-level typescript/no-floating-promises in index.test.ts
(expectTypeOf() is a sync type-assertion library that the
type-aware linter misidentifies)
Disabling rules at the source (next to the line that needs the
exemption) documents intent more clearly than a global config
override, and makes the trade-off visible to anyone reading the
code. Re-enabling a rule in the future only requires removing the
inline comment, not editing a central config.
57 lines
1.9 KiB
TypeScript
57 lines
1.9 KiB
TypeScript
/* oxlint-disable typescript/no-floating-promises -- expectTypeOf() is a sync type-assertion library that the type-aware linter misidentifies as a promise */
|
|
import { strict as assert } from "node:assert";
|
|
import { test } from "node:test";
|
|
|
|
import { expectTypeOf } from "expect-type";
|
|
|
|
import { type Matcher, P, match } from "./index.ts";
|
|
|
|
test("match returns a builder", () => {
|
|
const builder = match("x");
|
|
expectTypeOf(builder).toHaveProperty("with");
|
|
expectTypeOf(builder).toHaveProperty("exhaustive");
|
|
expectTypeOf(builder).toHaveProperty("otherwise");
|
|
});
|
|
|
|
test("P.literal narrows to its literal type", () => {
|
|
const matcher = P.literal("yes");
|
|
expectTypeOf(matcher).toMatchTypeOf<Matcher<"yes">>();
|
|
assert.equal(matcher.matches("yes"), true);
|
|
assert.equal(matcher.matches("no"), false);
|
|
});
|
|
|
|
test("P.type narrows to the typeof target", () => {
|
|
const matcher = P.type<string>("string");
|
|
expectTypeOf(matcher).toMatchTypeOf<Matcher<string>>();
|
|
assert.equal(matcher.matches("hi"), true);
|
|
assert.equal(matcher.matches(42), false);
|
|
});
|
|
|
|
test("exhaustive() returns the union of handler return types", () => {
|
|
const result = match<"a" | "b">("a")
|
|
.with(P.literal("a"), () => 1 as const)
|
|
.with(P.literal("b"), () => "two" as const)
|
|
.exhaustive();
|
|
|
|
expectTypeOf(result).toEqualTypeOf<1 | "two">();
|
|
assert.equal(result, 1);
|
|
});
|
|
|
|
test("otherwise() falls back when no case matches", () => {
|
|
const result = match<"x" | "y" | "z">("z")
|
|
.with(P.literal("x"), (v): string => `got ${v}`)
|
|
.otherwise((v): string => `fallback ${v}`);
|
|
assert.equal(result, "fallback z");
|
|
});
|
|
|
|
test("exhaustive throws when no case matches", () => {
|
|
assert.throws(
|
|
() =>
|
|
match<"a" | "b" | "c">("c")
|
|
.with(P.literal("a"), () => "A")
|
|
.with(P.literal("b"), () => "B")
|
|
.exhaustive(),
|
|
/no matching case/,
|
|
);
|
|
});
|