@jakubmazanec/ts-utils 1.0.0-fdb1c25

package/dist/types.js

@@ -0,0 +1,17 @@
+export * from "./types/AtLeastOneRequired.js";
+export * from "./types/DeepPartial.js";
+export * from "./types/DeepReadonly.js";
+export * from "./types/If.js";
+export * from "./types/IsEqual.js";
+export * from "./types/LiteralUnion.js";
+export * from "./types/NonArray.js";
+export * from "./types/NonArrayLike.js";
+export * from "./types/OptionalKeys.js";
+export * from "./types/Parameters.js";
+export * from "./types/Primitive.js";
+export * from "./types/RequiredKeys.js";
+export * from "./types/ReturnType.js";
+export * from "./types/TupleToUnion.js";
+export * from "./types/UnionToIntersection.js";
+
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["export * from './types/AtLeastOneRequired.js';\nexport * from './types/DeepPartial.js';\nexport * from './types/DeepReadonly.js';\nexport * from './types/If.js';\nexport * from './types/IsEqual.js';\nexport * from './types/LiteralUnion.js';\nexport * from './types/NonArray.js';\nexport * from './types/NonArrayLike.js';\nexport * from './types/OptionalKeys.js';\nexport * from './types/Parameters.js';\nexport * from './types/Primitive.js';\nexport * from './types/RequiredKeys.js';\nexport * from './types/ReturnType.js';\nexport * from './types/TupleToUnion.js';\nexport * from './types/UnionToIntersection.js';\n"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,gCAAgC,CAAC"}

package/dist/utils/assert.d.ts

@@ -0,0 +1,34 @@
+/**
+ * A subclass of `Error` that indicates an assertion  failure.
+ */
+export declare class AssertionError extends Error {
+    /**
+     * @param message Message added to the default error message
+     */
+    constructor(message?: string);
+}
+/**
+ * A function that throws {@linkcode AssertionError} (with optional message defined with `errorMessage`) if
+ * `condition` is falsy.
+ * You can use it to narrow types:
+ *
+ * ```TypeScript
+ * interface Foo {
+ *   kind: 'Foo';
+ * }
+ *
+ * interface Bar {
+ *   kind: 'Bar';
+ * }
+ *
+ * declare const foobar: Foo | Bar;
+ *
+ * assert(is<Foo>(foobar, foobar.kind === 'Foo'));
+ *
+ * // `typeof foobar` is now `Foo`
+ * ```
+ *
+ * @param condition Condition we're asserting isn't falsy
+ * @param errorMessage Message for the `AssertionError`
+ */
+export declare function assert(condition: unknown, errorMessage?: string): asserts condition;

package/dist/utils/assert.js

@@ -0,0 +1,41 @@
+/**
+ * A subclass of `Error` that indicates an assertion  failure.
+ */ export class AssertionError extends Error {
+    /**
+   * @param message Message added to the default error message
+   */ constructor(message){
+        super(`Wrong assertion encountered${message ? `: "${message}"` : ""}!`);
+        this.name = "AssertionError";
+    }
+}
+/**
+ * A function that throws {@linkcode AssertionError} (with optional message defined with `errorMessage`) if
+ * `condition` is falsy.
+ * You can use it to narrow types:
+ *
+ * ```TypeScript
+ * interface Foo {
+ *   kind: 'Foo';
+ * }
+ *
+ * interface Bar {
+ *   kind: 'Bar';
+ * }
+ *
+ * declare const foobar: Foo | Bar;
+ *
+ * assert(is<Foo>(foobar, foobar.kind === 'Foo'));
+ *
+ * // `typeof foobar` is now `Foo`
+ * ```
+ *
+ * @param condition Condition we're asserting isn't falsy
+ * @param errorMessage Message for the `AssertionError`
+ */ export function assert(condition, errorMessage) {
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- we don't mind here
+    if (!condition) {
+        throw new AssertionError(errorMessage);
+    }
+}
+
+//# sourceMappingURL=assert.js.map

package/dist/utils/assert.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/assert.ts"],"sourcesContent":["/**\n * A subclass of `Error` that indicates an assertion  failure.\n */\nexport class AssertionError extends Error {\n  /**\n   * @param message Message added to the default error message\n   */\n  constructor(message?: string) {\n    super(`Wrong assertion encountered${message ? `: \"${message}\"` : ''}!`);\n\n    this.name = 'AssertionError';\n  }\n}\n\n/**\n * A function that throws {@linkcode AssertionError} (with optional message defined with `errorMessage`) if\n * `condition` is falsy.\n * You can use it to narrow types:\n *\n * ```TypeScript\n * interface Foo {\n *   kind: 'Foo';\n * }\n *\n * interface Bar {\n *   kind: 'Bar';\n * }\n *\n * declare const foobar: Foo | Bar;\n *\n * assert(is<Foo>(foobar, foobar.kind === 'Foo'));\n *\n * // `typeof foobar` is now `Foo`\n * ```\n *\n * @param condition Condition we're asserting isn't falsy\n * @param errorMessage Message for the `AssertionError`\n */\nexport function assert(condition: unknown, errorMessage?: string): asserts condition {\n  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- we don't mind here\n  if (!condition) {\n    throw new AssertionError(errorMessage);\n  }\n}\n"],"names":["AssertionError","Error","constructor","message","name","assert","condition","errorMessage"],"mappings":"AAAA;;GAEG,CACH,OAAO,MAAMA,cAAc,SAASC,KAAK;IACvC;;KAEG,CACHC,YAAYC,OAAgB,CAAE;QAC5B,KAAK,CAAC,CAAC,2BAA2B,EAAEA,OAAO,GAAG,CAAC,GAAG,EAAEA,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAExE,IAAI,CAACC,IAAI,GAAG,gBAAgB,CAAC;KAC9B;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG,CACH,OAAO,SAASC,MAAM,CAACC,SAAkB,EAAEC,YAAqB,EAAqB;IACnF,+FAA+F;IAC/F,IAAI,CAACD,SAAS,EAAE;QACd,MAAM,IAAIN,cAAc,CAACO,YAAY,CAAC,CAAC;KACxC;CACF"}

package/dist/utils/is.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A generic type guard. If `isMatched` is `true`, TypeScript assumes `value` is of type `T`.
+ * You can use it to narrow types:
+ *
+ * ```TypeScript
+ * interface Foo {
+ *   value: string;
+ * }
+ *
+ * interface Bar {
+ *   value: number;
+ * }
+ *
+ * declare let foobar: Foo | Bar;
+ *
+ * if (is<Foo>(foobar, typeof foobar.value === 'string')) {
+ *   // `typeof foobar` is now `Foo`
+ * } else {
+ *   // `typeof foobar` is now `Bar`
+ * }
+ * ```
+ *
+ * @typeParam T Potential type of `value`
+ * @param value Value being checked
+ * @param isMatched Specifies if `value` is of type `T`
+ * @return Value of `isMatched`
+ */
+export declare function is<T>(value: unknown, isMatched: boolean): value is T;

package/dist/utils/is.js

@@ -0,0 +1,31 @@
+/**
+ * A generic type guard. If `isMatched` is `true`, TypeScript assumes `value` is of type `T`.
+ * You can use it to narrow types:
+ *
+ * ```TypeScript
+ * interface Foo {
+ *   value: string;
+ * }
+ *
+ * interface Bar {
+ *   value: number;
+ * }
+ *
+ * declare let foobar: Foo | Bar;
+ *
+ * if (is<Foo>(foobar, typeof foobar.value === 'string')) {
+ *   // `typeof foobar` is now `Foo`
+ * } else {
+ *   // `typeof foobar` is now `Bar`
+ * }
+ * ```
+ *
+ * @typeParam T Potential type of `value`
+ * @param value Value being checked
+ * @param isMatched Specifies if `value` is of type `T`
+ * @return Value of `isMatched`
+ */ export function is(value, isMatched) {
+    return isMatched;
+}
+
+//# sourceMappingURL=is.js.map

package/dist/utils/is.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/is.ts"],"sourcesContent":["/**\n * A generic type guard. If `isMatched` is `true`, TypeScript assumes `value` is of type `T`.\n * You can use it to narrow types:\n *\n * ```TypeScript\n * interface Foo {\n *   value: string;\n * }\n *\n * interface Bar {\n *   value: number;\n * }\n *\n * declare let foobar: Foo | Bar;\n *\n * if (is<Foo>(foobar, typeof foobar.value === 'string')) {\n *   // `typeof foobar` is now `Foo`\n * } else {\n *   // `typeof foobar` is now `Bar`\n * }\n * ```\n *\n * @typeParam T Potential type of `value`\n * @param value Value being checked\n * @param isMatched Specifies if `value` is of type `T`\n * @return Value of `isMatched`\n */\nexport function is<T>(value: unknown, isMatched: boolean): value is T {\n  return isMatched;\n}\n"],"names":["is","value","isMatched"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG,CACH,OAAO,SAASA,EAAE,CAAIC,KAAc,EAAEC,SAAkB,EAAc;IACpE,OAAOA,SAAS,CAAC;CAClB"}

package/dist/utils/isNonNullable.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A type guard that checks whether variable is not `null` or `undefined`:
+ *
+ * ```TypeScript
+ * declare let foobar: string | null;
+ *
+ * if (isNonNullable(foobar)) {
+ *   // `typeof foobar` is now `string`
+ * } else {
+ *   // `typeof foobar` is now `null`
+ * }
+ * ```
+ *
+ * @typeParam T Type of `value`
+ * @param value Value being checked
+ * @return `true` if `value` is non-nullable
+ */
+export declare function isNonNullable<T>(value: T): value is NonNullable<T>;

package/dist/utils/isNonNullable.js

@@ -0,0 +1,21 @@
+/**
+ * A type guard that checks whether variable is not `null` or `undefined`:
+ *
+ * ```TypeScript
+ * declare let foobar: string | null;
+ *
+ * if (isNonNullable(foobar)) {
+ *   // `typeof foobar` is now `string`
+ * } else {
+ *   // `typeof foobar` is now `null`
+ * }
+ * ```
+ *
+ * @typeParam T Type of `value`
+ * @param value Value being checked
+ * @return `true` if `value` is non-nullable
+ */ export function isNonNullable(value) {
+    return value !== undefined && value !== null;
+}
+
+//# sourceMappingURL=isNonNullable.js.map

package/dist/utils/isNonNullable.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/isNonNullable.ts"],"sourcesContent":["/**\n * A type guard that checks whether variable is not `null` or `undefined`:\n *\n * ```TypeScript\n * declare let foobar: string | null;\n *\n * if (isNonNullable(foobar)) {\n *   // `typeof foobar` is now `string`\n * } else {\n *   // `typeof foobar` is now `null`\n * }\n * ```\n *\n * @typeParam T Type of `value`\n * @param value Value being checked\n * @return `true` if `value` is non-nullable\n */\nexport function isNonNullable<T>(value: T): value is NonNullable<T> {\n  return value !== undefined && value !== null;\n}\n"],"names":["isNonNullable","value","undefined"],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG,CACH,OAAO,SAASA,aAAa,CAAIC,KAAQ,EAA2B;IAClE,OAAOA,KAAK,KAAKC,SAAS,IAAID,KAAK,KAAK,IAAI,CAAC;CAC9C"}

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export * from './utils/assert.js';
+export * from './utils/is.js';
+export * from './utils/isNonNullable.js';

package/dist/utils.js

@@ -0,0 +1,5 @@
+export * from "./utils/assert.js";
+export * from "./utils/is.js";
+export * from "./utils/isNonNullable.js";
+
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["export * from './utils/assert.js';\nexport * from './utils/is.js';\nexport * from './utils/isNonNullable.js';\n"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC"}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@jakubmazanec/ts-utils",
+  "version": "1.0.0-fdb1c25",
+  "description": "Collection of TypeScript types and utilities.",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:jakubmazanec/js-tools.git",
+    "directory": "packages/ts-utils"
+  },
+  "license": "MIT",
+  "author": "Jakub Mazanec <jakub@mazanec.dev>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": "./dist/main.js",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "swc src -d dist && tsc",
+    "clean": "del-cli dist *.tsbuildinfo",
+    "document": "typedoc --options typedoc.config.cjs",
+    "format": "prettier . --write --ignore-unknown --ignore-path ../../.prettierignore",
+    "lint": "eslint .",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest",
+    "typecheck": "tsc --project tsconfig.typecheck.json"
+  },
+  "devDependencies": {
+    "@jest/globals": "^28.1.3"
+  },
+  "packageManager": "npm@8.11.0",
+  "engines": {
+    "node": ">=16.15.0"
+  }
+}

package/src/main.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './utils.js';

package/src/types/AtLeastOneRequired.ts

@@ -0,0 +1,37 @@
+/**
+ * Constructs new type from `T` so that at least one property from the set of properties `P` is required:
+ *
+ * ```TypeScript
+ * import { AtLeastOneRequired } from '@ori/ts-utils';
+ *
+ * type FooOrBar = AtLeastOneRequired<{foo: string; bar: string; qux: string}, 'foo' | 'bar'>;
+ *
+ * const fooOrBar1: FooOrBar = {
+ *   foo: 'this is required',
+ *   qux: 'this always required',
+ * };
+ *
+ * const fooOrBar2: FooOrBar = {
+ *   bar: 'or this is required',
+ *   qux: 'this always required',
+ * };
+ *
+ * const fooOrBar3: FooOrBar = {
+ *   foo: 'we can have foo',
+ *   bar: 'and bar',
+ *   qux: 'this always required',
+ * };
+ *
+ * const fooOrBar4: FooOrBar = {
+ *   // no foo nor bar
+ *   qux: 'this always required',
+ * }; // error TS2322: Type '{ qux: string; }' is not assignable to type 'FooOrBar'
+ * ```
+ *
+ * @typeParam T Base for the new type
+ * @typeParam P String literal or union of string literals specifying properties of `T`
+ */
+export type AtLeastOneRequired<T, P extends keyof T = keyof T> = {
+  [K in P]-?: Partial<Pick<T, Exclude<P, K>>> & Required<Pick<T, K>>;
+}[P] &
+  Pick<T, Exclude<keyof T, P>>;

package/src/types/DeepPartial.ts

@@ -0,0 +1,83 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-interface -- needed */
+
+import type {Primitive} from './Primitive.js';
+
+/**
+ * Same as built-in `Partial`, but works recursively. Useful when 1) you have a config object to which you need to merge another object, which would be a deep partial of a default object, or 2) you need to test or mock complex object, but most of its keys would be redundant for this purpose.
+ *
+ * ```TypeScript
+ * import { DeepPartial } from '@ori/ts-utils';
+ * import { UiSettings } from './UiSettings';
+ *
+ * let settings: UiSettings = {
+ *   lineNumbers: true,
+ *   scrollbar: {
+ *     useShadows: false,
+ *     vertical: 'visible',
+ *     horizontal: 'auto',
+ *   },
+ *   minimap: {
+ *     enabled: false,
+ *   },
+ *   folding: {
+ *     enabled: true,
+ *   },
+ * };
+ *
+ * function updateSettings(newSettings: DeepPartial<UiSettings>) {
+ *   return { ...settings, ...newSettings };
+ * }
+ *
+ * settings = updateSettings({ minimap: { enabled: true } });
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */
+export type DeepPartial<T> = T extends Date | Primitive | RegExp
+  ? T
+  : T extends Map<infer KeyType, infer ValueType>
+  ? DeepPartialMap<KeyType, ValueType>
+  : T extends Set<infer ItemType>
+  ? DeepPartialSet<ItemType>
+  : T extends ReadonlyMap<infer KeyType, infer ValueType>
+  ? DeepPartialReadonlyMap<KeyType, ValueType>
+  : T extends ReadonlySet<infer ItemType>
+  ? DeepPartialReadonlySet<ItemType>
+  : T extends (...args: any[]) => unknown
+  ? T | undefined
+  : T extends object
+  ? T extends Array<infer I> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+    ? I[] extends T // Test for arrays (non-tuples) specifically
+      ? Array<DeepPartial<I | undefined>> // Recreate relevant array type to prevent eager evaluation of circular reference
+      : DeepPartialObject<T> // Tuples behave properly
+    : DeepPartialObject<T>
+  : unknown;
+
+/**
+ * Helper type for {@linkcode DeepPartial}.
+ */
+interface DeepPartialMap<KeyType, ValueType>
+  extends Map<DeepPartial<KeyType>, DeepPartial<ValueType>> {}
+
+/**
+ * Helper type for {@linkcode DeepPartial}.
+ */
+interface DeepPartialSet<T> extends Set<DeepPartial<T>> {}
+
+/**
+ * Helper type for {@linkcode DeepPartial}.
+ */
+interface DeepPartialReadonlyMap<KeyType, ValueType>
+  extends ReadonlyMap<DeepPartial<KeyType>, DeepPartial<ValueType>> {}
+
+/**
+ * Helper type for {@linkcode DeepPartial}.
+ */
+interface DeepPartialReadonlySet<T> extends ReadonlySet<DeepPartial<T>> {}
+
+/**
+ * Helper type for {@linkcode DeepPartial}.
+ */
+type DeepPartialObject<ObjectType extends object> = {
+  [KeyType in keyof ObjectType]?: DeepPartial<ObjectType[KeyType]>;
+};

package/src/types/DeepReadonly.ts

@@ -0,0 +1,47 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- needed */
+
+import type {Primitive} from './Primitive.js';
+
+/**
+ * Same as built-in `Readonly`, but works recursively:
+ *
+ * ```TypeScript
+ * import { DeepReadonly } from '@ori/ts-utils';
+ *
+ * const rawData = {
+ *   foo: ['bar'],
+ * };
+ *
+ * const data: DeepReadonly<typeof rawData> = rawData;
+ *
+ * data.foo.push('bar'); // error TS2339: Property 'push' does not exist on type 'readonly string[]'
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */
+export type DeepReadonly<T> = T extends Primitive | ((...args: any[]) => unknown)
+  ? T
+  : T extends ReadonlyMap<infer K, infer V>
+  ? DeepReadonlyMap<K, V>
+  : T extends ReadonlySet<infer I>
+  ? DeepReadonlySet<I>
+  : T extends object
+  ? DeepReadonlyObject<T>
+  : unknown;
+
+/**
+ * Helper type for {@linkcode DeepReadonly}.
+ */
+type DeepReadonlyMap<K, V> = ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>;
+
+/**
+ * Helper type for {@linkcode DeepReadonly}.
+ */
+type DeepReadonlySet<I> = ReadonlySet<DeepReadonly<I>>;
+
+/**
+ * Helper type for {@linkcode DeepReadonly}.
+ */
+type DeepReadonlyObject<O extends object> = {
+  readonly [K in keyof O]: DeepReadonly<O[K]>;
+};

package/src/types/If.ts

@@ -0,0 +1,15 @@
+/**
+ * `If<X, Y, T, F>` is shorthand for conditional type `X extends Y ? T : F`:
+ *
+ * ```TypeScript
+ * // these two types are equivalent:
+ * type NonNullable<T> = T extends null | undefined ? never : T;
+ * type NonNullable<T> = If<T, null | undefined, never, T>;
+ * ```
+ *
+ * @typeParam X Type on the left of the `extends`
+ * @typeParam Y Type on the right of the `extends`
+ * @typeParam T Type returned when `X` is assignable to `Y`
+ * @typeParam F Type returned when `X` isn't assignable to `Y`
+ */
+export type If<X, Y, T, F> = X extends Y ? T : F;

package/src/types/IsEqual.ts

@@ -0,0 +1,29 @@
+/**
+ * Allows you to test if two types are the same:
+ *
+ * ```TypeScript
+ * type Result = IsEqual<string, number> // `typeof Result` is `false`
+ * ```
+ *
+ * ```TypeScript
+ * type Result = IsEqual<{foo: string}, {foo: string}> // `typeof Result` is `true`
+ * ```
+ *
+ * @typeParam A1 First type to compare
+ * @typeParam A2 Second type to compare
+ */
+export type IsEqual<A1, A2> = IsStrictlyEqual<Unite<A1>, Unite<A2>>;
+
+/**
+ * Helper type for {@linkcode IsEqual}.
+ */
+type IsStrictlyEqual<A1, A2> = (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1
+  ? true
+  : false
+  ? true
+  : false;
+
+/**
+ * Helper type for {@linkcode IsEqual}.
+ */
+type Unite<T> = T extends Record<string, unknown> ? {[K in keyof T]: T[K]} : T;

package/src/types/LiteralUnion.ts

@@ -0,0 +1,22 @@
+import type {Primitive} from './Primitive.js';
+
+/**
+ * Creates union type by combining primitve types and literal types while allowing auto-completion in IDEs.
+ * This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729).
+ *
+ * ```TypeScript
+ * type Animal = 'cat' | 'dog' | string;
+ *
+ * const: animal: Animal = ''; // No auto-completion here...
+ * ```
+ *
+ * ```TypeScript
+ * type Animal = LiteralUnion<'cat' | 'dog', string>;
+ *
+ * const: animal: Animal = ''; // Auto-completion works: 'cat' and 'dog' is suggested!
+ * ```
+ *
+ * @typeParam L Union of literal types
+ * @typeParam T Primitive type
+ */
+export type LiteralUnion<L, T extends Primitive> = L | (Record<never, never> & T);

package/src/types/NonArray.ts

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- needed */
+
+export type NonArray<T> = T extends any[] ? never : T;

package/src/types/NonArrayLike.ts

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- needed */
+
+export type NonArrayLike<T> = T extends ArrayLike<any> ? never : T;

package/src/types/OptionalKeys.ts

@@ -0,0 +1,15 @@
+/**
+ * Extracts the optional keys of type `T`:
+ *
+ * ```TypeScript
+ * type Result = OptionalKeys<{ foo?: number; bar?: string; baz: boolean; }>; // `typeof Result` is `'foo' | 'bar`
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */
+export type OptionalKeys<T extends object> = Exclude<
+  {
+    [K in keyof T]: T extends Record<K, T[K]> ? never : K;
+  }[keyof T],
+  undefined
+>;

package/src/types/Parameters.ts

@@ -0,0 +1,20 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- needed */
+
+/**
+ * Constructs a tuple type from the types used in the parameters of a function type `T`.
+ * Similarly like built-in `Parameters` utility type, but works also on nullable and other types.
+ *
+ * ```TypeScript
+ * interface Foo {
+ *   get?: (id: number) => string;
+ * }
+ *
+ * declare const foo: Foo;
+ *
+ * type Result = Parameters<typeof foo.get>; // `typeof Result` is `[id: number]`
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */
+export type Parameters<T extends '' | false | ((...args: any[]) => any) | null | undefined> =
+  T extends (...args: infer P) => any ? P : never;

package/src/types/Primitive.ts

@@ -0,0 +1,4 @@
+/**
+ * Union of primitive types.
+ */
+export type Primitive = bigint | boolean | number | string | symbol | null | undefined;

package/src/types/RequiredKeys.ts

@@ -0,0 +1,15 @@
+/**
+ * Extracts the non-optional keys of type `T`:
+ *
+ * ```TypeScript
+ * type Result = RequiredKeys<{ foo: number; bar: string; baz?: boolean; }>; // `typeof Result` is `'foo' | 'bar`
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */
+export type RequiredKeys<T extends object> = Exclude<
+  {
+    [K in keyof T]: T extends Record<K, T[K]> ? K : never;
+  }[keyof T],
+  undefined
+>;

package/src/types/ReturnType.ts

@@ -0,0 +1,21 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- needed */
+
+/**
+ * Constructs a type consisting of the return type of function `T`.
+ * Similarly like built-in `ReturnType` utility type, but works also on nullable and other types,
+ * and if you use it with async function, it doesn't return the type as a `Promise`:
+ *
+ * ```TypeScript
+ * interface Foo {
+ *   get?: (id: number) => Promise<string>;
+ * }
+ *
+ * declare const foo: Foo;
+ *
+ * type Result = ReturnType<typeof foo.get>; // `typeof Result` is `string`
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */
+export type ReturnType<T extends '' | false | ((...args: any[]) => any) | null | undefined> =
+  T extends (...args: any[]) => infer R ? (R extends PromiseLike<infer J> ? J : R) : never;

package/src/types/TupleToUnion.ts

@@ -0,0 +1,10 @@
+/**
+ * Converts tuple type to union type:
+ *
+ * ```TypeScript
+ * type Result = TupleToUnion<['foo', 'bar']>; // `typeof Result` is `"foo" | "bar"`
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */
+export type TupleToUnion<T extends unknown[] | readonly unknown[]> = T[number];

package/src/types/UnionToIntersection.ts

@@ -0,0 +1,21 @@
+/**
+ * Converts union type to intersection type:
+ *
+ * ```TypeScript
+ * type Result = UnionToIntersection<{ foo: string } | { bar: string }>; // `typeof Result` is `{foo: string} & {bar: string}`
+ * ```
+ *
+ * @typeParam U Base for the new type
+ */
+export type UnionToIntersection<U> = boolean extends U
+  ? UnionToIntersectionHelper<Exclude<U, boolean>> & boolean
+  : UnionToIntersectionHelper<U>;
+
+/**
+ * Helper type for {@linkcode UnionToIntersection}.
+ */
+type UnionToIntersectionHelper<U> = (U extends unknown ? (k: U) => void : never) extends (
+  k: infer I,
+) => void
+  ? I
+  : never;

package/src/types.ts

@@ -0,0 +1,15 @@
+export * from './types/AtLeastOneRequired.js';
+export * from './types/DeepPartial.js';
+export * from './types/DeepReadonly.js';
+export * from './types/If.js';
+export * from './types/IsEqual.js';
+export * from './types/LiteralUnion.js';
+export * from './types/NonArray.js';
+export * from './types/NonArrayLike.js';
+export * from './types/OptionalKeys.js';
+export * from './types/Parameters.js';
+export * from './types/Primitive.js';
+export * from './types/RequiredKeys.js';
+export * from './types/ReturnType.js';
+export * from './types/TupleToUnion.js';
+export * from './types/UnionToIntersection.js';