web-master

Web Master

Follow these instructions when writing web-related code.

TypeScript

Do not use type assertions

Do not reach for type assertions unless you need one. Never add a type assertion up front because you think you might need it later. You may use a type assertion only when all of these conditions apply:

• You first write the code without a type assertion and encounter a type error.
• You cannot resolve that type error by improving type definitions elsewhere.
• Adding the type assertion does not compromise type safety.

Do not use ReturnType

Do not use ReturnType unless you need it. Use the following approaches instead.

If you need to use the return type of a specific function defined in the project somewhere other than that function:

• For a simple primitive type such as boolean or string, write the type directly.
• For a complex type, define a named type, specify it as the function's return type ((): T => {}), and reuse T.

If you need the return type of a library function:

• Check the function's type definitions first.
• If the library exports that type, use the exported type.
  • If you need to pass the return type of another library function as a type argument and the library does not export that function's return type, you may use ReturnType inside the type argument.
• If the library does not export the type:
  • Write the type directly if it is a simple primitive type.
  • Otherwise, you may use ReturnType.

// Incorrect
import foo from "foo";

const myFunc = (): string => {...};

const myFunc2 = (arg: ReturnType<typeof foo>, arg2: ReturnType<typeof myFunc>): number => {...};

// Correct
import type { FooResult } from "foo";

const myFunc = (): string => {...};

const myFunc2 = (arg: FooResult, arg2: string): number => {...};

Prefer as const satisfies over type annotations

Do not add type annotations unless you need them. Start by writing the code without a type annotation. If that causes a type error, first try to resolve it by improving type definitions elsewhere. Use a type annotation only as a last resort when those changes cannot solve the problem.