TypeScript: type-level programming and some helpers

asserts.ts

import { DeepNonNullable, Falsy, isFalsy } from "utility-types";

export const isNullable = <T>(value: Nullable<T>): value is null | undefined => value == null;

export const assertIsDefined = <T>(val: T): asserts val is NonNullable<T> => {
  if (isNullable(val)) {
    throw new Error(`Expected 'val' to be defined, but received ${val}`);
  }
};

type Truthy<T> = Exclude<T, Falsy>;

export const assertTruthy = <T>(value: T, message?: string): asserts value is Truthy<T> => {
  if (isFalsy(value)) {
    throw new Error(message);
  }
};

async-await.ts

type Async<F extends (...args: any[]) => any> = (...args: Parameters<F>) => Promise<ReturnType<F>>;

defined.ts

type Defined<T> = Exclude<T, undefined>;

equals.ts

// https://github.com/Microsoft/TypeScript/issues/27024
export type Equals<X, Y> =
  (<T>() => T extends X ? 1 : 0) extends
  (<T>() => T extends Y ? 1 : 0) ? true : false;

index-signature.ts

export type IndexSignature<O extends object> = {
  [P in keyof O]: O[P];
};

infer-intersection.ts

type InferIntersection<I, T> = I extends (T & infer U) ? U : never;

nullable.ts

type Nullable<T> = T | null;

const nonNull = <T>(x?: Nullable<T>): boolean = x != null;

ShouldNotBeNull.ts

type ShouldNotBeNull<T> = 1 extends (T extends null ? 1 : never) ? never : T;

function f<K>(x: ShouldNotBeNull<K>): void { x; }

f<number>(1)
// @ts-expect-error: TS2345
f<number|null>(1)

ref

• types
  • https://qiita.com/uhyo/items/e2fdef2d3236b9bfe74a
• conditional types
  • https://qiita.com/Quramy/items/b45711789605ef9f96de
• utils
  • https://www.typescriptlang.org/docs/handbook/utility-types.html
• index signature
  • microsoft/TypeScript#15300 (comment)

type AndExtends<T, A, B> = any extends T ? A : B
type AndExtends<T, A, B> = A | B; // T != any

ShouldNotBeNull

• TS Playground
• https://twitter.com/todesking/status/1653789795154538498