TypeScript Ecosystem

<pattern name="bundler">
  <description>For projects using bundlers (Vite, esbuild, webpack)</description>
  <example>
    {
    "compilerOptions": {
    "module": "esnext",
    "moduleResolution": "bundler"
    }
    }
  </example>
</pattern>

<pattern name="path_aliases">
  <description>Import path aliases</description>
  <example>
    {
    "compilerOptions": {
    "baseUrl": ".",
    "paths": {
    "@/*": ["src/*"],
    "@components/*": ["src/components/*"]
    }
    }
    }
  </example>
  <warning>baseUrl: deprecated in TS 6.0, removed in TS 7.0; prefer paths without baseUrl</warning>
  <warning>moduleResolution: "node" (alias "node10"): deprecated in TS 5.x; use "nodenext" or "bundler"</warning>
  <decision_tree name="when_to_use">
    <question>Are you using a bundler or working with Node.js modules?</question>
    <if_yes>Configure appropriate moduleResolution: bundler for bundlers, nodenext for Node.js</if_yes>
    <if_no>Stick with default module resolution for simple projects</if_no>
  </decision_tree>
</pattern>

<pattern name="constraints">
  <description>Generic with type constraints</description>
  <example>
    function getProperty&lt;T, K extends keyof T&gt;(obj: T, key: K): T[K] {
    return obj[key];
    }
  </example>
</pattern>

<pattern name="default_type">
  <description>Generic with default type parameter</description>
  <example>
    interface Container&lt;T = string&gt; {
    value: T;
    }
  </example>
</pattern>

<pattern name="multiple_constraints">
  <description>Multiple generic parameters with constraints</description>
  <example>
    function merge&lt;T extends object, U extends object&gt;(a: T, b: U): T &amp; U {
    return { ...a, ...b };
    }
  </example>
</pattern>

<pattern name="infer">
  <description>Extract types within conditional</description>
  <example>
    type UnwrapPromise&lt;T&gt; = T extends Promise&lt;infer U&gt; ? U : T;
    type ArrayElement&lt;T&gt; = T extends (infer E)[] ? E : never;
  </example>
</pattern>

<pattern name="distributive">
  <description>Distributes over union types</description>
  <example>
    type ToArray&lt;T&gt; = T extends any ? T[] : never;
    // ToArray&lt;string | number&gt; = string[] | number[]
  </example>
</pattern>

<pattern name="key_remapping">
  <description>Map keys with renaming</description>
  <example>
    type Getters&lt;T&gt; = {
    [K in keyof T as `get${Capitalize&lt;string &amp; K&gt;}`]: () =&gt; T[K];
    };
  </example>
</pattern>

<pattern name="filtering">
  <description>Filter properties by type</description>
  <example>
    type OnlyStrings&lt;T&gt; = {
    [K in keyof T as T[K] extends string ? K : never]: T[K];
    };
  </example>
</pattern>

<pattern name="inference">
  <description>Extract parameters from template literals</description>
  <example>
    type ExtractRouteParams&lt;T&gt; = T extends `${string}:${infer Param}/${infer Rest}`
    ? Param | ExtractRouteParams&lt;Rest&gt;
    : T extends `${string}:${infer Param}`
    ? Param
    : never;
  </example>
</pattern>

<pattern name="instanceof">
  <description>Built-in instanceof type guard</description>
  <example>
    function handle(error: Error | string) {
    if (error instanceof Error) {
    return error.message;
    }
    return error;
    }
  </example>
</pattern>

<pattern name="custom">
  <description>Custom type guard function</description>
  <example>
    interface Cat { meow(): void; }
    interface Dog { bark(): void; }

    function isCat(pet: Cat | Dog): pet is Cat {
    return (pet as Cat).meow !== undefined;
    }
  </example>
  <decision_tree name="when_to_use">
    <question>Does TypeScript need help narrowing union types?</question>
    <if_yes>Implement custom type guard with is predicate</if_yes>
    <if_no>Use built-in typeof or instanceof guards</if_no>
  </decision_tree>
</pattern>

<pattern name="in_operator">
  <description>Property existence type guard</description>
  <example>
    function move(animal: Fish | Bird) {
    if ("swim" in animal) {
    animal.swim();
    } else {
    animal.fly();
    }
    }
  </example>
</pattern>

    function createUserId(id: string): UserId {
    return id as UserId;
    }
  </example>
  <note>Prevent mixing similar primitive types</note>
</pattern>

    function parseJson<T>(json: string): Result<T> {
    try {
    return { success: true, data: JSON.parse(json) };
    } catch (e) {
    return { success: false, error: e as Error };
    }
    }
  </example>
  <decision_tree name="when_to_use">
    <question>Do you need explicit error handling without exceptions?</question>
    <if_yes>Use Result type for functional error handling</if_yes>
    <if_no>Use try-catch for traditional exception handling</if_no>
  </decision_tree>
</pattern>

<pattern name="custom_errors">
  <description>Custom error classes with additional context</description>
  <example>
    class ValidationError extends Error {
    constructor(
    message: string,
    public readonly field: string,
    public readonly code: string
    ) {
    super(message);
    this.name = "ValidationError";
    }
    }
  </example>
</pattern>

<pattern name="error_cause">
  <description>Error chaining with cause (ES2022+)</description>
  <example>
    try {
    await fetchData();
    } catch (e) {
    throw new Error("Failed to fetch data", { cause: e });
    }
  </example>
</pattern>

<pattern name="promise_allSettled">
  <description>Handle mixed success/failure</description>
  <example>
    const results = await Promise.allSettled([
    fetchUser(1),
    fetchUser(2),
    fetchUser(3),
    ]);

    const successful = results
    .filter((r): r is PromiseFulfilledResult&lt;User&gt; =&gt; r.status === "fulfilled")
    .map((r) =&gt; r.value);
  </example>
</pattern>

<pattern name="async_iterator">
  <description>Async generator for pagination</description>
  <example>
    async function* paginate&lt;T&gt;(fetchPage: (page: number) =&gt; Promise&lt;T[]&gt;) {
    let page = 0;
    while (true) {
    const items = await fetchPage(page++);
    if (items.length === 0) break;
    yield* items;
    }
    }

    for await (const item of paginate(fetchUsers)) {
    console.log(item);
    }
  </example>
</pattern>

    // Default export
    export default class Service {}

    // Re-exports
    export { util } from "./util.js";
    export type { UtilOptions } from "./util.js";
  </example>
</pattern>

<pattern name="barrel_exports">
  <description>index.ts for clean imports</description>
  <example>
    // src/components/index.ts
    export { Button } from "./Button.js";
    export { Input } from "./Input.js";
    export type { ButtonProps, InputProps } from "./types.js";
  </example>
  <warning>Can impact tree-shaking; use sparingly</warning>
</pattern>

<pattern name="dynamic_import">
  <description>Code splitting with dynamic imports</description>
  <example>
    const module = await import("./heavy-module.js");
    module.doSomething();
  </example>
</pattern>

    export default tseslint.config(
    eslint.configs.recommended,
    ...tseslint.configs.strictTypeChecked,
    {
    languageOptions: {
    parserOptions: {
    projectService: true,
    tsconfigRootDir: import.meta.dirname,
    },
    },
    }
    );
  </example>
  <note>import.meta.dirname requires Node.js 20.11+ or 21.2+ (not available in Node.js 18 LTS)</note>
</pattern>

<key_rules>
  <rule name="@typescript-eslint/no-explicit-any">Prefer unknown over any</rule>
  <rule name="@typescript-eslint/no-unused-vars">Detect unused variables</rule>
  <rule name="@typescript-eslint/strict-boolean-expressions">Require explicit boolean conditions</rule>
  <rule name="@typescript-eslint/no-floating-promises">Require awaiting promises</rule>
  <rule name="@typescript-eslint/prefer-nullish-coalescing">Use ?? over ||</rule>
</key_rules>

      export default defineConfig({
      test: {
      globals: true,
      environment: "node",
      coverage: {
      provider: "v8",
      reporter: ["text", "json", "html"],
      },
      },
      });
    </example>
  </pattern>
</vitest>

<jest>
  <pattern name="config">
    <description>Jest configuration for TypeScript</description>
    <example>
      // jest.config.ts
      import type { Config } from "jest";

      const config: Config = {
      preset: "ts-jest",
      testEnvironment: "node",
      roots: ["&lt;rootDir&gt;/src"],
      moduleNameMapper: {
      "^@/(.\*)$": "&lt;rootDir&gt;/src/$1",
      },
      };

      export default config;
    </example>
  </pattern>
</jest>

<tsx>
  <tool name="tsx">
    <description>TypeScript execution with esbuild</description>
    <use_case name="run">tsx src/index.ts - Run TypeScript directly</use_case>
    <use_case name="watch">tsx watch src/index.ts - Watch mode</use_case>
  </tool>
</tsx>

<tsup>
  <pattern name="config">
    <description>Bundle TypeScript libraries</description>
    <example>
      // tsup.config.ts
      import { defineConfig } from "tsup";

      export default defineConfig({
      entry: ["src/index.ts"],
      format: ["cjs", "esm"],
      dts: true,
      clean: true,
      sourcemap: true,
      });
    </example>
  </pattern>
</tsup>

  type Status = (typeof Status)[keyof typeof Status];
</example>