@evolu/common 5.4.7 → 6.0.0

package/dist/src/Types.d.ts

@@ -0,0 +1,188 @@
+/**
+ * TypeScript utility types
+ *
+ * @module
+ */
+import * as Kysely from "kysely";
+/**
+ * Checks a condition on a value and returns a boolean.
+ *
+ * A predicate starts with an 'is' prefix, e.g., `isEven`.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const isEven: Predicate<number> = (n) => n % 2 === 0;
+ *
+ * const numbers = [1, 2, 3, 4];
+ * const evenNumbers = numbers.filter(isEven); // [2, 4]
+ * ```
+ */
+export type Predicate<T> = (value: T) => boolean;
+/**
+ * A type guard function that refines type `A` to a narrower type `B`.
+ *
+ * ### Example
+ *
+ * ```ts
+ * type Animal = { name: string };
+ * type Dog = Animal & { breed: string };
+ *
+ * const isDog: Refinement<Animal, Dog> = (animal): animal is Dog =>
+ *   "breed" in animal;
+ *
+ * const animal: Animal = { name: "Dog", breed: "Beagle" };
+ * if (isDog(animal)) {
+ *   console.log(animal.breed); // Safe access to `breed`
+ * }
+ * ```
+ */
+export type Refinement<in A, out B extends A> = (a: A) => a is B;
+/**
+ * Makes properties optional if they accept `null` as a value.
+ *
+ * For each property in `T`, if `null` is a valid value for that property, the
+ * property will be made optional in the resulting type.
+ *
+ * ### Example
+ *
+ * ```ts
+ * type Example = {
+ *   required: string;
+ *   optionalWithNull: string | null;
+ * };
+ *
+ * type Result = NullablePartial<Example>;
+ * // Result is:
+ * // {
+ * //   required: string;
+ * //   optionalWithNull?: string | null;
+ * // }
+ * ```
+ */
+export type NullablePartial<T, NK extends keyof T = {
+    [K in keyof T]: null extends T[K] ? K : never;
+}[keyof T], NP = Pick<T, Exclude<keyof T, NK>> & Partial<Pick<T, NK>>> = {
+    [K in keyof NP]: NP[K];
+};
+/**
+ * A type alias for `never` that is used intentionally when casting is not
+ * needed and unit tests exist to ensure correctness.
+ */
+export type IntentionalNever = never;
+/**
+ * A utility interface for creating branded types.
+ *
+ * Branded types enhance type safety by differentiating otherwise identical base
+ * types, such as `number` or `string`, to enforce stricter type checks.
+ *
+ * Supports multiple brands, allowing types to act like flags.
+ *
+ * ### Example 1: Single Brand
+ *
+ * ```ts
+ * // A branded type definition
+ * type UserId = number & Brand<"UserId">;
+ *
+ * // A function that creates `UserId` values.
+ * // Casting with `as UserId` is unsafe, so `createUserId` must be unit-tested.
+ * const createUserId = (): UserId => {
+ *   return 123 as UserId; // Unsafe casting
+ * };
+ *
+ * const userId = createUserId();
+ *
+ * // A function that accepts only `UserId`.
+ * const getUser = (id: UserId) => {
+ *   // Implementation
+ * };
+ *
+ * getUser(userId); // ✅ Valid
+ * getUser(123); // ❌ TypeScript error
+ * getUser("123"); // ❌ TypeScript error
+ * ```
+ *
+ * ### Example 2: Multiple Brands
+ *
+ * ```ts
+ * // Define branded types
+ * type Min1 = string & Brand<"Min1">;
+ * type Max100 = string & Brand<"Max100">;
+ * type Min1Max100 = string & Brand<"Min1" | "Max100">;
+ *
+ * // Functions requiring specific brands
+ * const requiresMin1 = (value: Min1): void => {};
+ * const requiresMax100 = (value: Max100): void => {};
+ *
+ * // Values with single brands
+ * const min1Value: Min1 = "hello" as Min1;
+ * const max100Value: Max100 = "world" as Max100;
+ *
+ * // Value with multiple brands
+ * const min1Max100Value: Min1Max100 = "typescript" as Min1Max100;
+ *
+ * // Valid cases
+ * requiresMin1(min1Value); // ✅ Valid
+ * requiresMax100(max100Value); // ✅ Valid
+ * requiresMin1(min1Max100Value); // ✅ Valid: Min1Max100 satisfies Min1
+ * requiresMax100(min1Max100Value); // ✅ Valid: Min1Max100 satisfies Max100
+ * ```
+ */
+export interface Brand<B extends string> {
+    readonly [__brand]: Readonly<Record<B, true>>;
+}
+declare const __brand: unique symbol;
+/**
+ * Determines whether a type `T` is a branded type.
+ *
+ * Works with any base type intersected with a `Brand`.
+ *
+ * ### Examples
+ *
+ * - `IsBranded<string>` -> false
+ * - `IsBranded<string & Brand<"X">>` -> true
+ */
+export type IsBranded<T> = T extends Brand<string> ? true : false;
+/**
+ * String | number | bigint | boolean | undefined | null
+ *
+ * https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types
+ */
+export type Literal = string | number | bigint | boolean | undefined | null;
+/**
+ * Infers a broader type from a specific literal value type.
+ *
+ * Examples:
+ *
+ * - "foo" -> string
+ * - 42 -> number
+ * - 42n -> bigint
+ * - True -> boolean
+ */
+export type WidenLiteral<T extends Literal> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T;
+/**
+ * Simplify an intersection type into a single mapped type.
+ *
+ * This utility forces TypeScript to "flatten" an intersection type into a
+ * single object type so that tooltips and error messages are easier to read.
+ *
+ * ### Example
+ *
+ * ```ts
+ * type A = { a: string } & { b: number };
+ * // Without Simplify, TypeScript may display A as:
+ * // { a: string } & { b: number }
+ *
+ * type B = Simplify<A>;
+ * // B is equivalent to:
+ * // { a: string; b: number }
+ * ```
+ */
+export type Simplify<T> = Kysely.Simplify<T>;
+/**
+ * Makes a specific property of an object optional while keeping others
+ * unchanged.
+ */
+export type PartialProp<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export {};
+//# sourceMappingURL=Types.d.ts.map

package/dist/src/Types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Types.d.ts","sourceRoot":"","sources":["../../src/Types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,eAAe,CACzB,CAAC,EACD,EAAE,SAAS,MAAM,CAAC,GAAG;KAClB,CAAC,IAAI,MAAM,CAAC,GAAG,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;CAC9C,CAAC,MAAM,CAAC,CAAC,EACV,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IACvD;KAAG,CAAC,IAAI,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;CAAE,CAAC;AAE/B;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC,SAAS,MAAM;IACrC,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;CAC/C;AAED,OAAO,CAAC,MAAM,OAAO,EAAE,OAAO,MAAM,CAAC;AAErC;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AAElE;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,IAAI,CAAC;AAE5E;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,OAAO,IAAI,CAAC,SAAS,MAAM,GAC1D,MAAM,GACN,CAAC,SAAS,MAAM,GACd,MAAM,GACN,CAAC,SAAS,OAAO,GACf,OAAO,GACP,CAAC,SAAS,MAAM,GACd,MAAM,GACN,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AAE7C;;;GAGG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GACxD,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC"}

package/dist/src/Types.js

@@ -0,0 +1,6 @@
+/**
+ * TypeScript utility types
+ *
+ * @module
+ */
+export {};

package/dist/src/WebSocket.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Websocket with auto-reconnect and offline support
+ *
+ * @module
+ */
+import { RetryError, RetryOptions } from "./Promise.js";
+import { Result } from "./Result.js";
+/** WebSocket with auto-reconnect and offline support. */
+export interface WebSocket extends Disposable {
+    /**
+     * Send data through the WebSocket connection. Returns {@link Result} with an
+     * error if the data couldn't be sent.
+     */
+    send: (data: string | ArrayBufferLike | Blob | ArrayBufferView) => Result<void, WebSocketSendError>;
+    readonly getReadyState: () => WebSocketReadyState;
+}
+/**
+ * An error that occurs when trying to send data but WebSocket is connecting.
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
+ */
+export interface WebSocketSendError {
+    readonly type: "WebSocketSendError";
+}
+/** WebSocket connection states. */
+export type WebSocketReadyState = "connecting" | "open" | "closing" | "closed";
+export type CreateWebSocket = (url: string, options?: WebSocketOptions) => WebSocket;
+export interface CreateWebSocketDep {
+    readonly createWebSocket: CreateWebSocket;
+}
+/** Options for creating {@link WebSocket} */
+export interface WebSocketOptions {
+    /** Protocol(s) to use with the WebSocket connection. */
+    protocols?: string | Array<string>;
+    /** Sets the binary type for the data being received. */
+    binaryType?: "blob" | "arraybuffer";
+    /** Callback when the connection is established. */
+    onOpen?: () => void;
+    /** Callback when an error occurs. */
+    onError?: (error: WebSocketError) => void;
+    /** Callback when the connection is closed. */
+    onClose?: (event: CloseEvent) => void;
+    /** Callback when message data is received. */
+    onMessage?: (data: string | ArrayBuffer | Blob) => void;
+    /** Options for retry behavior. */
+    retryOptions?: Omit<RetryOptions<WebSocketRetryError>, "signal">;
+    /**
+     * For custom WebSocket implementations.
+     *
+     * This suppors blob:
+     *
+     * https://github.com/callstackincubator/react-native-fast-io
+     */
+    WebSocketConstructor?: typeof globalThis.WebSocket;
+}
+export type WebSocketError = WebSocketConnectError | WebSocketConnectionError | RetryError<WebSocketRetryError>;
+/**
+ * An error that occurs when a connection cannot be established due to a network
+ * error.
+ */
+export interface WebSocketConnectError {
+    readonly type: "WebSocketConnectError";
+    readonly event: Event;
+}
+/**
+ * An error that occurs when a connection is closed due to an issue (e.g.,
+ * failure to send some data).
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/error_event
+ */
+export interface WebSocketConnectionError {
+    readonly type: "WebSocketConnectionError";
+    readonly event: Event;
+}
+export type WebSocketRetryError = WebSocketConnectError | WebSocketConnectionCloseError;
+export interface WebSocketConnectionCloseError {
+    readonly type: "WebSocketConnectionCloseError";
+    readonly event: CloseEvent;
+}
+/**
+ * Create a new {@link WebSocket}.
+ *
+ * The default behavior is that WebSocket tries to reconnect repeatedly in case
+ * the application is offline, because online events (both web and native) are
+ * not reliable. Once it connects and the connection is closed, it tries to
+ * reconnect again. Retrying the connection can be controlled using the
+ * retryOptions retryable predicate.
+ *
+ * ### How Binary Messages Work in WebSockets
+ *
+ * The Server Chooses the Message Type:
+ *
+ * - Text (0x1) → Sent as UTF-8 encoded text (always received as a string in the
+ *   browser).
+ * - Binary (0x2) → Sent as raw binary data (received as a Blob or ArrayBuffer,
+ *   depending on binaryType).
+ *
+ * The Client's binaryType Controls How Binary Data is Processed:
+ *
+ * - If the server sends a text frame (0x1), the browser always delivers
+ *   event.data as a string, regardless of binaryType.
+ * - If the server sends a binary frame (0x2), the browser delivers event.data as:
+ *
+ *   - A Blob (default: "blob")
+ *   - An ArrayBuffer ("arraybuffer")
+ *
+ * ### Example
+ *
+ * TODO:
+ */
+export declare const createWebSocket: CreateWebSocket;
+//# sourceMappingURL=WebSocket.d.ts.map

package/dist/src/WebSocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocket.d.ts","sourceRoot":"","sources":["../../src/WebSocket.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAS,UAAU,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAW,MAAM,EAAE,MAAM,aAAa,CAAC;AAE9C,yDAAyD;AACzD,MAAM,WAAW,SAAU,SAAQ,UAAU;IAC3C;;;OAGG;IACH,IAAI,EAAE,CACJ,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,GAAG,eAAe,KACpD,MAAM,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC;IAEtC,QAAQ,CAAC,aAAa,EAAE,MAAM,mBAAmB,CAAC;CACnD;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;CACrC;AAED,mCAAmC;AACnC,MAAM,MAAM,mBAAmB,GAAG,YAAY,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE/E,MAAM,MAAM,eAAe,GAAG,CAC5B,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,gBAAgB,KACvB,SAAS,CAAC;AAEf,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;CAC3C;AAED,6CAA6C;AAC7C,MAAM,WAAW,gBAAgB;IAC/B,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IAEnC,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC;IAEpC,mDAAmD;IACnD,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IAEpB,qCAAqC;IACrC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;IAE1C,8CAA8C;IAC9C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAEtC,8CAA8C;IAC9C,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,KAAK,IAAI,CAAC;IAExD,kCAAkC;IAClC,YAAY,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC,mBAAmB,CAAC,EAAE,QAAQ,CAAC,CAAC;IAEjE;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,OAAO,UAAU,CAAC,SAAS,CAAC;CACpD;AAED,MAAM,MAAM,cAAc,GACtB,qBAAqB,GACrB,wBAAwB,GACxB,UAAU,CAAC,mBAAmB,CAAC,CAAC;AAEpC;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,0BAA0B,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;CACvB;AAED,MAAM,MAAM,mBAAmB,GAC3B,qBAAqB,GACrB,6BAA6B,CAAC;AAElC,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,IAAI,EAAE,+BAA+B,CAAC;IAC/C,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,eAAe,EAAE,eA0H7B,CAAC"}

package/dist/src/WebSocket.js

@@ -0,0 +1,139 @@
+/**
+ * Websocket with auto-reconnect and offline support
+ *
+ * @module
+ */
+import { assertNoErrorInCatch } from "./Assert.js";
+import { retry } from "./Promise.js";
+import { err, ok } from "./Result.js";
+/**
+ * Create a new {@link WebSocket}.
+ *
+ * The default behavior is that WebSocket tries to reconnect repeatedly in case
+ * the application is offline, because online events (both web and native) are
+ * not reliable. Once it connects and the connection is closed, it tries to
+ * reconnect again. Retrying the connection can be controlled using the
+ * retryOptions retryable predicate.
+ *
+ * ### How Binary Messages Work in WebSockets
+ *
+ * The Server Chooses the Message Type:
+ *
+ * - Text (0x1) → Sent as UTF-8 encoded text (always received as a string in the
+ *   browser).
+ * - Binary (0x2) → Sent as raw binary data (received as a Blob or ArrayBuffer,
+ *   depending on binaryType).
+ *
+ * The Client's binaryType Controls How Binary Data is Processed:
+ *
+ * - If the server sends a text frame (0x1), the browser always delivers
+ *   event.data as a string, regardless of binaryType.
+ * - If the server sends a binary frame (0x2), the browser delivers event.data as:
+ *
+ *   - A Blob (default: "blob")
+ *   - An ArrayBuffer ("arraybuffer")
+ *
+ * ### Example
+ *
+ * TODO:
+ */
+export const createWebSocket = (url, options = {}) => {
+    const { protocols, binaryType, onOpen, onClose, onMessage, onError, retryOptions, WebSocketConstructor = globalThis.WebSocket, } = options;
+    let isDisposed = false;
+    const reconnectController = new AbortController();
+    const defaultRetryOptions = {
+        signal: reconnectController.signal,
+        maxRetries: Infinity,
+    };
+    let socket = null;
+    const disposeSocket = () => {
+        if (!socket)
+            return;
+        // Remove all listeners before closing
+        socket.onopen = null;
+        socket.onclose = null;
+        socket.onmessage = null;
+        socket.onerror = null;
+        socket.close();
+        socket = null;
+    };
+    // To prevent a memory leak from pending connection promise.
+    let disposePromise = null;
+    /**
+     * This promise represents continuous connection which:
+     *
+     * - Is rejected when a connection cannot be established.
+     * - Is rejected when a connection is closed.
+     * - Is resolved when WebSocket is disposed().
+     */
+    retry(() => new Promise((resolve) => {
+        disposePromise = () => {
+            resolve(ok());
+        };
+        if (isDisposed)
+            disposePromise();
+        disposeSocket();
+        socket = new WebSocketConstructor(url, protocols);
+        if (binaryType)
+            socket.binaryType = binaryType;
+        let isOpen = false;
+        socket.onopen = () => {
+            isOpen = true;
+            onOpen?.();
+        };
+        socket.onerror = (event) => {
+            const error = isOpen
+                ? { type: "WebSocketConnectionError", event }
+                : { type: "WebSocketConnectError", event };
+            onError?.(error);
+            // Trigger reconnect only on WebSocketConnectError.
+            if (error.type === "WebSocketConnectError") {
+                resolve(err(error));
+            }
+        };
+        socket.onclose = (event) => {
+            onClose?.(event);
+            resolve(err({ type: "WebSocketConnectionCloseError", event }));
+        };
+        socket.onmessage = (event) => {
+            onMessage?.(event.data);
+        };
+    }), {
+        ...defaultRetryOptions,
+        ...retryOptions,
+    })
+        .then((result) => {
+        if (result.ok || result.error.type === "RetryAbortError")
+            return;
+        onError?.(result.error);
+    })
+        .catch((error) => {
+        assertNoErrorInCatch("WebSocket retry", error);
+    });
+    const webSocket = {
+        send: (data) => {
+            // https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
+            if (!socket || socket.readyState === socket.CONNECTING) {
+                return err({ type: "WebSocketSendError" });
+            }
+            socket.send(data);
+            return ok();
+        },
+        getReadyState: () => socket ? nativeToStringState[socket.readyState] : "connecting",
+        [Symbol.dispose]() {
+            if (isDisposed)
+                return;
+            isDisposed = true;
+            reconnectController.abort();
+            disposeSocket();
+            disposePromise?.();
+        },
+    };
+    return webSocket;
+};
+const nativeToStringState = {
+    [WebSocket.CONNECTING]: "connecting",
+    [WebSocket.OPEN]: "open",
+    [WebSocket.CLOSING]: "closing",
+    [WebSocket.CLOSED]: "closed",
+};

package/dist/src/Worker.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Cross-platform worker abstraction
+ *
+ * @module
+ */
+import { TransferableError } from "./Error.js";
+/** Cross-platform worker abstraction. */
+export interface Worker<Input, Output> {
+    /** Sends a message to the worker. */
+    readonly postMessage: (message: Input) => void;
+    /** Sets a callback for messages from the worker. */
+    readonly onMessage: (callback: (message: Output) => void) => void;
+}
+export interface WorkerPostMessageDep<Output> {
+    readonly postMessage: (message: Output) => void;
+}
+/**
+ * Creates a {@link Worker} that supports initialization with dependencies and
+ * safe error handling.
+ */
+export declare const createInitializedWorker: <Input extends {
+    readonly type: string;
+} & HasInit<Input>, Output extends {
+    readonly type: string;
+} & HasWorkerErrorOutput<Output>, Deps>({ init, onMessage, }: {
+    readonly init: (initMessage: Extract<Input, {
+        type: "init";
+    }>, postMessage: (msg: Output) => void, safeHandler: <A extends Array<any>>(handler: (...args: A) => void) => (...args: A) => void) => Promise<Deps | null>;
+    readonly onMessage: (deps: Deps) => (message: Exclude<Input, {
+        type: "init";
+    }>) => void;
+}) => Worker<Input, Output>;
+type HasInit<Input> = Extract<Input, {
+    type: "init";
+}> extends never ? ["Input must contain a variant with { type: 'init' }"] : unknown;
+type HasWorkerErrorOutput<T> = Extract<T, {
+    type: "onError";
+}> extends infer E ? [E] extends [never] ? [
+    "Output must contain { type: 'onError'; error: TransferableError | ... }"
+] : E extends {
+    error: infer Err;
+} ? TransferableError extends Err ? unknown : ["Output.onError.error must include TransferableError"] : ["Output.onError must have an error property"] : never;
+export {};
+//# sourceMappingURL=Worker.d.ts.map

package/dist/src/Worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Worker.d.ts","sourceRoot":"","sources":["../../src/Worker.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAA2B,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAExE,yCAAyC;AACzC,MAAM,WAAW,MAAM,CAAC,KAAK,EAAE,MAAM;IACnC,qCAAqC;IACrC,QAAQ,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,KAAK,KAAK,IAAI,CAAC;IAE/C,oDAAoD;IACpD,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,KAAK,IAAI,CAAC;CACnE;AAED,MAAM,WAAW,oBAAoB,CAAC,MAAM;IAC1C,QAAQ,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjD;AAED;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAClC,KAAK,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,KAAK,CAAC,EACxD,MAAM,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,oBAAoB,CAAC,MAAM,CAAC,EACvE,IAAI,EACJ,sBAGC;IACD,QAAQ,CAAC,IAAI,EAAE,CACb,WAAW,EAAE,OAAO,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,EAC7C,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,EAClC,WAAW,EAAE,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,EAChC,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,KAC1B,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,KACtB,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,CAClB,IAAI,EAAE,IAAI,KACP,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,KAAK,IAAI,CAAC;CAC1D,KAAG,MAAM,CAAC,KAAK,EAAE,MAAM,CAkEvB,CAAC;AAEF,KAAK,OAAO,CAAC,KAAK,IAChB,OAAO,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,SAAS,KAAK,GAC1C,CAAC,oDAAoD,CAAC,GACtD,OAAO,CAAC;AAEd,KAAK,oBAAoB,CAAC,CAAC,IACzB,OAAO,CAAC,CAAC,EAAE;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC,SAAS,MAAM,CAAC,GAC3C,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GACjB;IACE,yEAAyE;CAC1E,GACD,CAAC,SAAS;IAAE,KAAK,EAAE,MAAM,GAAG,CAAA;CAAE,GAC5B,iBAAiB,SAAS,GAAG,GAC3B,OAAO,GACP,CAAC,qDAAqD,CAAC,GACzD,CAAC,4CAA4C,CAAC,GAClD,KAAK,CAAC"}

package/dist/src/Worker.js

@@ -0,0 +1,66 @@
+/**
+ * Cross-platform worker abstraction
+ *
+ * @module
+ */
+import { assert } from "./Assert.js";
+import { createTransferableError } from "./Error.js";
+/**
+ * Creates a {@link Worker} that supports initialization with dependencies and
+ * safe error handling.
+ */
+export const createInitializedWorker = ({ init, onMessage, }) => {
+    let onMessageCallback = null;
+    let deps = null;
+    const pendingMessages = [];
+    let initializing = false;
+    const postMessage = (msg) => {
+        assert(onMessageCallback != null, "The onMessage wasn't set");
+        onMessageCallback(msg);
+    };
+    const postMessageTransferableError = (error) => {
+        postMessage({
+            type: "onError",
+            error: createTransferableError(error),
+        });
+    };
+    const safeHandler = (handler) => (...args) => {
+        try {
+            handler(...args);
+        }
+        catch (error) {
+            postMessageTransferableError(error);
+        }
+    };
+    const worker = {
+        postMessage: (message) => {
+            if (message.type !== "init") {
+                if (!deps) {
+                    pendingMessages.push(message);
+                }
+                else {
+                    safeHandler(onMessage(deps))(message);
+                }
+                return;
+            }
+            if (initializing)
+                return;
+            initializing = true;
+            init(message, postMessage, safeHandler)
+                .then((_deps) => {
+                if (_deps == null)
+                    return;
+                deps = _deps;
+                for (const message of pendingMessages) {
+                    safeHandler(onMessage(deps))(message);
+                }
+                pendingMessages.length = 0;
+            })
+                .catch(postMessageTransferableError);
+        },
+        onMessage: (callback) => {
+            onMessageCallback = callback;
+        },
+    };
+    return worker;
+};

package/dist/src/index.d.ts

@@ -1,16 +1,29 @@
-export * from "./Config.js";
-export * from "./Crdt.js";
+export * from "./Array.js";
+export * from "./Assert.js";
+export * from "./BigInt.js";
+export * from "./Buffer.js";
+export * from "./Callbacks.js";
+export * from "./Console.js";
 export * from "./Crypto.js";
-export * from "./Db.js";
-export * from "./Diff.js";
+export * from "./Eq.js";
 export * from "./Error.js";
-export * from "./Evolu.js";
-export * from "./Model.js";
-export * from "./Murmurhash.js";
-export * from "./Owner.js";
-export * from "./Platform.js";
-export * from "./Protobuf.js";
+export * from "./Evolu/Public.js";
+export * from "./Function.js";
+export * from "./ManyToManyMap.js";
+export * from "./NanoId.js";
+export * from "./Number.js";
+export * from "./Object.js";
+export * from "./Order.js";
+export * from "./Promise.js";
+export * from "./Random.js";
+export * from "./Ref.js";
+export * from "./Result.js";
 export * from "./Sqlite.js";
 export * from "./Store.js";
-export * from "./Sync.js";
+export * from "./String.js";
+export * from "./Time.js";
+export * from "./Type.js";
+export * from "./Types.js";
+export * from "./WebSocket.js";
+export * from "./Worker.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC"}

package/dist/src/index.js

@@ -1,15 +1,28 @@
-export * from "./Config.js";
-export * from "./Crdt.js";
+export * from "./Array.js";
+export * from "./Assert.js";
+export * from "./BigInt.js";
+export * from "./Buffer.js";
+export * from "./Callbacks.js";
+export * from "./Console.js";
 export * from "./Crypto.js";
-export * from "./Db.js";
-export * from "./Diff.js";
+export * from "./Eq.js";
 export * from "./Error.js";
-export * from "./Evolu.js";
-export * from "./Model.js";
-export * from "./Murmurhash.js";
-export * from "./Owner.js";
-export * from "./Platform.js";
-export * from "./Protobuf.js";
+export * from "./Evolu/Public.js";
+export * from "./Function.js";
+export * from "./ManyToManyMap.js";
+export * from "./NanoId.js";
+export * from "./Number.js";
+export * from "./Object.js";
+export * from "./Order.js";
+export * from "./Promise.js";
+export * from "./Random.js";
+export * from "./Ref.js";
+export * from "./Result.js";
 export * from "./Sqlite.js";
 export * from "./Store.js";
-export * from "./Sync.js";
+export * from "./String.js";
+export * from "./Time.js";
+export * from "./Type.js";
+export * from "./Types.js";
+export * from "./WebSocket.js";
+export * from "./Worker.js";