@planet-matrix/mobius-model 0.3.0 → 0.5.0

package/src/type/helper.ts

@@ -0,0 +1,135 @@
+// oxlint-disable ban-types
+// oxlint-disable no-explicit-any
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+/**
+ * @example
+ * ```
+ * // Expect: string | number | symbol
+ * type Example1 = KeyOfBase
+ * ```
+ */
+export type KeyOfBase = keyof any
+
+/**
+ * Cast type T to SafeT if possible; otherwise, return SafeT.
+ *
+ * @example
+ * ```
+ * // Expect: number
+ * type Example1 = Cast<42, number>;
+ * // Expect: string
+ * type Example2 = Cast<42, string>;
+ * ```
+ */
+export type Cast<T, SafeT> = T extends SafeT ? T : SafeT
+
+/**
+ * Select a type based on a boolean condition.
+ *
+ * @example
+ * ```
+ * // Expect: 1
+ * type Example1 = If<true, 1, 2>
+ * // Expect: 2
+ * type Example2 = If<false, 1, 2>
+ * ```
+ */
+export type If<T extends boolean, TRUE, FALSE = never> = T extends true ? TRUE : FALSE
+
+/**
+ * Return `T` if it extends `SafeT`, otherwise return `Catch`.
+ *
+ * @example
+ * ```
+ * // Expect: 42
+ * type Example1 = Try<42, number, 0>
+ * // Expect: 0
+ * type Example2 = Try<'x', number, 0>
+ * ```
+ */
+export type Try<T, SafeT, Catch = never> = T extends SafeT ? T : Catch
+
+/**
+ * Get keys of an array/tuple or object, with numeric index support for tuples.
+ *
+ * @example
+ * ```
+ * // Expect: 0 | 1 | number
+ * type Example1 = Keys<[string, number]>
+ * // Expect: 'a' | 'b'
+ * type Example2 = Keys<{ a: 1; b: 2 }>
+ * ```
+ */
+export type Keys<A> = A extends readonly any[]
+  ? Exclude<keyof A, keyof any[]> | number
+  : keyof A
+
+/**
+ * Check if two types are exactly equal.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * type Example1 = IsEqual<1, 1>
+ * // Expect: false
+ * type Example2 = IsEqual<1, number>
+ * ```
+ * WARNING: https://github.com/ts-essentials/ts-essentials/blob/5aa1f264e77fb36bb3f673c49f00927c7c181a7f/lib/types.ts#L440
+ * @see https://stackoverflow.com/a/52473108/1815209 with comments
+ * @see https://github.com/millsp/ts-toolbelt/blob/319e551/sources/Any/Equals.ts#L15
+ */
+export type IsEqual<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false
+/**
+ * Select types based on exact type equality.
+ *
+ * @example
+ * ```
+ * // Expect: 'yes'
+ * type Example1 = IfEqual<1, 1, 'yes', 'no'>
+ * // Expect: 'no'
+ * type Example2 = IfEqual<1, number, 'yes', 'no'>
+ * ```
+ */
+export type IfEqual<X, Y, TRUE = true, FALSE = false> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? TRUE : FALSE
+
+declare const InternalBrandId: unique symbol
+/**
+ * Define nominal type of U based on type of T. Similar to Opaque types in Flow.
+ *
+ * @example
+ * ```
+ * type USD = Brand<number, "USD">
+ * type EUR = Brand<number, "EUR">
+ *
+ * const tax = 5 as USD;
+ * const usd = 10 as USD;
+ * const eur = 10 as EUR;
+ *
+ * function gross(net: USD): USD {
+ *   return (net + tax) as USD;
+ * }
+ *
+ * // Expect: No compile error
+ * gross(usd);
+ * // Expect: Compile error (Type '"EUR"' is not assignable to type '"USD"'.)
+ * gross(eur);
+ * ```
+ * @see {@link https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts}
+ */
+export type Brand<T, U> = T & { [InternalBrandId]: U }
+
+declare const InternalXPlaceholder: unique symbol
+/**
+ * Provide an opaque placeholder type for generics.
+ *
+ * @example
+ * ```
+ * // Expect: X
+ * type Example1 = X
+ * ```
+ */
+export type X = typeof InternalXPlaceholder & {}

package/src/type/index.ts

@@ -0,0 +1,14 @@
+export * from "./helper.ts"
+export * from "./is.ts"
+export * from "./union.ts"
+export * from "./intersection.ts"
+export * from "./string.ts"
+export * from "./path.ts"
+export * from "./boolean.ts"
+export * from "./number.ts"
+export * from "./object.ts"
+export * from "./function.ts"
+export * from "./tuple.ts"
+export * from "./array.ts"
+export * from "./class.ts"
+export * from "./iteration.ts"

package/src/type/intersection.ts

@@ -0,0 +1,93 @@
+import type { UnionToIntersection, UnionToTuple } from "./union.ts"
+
+// ============================================================================
+// Generation
+// ============================================================================
+
+/**
+ * Create an intersection from a tuple of types.
+ *
+ * @example
+ * ```
+ * // Expect: { a: 1 } & { b: 2 }
+ * type Example1 = IntersectionAll<[{ a: 1 }, { b: 2 }]>
+ * // Expect: string & number
+ * type Example2 = IntersectionAll<[string, number]>
+ * // Expect: unknown
+ * type Example3 = IntersectionAll<[]>
+ * ```
+ */
+export type IntersectionAll<T extends readonly unknown[], Fallback = unknown> =
+  [T[number]] extends [never] ? Fallback : UnionToIntersection<T[number]>
+
+// ============================================================================
+// Manipulation
+// ============================================================================
+
+/**
+ * Merge an intersection of object types into a single object type.
+ *
+ * @example
+ * ```
+ * // Expect: { a: 1; b: 2 }
+ * type Example1 = IntersectionMerge<{ a: 1 } & { b: 2 }>
+ * // Expect: { a: string & number }
+ * type Example2 = IntersectionMerge<{ a: string } & { a: number }>
+ * // Expect: {}
+ * type Example3 = IntersectionMerge<{}>
+ * ```
+ */
+export type IntersectionMerge<T extends Record<PropertyKey, unknown>> = {
+  [Key in keyof T]: T[Key]
+}
+
+/**
+ * Prettify an intersection of object types.
+ *
+ * @example
+ * ```
+ * // Expect: { id: string; active: boolean }
+ * type Example1 = IntersectionPrettify<{ id: string } & { active: boolean }>
+ * // Expect: { value: number }
+ * type Example2 = IntersectionPrettify<{ value: number }>
+ * // Expect: {}
+ * type Example3 = IntersectionPrettify<{}>
+ * ```
+ */
+export type IntersectionPrettify<T extends Record<PropertyKey, unknown>> = IntersectionMerge<T>
+
+// ============================================================================
+// Conversion
+// ============================================================================
+
+/**
+ * Convert an intersection of object types into a union of object types.
+ *
+ * @example
+ * ```
+ * // Expect: { a: string } | { b: number }
+ * type Example1 = ObjectIntersectionToUnion<{ a: string } & { b: number }>
+ * // Expect: { a: never }
+ * type Example2 = ObjectIntersectionToUnion<{ a: string } & { a: number }>
+ * // Expect: never
+ * type Example3 = ObjectIntersectionToUnion<{}>
+ * ```
+ */
+export type ObjectIntersectionToUnion<T> = {
+  [K in keyof T]: { [P in K]: T[P] }
+}[keyof T]
+
+/**
+ * Convert an intersection of object types into a tuple of object types.
+ *
+ * @example
+ * ```
+ * // Expect: [{ a: string }, { b: number }]
+ * type Example1 = ObjectIntersectionToTuple<{ a: string } & { b: number }>
+ * // Expect: [{ a: never }]
+ * type Example2 = ObjectIntersectionToTuple<{ a: string } & { a: number }>
+ * // Expect: []
+ * type Example3 = ObjectIntersectionToTuple<{}>
+ * ```
+ */
+export type ObjectIntersectionToTuple<T> = UnionToTuple<ObjectIntersectionToUnion<T>>

package/src/type/is.ts

@@ -0,0 +1,247 @@
+// oxlint-disable no-explicit-any
+
+/**
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types}
+ */
+export type Primitive = string | number | boolean | bigint | symbol | null | undefined
+/**
+  * @see {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#object-type}
+  */
+export type NonPrimitive = object
+
+export type IsPrimitive<T> =
+  T extends string ? true : T extends number ? true : T extends boolean ? true : T extends bigint ? true
+  : T extends symbol ? true : T extends null ? true : T extends undefined ? true : false
+export type IfPrimitive<T, TRUE = true, FALSE = never> = IsPrimitive<T> extends true ? TRUE : FALSE
+
+export type IsPrimitiveUnion<T> = T extends Primitive ? true : false
+export type IfPrimitiveUnion<T, TRUE = true, FALSE = never> = IsPrimitiveUnion<T> extends true ? TRUE : FALSE
+
+/**
+ * Predicate whether the target is `string`.
+ */
+export type IsString<T> = T extends string ? true : false
+export type IfString<T, TRUE = true, FALSE = never> = IsString<T> extends true ? TRUE : FALSE
+export type CastString<T> = T extends string ? T : string
+export type IsStringLiteral<T> = T extends string ? (string extends T ? false : true) : false
+
+/**
+ * Predicate whether the target is `number`.
+ */
+export type IsNumber<T> = T extends number ? true : false
+export type IfNumber<T, TRUE = true, FALSE = never> = IsNumber<T> extends true ? TRUE : FALSE
+export type CastNumber<T> = T extends number ? T : number
+export type IsNumberLiteral<T> = T extends number ? (number extends T ? false : true) : false
+
+/**
+ * Predicate whether the target is `boolean`.
+ */
+export type IsBoolean<T> = T extends boolean ? true : false
+export type IfBoolean<T, TRUE = true, FALSE = never> = IsBoolean<T> extends true ? TRUE : FALSE
+export type CastBoolean<T> = T extends boolean ? T : boolean
+export type IsTrue<T> = T extends true ? true : false
+export type IsFalse<T> = T extends false ? true : false
+export type IsBooleanLiteral<T> =
+  [T] extends [boolean] // Check if T is assignable to boolean (true, false, or boolean)
+  ? ([boolean] extends [T] // Check if boolean is assignable to T (only true for 'boolean' itself)
+    ? false // If both are true, it's the general 'boolean' type
+    : true // Otherwise, it's a specific literal (true or false)
+  )
+  : false; // Not a boolean type at all
+
+/**
+ * Predicate whether the target is `bigint`.
+ */
+export type IsBigInt<T> = T extends bigint ? true : false
+export type IfBigInt<T, TRUE = true, FALSE = never> = IsBigInt<T> extends true ? TRUE : FALSE
+export type CastBigInt<T> = T extends bigint ? T : bigint
+
+/**
+ * Predicate whether the target is `symbol`.
+ */
+export type IsSymbol<T> = T extends symbol ? true : false
+export type IfSymbol<T, TRUE = true, FALSE = never> = IsSymbol<T> extends true ? TRUE : FALSE
+export type CastSymbol<T> = T extends symbol ? T : symbol
+
+/**
+ * Predicate whether the target is `null`.
+ */
+export type IsNull<T> = Exclude<T, null> extends never ? true : false
+export type IfNull<T, TRUE = true, FALSE = never> = IsNull<T> extends true ? TRUE : FALSE
+export type CastNull<T> = T extends null ? T : null
+export type IsNullable<T> = T extends Exclude<T, null> ? false : true
+export type IfNullable<T, TRUE = true, FALSE = never> = IsNullable<T> extends true ? TRUE : FALSE
+export type Nullable<T> = T | null
+export type NonNullable<T> = Exclude<T, null>
+
+/**
+ * Predicate whether the target is `undefined`.
+ */
+export type IsUndefined<T> = Exclude<T, undefined> extends never ? true : false
+export type IfUndefined<T, TRUE = true, FALSE = never> = IsUndefined<T> extends true ? TRUE : FALSE
+export type CastUndefined<T> = T extends undefined ? T : undefined
+export type IsUndefinedable<T> = T extends Exclude<T, undefined> ? false : true
+export type IfUndefinedable<T, TRUE = true, FALSE = never> = IsUndefinedable<T> extends true ? TRUE : FALSE
+export type Undefinedable<T> = T | undefined
+export type NonUndefinedable<T> = Exclude<T, undefined>
+
+/**
+ * Predicate whether the target is `null | undefined`.
+ */
+export type IsNil<T> = Exclude<T, undefined | null> extends never ? true : false
+export type IfNil<T, TRUE = true, FALSE = never> = IsNil<T> extends true ? TRUE : FALSE
+export type CastNil<T> = T extends undefined | null ? T : undefined | null
+export type IsNilable<T> = T extends Exclude<T, null | undefined> ? false : true
+export type IfNilable<T, TRUE = true, FALSE = never> = IsNilable<T> extends true ? TRUE : FALSE
+export type Nilable<T> = T | null | undefined
+export type NonNilable<T> = Exclude<T, null | undefined>
+
+/**
+ * Predicate whether the target is `Record`.
+ */
+export type IsRecord<T> = T extends Record<string | number | symbol, unknown> ? true : false
+export type IfRecord<T, TRUE = true, FALSE = never> = IsRecord<T> extends true ? TRUE : FALSE
+export type IsStringRecord<T> = T extends Record<string, unknown> ? true : false
+export type IfStringRecord<T, TRUE = true, FALSE = never> = IsStringRecord<T> extends true ? TRUE : FALSE
+export type IsNumberRecord<T> = T extends Record<number, unknown> ? true : false
+export type IfNumberRecord<T, TRUE = true, FALSE = never> = IsNumberRecord<T> extends true ? TRUE : FALSE
+export type IsSymbolRecord<T> = T extends Record<symbol, unknown> ? true : false
+export type IfSymbolRecord<T, TRUE = true, FALSE = never> = IsSymbolRecord<T> extends true ? TRUE : FALSE
+
+// oxlint-disable-next-line no-wrapper-object-types ban-types
+export type IsObject<Target> = Target extends Object ? true : false
+export type IfObject<Target, TRUE = true, FALSE = never> = IsObject<Target> extends true ? TRUE : FALSE
+export type PlainObject = Record<PropertyKey, unknown>
+/**
+ * Predicate whether the target is `EmptyObject`(`{}`).
+ */
+export type IsEmptyObject<Target extends Record<PropertyKey, unknown>> = keyof Target extends never ? true : false
+export type IfEmptyObject<Target extends Record<PropertyKey, unknown>, TRUE = true, FALSE = never> = IsEmptyObject<Target> extends true ? TRUE : FALSE
+
+/**
+ * Predicate whether the target is `Array`.
+ */
+export type IsArray<T> = T extends readonly unknown[] ? (number extends T["length"] ? true : false) : false
+export type IfArray<T, TRUE = true, FALSE = never> = IsArray<T> extends true ? TRUE : FALSE
+// ReadonlyArray is subset of Array.
+export type IsReadonlyArray<T> = T extends readonly unknown[] ? (T extends unknown[] ? false : true) : false
+export type IfReadonlyArray<T, TRUE = true, FALSE = never> = IsReadonlyArray<T> extends true ? TRUE : FALSE
+export type IsWritableArray<T> = T extends unknown[] ? (number extends T["length"] ? true : false) : false
+export type IfWritableArray<T, TRUE = true, FALSE = never> = IsWritableArray<T> extends true ? TRUE : FALSE
+
+/**
+ * Predicate whether the target is `ArrayLike`.
+ */
+export type IsArrayLike<T> = T extends ArrayLike<unknown> ? true : false
+export type IfArrayLike<T, TRUE = true, FALSE = never> = IsArrayLike<T> extends true ? TRUE : FALSE
+
+/**
+ * Predicate whether the target is `Tuple`.
+ *
+ * @see {@link https://github.com/type-challenges/type-challenges/issues/4491#issuecomment-975808109}
+ */
+export type IsTuple<T> = T extends readonly unknown[] ? (number extends T["length"] ? false : true) : false
+export type IfTuple<T, TRUE = true, FALSE = never> = IsTuple<T> extends true ? TRUE : FALSE
+export type IsReadonlyTuple<T> = T extends readonly unknown[] ? (T extends unknown[] ? false : true) : false
+export type IfReadonlyTuple<T, TRUE = true, FALSE = never> = IsReadonlyTuple<T> extends true ? TRUE : FALSE
+export type IsWritableTuple<T> = T extends unknown[] ? (number extends T["length"] ? false : true) : false
+export type IfWritableTuple<T, TRUE = true, FALSE = never> = IsWritableTuple<T> extends true ? TRUE : FALSE
+
+/**
+ * Predicate whether the target is `Array` or `Tuple`.
+ */
+export type IsArrayOrTuple<T> = T extends readonly unknown[] ? true : false
+export type IfArrayOrTuple<T, TRUE = true, FALSE = never> = IsArrayOrTuple<T> extends true ? TRUE : FALSE
+
+/**
+ * Predicate whether the target is of type function.
+ */
+export type AnyFunction = (...args: any[]) => any
+export type AnyFunctionOfTake<A> = A extends readonly [...infer R] ? ((...args: R) => any) : ((arg: A) => any)
+export type AnyFunctionOfReturn<T> = (...args: any[]) => T
+export type IsFunction<T> = T extends AnyFunction ? true : false
+export type IfFunction<T, TRUE = true, FALSE = never> = IsFunction<T> extends true ? TRUE : FALSE
+export type CastFunction<T> = T extends AnyFunction ? T : AnyFunction
+
+export type AnySyncFunction = (...args: any[]) => Exclude<unknown, Promise<any>>;
+/**
+ * Predicate whether the target is of type sync function.
+ */
+export type IsSyncFunction<T> = T extends (...args: any[]) => infer R ? (R extends Promise<any> ? false : true) : false
+export type IfSyncFunction<T, TRUE = true, FALSE = never> = IsSyncFunction<T> extends true ? TRUE : FALSE
+export type CastSyncFunction<T> = T extends (...args: unknown[]) => infer R ? (R extends Promise<unknown> ? (...args: Parameters<T>) => Awaited<R> : T) : AnyFunction
+
+export type AnyAsyncFunction = (...args: any[]) => Promise<any>
+/**
+ * Predicate whether the target is of type async function.
+ */
+export type IsAsyncFunction<T> = T extends AnyAsyncFunction ? true : false
+export type IfAsyncFunction<T, TRUE = true, FALSE = never> = IsAsyncFunction<T> extends true ? TRUE : FALSE
+export type CastAsyncFunction<T> = T extends AnyAsyncFunction ? T : AnyAsyncFunction
+
+export type AnyGeneratorFunction = (...args: any[]) => Generator<any, any, any>
+/**
+ * Predicate whether the target is of type generator function.
+ */
+export type IsGeneratorFunction<T> = T extends AnyGeneratorFunction ? true : false
+export type IfGeneratorFunction<T, TRUE = true, FALSE = never> = IsGeneratorFunction<T> extends true ? TRUE : FALSE
+export type CastGeneratorFunction<T> = T extends AnyGeneratorFunction ? T : AnyGeneratorFunction
+
+export type AnyAsyncGeneratorFunction = (...args: any[]) => AsyncGenerator<any, any, any>
+/**
+ * Predicate whether the target is of type async generator function.
+ */
+export type IsAsyncGeneratorFunction<T> = T extends AnyAsyncGeneratorFunction ? true : false
+export type IfAsyncGeneratorFunction<T, TRUE = true, FALSE = never> = IsAsyncGeneratorFunction<T> extends true ? TRUE : FALSE
+export type CastAsyncGeneratorFunction<T> = T extends AnyAsyncGeneratorFunction ? T : AnyAsyncGeneratorFunction
+
+/**
+ * Predicate whether the target is `never`.
+ */
+export type IsNever<T> = [T] extends [never] ? true : false
+export type IfNever<T, TRUE = true, FALSE = never> = IsNever<T> extends true ? TRUE : FALSE
+export type CastNever<T> = T extends never ? T : never
+
+/**
+ * Predicate whether the target is `any`.
+ * @see {@link https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360}
+ */
+export type IsAny<T> = 0 extends (1 & T) ? true : false
+export type IfAny<T, TRUE = true, FALSE = never> = IsAny<T> extends true ? TRUE : FALSE
+export type CastAny<T> = T extends any ? T : any
+
+/**
+ * Predicate whether the target is `unknown`.
+ * @see {@link https://www.typescriptlang.org/docs/handbook/type-compatibility.html#any-unknown-object-void-undefined-null-and-never-assignability}
+ */
+export type IsUnknown<T> = IsNever<T> extends true
+  ? false
+  : (
+    T extends unknown
+    ? (
+      unknown extends T
+      ? (IsAny<T> extends true ? false : true)
+      : false
+    )
+    : false
+  )
+export type IfUnknown<T, TRUE = true, FALSE = never> = IsUnknown<T> extends true ? TRUE : FALSE
+export type CastUnknown<T> = T extends unknown ? T : unknown
+
+type InternalIsUnion<T, U> =
+  [T] extends [never]
+  ? false
+  : (
+    T extends any
+    ? ([U] extends [T] ? false : true)
+    : false
+  )
+/**
+ * Predicate whether the target is `Union` type.
+ *
+ * @see {@link https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types}
+ */
+export type IsUnion<T> = InternalIsUnion<T, T>;
+export type IfUnion<T, TRUE = true, FALSE = never> = IsUnion<T> extends true ? TRUE : FALSE
+
+export interface EmptyInterface { }