@rebasepro/client 0.23.0 → 0.24.1-canary.g56af4a4

package/dist/offline-codec.d.ts

@@ -1,4 +1,16 @@
+import type { PendingMutation } from "./offline-store.js";
+/**
+ * `out[key] = value`, as an own property whatever the key. Assigned, a key
+ * read from stored data that is literally `__proto__` (which `JSON.parse`
+ * creates as an own property) set the new object's prototype instead, and the
+ * column was gone from the row.
+ */
+export declare function setOwn(out: Record<string, unknown>, key: string, value: unknown): void;
 /** Prepare a row for the store. */
 export declare function dehydrateRow<T extends Record<string, unknown>>(row: T): Record<string, unknown>;
 /** Restore a row read back from the store. */
 export declare function hydrateRow<T extends Record<string, unknown>>(row: Record<string, unknown>): T;
+/** Prepare a queued write for the store. */
+export declare function dehydrateMutation(op: PendingMutation): PendingMutation;
+/** Restore a queued write read back from the store. */
+export declare function hydrateMutation(op: PendingMutation): PendingMutation;

package/dist/offline-connectivity.d.ts

@@ -90,6 +90,12 @@ export declare class ConnectivityMonitor {
     private readonly clearTimer;
     /** Called when the backoff window expires, to drive an automatic retry. */
     onRetryDue?: () => void;
+    /**
+     * Called when the browser says the connection is back. Its own hook rather
+     * than {@link onRetryDue}: a client with automatic retries off sets no retry
+     * callback, and the `online` event has to wake it all the same.
+     */
+    onOnline?: () => void;
     private readonly handleOnline;
     private readonly handleOffline;
     constructor(options?: ConnectivityOptions);

package/dist/offline-errors.d.ts

@@ -0,0 +1,9 @@
+/**
+ * True when a read failed because there was neither network nor local data.
+ *
+ * The code is `OFFLINE`. It was `"offline"`, the one lowercase code in a
+ * surface whose every other code is `SCREAMING_SNAKE_CASE` — including the
+ * `NETWORK_ERROR` it sits next to — so `e.code === "OFFLINE"`, which is what
+ * anyone writes, never matched.
+ */
+export declare function isOfflineError(error: unknown): boolean;

package/dist/offline-lazy.d.ts

@@ -0,0 +1,58 @@
+import { type SDKCollectionClient } from "@rebasepro/types";
+import type { CollectionClient } from "./collection.js";
+import type { OfflineApi, OfflineConfig } from "./offline.js";
+type AnyRow = Record<string, unknown>;
+type InnerFactory = (slug: string) => SDKCollectionClient<AnyRow>;
+/**
+ * `createRebaseClient({ offline })`'s handle on the sync engine, which it
+ * fetches with `import()` the moment the client is created.
+ *
+ * The engine ({@link OfflineManager} and the local query evaluator, store and
+ * codec it brings) is most of the SDK's weight, and a client created without
+ * `offline` never runs a line of it. It used to be a static import of the
+ * client factory, so every app built on the SDK downloaded it before its first
+ * paint whether or not it turned offline on.
+ *
+ * Everything the factory and the app reach is here, with the same shape:
+ *
+ * - Calls made before the engine has arrived are queued and run, in the order
+ *   they were made, the moment it does — the scope changes the factory makes
+ *   from auth events, and every collection a client wrapped meanwhile.
+ * - What answers with a promise waits for the engine and then asks it.
+ * - What answers synchronously answers what the engine would have before
+ *   anything ran: `status()` is the initial status, a subscription is
+ *   registered as soon as there is something to register it with, and its
+ *   unsubscribe works before and after.
+ *
+ * Once the engine is there every call goes straight to it.
+ *
+ * @internal
+ */
+export declare class LazyOfflineManager {
+    private engine?;
+    private loadError?;
+    private queued;
+    private readonly failed;
+    readonly api: OfflineApi;
+    readonly keepsLastUser: boolean;
+    constructor(config: OfflineConfig, createInner: InnerFactory);
+    /**
+     * Run `op` on the engine: now if it is there, otherwise once it is, after
+     * everything queued before it.
+     */
+    private run;
+    /** A subscription made now, registered on the engine as soon as there is one. */
+    private subscribe;
+    holdScope(): void;
+    setScope(uid: string | undefined, options?: {
+        unverified?: boolean;
+    }): void;
+    resumeLastUser(): Promise<void>;
+    dispose(): void;
+    /**
+     * The engine's wrapper around `inner` — itself once the engine is there,
+     * and until then a client of the same shape that hands each call to it.
+     */
+    wrap<M extends AnyRow>(slug: string, inner: CollectionClient<M>): CollectionClient<M>;
+}
+export {};