@tstdl/base 0.93.34 → 0.93.36

package/source/types/README.md

@@ -0,0 +1,216 @@
+# TypeScript Type Utilities (`@tstdl/base/types`)
+
+A comprehensive collection of fundamental, advanced, and specialized TypeScript utility types designed to enhance type safety, improve developer experience, and provide standard definitions for common data structures.
+
+## Table of Contents
+
+- [Features](#features)
+- [Core Concepts](#core-concepts)
+  - [General Utility Types](#general-utility-types)
+  - [Tagged Types](#tagged-types)
+  - [GeoJSON Types](#geojson-types)
+  - [Web Types](#web-types)
+- [Usage](#usage)
+  - [General Utilities](#general-utilities)
+  - [Tagged Types](#tagged-types)
+  - [GeoJSON Types](#geojson-types)
+- [API Summary](#api-summary)
+  - [General Utility Types](#general-utility-types-1)
+  - [Tagged Types](#tagged-types-1)
+  - [GeoJSON Types](#geojson-types-1)
+  - [Web Types](#web-types)
+
+## Features
+
+- **Rich Utility Belt**: A vast collection of utility types for advanced type manipulation, including `Writable`, `DeepPartial`, `Simplify`, `PickBy`, `OmitBy`, `Optionalize`, `Paths`, `PickDeep`, and many more.
+- **Tagged (Branded) Types**: A robust implementation to create distinct nominal types from primitives (e.g., `string`, `number`) for improved type safety.
+- **GeoJSON Types**: A complete set of type definitions for all standard GeoJSON objects, compliant with RFC 7946.
+- **Web-related Types**: Standardized types for HTML input attributes like `InputType`, `InputMode`, and `InputAutocomplete`.
+
+## Core Concepts
+
+### General Utility Types
+
+This module provides a rich set of utility types inspired by popular libraries like `type-fest`. These types allow you to manipulate, transform, and inspect other types in powerful ways. They help in creating more precise and expressive types, reducing boilerplate, and catching potential errors at compile time. For example, you can make all properties of an object writable, pick properties based on their type, or simplify complex inferred types for better readability in tooltips.
+
+### Tagged Types
+
+In many applications, primitives like `string` or `number` are used to represent different kinds of data, such as a user ID, a product ID, or an email address. While they are all strings, they are not semantically interchangeable. Assigning a `ProductId` to a variable expecting a `UserId` can lead to bugs.
+
+**Tagged Types** solve this problem by creating new, distinct types that are not directly assignable to each other, even if they share the same underlying primitive type. This module provides a `Tagged<Type, TagName>` utility to easily create these types. This pattern is also known as "nominal typing" or "branded types" and significantly enhances type safety by catching logical errors at compile time.
+
+### GeoJSON Types
+
+GeoJSON is a standard format for encoding a variety of geographic data structures. This module provides a comprehensive set of TypeScript interfaces (`Point`, `LineString`, `Polygon`, `Feature`, `FeatureCollection`, etc.) that align with the official GeoJSON specification. These types ensure that your geospatial data structures are correctly typed and validated by the TypeScript compiler.
+
+### Web Types
+
+To streamline web development with TypeScript, this module includes standardized types for common HTML attributes. This includes literal unions for an `<input>` element's `type`, `inputmode`, and `autocomplete` attributes, as well as comprehensive interfaces for all valid attributes on `<input>` and `<textarea>` elements.
+
+## Usage
+
+### General Utilities
+
+Here are some examples of how to use the general utility types to manipulate and refine your types.
+
+```typescript
+import type { Writable, Simplify, Optionalize, Paths, TypeFromPath } from '@tstdl/base/types';
+
+// Making a readonly object writable
+const user = { id: 1, name: 'John' } as const;
+type WritableUser = Writable<typeof user>; // { id: number; name: string; }
+const mutableUser: WritableUser = { id: 1, name: 'John' };
+mutableUser.name = 'Jane'; // OK
+
+// Simplifying a complex inferred type for cleaner tooltips
+type Complex = Pick<{ a: 1 } & { b: 2 }, 'a' | 'b'>; // Inferred as Pick<{ a: 1; } & { b: 2; }, "a" | "b">
+type Simple = Simplify<Complex>; // Inferred as { a: 1; b: 2; }
+
+// Making properties with `| undefined` optional
+type ProductWithUndefined = {
+  id: string;
+  description: string | undefined;
+  price: number;
+};
+type OptionalProduct = Optionalize<ProductWithUndefined>;
+// type is { id: string; description?: string | undefined; price: number; }
+const product: OptionalProduct = { id: 'p1', price: 100 }; // OK, description is optional
+
+// Working with nested object paths
+type UserProfile = {
+  id: number;
+  contact: {
+    email: string;
+    address: { city: string; zip: string; };
+  };
+};
+
+type UserPaths = Paths<UserProfile>; // "id" | "contact" | "contact.email" | "contact.address" | "contact.address.city" | "contact.address.zip"
+const emailPath: UserPaths = 'contact.email';
+
+type CityType = TypeFromPath<UserProfile, 'contact.address.city'>; // string
+```
+
+### Tagged Types
+
+You can create distinct types for different kinds of IDs, even though they are all strings.
+
+```typescript
+import type { Tagged } from '@tstdl/base/types';
+
+// Define distinct types for User and Product IDs
+type UserId = Tagged<string, 'UserId'>;
+type ProductId = Tagged<string, 'ProductId'>;
+
+// Functions that operate on specific ID types
+function getUser(id: UserId): void {
+  console.log(`Fetching user with ID: ${id}`);
+}
+
+function getProduct(id: ProductId): void {
+  console.log(`Fetching product with ID: ${id}`);
+}
+
+// You must cast a primitive to the tagged type.
+const userId = 'user-123' as UserId;
+const productId = 'prod-456' as ProductId;
+const plainString = 'some-string';
+
+getUser(userId); // OK
+getProduct(productId); // OK
+
+// The following lines will cause a TypeScript compilation error,
+// preventing logical mistakes.
+// getUser(productId); // Error: Type 'ProductId' is not assignable to type 'UserId'.
+// getUser(plainString); // Error: Type 'string' is not assignable to type 'UserId'.
+```
+
+### GeoJSON Types
+
+Define a GeoJSON `Feature` with a `Point` geometry.
+
+```typescript
+import type { Feature, Point } from '@tstdl/base/types';
+
+// Define properties for your feature
+interface ParkProperties {
+  name: string;
+  area: number; // in square meters
+}
+
+// Create a GeoJSON Feature object
+const parkFeature: Feature<Point, ParkProperties> = {
+  type: 'Feature',
+  geometry: {
+    type: 'Point',
+    coordinates: [-73.9654, 40.7829], // [longitude, latitude]
+  },
+  properties: {
+    name: 'Central Park',
+    area: 3410000,
+  },
+};
+
+function logLocation(feature: Feature<Point, ParkProperties>): void {
+  const [longitude, latitude] = feature.geometry.coordinates;
+  console.log(`${feature.properties.name} is at ${latitude}, ${longitude}`);
+}
+
+logLocation(parkFeature);
+```
+
+## API Summary
+
+### General Utility Types
+
+This module provides a wide array of utility types for type manipulation. Below are some of the most common ones.
+
+| Type | Description |
+| --- | --- |
+| `Writable<T>` | Makes all properties of `T` mutable (removes `readonly`). |
+| `DeepWritable<T>` | Recursively makes all properties of `T` mutable. |
+| `DeepPartial<T>` | Recursively makes all properties of `T` optional. |
+| `DeepReadonly<T>` | Recursively makes all properties of `T` readonly. |
+| `DeepNonNullable<T>` | Recursively removes `null` and `undefined` from all properties of `T`. |
+| `Simplify<T>` | Flattens intersection types (`&`) into a single object type for better readability. |
+| `Optionalize<T>` | Converts properties of `T` that can be `undefined` into optional properties (`?`). |
+| `PickBy<T, V>` | Creates a type by picking properties from `T` whose values are assignable to `V`. |
+| `OmitBy<T, V>` | Creates a type by omitting properties from `T` whose values are assignable to `V`. |
+| `OneOrMany<T>` | Represents a single `T` or a `readonly T[]`. |
+| `Json` | Represents any valid JSON value (`string \| number \| boolean \| null \| JsonObject \| JsonArray`). |
+| `Paths<T>` | Creates a union of all possible dot-notation paths for keys in object `T`. |
+| `TypeFromPath<T, Path>` | Infers the type of a property in `T` at a given `Path`. |
+| `PickDeep<T, S>` | Picks properties from `T` recursively based on a selection shape `S`. |
+| `OmitDeep<T, S>` | Omits properties from `T` recursively based on a selection shape `S`. |
+| `Merge<T1, T2>` | Merges two types, with properties from `T2` overwriting those in `T1`. |
+
+### Tagged Types
+
+| Type | Description |
+| --- | --- |
+| `Tagged<Type, TagName>` | Creates a new, distinct ("branded") type from a base `Type`. |
+| `Untagged<T>` | Extracts the base, untagged type from a `Tagged` type. |
+| `GetTagMetadata<Type, TagName>` | Extracts the metadata from a `Tagged` type. |
+| `HasTag<T, Token>` | Checks if a type `T` has a specific tag `Token`. Returns `true` or `false`. |
+
+### GeoJSON Types
+
+| Type | Description |
+| --- | --- |
+| `Position` | A tuple representing coordinates: `[longitude, latitude, elevation?]`. |
+| `Point` | A GeoJSON geometry object with a single `Position`. |
+| `LineString` | A GeoJSON geometry object with an array of `Position`s. |
+| `Polygon` | A GeoJSON geometry object with an array of `Position` arrays (rings). |
+| `Geometry` | A union of all possible GeoJSON geometry types. |
+| `Feature<G, P>` | A GeoJSON object containing a `Geometry` object and properties. |
+| `FeatureCollection<G, P>` | A GeoJSON object containing an array of `Feature` objects. |
+
+### Web Types
+
+| Type | Description |
+| --- | --- |
+| `InputType` | A literal union of all valid `type` attribute values for an HTML `<input>` element. |
+| `InputMode` | A literal union of all valid `inputmode` attribute values for an HTML `<input>` element. |
+| `InputAutocomplete` | A literal union of all valid `autocomplete` attribute values for an HTML `<input>` element. |
+| `InputAttributes` | An object type representing all valid attributes for an HTML `<input>` element. |
+| `TextAreaAttributes` | An object type representing all valid attributes for an HTML `<textarea>` element. |

package/source/types/geo-json.ts

@@ -0,0 +1,48 @@
+import type { JsonObject } from './types.js';
+
+export type Position = [longitude: number, latitude: number, elevation?: number];
+
+export type GeoJsonObject<Type extends string> = {
+  type: Type,
+  bbox?: [number, number, number, number] | [number, number, number, number, number, number],
+};
+
+export type Point = GeoJsonObject<'Point'> & {
+  coordinates: Position,
+};
+
+export type LineString = GeoJsonObject<'LineString'> & {
+  coordinates: Position[],
+};
+
+export type Polygon = GeoJsonObject<'Polygon'> & {
+  coordinates: Position[][],
+};
+
+export type MultiPoint = GeoJsonObject<'MultiPoint'> & {
+  coordinates: Position[],
+};
+
+export type MultiLineString = GeoJsonObject<'MultiLineString'> & {
+  coordinates: Position[][],
+};
+
+export type MultiPolygon = GeoJsonObject<'MultiPolygon'> & {
+  coordinates: Position[][][],
+};
+
+export type GeometryCollection = GeoJsonObject<'GeometryCollection'> & {
+  geometries: Geometry[],
+};
+
+export type Geometry = Point | LineString | Polygon | MultiPoint | MultiLineString | MultiPolygon | GeometryCollection;
+
+export type Feature<G extends Geometry | null = null, P extends JsonObject | null = null> = GeoJsonObject<'Feature'> & {
+  id?: string | number,
+  geometry: G,
+  properties: P,
+};
+
+export type FeatureCollection<G extends Geometry | null = null, P extends JsonObject | null = null> = GeoJsonObject<'FeatureCollection'> & {
+  features: Feature<G, P>[],
+};

package/source/types/index.ts

@@ -0,0 +1,4 @@
+export type * from './geo-json.js';
+export type * from './tagged.js';
+export type * from './types.js';
+export type * from './web-types.js';

package/source/types/tagged.ts

@@ -0,0 +1,23 @@
+import type { Record } from './types.js';
+
+export declare const tag: unique symbol;
+export declare const type: unique symbol;
+
+export type TagContainer<Type, Token> = { readonly [tag]?: Token, readonly [type]?: Type };
+
+export type Tag<Type, Token extends PropertyKey, TagMetadata> = TagContainer<Type, Record<Token, TagMetadata>>;
+
+export type HasTag<T, Token = unknown> = T extends TagContainer<unknown, Token> ? true : false;
+
+export type Tagged<Type = unknown, TagName extends PropertyKey = PropertyKey, TagMetadata = unknown> = Type & Tag<Type, TagName, TagMetadata>;
+
+export type GetTagMetadata<Type extends Tag<unknown, TagName, unknown>, TagName extends PropertyKey> = NonNullable<Type[typeof tag]>[TagName];
+
+export type UnwrapTagged<TaggedType extends Tag<unknown, PropertyKey, any>> = TaggedType extends Tagged<infer Type, PropertyKey, any> ? Type : never;
+
+export type Untagged<T> = T extends Tagged ? UnwrapTagged<T> : T;
+
+export type UntaggedDeep<T> =
+  Untagged<T> extends any[] | Record
+  ? { [P in keyof Untagged<T>]: UntaggedDeep<Untagged<T>[P]> }
+  : Untagged<T>;

package/source/types/types.ts

@@ -0,0 +1,290 @@
+/* eslint-disable @typescript-eslint/consistent-indexed-object-style */
+
+import type { Observable } from 'rxjs';
+import type { CamelCase, Except, IsEqual, LiteralUnion } from 'type-fest';
+
+import type { Signal } from '#/signals/api.js';
+
+export type ObjectLiteral = {}; // eslint-disable-line @typescript-eslint/no-empty-object-type
+
+export type Function<P extends any[] = any[], R = any> = (...params: P) => R;
+
+export type PrimitiveTypeMap = {
+  string: string,
+  number: number,
+  boolean: boolean,
+  bigint: bigint,
+  symbol: symbol,
+  object: object,
+  function: Function,
+  undefined: undefined,
+};
+
+export type PrimitiveTypeString<T extends PrimitiveTypeMap[keyof PrimitiveTypeMap] = PrimitiveTypeMap[keyof PrimitiveTypeMap]> = Simplify<keyof PickBy<PrimitiveTypeMap, T>>;
+export type PrimitiveType<T extends keyof PrimitiveTypeMap = keyof PrimitiveTypeMap> = Simplify<PrimitiveTypeMap[T]>;
+
+export type Nested<T> = T | NestedObject<T> | NestedArray<T>;
+export type NestedObject<T> = { [key: string]: Nested<T> };
+export type NestedArray<T> = T[];
+
+export type FilledArray<T> = [T, ...(T)[]];
+export type FilledReadonlyArray<T> = readonly [T, ... (T)[]];
+
+export type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+export type PrimitiveValue = Primitive | PrimitiveObject | PrimitiveArray;
+export type PrimitiveObject = { [key: string]: PrimitiveValue };
+export type PrimitiveArray = PrimitiveValue[];
+export type BuiltIn = Primitive | RegExp | Date | Function;
+export type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
+
+export type Json = JsonPrimitive | JsonObject | JsonArray;
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonObject = { [key: string]: Json };
+export type JsonArray = Json[] | readonly Json[];
+
+export type UndefinableJson = JsonPrimitive | UndefinableJsonObject | UndefinableJsonArray;
+export type UndefinableJsonInnerNode = UndefinableJsonPrimitive | UndefinableJsonObject | UndefinableJsonArray;
+export type UndefinableJsonPrimitive = JsonPrimitive | undefined;
+export type UndefinableJsonObject = { [key: string]: UndefinableJsonInnerNode };
+export type UndefinableJsonArray = UndefinableJsonInnerNode[] | readonly UndefinableJsonInnerNode[];
+
+export type ArrayItem<T extends readonly any[]> = T extends readonly (infer U)[] ? U : never;
+
+export type Enumeration = EnumerationArray | EnumerationObject;
+export type EnumerationArray = readonly [string | number, ...(string | number)[]];
+export type EnumerationObject<V extends string | number = string | number> = Record<string, V>;
+export type EnumerationKey<T extends EnumerationObject = EnumerationObject> = Extract<keyof T, string>;
+export type EnumerationMap<T extends EnumerationObject = EnumerationObject> = SimplifyObject<{ [P in EnumerationKey<T>]: (T[P] extends number ? (`${T[P]}` extends `${infer U extends number}` ? U : never) : T[P]) | T[P] }>;
+export type EnumerationValue<T extends Enumeration = Enumeration> = T extends EnumerationObject ? SimplifyDeep<EnumerationMap<T>[keyof EnumerationMap<T>]> : T extends EnumerationArray ? T[number] : never;
+export type EnumerationEntry<T extends EnumerationObject = EnumerationObject> = { [P in EnumerationKey<T>]: [P, EnumerationMap<T>[P]] }[EnumerationKey<T>];
+type EnumerationEntriesHelper<T extends EnumerationObject = EnumerationObject, Tuple = UnionToTuple<EnumerationKey<T>>> = { [P in keyof Tuple]: [Tuple[P], Tuple[P] extends EnumerationKey<T> ? EnumerationMap<T>[Tuple[P]] : never] };
+export type EnumerationEntries<T extends EnumerationObject = EnumerationObject> = EnumerationEntriesHelper<T> extends (infer U)[] ? U[] : never;
+
+export type Type<T = any, Arguments extends any[] = any> = Constructor<T, Arguments> & { prototype: T };
+export type Constructor<T = any, Arguments extends any[] = any[]> = new (...args: Arguments) => T;
+export type AbstractType<T = any, Arguments extends any[] = any[]> = AbstractConstructor<T, Arguments> & { prototype: T };
+export type AbstractConstructor<T = any, Arguments extends any[] = any> = abstract new (...args: Arguments) => T;
+export type ReturnTypeOrT<T> = T extends (...args: any) => infer R ? R : T;
+
+export type Cast<X, Y> = X extends Y ? X : Y;
+export type Record<K extends PropertyKey = PropertyKey, V = any> = { [P in K]: V };
+export type DeepRecord<K extends PropertyKey = PropertyKey, V = any> = { [P in K]: V | DeepRecord<K, V> };
+export type StringMap<T = any> = Record<string, T>;
+export type NumberMap<T = any> = Record<number, T>;
+export type StringNumberMap<T = any> = { [key: string]: T, [key: number]: T };
+
+export type OneOrMany<T> = T | readonly T[];
+export type WritableOneOrMany<T> = T | T[];
+
+export type Entries<T> = Extract<{
+  [K in keyof T]: [K, T[K]];
+}[keyof T], any[]>[];
+
+type FromEntriesEntryValue<T extends readonly (readonly [any, any])[], K> = Extract<T[number], readonly [K, any]>[1];
+
+export type FromEntries<T> = T extends readonly (readonly [infer Key, any])[]
+  ? { [K in Cast<Key, PropertyKey>]: Fallback<FromEntriesEntryValue<T, K>, T[number][1]> }
+  : never;
+
+export type Writable<T> = T extends readonly (infer U)[] ? U[] : { -readonly [P in keyof T]: T[P] };
+export type DeepWritable<T> = T extends readonly (infer U)[] ? DeepWritable<U>[] : { -readonly [P in keyof T]: DeepWritable<T[P]> };
+
+export type RequiredKeys<T> = { [K in keyof T]-?: ObjectLiteral extends Pick<T, K> ? never : K }[keyof T];
+export type OptionalKeys<T> = { [K in keyof T]-?: ObjectLiteral extends Pick<T, K> ? K : never }[keyof T];
+
+export type TypedOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export type TypedExclude<T, U extends T> = T extends U ? never : T;
+export type TypedExtract<T, U extends T> = T extends U ? T : never;
+
+export type ReplaceIfUnknown<T, U> = IfUnknown<T, U, T>;
+
+export type OmitNever<T extends Record> = { [K in keyof T as T[K] extends never ? never : K]: T[K] };
+
+export type BaseType<T extends Exclude<Primitive, null | undefined>> =
+  T extends string ? string
+  : T extends number ? number
+  : T extends boolean ? boolean
+  : T extends bigint ? bigint
+  : T extends symbol ? symbol
+  : T extends null ? null
+  : T extends undefined ? undefined
+  : never;
+
+export type SharedProperties<A, B, C = unknown, D = unknown, E = unknown, F = unknown, G = unknown, H = unknown, I = unknown, J = unknown> = OmitNever<Pick<
+  A & B & C & D & E & F & G & H & I & J,
+  keyof A & keyof B & keyof ReplaceIfUnknown<C, never> & keyof ReplaceIfUnknown<D, never> & keyof ReplaceIfUnknown<E, never> & keyof ReplaceIfUnknown<F, never> & keyof ReplaceIfUnknown<G, never> & keyof ReplaceIfUnknown<H, never> & keyof ReplaceIfUnknown<I, never> & keyof ReplaceIfUnknown<J, never>
+>>;
+
+/**
+ * Omit properties from a type that extend from a specific type.
+ */
+export type OmitBy<T, V> = Omit<T, { [K in keyof T]: V extends Extract<T[K], V> ? K : never }[keyof T]>;
+
+/**
+ * Normalize properties of a type that allow `undefined` to make them optional.
+ */
+export type Optionalize<T extends object> = SimplifyObject<OmitBy<T, undefined> & Partial<PickBy<T, undefined>>>;
+
+export type OptionalizeDeep<T> = T extends BuiltIn ? T
+  : T extends (infer U)[] ? OptionalizeDeep<U>[]
+  : T extends readonly (infer U)[] ? readonly OptionalizeDeep<U>[]
+  : Optionalize<{ [P in keyof T]: OptionalizeDeep<T[P]> }>;
+
+export type OptionalizeNull<T extends object> = SimplifyObject<OmitBy<T, null> & Partial<PickBy<T, null>>>;
+
+export type OptionalizeNullDeep<T> = T extends BuiltIn ? T
+  : T extends (infer U)[] ? OptionalizeNullDeep<U>[]
+  : T extends readonly (infer U)[] ? readonly OptionalizeNullDeep<U>[]
+  : OptionalizeNull<{ [P in keyof T]: OptionalizeNullDeep<T[P]> }>;
+
+export type OptionalizeNullable<T extends object> = SimplifyObject<OmitBy<T, null | undefined> & Partial<PickBy<T, null | undefined>>>;
+
+export type OptionalizeNullableDeep<T> = T extends BuiltIn ? T
+  : T extends readonly (infer U)[] ? OptionalizeNullableDeep<U>[]
+  : T extends (infer U)[] ? OptionalizeNullableDeep<U>[]
+  : OptionalizeNullable<{ [P in keyof T]: OptionalizeNullableDeep<T[P]> }>;
+
+export type Unoptionalize<T extends object> = SimplifyObject<OmitBy<T, undefined> & { [P in PropertiesOfType<T, undefined>]: T[P] | undefined }>;
+
+export type Merge<T1, T2> = SimplifyObject<Except<T1, Extract<keyof T1, keyof T2>> & T2>;
+
+export type Simplify<T> = T extends BuiltIn ? T
+  : T extends readonly any[] ? SimplifyArray<T>
+  : T extends Record ? SimplifyObject<T>
+  : T;
+
+export type SimplifyObject<T extends Record> = { [K in keyof T]: T[K] } & {};
+export type SimplifyArray<T extends readonly any[]> = { [I in keyof T]: Simplify<T[I]> };
+
+export type SimplifyDeep<T> = T extends BuiltIn ? T
+  : T extends readonly any[] ? { [I in keyof T]: SimplifyDeep<T[I]> }
+  : T extends Record ? { [K in keyof T]: SimplifyDeep<T[K]> } & {}
+  : T;
+
+export type SimplifiedLiteralUnion<Literal extends Primitive, Base extends Primitive = BaseType<Exclude<Literal, null | undefined>>> = If<IsEqual<Literal, Base>, Literal, LiteralUnion<Literal, Base>>;
+
+export type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection : never;
+
+export type UnionToTuple<T, Tuple extends any[] = []> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? UnionToTuple<Exclude<T, R>, [R, ...Tuple]> : Tuple;
+
+export type UndefinableObject<T extends Record> = { [K in keyof T]: T[K] | undefined };
+
+/**
+ * Pick properties from a type that extend from a specific type.
+ */
+export type PickBy<T, V> = Pick<T, { [K in keyof T]: V extends Extract<T[K], V> ? K : never }[keyof T]>;
+
+export type NonNullable<T> = T extends null ? never : T;
+export type NonUndefinable<T> = T extends undefined ? never : T;
+export type NonNullOrUndefinable<T> = T extends null | undefined ? never : T;
+export type NoUnion<T> = [T] extends [boolean] ? boolean : [T] extends [UnionToIntersection<T>] ? T : never;
+
+/**
+ * Makes optional properties required and removes null and undefined
+ */
+export type DeepNonNullable<T> = T extends Record ? { [P in keyof T]-?: DeepNonNullable<T[P]> } : NonNullable<T>;
+
+export type IfAny<T, Then, Else = never> = true extends (false & T) ? Then : Else;
+export type IfUnknown<T, Then, Else = never> = unknown extends T ? Then : Else;
+
+export type IsAny<T> = IfAny<T, true, false>;
+export type IsUnknown<T> = IfUnknown<T, true, false>;
+
+export type If<B extends boolean, Then, Else> = B extends true ? Then : Else;
+export type Not<T extends boolean> = T extends true ? false : true;
+
+export type Fallback<T, F> = [T] extends [never] ? F : T;
+
+export type PartialProperty<T, P extends keyof T> = Omit<T, P> & Partial<Pick<T, P>>;
+export type TypeOf<T extends object, P extends keyof T> = T[P];
+export type PropertyOf<T extends object, P extends keyof T> = Property<Of<T>, P>;
+export type Property<T extends object, P extends keyof T> = { [P2 in keyof T[P]]: T[P][P2] };
+export type Of<T> = T;
+export type PropertiesOfType<T, U> = keyof PickBy<T, U>;
+
+export type Flatten<T> = T extends readonly (infer R)[] ? R : T;
+export type DeepFlatten<T> = T extends readonly (infer R)[]
+  ? DeepFlatten<R>
+  : T extends Record ? { [P in keyof T]: DeepFlatten<T[P]> }
+  : T;
+
+export type DeepArray<T> = (T | DeepArray<T>)[];
+
+export type DeepReadonly<T> = T extends BuiltIn ? T : T extends (any[] | readonly any[]) ? DeepReadonlyArray<T[number]> : DeepReadonlyObject<T>;
+export type DeepReadonlyObject<T> = { readonly [P in keyof T]: DeepReadonly<T[P]> };
+export type DeepReadonlyArray<T> = readonly DeepReadonly<T>[];
+
+export type ReplaceKey<T, K extends keyof T, U> = SimplifyObject<{ [P in keyof T]: P extends K ? U : T[P] }>;
+
+export type DeepPartial<T> = T extends BuiltIn
+  ? T
+  : T extends any[] ? DeepPartialArray<T[number]>
+  : T extends readonly any[] ? Readonly<DeepPartialArray<T[number]>>
+  : DeepPartialObject<T>;
+export type DeepPartialObject<T> = { [P in keyof T]?: DeepPartial<T[P]> };
+export type DeepPartialArray<T> = DeepPartial<T>[];
+
+export type TypedArray =
+  | Int8Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Float32Array
+  | Float64Array
+  | BigInt64Array
+  | BigUint64Array;
+
+export type BinaryData<T extends ArrayBufferLike = ArrayBufferLike> = ArrayBufferView<T> | T;
+
+export type Path<T extends Record> = T extends object
+  ? { [K in keyof T]-?: K extends string | number ? `${K}` | `${K}.${Path<T[K]>}` : never }[keyof T]
+  : never;
+
+export type TypeFromPath<T extends Record, P extends Path<T> | string> = {
+  [K in P]: K extends keyof T
+  ? T[K]
+  : K extends `${infer P}.${infer S}`
+  ? T[P] extends Record
+  ? TypeFromPath<T[P], S>
+  : never
+  : never;
+}[P];
+
+export type ConstructorParameterDecorator = (target: object, propertyKey: undefined, parameterIndex: number) => void;
+
+export type ReactiveValue<T> = T | Signal<T> | Observable<T>;
+
+/* Type-fests PascalCase minus options. Fixes tsc bug for some reason */
+export type PascalCase<Value> = CamelCase<Value> extends string ? Capitalize<CamelCase<Value>> : CamelCase<Value>;
+
+type PickOmitDeepSelection<T> = T extends (infer U)[] ? (boolean | PickOmitDeepSelection<U>)
+  : T extends Record<any> ? (boolean | { [P in keyof T]?: PickOmitDeepSelection<T[P]> })
+  : boolean;
+
+export type PickDeepSelection<T> = PickOmitDeepSelection<T>;
+export type OmitDeepSelection<T> = PickOmitDeepSelection<T>;
+
+export type PickDeep<T, S extends PickDeepSelection<T>> =
+  T extends Record<any> ? Simplify<{
+    [P in keyof S as S[P] extends (true | Record<any>) ? P : never]:
+    S[P] extends true
+    ? T[Extract<P, keyof T>]
+    : T[Extract<P, keyof T>] extends (infer U)[]
+    ? S[P] extends PickDeepSelection<U> ? PickDeep<U, S[P]>[] : never
+    : S[P] extends Record<any>
+    ? S[P] extends PickDeepSelection<T[Extract<P, keyof T>]> ? PickDeep<T[Extract<P, keyof T>], S[P]> : never
+    : never
+  }> : T;
+
+export type OmitDeep<T, S extends OmitDeepSelection<T>> = T extends Record<any> ? Simplify<{
+  [P in keyof T as true extends S[Extract<P, keyof S>] ? never : P]:
+  [S[Extract<P, keyof S>]] extends ([false] | [never]) ? T[P]
+  : S[Extract<P, keyof S>] extends Record<any>
+  ? T[P] extends (infer U)[]
+  ? S[Extract<P, keyof S>] extends OmitDeepSelection<U> ? OmitDeep<U, S[Extract<P, keyof S>]>[] : never
+  : S[Extract<P, keyof S>] extends OmitDeepSelection<T[P]> ? OmitDeep<T[P], S[Extract<P, keyof S>]> : never
+  : never
+}> : T;