🔧 Resolve oxlint warnings; defer stylistic rules to oxfmt

.oxlintrc.json

@@ -13,7 +13,14 @@
         "eslint/no-undefined": "off",
         "eslint/sort-keys": "off",
         "eslint/id-length": "off",
-        "import/no-named-export": "off"
+        "import/no-named-export": "off",
+        "eslint/one-var": "off",
+        "import/group-exports": "off",
+        "import/exports-last": "off",
+        "eslint/sort-imports": "off",
+        "import/consistent-type-specifier-style": "off",
+        "unicorn/prefer-export-from": "off",
+        "typescript/method-signature-style": "off"
     },
     "env": {
         "builtin": true,

project-specs.md

@@ -27,6 +27,22 @@ typescript-lib-starter-tiny => https://github.com/tmueller/typescript-lib-starte
     - `eslint/sort-keys` — handler/case order is semantic, not alphabetical.
     - `eslint/id-length` — `T`, `R`, `U`, `V` are standard TS generics.
     - `import/no-named-export` — false positive on library entry re-exports.
+    - Stylistic rules superseded by oxfmt (oxfmt is the canonical
+      formatter; these rules either conflict with its output or
+      duplicate features oxfmt already provides):
+        - `eslint/one-var` — oxfmt uses comma-joined `const`
+          declarations; oxlint wanted to split them.
+        - `import/group-exports` — oxfmt keeps separate `export`
+          statements as-is.
+        - `import/exports-last` — statement ordering is up to oxfmt.
+        - `eslint/sort-imports` — replaced by oxfmt's built-in
+          `sortImports` (enabled in `.oxfmtrc.json`).
+        - `import/consistent-type-specifier-style` — inline
+          `import { type X, Y }` is intentional for grouping.
+        - `unicorn/prefer-export-from` — conflicts with how the
+          barrel `src/index.ts` re-exports through `src/match.ts`.
+        - `typescript/method-signature-style` — method signatures
+          in `interface` are conventional TS ergonomics.
           For `*.test.ts` files additionally: `no-unused-expressions` (for
           `expectTypeOf(...)` calls), `no-empty-file` (we have a single import
           per test file in some cases), `import/no-nodejs-modules` (we use

src/index.test.ts

@@ -3,7 +3,7 @@ import { test } from "node:test";
 
 import { expectTypeOf } from "expect-type";
 
-import { match, P, type Matcher } from "./index.ts";
+import { type Matcher, P, match } from "./index.ts";
 
 test("match returns a builder", () => {
     const builder = match("x");

src/match.ts

@@ -1,8 +1,6 @@
 import { P, type Matcher, type Pattern } from "./pattern.ts";
 
-type Cases<R> = ReadonlyArray<
+type Cases<R> = readonly (readonly [Matcher<unknown>, (value: unknown) => R])[];
-    readonly [Matcher<unknown>, (value: unknown) => R]
->;
 
 interface MatchBuilder<T, R> {
     with<U extends T, V>(

src/pattern.ts

@@ -14,7 +14,6 @@ const literalMatcher = <
 ): Matcher<L> => ({
     matches: (candidate): candidate is L => candidate === value,
 });
-
 const typeMatcher = <T>(
         type:
             | "string"
@@ -27,54 +26,66 @@ const typeMatcher = <T>(
             | "function",
     ): Matcher<T> => {
         const matches = (value: unknown): value is T => {
-        if (type === "undefined") return value === undefined;
+            if (type === "undefined") {
-        if (type === "object")
+                return value === undefined;
+            }
+            if (type === "object") {
                 return (
                     (typeof value === "object" && value !== null) ||
                     typeof value === "function"
                 );
+            }
             return typeof value === type;
         };
         return { matches };
-};
+    },
-
+    whenMatcher = <T>(
-const whenMatcher = <T>(
         predicate: (value: unknown) => value is T,
     ): Matcher<T> => ({
         matches: predicate,
-});
+    }),
-
+    whenMatcherAny = <T>(
-const whenMatcherAny = <T>(
         predicate: (value: unknown) => boolean,
     ): Matcher<T> => ({
         matches: (value: unknown): value is T => predicate(value),
-});
+    }),
-
+    isNestedMatcher = (expected: unknown): expected is Matcher<unknown> =>
-const structuralMatcher = <S extends object, T extends S>(
-    shape: S,
-    refine?: (value: S) => value is T,
-): Matcher<T> => ({
-    matches: (value: unknown): value is T => {
-        if (typeof value !== "object" || value === null) return false;
-        const candidate = value as S;
-        for (const key of Object.keys(shape) as Array<keyof S>) {
-            if (!(key in candidate)) return false;
-            const expected = shape[key];
-            const actual = candidate[key];
-            if (
         typeof expected === "object" &&
         expected !== null &&
-                "matches" in expected
+        "matches" in expected,
-            ) {
+    keysMatch = <S extends object>(shape: S, candidate: object): boolean => {
-                const nested = expected as unknown as Matcher<unknown>;
+        for (const key of Object.keys(shape) as (keyof S)[]) {
-                if (!nested.matches(actual)) return false;
+            if (!(key in candidate)) {
+                return false;
+            }
+            const expected = shape[key],
+                actual = candidate[key as keyof object];
+            if (isNestedMatcher(expected)) {
+                if (!expected.matches(actual)) {
+                    return false;
+                }
             } else if (actual !== expected) {
                 return false;
             }
         }
-        return refine
+        return true;
-            ? refine(candidate)
+    },
-            : (true as T extends S ? true : never);
+    structuralMatcher = <S extends object, T extends S>(
+        shape: S,
+        refine?: (value: S) => value is T,
+    ): Matcher<T> => ({
+        matches: (value: unknown): value is T => {
+            if (typeof value !== "object" || value === null) {
+                return false;
+            }
+            const candidate = value as S;
+            if (!keysMatch(shape, candidate)) {
+                return false;
+            }
+            if (refine && !refine(candidate)) {
+                return false;
+            }
+            return true;
         },
     });