@evolu/common 7.3.0 → 7.4.1

package/src/Type.ts

@@ -1,6 +1,19 @@
+import { utf8ToBytes } from "@noble/ciphers/utils.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import * as bip39 from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import { pack } from "msgpackr";
+import type { Brand } from "./Brand.js";
+import type { RandomBytesDep } from "./Crypto.js";
+import { isPlainObject } from "./Object.js";
+import { hasNodeBuffer } from "./Platform.js";
+import { err, getOrNull, getOrThrow, ok, Result, trySync } from "./Result.js";
+import { safelyStringifyUnknownValue } from "./String.js";
+import type { TimeDep } from "./Time.js";
+import type { Literal, Refinement, Simplify, WidenLiteral } from "./Types.js";
+import { IntentionalNever } from "./Types.js";
+
 /**
- * Runtime types
- *
  * Evolu {@link Type} is like a type guard that returns typed errors (via
  * {@link Result}) instead of throwing. We either get a safely typed value or a
  * composable typed error telling us exactly why validation failed.
@@ -197,25 +210,7 @@
  * ```
  *
  * Note `minLength` and `maxLength` are curried because they are factories.
- *
- * @module
  */
-
-import { utf8ToBytes } from "@noble/ciphers/utils.js";
-import { sha256 } from "@noble/hashes/sha2.js";
-import * as bip39 from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english.js";
-import { pack } from "msgpackr";
-import type { Brand } from "./Brand.js";
-import type { RandomBytesDep } from "./Crypto.js";
-import { isPlainObject } from "./Object.js";
-import { hasNodeBuffer } from "./Platform.js";
-import { err, getOrNull, getOrThrow, ok, Result, trySync } from "./Result.js";
-import { safelyStringifyUnknownValue } from "./String.js";
-import type { TimeDep } from "./Time.js";
-import type { Literal, Refinement, Simplify, WidenLiteral } from "./Types.js";
-import { IntentionalNever } from "./Types.js";
-
 export interface Type<
   Name extends TypeName,
   /** The type this Type resolves to. */
@@ -796,13 +791,14 @@ export interface InstanceOfError extends TypeError<"InstanceOf"> {
   readonly ctor: string;
 }
 
-export interface InstanceOfType<T extends abstract new (...args: any) => any>
-  extends Type<
-    "InstanceOf",
-    InstanceType<T>,
-    InstanceType<T>,
-    InstanceOfError
-  > {
+export interface InstanceOfType<
+  T extends abstract new (...args: any) => any,
+> extends Type<
+  "InstanceOf",
+  InstanceType<T>,
+  InstanceType<T>,
+  InstanceOfError
+> {
   ctor: T;
 }
 
@@ -1036,13 +1032,13 @@ export interface BrandType<
   Error extends TypeError = never,
   ParentError extends TypeError = never,
 > extends Type<
-    "Brand",
-    InferType<ParentType> & Brand<Name>,
-    InferInput<ParentType>,
-    Error,
-    InferType<ParentType>,
-    ParentError
-  > {
+  "Brand",
+  InferType<ParentType> & Brand<Name>,
+  InferInput<ParentType>,
+  Error,
+  InferType<ParentType>,
+  ParentError
+> {
   readonly brand: Name;
   readonly parentType: ParentType;
 }
@@ -1229,8 +1225,9 @@ export const minLength: <Min extends number>(
       value.length >= min ? ok(value) : err({ type: "MinLength", value, min }),
     );
 
-export interface MinLengthError<Min extends number = number>
-  extends TypeError<"MinLength"> {
+export interface MinLengthError<
+  Min extends number = number,
+> extends TypeError<"MinLength"> {
   readonly min: Min;
 }
 
@@ -1260,8 +1257,9 @@ export const maxLength: <Max extends number>(
       value.length <= max ? ok(value) : err({ type: "MaxLength", value, max }),
     );
 
-export interface MaxLengthError<Max extends number = number>
-  extends TypeError<"MaxLength"> {
+export interface MaxLengthError<
+  Max extends number = number,
+> extends TypeError<"MaxLength"> {
   readonly max: Max;
 }
 
@@ -1293,8 +1291,9 @@ export const length: <Exact extends number>(
         : err({ type: "Length", value, exact }),
     );
 
-export interface LengthError<Exact extends number = number>
-  extends TypeError<"Length"> {
+export interface LengthError<
+  Exact extends number = number,
+> extends TypeError<"Length"> {
   readonly exact: Exact;
 }
 
@@ -1393,8 +1392,9 @@ export const regex: <Name extends TypeName>(
     });
 };
 
-export interface RegexError<Name extends TypeName = TypeName>
-  extends TypeError<"Regex"> {
+export interface RegexError<
+  Name extends TypeName = TypeName,
+> extends TypeError<"Regex"> {
   readonly name: Name;
   readonly pattern: RegExp;
 }
@@ -1762,20 +1762,20 @@ export const id = <Table extends TypeName>(table: Table): TableId<Table> => {
   };
 };
 
-export interface TableId<Table extends TypeName>
-  extends Type<
-    "Id",
-    string & Brand<"Id"> & Brand<Table>,
-    string,
-    TableIdError<Table>,
-    string,
-    StringError
-  > {
+export interface TableId<Table extends TypeName> extends Type<
+  "Id",
+  string & Brand<"Id"> & Brand<Table>,
+  string,
+  TableIdError<Table>,
+  string,
+  StringError
+> {
   table: Table;
 }
 
-export interface TableIdError<Table extends TypeName = TypeName>
-  extends TypeError<"TableId"> {
+export interface TableIdError<
+  Table extends TypeName = TypeName,
+> extends TypeError<"TableId"> {
   readonly table: Table;
 }
 
@@ -2020,8 +2020,9 @@ export const greaterThan: <Min extends number>(
       value > min ? ok(value) : err({ type: "GreaterThan", value, min }),
     );
 
-export interface GreaterThanError<Min extends number = number>
-  extends TypeError<"GreaterThan"> {
+export interface GreaterThanError<
+  Min extends number = number,
+> extends TypeError<"GreaterThan"> {
   readonly min: Min;
 }
 
@@ -2043,8 +2044,9 @@ export const lessThan: <Max extends number>(
       value < max ? ok(value) : err({ type: "LessThan", value, max }),
     );
 
-export interface LessThanError<Max extends number = number>
-  extends TypeError<"LessThan"> {
+export interface LessThanError<
+  Max extends number = number,
+> extends TypeError<"LessThan"> {
   readonly max: Max;
 }
 
@@ -2070,8 +2072,9 @@ export const greaterThanOrEqualTo: <Min extends number>(
       : err({ type: "GreaterThanOrEqualTo", value, min }),
   );
 
-export interface GreaterThanOrEqualToError<Min extends number = number>
-  extends TypeError<"GreaterThanOrEqualTo"> {
+export interface GreaterThanOrEqualToError<
+  Min extends number = number,
+> extends TypeError<"GreaterThanOrEqualTo"> {
   readonly min: Min;
 }
 
@@ -2096,8 +2099,9 @@ export const lessThanOrEqualTo: <Max extends number>(
     value <= max ? ok(value) : err({ type: "LessThanOrEqualTo", value, max }),
   );
 
-export interface LessThanOrEqualToError<Max extends number = number>
-  extends TypeError<"LessThanOrEqualTo"> {
+export interface LessThanOrEqualToError<
+  Max extends number = number,
+> extends TypeError<"LessThanOrEqualTo"> {
   readonly max: Max;
 }
 
@@ -2177,8 +2181,9 @@ export const multipleOf: <Divisor extends number>(
         : err({ type: "MultipleOf", value, divisor }),
     );
 
-export interface MultipleOfError<Divisor extends number = number>
-  extends TypeError<"MultipleOf"> {
+export interface MultipleOfError<
+  Divisor extends number = number,
+> extends TypeError<"MultipleOf"> {
   readonly divisor: Divisor;
 }
 
@@ -2255,13 +2260,18 @@ export const literal = <T extends Literal>(expected: T): LiteralType<T> => {
   } as LiteralType<T>;
 };
 
-export interface LiteralType<T extends Literal>
-  extends Type<"Literal", T, WidenLiteral<T>, LiteralError<T>> {
+export interface LiteralType<T extends Literal> extends Type<
+  "Literal",
+  T,
+  WidenLiteral<T>,
+  LiteralError<T>
+> {
   expected: T;
 }
 
-export interface LiteralError<T extends Literal = Literal>
-  extends TypeError<"Literal"> {
+export interface LiteralError<
+  T extends Literal = Literal,
+> extends TypeError<"Literal"> {
   readonly expected: T;
 }
 
@@ -2356,28 +2366,28 @@ export const array = <ElementType extends AnyType>(
 };
 
 /** ArrayType extends Type with an additional `element` property for reflection. */
-export interface ArrayType<ElementType extends AnyType>
-  extends Type<
-    "Array",
-    ReadonlyArray<InferType<ElementType>>,
-    ReadonlyArray<InferInput<ElementType>>,
-    ArrayError<InferError<ElementType>>,
-    ReadonlyArray<InferParent<ElementType>>,
-    ArrayError<InferParentError<ElementType>>
-  > {
+export interface ArrayType<ElementType extends AnyType> extends Type<
+  "Array",
+  ReadonlyArray<InferType<ElementType>>,
+  ReadonlyArray<InferInput<ElementType>>,
+  ArrayError<InferError<ElementType>>,
+  ReadonlyArray<InferParent<ElementType>>,
+  ArrayError<InferParentError<ElementType>>
+> {
   readonly element: ElementType;
 }
 
-export interface ArrayError<Error extends TypeError = TypeError>
-  extends TypeErrorWithReason<
-    "Array",
-    | { readonly kind: "NotArray" }
-    | {
-        readonly kind: "Element";
-        readonly index: number;
-        readonly error: Error;
-      }
-  > {}
+export interface ArrayError<
+  Error extends TypeError = TypeError,
+> extends TypeErrorWithReason<
+  "Array",
+  | { readonly kind: "NotArray" }
+  | {
+      readonly kind: "Element";
+      readonly index: number;
+      readonly error: Error;
+    }
+> {}
 
 export const formatArrayError = <Error extends TypeError>(
   formatTypeError: TypeErrorFormatter<Error>,
@@ -2474,28 +2484,28 @@ export const set = <ElementType extends AnyType>(
 };
 
 /** SetType extends Type with an additional `element` property for reflection. */
-export interface SetType<ElementType extends AnyType>
-  extends Type<
-    "Set",
-    ReadonlySet<InferType<ElementType>>,
-    ReadonlySet<InferInput<ElementType>>,
-    SetError<InferError<ElementType>>,
-    ReadonlySet<InferParent<ElementType>>,
-    SetError<InferParentError<ElementType>>
-  > {
+export interface SetType<ElementType extends AnyType> extends Type<
+  "Set",
+  ReadonlySet<InferType<ElementType>>,
+  ReadonlySet<InferInput<ElementType>>,
+  SetError<InferError<ElementType>>,
+  ReadonlySet<InferParent<ElementType>>,
+  SetError<InferParentError<ElementType>>
+> {
   readonly element: ElementType;
 }
 
-export interface SetError<Error extends TypeError = TypeError>
-  extends TypeErrorWithReason<
-    "Set",
-    | { readonly kind: "NotSet" }
-    | {
-        readonly kind: "Element";
-        readonly index: number;
-        readonly error: Error;
-      }
-  > {}
+export interface SetError<
+  Error extends TypeError = TypeError,
+> extends TypeErrorWithReason<
+  "Set",
+  | { readonly kind: "NotSet" }
+  | {
+      readonly kind: "Element";
+      readonly index: number;
+      readonly error: Error;
+    }
+> {}
 
 export const formatSetError = <Error extends TypeError>(
   formatTypeError: TypeErrorFormatter<Error>,
@@ -2670,13 +2680,13 @@ export interface RecordType<
   KeyParentError extends TypeError,
   Value extends AnyType = AnyType,
 > extends Type<
-    "Record",
-    Readonly<Record<KeyT, InferType<Value>>>,
-    Readonly<Record<KeyInput, InferInput<Value>>>,
-    RecordError<KeyError, InferError<Value>>,
-    Readonly<Record<KeyParent, InferParent<Value>>>,
-    RecordError<KeyParentError, InferParentError<Value>>
-  > {
+  "Record",
+  Readonly<Record<KeyT, InferType<Value>>>,
+  Readonly<Record<KeyInput, InferInput<Value>>>,
+  RecordError<KeyError, InferError<Value>>,
+  Readonly<Record<KeyParent, InferParent<Value>>>,
+  RecordError<KeyParentError, InferParentError<Value>>
+> {
   readonly key: Type<
     KeyName,
     KeyT,
@@ -2692,19 +2702,19 @@ export interface RecordError<
   KeyError extends TypeError = TypeError,
   ValueError extends TypeError = TypeError,
 > extends TypeErrorWithReason<
-    "Record",
-    | { readonly kind: "NotRecord" }
-    | {
-        readonly kind: "Key";
-        readonly key: unknown;
-        readonly error: KeyError;
-      }
-    | {
-        readonly kind: "Value";
-        readonly key: unknown;
-        readonly error: ValueError;
-      }
-  > {}
+  "Record",
+  | { readonly kind: "NotRecord" }
+  | {
+      readonly kind: "Key";
+      readonly key: unknown;
+      readonly error: KeyError;
+    }
+  | {
+      readonly kind: "Value";
+      readonly key: unknown;
+      readonly error: ValueError;
+    }
+> {}
 
 export const formatRecordError = <Error extends TypeError>(
   formatTypeError: TypeErrorFormatter<Error>,
@@ -3016,15 +3026,14 @@ export function object(
  * ObjectType extends {@link Type} with an additional `props` property for
  * reflection.
  */
-export interface ObjectType<Props extends Record<string, AnyType>>
-  extends Type<
-    "Object",
-    Readonly<ObjectT<Props>>,
-    Readonly<ObjectInput<Props>>,
-    ObjectError<{ [K in keyof Props]: InferError<Props[K]> }>,
-    Readonly<ObjectParent<Props>>,
-    ObjectError<{ [K in keyof Props]: InferParentError<Props[K]> }>
-  > {
+export interface ObjectType<Props extends Record<string, AnyType>> extends Type<
+  "Object",
+  Readonly<ObjectT<Props>>,
+  Readonly<ObjectInput<Props>>,
+  ObjectError<{ [K in keyof Props]: InferError<Props[K]> }>,
+  Readonly<ObjectParent<Props>>,
+  ObjectError<{ [K in keyof Props]: InferParentError<Props[K]> }>
+> {
   readonly props: Props;
 }
 
@@ -3070,14 +3079,14 @@ type OptionalKeys<Props extends Record<string, AnyType>> = {
 export interface ObjectError<
   PropsErrors extends Record<string, TypeError> = Record<string, TypeError>,
 > extends TypeErrorWithReason<
-    "Object",
-    | { readonly kind: "NotObject" }
-    | {
-        readonly kind: "Props";
-        readonly errors: Partial<PropsErrors>;
-      }
-    | { readonly kind: "ExtraKeys"; readonly extraKeys: ReadonlyArray<string> }
-  > {}
+  "Object",
+  | { readonly kind: "NotObject" }
+  | {
+      readonly kind: "Props";
+      readonly errors: Partial<PropsErrors>;
+    }
+  | { readonly kind: "ExtraKeys"; readonly extraKeys: ReadonlyArray<string> }
+> {}
 
 /**
  * Merge Error and ParentError into one ObjectError so tooltips and error
@@ -3123,23 +3132,22 @@ export interface ObjectWithRecordType<
   KeyParentError extends TypeError,
   Value extends AnyType,
 > extends Type<
-    "ObjectWithRecord",
-    Readonly<ObjectT<Props>> & Readonly<Record<KeyT, InferType<Value>>>,
-    Readonly<ObjectInput<Props>> &
-      Readonly<Record<KeyInput, InferInput<Value>>>,
-    ObjectWithRecordError<
-      { [K in keyof Props]: InferError<Props[K]> },
-      KeyError,
-      InferError<Value>
-    >,
-    Readonly<ObjectParent<Props>> &
-      Readonly<Record<KeyParent, InferParent<Value>>>,
-    ObjectWithRecordError<
-      { [K in keyof Props]: InferParentError<Props[K]> },
-      KeyParentError,
-      InferParentError<Value>
-    >
-  > {
+  "ObjectWithRecord",
+  Readonly<ObjectT<Props>> & Readonly<Record<KeyT, InferType<Value>>>,
+  Readonly<ObjectInput<Props>> & Readonly<Record<KeyInput, InferInput<Value>>>,
+  ObjectWithRecordError<
+    { [K in keyof Props]: InferError<Props[K]> },
+    KeyError,
+    InferError<Value>
+  >,
+  Readonly<ObjectParent<Props>> &
+    Readonly<Record<KeyParent, InferParent<Value>>>,
+  ObjectWithRecordError<
+    { [K in keyof Props]: InferParentError<Props[K]> },
+    KeyParentError,
+    InferParentError<Value>
+  >
+> {
   readonly props: Props;
   readonly record: RecordType<
     KeyName,
@@ -3157,20 +3165,20 @@ export interface ObjectWithRecordError<
   KeyError extends TypeError = TypeError,
   ValueError extends TypeError = TypeError,
 > extends TypeErrorWithReason<
-    "ObjectWithRecord",
-    | { readonly kind: "NotObject" }
-    | { readonly kind: "Props"; readonly errors: Partial<PropsErrors> }
-    | {
-        readonly kind: "IndexKey";
-        readonly key: unknown;
-        readonly error: KeyError;
-      }
-    | {
-        readonly kind: "IndexValue";
-        readonly key: string;
-        readonly error: ValueError;
-      }
-  > {}
+  "ObjectWithRecord",
+  | { readonly kind: "NotObject" }
+  | { readonly kind: "Props"; readonly errors: Partial<PropsErrors> }
+  | {
+      readonly kind: "IndexKey";
+      readonly key: unknown;
+      readonly error: KeyError;
+    }
+  | {
+      readonly kind: "IndexValue";
+      readonly key: string;
+      readonly error: ValueError;
+    }
+> {}
 
 export const formatObjectWithRecordError = <Error extends TypeError>(
   formatTypeError: TypeErrorFormatter<Error>,
@@ -3276,20 +3284,22 @@ export function union(...args: ReadonlyArray<any>): any {
  * UnionType extends {@link Type} with an additional `members` property for
  * reflection.
  */
-export interface UnionType<Members extends [AnyType, ...ReadonlyArray<AnyType>]>
-  extends Type<
-    "Union",
-    InferType<Members[number]>,
-    InferInput<Members[number]>,
-    UnionError<InferErrors<Members[number]>>,
-    InferInput<Members[number]>,
-    never
-  > {
+export interface UnionType<
+  Members extends [AnyType, ...ReadonlyArray<AnyType>],
+> extends Type<
+  "Union",
+  InferType<Members[number]>,
+  InferInput<Members[number]>,
+  UnionError<InferErrors<Members[number]>>,
+  InferInput<Members[number]>,
+  never
+> {
   readonly members: Members;
 }
 
-export interface UnionError<E extends TypeError = TypeError>
-  extends TypeError<"Union"> {
+export interface UnionError<
+  E extends TypeError = TypeError,
+> extends TypeError<"Union"> {
   readonly errors: Array<E>;
 }
 
@@ -3379,15 +3389,14 @@ export const recursive = <ParentType extends AnyType>(
   } as RecursiveType<ParentType>;
 };
 
-export interface RecursiveType<ParentType extends AnyType>
-  extends Type<
-    "Recursive",
-    InferType<ParentType>,
-    InferInput<ParentType>,
-    InferError<ParentType>,
-    InferParent<ParentType>,
-    InferParentError<ParentType>
-  > {
+export interface RecursiveType<ParentType extends AnyType> extends Type<
+  "Recursive",
+  InferType<ParentType>,
+  InferInput<ParentType>,
+  InferError<ParentType>,
+  InferParent<ParentType>,
+  InferParentError<ParentType>
+> {
   getParentType(): ParentType;
 }
 
@@ -3551,26 +3560,27 @@ export const tuple = <Elements extends [AnyType, ...ReadonlyArray<AnyType>]>(
 export interface TupleType<
   Elements extends readonly [AnyType, ...ReadonlyArray<AnyType>],
 > extends Type<
-    "Tuple",
-    readonly [...{ [K in keyof Elements]: InferType<Elements[K]> }],
-    readonly [...{ [K in keyof Elements]: InferInput<Elements[K]> }],
-    TupleError<{ [K in keyof Elements]: InferError<Elements[K]> }[number]>,
-    readonly [...{ [K in keyof Elements]: InferParent<Elements[K]> }],
-    TupleError<{ [K in keyof Elements]: InferParentError<Elements[K]> }[number]>
-  > {
+  "Tuple",
+  readonly [...{ [K in keyof Elements]: InferType<Elements[K]> }],
+  readonly [...{ [K in keyof Elements]: InferInput<Elements[K]> }],
+  TupleError<{ [K in keyof Elements]: InferError<Elements[K]> }[number]>,
+  readonly [...{ [K in keyof Elements]: InferParent<Elements[K]> }],
+  TupleError<{ [K in keyof Elements]: InferParentError<Elements[K]> }[number]>
+> {
   readonly elements: Elements;
 }
 
-export interface TupleError<ElementError extends TypeError = TypeError>
-  extends TypeErrorWithReason<
-    "Tuple",
-    | { readonly kind: "InvalidLength"; readonly expected: number }
-    | {
-        readonly kind: "Element";
-        readonly index: number;
-        readonly error: ElementError;
-      }
-  > {}
+export interface TupleError<
+  ElementError extends TypeError = TypeError,
+> extends TypeErrorWithReason<
+  "Tuple",
+  | { readonly kind: "InvalidLength"; readonly expected: number }
+  | {
+      readonly kind: "Element";
+      readonly index: number;
+      readonly error: ElementError;
+    }
+> {}
 
 export const formatTupleError = <Error extends TypeError>(
   formatTypeError: TypeErrorFormatter<Error>,
@@ -3874,15 +3884,14 @@ export const optional = <T extends AnyType>(type: T): OptionalType<T> => ({
   parent: type,
 });
 
-export interface OptionalType<T extends AnyType>
-  extends Type<
-    "Optional",
-    InferType<T>,
-    InferInput<T>,
-    InferError<T>,
-    InferParent<T>,
-    InferParentError<T>
-  > {
+export interface OptionalType<T extends AnyType> extends Type<
+  "Optional",
+  InferType<T>,
+  InferInput<T>,
+  InferError<T>,
+  InferParent<T>,
+  InferParentError<T>
+> {
   readonly parent: T;
 }
 
@@ -4015,8 +4024,7 @@ export const validMutationSize = <T extends AnyType>(
       : err<ValidMutationSizeError>({ type: "ValidMutationSize", value }),
   );
 
-export interface ValidMutationSizeError
-  extends TypeError<"ValidMutationSize"> {}
+export interface ValidMutationSizeError extends TypeError<"ValidMutationSize"> {}
 
 export const formatValidMutationSizeError =
   createTypeErrorFormatter<ValidMutationSizeError>(

package/src/index.ts

@@ -18,6 +18,7 @@ export * from "./Object.js";
 export * from "./Order.js";
 export * from "./Platform.js";
 export * from "./Random.js";
+export * from "./Redacted.js";
 export * from "./Ref.js";
 export * from "./Relation.js";
 export * from "./Resources.js";