@rocicorp/zero 0.0.202410040740 → 0.0.202410040818

package/out/replicache/src/replicache-options.d.ts

@@ -0,0 +1,209 @@
+import type { LogLevel, LogSink } from '@rocicorp/logger';
+import type { IndexDefinitions } from './index-defs.js';
+import type { StoreProvider } from './kv/store.js';
+import type { Puller } from './puller.js';
+import type { Pusher } from './pusher.js';
+import type { MutatorDefs, RequestOptions } from './types.js';
+/**
+ * The options passed to {@link Replicache}.
+ */
+export interface ReplicacheOptions<MD extends MutatorDefs> {
+    /**
+     * This is the URL to the server endpoint dealing with the push updates. See
+     * [Push Endpoint Reference](https://doc.replicache.dev/reference/server-push) for more
+     * details.
+     *
+     * If not provided, push requests will not be made unless a custom
+     * {@link ReplicacheOptions.pusher} is provided.
+     */
+    pushURL?: string | undefined;
+    /**
+     * This is the authorization token used when doing a
+     * [pull](https://doc.replicache.dev/reference/server-pull#authorization) and
+     * [push](https://doc.replicache.dev/reference/server-push#authorization).
+     */
+    auth?: string | undefined;
+    /**
+     * This is the URL to the server endpoint dealing with pull. See [Pull
+     * Endpoint Reference](https://doc.replicache.dev/reference/server-pull) for more
+     * details.
+     *
+     * If not provided, pull requests will not be made unless a custom
+     * {@link ReplicacheOptions.puller} is provided.
+     */
+    pullURL?: string | undefined;
+    /**
+     * The name of the Replicache database.
+     *
+     * It is important to use user specific names so that if there are multiple
+     * tabs open for different distinct users their data is kept separate.
+     *
+     * For efficiency and performance, a new {@link Replicache} instance will
+     * initialize its state from the persisted state of an existing {@link Replicache}
+     * instance with the same `name`, domain and browser profile.
+     *
+     * Mutations from one {@link Replicache} instance may be pushed using the
+     * {@link ReplicacheOptions.auth}, {@link ReplicacheOptions.pushURL},
+     * {@link ReplicacheOptions.pullURL}, {@link ReplicacheOptions.pusher}, and
+     * {@link ReplicacheOptions.puller}  of another Replicache instance with the same
+     * `name`, domain and browser profile.
+     *
+     * You can use multiple Replicache instances for the same user as long as the
+     * names are unique.  e.g. `name: `$userID:$roomID`
+     */
+    name: string;
+    /**
+     * The schema version of the data understood by this application. This enables
+     * versioning of mutators (in the push direction) and the client view (in the
+     * pull direction).
+     */
+    schemaVersion?: string | undefined;
+    /**
+     * The duration between each {@link pull} in milliseconds. Set this to `null` to
+     * prevent pulling in the background.  Defaults to 60 seconds.
+     */
+    pullInterval?: number | null | undefined;
+    /**
+     * The delay between when a change is made to Replicache and when Replicache
+     * attempts to push that change.
+     */
+    pushDelay?: number | undefined;
+    /**
+     * Determines how much logging to do. When this is set to `'debug'`,
+     * Replicache will also log `'info'` and `'error'` messages. When set to
+     * `'info'` we log `'info'` and `'error'` but not `'debug'`. When set to
+     * `'error'` we only log `'error'` messages.
+     * Default is `'info'`.
+     */
+    logLevel?: LogLevel | undefined;
+    /**
+     * Enables custom handling of logs.
+     *
+     * By default logs are logged to the console.  If you would like logs to be
+     * sent elsewhere (e.g. to a cloud logging service like DataDog) you can
+     * provide an array of {@link LogSink}s.  Logs at or above
+     * {@link ReplicacheOptions.logLevel} are sent to each of these {@link LogSink}s.
+     * If you would still like logs to go to the console, include
+     * `consoleLogSink` in the array.
+     *
+     * ```ts
+     * logSinks: [consoleLogSink, myCloudLogSink],
+     * ```
+     */
+    logSinks?: LogSink[] | undefined;
+    /**
+     * An object used as a map to define the *mutators*. These gets registered at
+     * startup of {@link Replicache}.
+     *
+     * *Mutators* are used to make changes to the data.
+     *
+     * #### Example
+     *
+     * The registered *mutations* are reflected on the
+     * {@link Replicache.mutate | mutate} property of the {@link Replicache} instance.
+     *
+     * ```ts
+     * const rep = new Replicache({
+     *   name: 'user-id',
+     *   mutators: {
+     *     async createTodo(tx: WriteTransaction, args: JSONValue) {
+     *       const key = `/todo/${args.id}`;
+     *       if (await tx.has(key)) {
+     *         throw new Error('Todo already exists');
+     *       }
+     *       await tx.set(key, args);
+     *     },
+     *     async deleteTodo(tx: WriteTransaction, id: number) {
+     *       ...
+     *     },
+     *   },
+     * });
+     * ```
+     *
+     * This will create the function to later use:
+     *
+     * ```ts
+     * await rep.mutate.createTodo({
+     *   id: 1234,
+     *   title: 'Make things work offline',
+     *   complete: true,
+     * });
+     * ```
+     *
+     * #### Replays
+     *
+     * *Mutators* run once when they are initially invoked, but they might also be
+     * *replayed* multiple times during sync. As such *mutators* should not modify
+     * application state directly. Also, it is important that the set of
+     * registered mutator names only grows over time. If Replicache syncs and
+     * needed *mutator* is not registered, it will substitute a no-op mutator, but
+     * this might be a poor user experience.
+     *
+     * #### Server application
+     *
+     * During push, a description of each mutation is sent to the server's [push
+     * endpoint](https://doc.replicache.dev/reference/server-push) where it is applied. Once
+     * the *mutation* has been applied successfully, as indicated by the client
+     * view's
+     * [`lastMutationId`](https://doc.replicache.dev/reference/server-pull#lastmutationid)
+     * field, the local version of the *mutation* is removed. See the [design
+     * doc](https://doc.replicache.dev/design#commits) for additional details on
+     * the sync protocol.
+     *
+     * #### Transactionality
+     *
+     * *Mutators* are atomic: all their changes are applied together, or none are.
+     * Throwing an exception aborts the transaction. Otherwise, it is committed.
+     * As with {@link query} and {@link subscribe} all reads will see a consistent view of
+     * the cache while they run.
+     */
+    mutators?: MD | undefined;
+    /**
+     * Options to use when doing pull and push requests.
+     */
+    requestOptions?: RequestOptions | undefined;
+    /**
+     * Allows passing in a custom implementation of a {@link Puller} function. This
+     * function is called when doing a pull and it is responsible for
+     * communicating with the server.
+     *
+     * Normally, this is just a POST to a URL with a JSON body but you can provide
+     * your own function if you need to do things differently.
+     */
+    puller?: Puller | undefined;
+    /**
+     * Allows passing in a custom implementation of a {@link Pusher} function. This
+     * function is called when doing a push and it is responsible for
+     * communicating with the server.
+     *
+     * Normally, this is just a POST to a URL with a JSON body but you can provide
+     * your own function if you need to do things differently.
+     */
+    pusher?: Pusher | undefined;
+    /**
+     * @deprecated Replicache no longer uses a license key. This option is now
+     * ignored and will be removed in a future release.
+     */
+    licenseKey?: string | undefined;
+    /**
+     * Allows providing a custom implementation of the underlying storage layer.
+     */
+    kvStore?: 'mem' | 'idb' | StoreProvider | undefined;
+    /**
+     * Defines the indexes, if any, to use on the data.
+     */
+    readonly indexes?: IndexDefinitions | undefined;
+    /**
+     * The maximum age of a client in milliseconds. If a client hasn't been seen
+     * and has no pending mutations for this long, it will be removed from the
+     * cache. Default is 24 hours.
+     *
+     * This means that this is the maximum time a tab can be in the background
+     * (frozen or in fbcache) and still be able to sync when it comes back to the
+     * foreground. If tab comes back after this time the
+     * {@linkcode onClientStateNotFound} callback is called on the Replicache
+     * instance.
+     */
+    clientMaxAgeMs?: number | undefined;
+}
+//# sourceMappingURL=replicache-options.d.ts.map

package/out/replicache/src/replicache-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replicache-options.d.ts","sourceRoot":"","sources":["../../../../replicache/src/replicache-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAE,OAAO,EAAC,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,WAAW,EAAE,cAAc,EAAC,MAAM,YAAY,CAAC;AAE5D;;GAEG;AAEH,MAAM,WAAW,iBAAiB,CAAC,EAAE,SAAS,WAAW;IACvD;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE7B;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE1B;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE7B;;;;;;;;;;;;;;;;;;OAkBG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEnC;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAEzC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE/B;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAEhC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,EAAE,OAAO,EAAE,GAAG,SAAS,CAAC;IAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiEG;IACH,QAAQ,CAAC,EAAE,EAAE,GAAG,SAAS,CAAC;IAE1B;;OAEG;IACH,cAAc,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IAE5C;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE5B;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE5B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEhC;;OAEG;IACH,OAAO,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,aAAa,GAAG,SAAS,CAAC;IAEpD;;OAEG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAEhD;;;;;;;;;;OAUG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC"}

package/out/replicache/src/replicache.d.ts

@@ -0,0 +1,298 @@
+import type { LogContext } from '@rocicorp/logger';
+import type { MaybePromise } from '../../shared/src/types.js';
+import type { StoreProvider } from './kv/store.js';
+import type { PendingMutation } from './pending-mutations.js';
+import type { Puller } from './puller.js';
+import type { Pusher } from './pusher.js';
+import { ReplicacheImpl } from './replicache-impl.js';
+import type { ReplicacheOptions } from './replicache-options.js';
+import type { SubscribeOptions, WatchCallbackForOptions, WatchNoIndexCallback, WatchOptions } from './subscriptions.js';
+import type { ReadTransaction } from './transactions.js';
+import type { MakeMutators, MutatorDefs, Poke, RequestOptions, UpdateNeededReason } from './types.js';
+type MakeImpl = <MD extends MutatorDefs>(options: ReplicacheOptions<MD>) => ReplicacheImpl<MD>;
+export declare function setMakeImplForTest(testMakeImpl: MakeImpl): void;
+export declare function restoreMakeImplForTest(): void;
+export declare const httpStatusUnauthorized = 401;
+/**
+ * Returns the name of the IDB database that will be used for a particular Replicache instance.
+ * @param name The name of the Replicache instance (i.e., the `name` field of `ReplicacheOptions`).
+ * @param schemaVersion The schema version of the database (i.e., the `schemaVersion` field of `ReplicacheOptions`).
+ * @returns
+ */
+export declare function makeIDBName(name: string, schemaVersion?: string): string;
+declare function makeIDBNameInternal(name: string, schemaVersion: string | undefined, formatVersion: number): string;
+export { makeIDBNameInternal as makeIDBNameForTesting };
+export declare class Replicache<MD extends MutatorDefs = {}> {
+    #private;
+    constructor(options: ReplicacheOptions<MD>);
+    /** The URL to use when doing a pull request. */
+    get pullURL(): string;
+    set pullURL(value: string);
+    /** The URL to use when doing a push request. */
+    get pushURL(): string;
+    set pushURL(value: string);
+    /** The authorization token used when doing a push request. */
+    get auth(): string;
+    set auth(value: string);
+    /** The name of the Replicache database. Populated by {@link ReplicacheOptions#name}. */
+    get name(): string;
+    /**
+     * This is the name Replicache uses for the IndexedDB database where data is
+     * stored.
+     */
+    get idbName(): string;
+    /** The schema version of the data understood by this application. */
+    get schemaVersion(): string;
+    /**
+     * The mutators that was registered in the constructor.
+     */
+    get mutate(): MakeMutators<MD>;
+    /**
+     * The duration between each periodic {@link pull}. Setting this to `null`
+     * disables periodic pull completely. Pull will still happen if you call
+     * {@link pull} manually.
+     */
+    get pullInterval(): number | null;
+    set pullInterval(value: number | null);
+    /**
+     * The delay between when a change is made to Replicache and when Replicache
+     * attempts to push that change.
+     */
+    get pushDelay(): number;
+    set pushDelay(value: number);
+    /**
+     * The function to use to pull data from the server.
+     */
+    get puller(): Puller;
+    set puller(value: Puller);
+    /**
+     * The function to use to push data to the server.
+     */
+    get pusher(): Pusher;
+    set pusher(value: Pusher);
+    /**
+     * The options used to control the {@link pull} and push request behavior. This
+     * object is live so changes to it will affect the next pull or push call.
+     */
+    get requestOptions(): Required<RequestOptions>;
+    /**
+     * `onSync(true)` is called when Replicache transitions from no push or pull
+     * happening to at least one happening. `onSync(false)` is called in the
+     * opposite case: when Replicache transitions from at least one push or pull
+     * happening to none happening.
+     *
+     * This can be used in a React like app by doing something like the following:
+     *
+     * ```js
+     * const [syncing, setSyncing] = useState(false);
+     * useEffect(() => {
+     *   rep.onSync = setSyncing;
+     * }, [rep]);
+     * ```
+     */
+    get onSync(): ((syncing: boolean) => void) | null;
+    set onSync(value: ((syncing: boolean) => void) | null);
+    /**
+     * `onClientStateNotFound` is called when the persistent client has been
+     * garbage collected. This can happen if the client has no pending mutations
+     * and has not been used for a while.
+     *
+     * The default behavior is to reload the page (using `location.reload()`). Set
+     * this to `null` or provide your own function to prevent the page from
+     * reloading automatically.
+     */
+    get onClientStateNotFound(): (() => void) | null;
+    set onClientStateNotFound(value: (() => void) | null);
+    /**
+     * `onUpdateNeeded` is called when a code update is needed.
+     *
+     * A code update can be needed because:
+     * - the server no longer supports the {@link pushVersion},
+     *   {@link pullVersion} or {@link schemaVersion} of the current code.
+     * - a new Replicache client has created a new client group, because its code
+     *   has different mutators, indexes, schema version and/or format version
+     *   from this Replicache client. This is likely due to the new client having
+     *   newer code. A code update is needed to be able to locally sync with this
+     *   new Replicache client (i.e. to sync while offline, the clients can can
+     *   still sync with each other via the server).
+     *
+     * The default behavior is to reload the page (using `location.reload()`). Set
+     * this to `null` or provide your own function to prevent the page from
+     * reloading automatically. You may want to provide your own function to
+     * display a toast to inform the end user there is a new version of your app
+     * available and prompting them to refresh.
+     */
+    get onUpdateNeeded(): ((reason: UpdateNeededReason) => void) | null;
+    set onUpdateNeeded(value: ((reason: UpdateNeededReason) => void) | null);
+    /**
+     * This gets called when we get an HTTP unauthorized (401) response from the
+     * push or pull endpoint. Set this to a function that will ask your user to
+     * reauthenticate.
+     */
+    get getAuth(): (() => MaybePromise<string | null | undefined>) | null | undefined;
+    set getAuth(value: (() => MaybePromise<string | null | undefined>) | null | undefined);
+    /**
+     * The browser profile ID for this browser profile. Every instance of Replicache
+     * browser-profile-wide shares the same profile ID.
+     */
+    get profileID(): Promise<string>;
+    /**
+     * The client ID for this instance of Replicache. Each instance of Replicache
+     * gets a unique client ID.
+     */
+    get clientID(): string;
+    /**
+     * The client group ID for this instance of Replicache. Instances of
+     * Replicache will have the same client group ID if and only if they have
+     * the same name, mutators, indexes, schema version, format version, and
+     * browser profile.
+     */
+    get clientGroupID(): Promise<string>;
+    /**
+     * `onOnlineChange` is called when the {@link online} property changes. See
+     * {@link online} for more details.
+     */
+    get onOnlineChange(): ((online: boolean) => void) | null;
+    set onOnlineChange(value: ((online: boolean) => void) | null);
+    /**
+     * A rough heuristic for whether the client is currently online. Note that
+     * there is no way to know for certain whether a client is online - the next
+     * request can always fail. This property returns true if the last sync attempt succeeded,
+     * and false otherwise.
+     */
+    get online(): boolean;
+    /**
+     * Whether the Replicache database has been closed. Once Replicache has been
+     * closed it no longer syncs and you can no longer read or write data out of
+     * it. After it has been closed it is pretty much useless and should not be
+     * used any more.
+     */
+    get closed(): boolean;
+    /**
+     * Closes this Replicache instance.
+     *
+     * When closed all subscriptions end and no more read or writes are allowed.
+     */
+    close(): Promise<void>;
+    /**
+     * Push pushes pending changes to the {@link pushURL}.
+     *
+     * You do not usually need to manually call push. If {@link pushDelay} is
+     * non-zero (which it is by default) pushes happen automatically shortly after
+     * mutations.
+     *
+     * If the server endpoint fails push will be continuously retried with an
+     * exponential backoff.
+     *
+     * @param [now=false] If true, push will happen immediately and ignore
+     *   {@link pushDelay}, {@link RequestOptions.minDelayMs} as well as the
+     *   exponential backoff in case of errors.
+     * @returns A promise that resolves when the next push completes. In case of
+     * errors the first error will reject the returned promise. Subsequent errors
+     * will not be reflected in the promise.
+     */
+    push({ now }?: {
+        now?: boolean | undefined;
+    }): Promise<void>;
+    /**
+     * Pull pulls changes from the {@link pullURL}. If there are any changes local
+     * changes will get replayed on top of the new server state.
+     *
+     * If the server endpoint fails pull will be continuously retried with an
+     * exponential backoff.
+     *
+     * @param [now=false] If true, pull will happen immediately and ignore
+     *   {@link RequestOptions.minDelayMs} as well as the exponential backoff in
+     *   case of errors.
+     * @returns A promise that resolves when the next pull completes. In case of
+     * errors the first error will reject the returned promise. Subsequent errors
+     * will not be reflected in the promise.
+     */
+    pull({ now }?: {
+        now?: boolean | undefined;
+    }): Promise<void>;
+    /**
+     * Applies an update from the server to Replicache.
+     * Throws an error if cookie does not match. In that case the server thinks
+     * this client has a different cookie than it does; the caller should disconnect
+     * from the server and re-register, which transmits the cookie the client actually
+     * has.
+     *
+     * @experimental This method is under development and its semantics will change.
+     */
+    poke(poke: Poke): Promise<void>;
+    /**
+     * Subscribe to the result of a {@link query}. The `body` function is
+     * evaluated once and its results are returned via `onData`.
+     *
+     * Thereafter, each time the the result of `body` changes, `onData` is fired
+     * again with the new result.
+     *
+     * `subscribe()` goes to significant effort to avoid extraneous work
+     * re-evaluating subscriptions:
+     *
+     * 1. subscribe tracks the keys that `body` accesses each time it runs. `body`
+     *    is only re-evaluated when those keys change.
+     * 2. subscribe only re-fires `onData` in the case that a result changes by
+     *    way of the `isEqual` option which defaults to doing a deep JSON value
+     *    equality check.
+     *
+     * Because of (1), `body` must be a pure function of the data in Replicache.
+     * `body` must not access anything other than the `tx` parameter passed to it.
+     *
+     * Although subscribe is as efficient as it can be, it is somewhat constrained
+     * by the goal of returning an arbitrary computation of the cache. For even
+     * better performance (but worse dx), see {@link experimentalWatch}.
+     *
+     * If an error occurs in the `body` the `onError` function is called if
+     * present. Otherwise, the error is logged at log level 'error'.
+     *
+     * To cancel the subscription, call the returned function.
+     *
+     * @param body The function to evaluate to get the value to pass into
+     *    `onData`.
+     * @param options Options is either a function or an object. If it is a
+     *    function it is equivalent to passing it as the `onData` property of an
+     *    object.
+     */
+    subscribe<R>(body: (tx: ReadTransaction) => Promise<R>, options: SubscribeOptions<R> | ((result: R) => void)): () => void;
+    /**
+     * Watches Replicache for changes.
+     *
+     * The `callback` gets called whenever the underlying data changes and the
+     * `key` changes matches the `prefix` of {@link ExperimentalWatchIndexOptions} or
+     * {@link ExperimentalWatchNoIndexOptions} if present. If a change
+     * occurs to the data but the change does not impact the key space the
+     * callback is not called. In other words, the callback is never called with
+     * an empty diff.
+     *
+     * This gets called after commit (a mutation or a rebase).
+     *
+     * @experimental This method is under development and its semantics will
+     * change.
+     */
+    experimentalWatch(callback: WatchNoIndexCallback): () => void;
+    experimentalWatch<Options extends WatchOptions>(callback: WatchCallbackForOptions<Options>, options?: Options): () => void;
+    /**
+     * Query is used for read transactions. It is recommended to use transactions
+     * to ensure you get a consistent view across multiple calls to `get`, `has`
+     * and `scan`.
+     */
+    query<R>(body: (tx: ReadTransaction) => Promise<R> | R): Promise<R>;
+    /**
+     * List of pending mutations. The order of this is from oldest to newest.
+     *
+     * Gives a list of local mutations that have `mutationID` >
+     * `syncHead.mutationID` that exists on the main client group.
+     *
+     * @experimental This method is experimental and may change in the future.
+     */
+    experimentalPendingMutations(): Promise<readonly PendingMutation[]>;
+}
+/**
+ * Wrapper error class that should be reported as error (logger.error)
+ */
+export declare class ReportError extends Error {
+}
+export declare function getKVStoreProvider(lc: LogContext, kvStore: 'mem' | 'idb' | StoreProvider | undefined): StoreProvider;
+//# sourceMappingURL=replicache.d.ts.map

package/out/replicache/src/replicache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replicache.d.ts","sourceRoot":"","sources":["../../../../replicache/src/replicache.ts"],"names":[],"mappings":"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"}

package/out/replicache/src/request-idle.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A Promise wrapper for requestIdleCallback with fallback to setTimeout for
+ * browsers without support (aka Safari)
+ */
+export declare function requestIdle(timeout: number): Promise<void>;
+//# sourceMappingURL=request-idle.d.ts.map

package/out/replicache/src/request-idle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-idle.d.ts","sourceRoot":"","sources":["../../../../replicache/src/request-idle.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ1D"}

package/out/replicache/src/scan-iterator.d.ts

@@ -0,0 +1,127 @@
+import type { ReadonlyJSONValue } from '../../shared/src/json.js';
+import { type IndexKey } from './db/index.js';
+import type { IterableUnion } from './iterable-union.js';
+import { type KeyTypeForScanOptions, type ScanIndexOptions, type ScanOptions } from './scan-options.js';
+import { type Closed } from './transaction-closed-error.js';
+import { type EntryForOptions } from './transactions.js';
+type ScanKey = string | IndexKey;
+/**
+ * This class is used for the results of {@link ReadTransaction.scan | scan}. It
+ * implements `AsyncIterable<JSONValue>` which allows you to use it in a `for
+ * await` loop. There are also methods to iterate over the {@link keys},
+ * {@link entries} or {@link values}.
+ */
+export declare class ScanResultImpl<Options extends ScanOptions, V> implements ScanResult<KeyTypeForScanOptions<Options>, V> {
+    #private;
+    constructor(iter: AsyncIterable<EntryForOptions<Options, ReadonlyJSONValue>>, options: Options, dbDelegateOptions: Closed, onLimitKey: (inclusiveLimitKey: string) => void);
+    /** The default AsyncIterable. This is the same as {@link values}. */
+    [Symbol.asyncIterator](): AsyncIterableIteratorToArray<V>;
+    /** Async iterator over the values of the {@link ReadTransaction.scan | scan} call. */
+    values(): AsyncIterableIteratorToArray<V>;
+    /**
+     * Async iterator over the keys of the {@link ReadTransaction.scan | scan}
+     * call. If the {@link ReadTransaction.scan | scan} is over an index the key
+     * is a tuple of `[secondaryKey: string, primaryKey]`
+     */
+    keys(): AsyncIterableIteratorToArray<KeyTypeForScanOptions<Options>>;
+    /**
+     * Async iterator over the entries of the {@link ReadTransaction.scan | scan}
+     * call. An entry is a tuple of key values. If the
+     * {@link ReadTransaction.scan | scan} is over an index the key is a tuple of
+     * `[secondaryKey: string, primaryKey]`
+     */
+    entries(): AsyncIterableIteratorToArray<readonly [KeyTypeForScanOptions<Options>, V]>;
+    /** Returns all the values as an array. Same as `values().toArray()` */
+    toArray(): Promise<V[]>;
+}
+export interface ScanResult<K extends ScanKey, V> extends AsyncIterable<V> {
+    /** The default AsyncIterable. This is the same as {@link values}. */
+    [Symbol.asyncIterator](): AsyncIterableIteratorToArray<V>;
+    /** Async iterator over the values of the {@link ReadTransaction.scan | scan} call. */
+    values(): AsyncIterableIteratorToArray<V>;
+    /**
+     * Async iterator over the keys of the {@link ReadTransaction.scan | scan}
+     * call. If the {@link ReadTransaction.scan | scan} is over an index the key
+     * is a tuple of `[secondaryKey: string, primaryKey]`
+     */
+    keys(): AsyncIterableIteratorToArray<K>;
+    /**
+     * Async iterator over the entries of the {@link ReadTransaction.scan | scan}
+     * call. An entry is a tuple of key values. If the
+     * {@link ReadTransaction.scan | scan} is over an index the key is a tuple of
+     * `[secondaryKey: string, primaryKey]`
+     */
+    entries(): AsyncIterableIteratorToArray<readonly [K, V]>;
+    /** Returns all the values as an array. Same as `values().toArray()` */
+    toArray(): Promise<V[]>;
+}
+/**
+ * An interface that adds a {@link toArray} method to `AsyncIterableIterator`.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const keys: string[] = await rep.scan().keys().toArray();
+ * ```
+ */
+export interface AsyncIterableIteratorToArray<V> extends AsyncIterableIterator<V> {
+    toArray(): Promise<V[]>;
+}
+export type Entry<V> = readonly [key: string, value: V];
+/**
+ * This is called when doing a {@link ReadTransaction.scan | scan} without an
+ * `indexName`.
+ *
+ * @param fromKey The `fromKey` is computed by `scan` and is the key of the
+ * first entry to return in the iterator. It is based on `prefix` and
+ * `start.key` of the {@link ScanNoIndexOptions}.
+ */
+export type GetScanIterator = (fromKey: string) => IterableUnion<Entry<ReadonlyJSONValue>>;
+/**
+ * When using {@link makeScanResult} this is the type used for the function called when doing a {@link ReadTransaction.scan | scan} with an
+ * `indexName`.
+ *
+ * @param indexName The name of the index we are scanning over.
+ * @param fromSecondaryKey The `fromSecondaryKey` is computed by `scan` and is
+ * the secondary key of the first entry to return in the iterator. It is based
+ * on `prefix` and `start.key` of the {@link ScanIndexOptions}.
+ * @param fromPrimaryKey The `fromPrimaryKey` is computed by `scan` and is the
+ * primary key of the first entry to return in the iterator. It is based on
+ * `prefix` and `start.key` of the {@link ScanIndexOptions}.
+ */
+export type GetIndexScanIterator = (indexName: string, fromSecondaryKey: string, fromPrimaryKey: string | undefined) => IterableUnion<readonly [key: IndexKey, value: ReadonlyJSONValue]>;
+/**
+ * A helper function that makes it easier to implement {@link ReadTransaction.scan}
+ * with a custom backend.
+ *
+ * If you are implementing a custom backend and have an in memory pending async
+ * iterable we provide two helper functions to make it easier to merge these
+ * together. {@link mergeAsyncIterables} and {@link filterAsyncIterable}.
+ *
+ * For example:
+ *
+ * ```ts
+ * const scanResult = makeScanResult(
+ *   options,
+ *   options.indexName
+ *     ? () => {
+ *         throw Error('not implemented');
+ *       }
+ *     : fromKey => {
+ *         const persisted: AsyncIterable<Entry<ReadonlyJSONValue>> = ...;
+ *         const pending: AsyncIterable<Entry<ReadonlyJSONValue | undefined>> = ...;
+ *         const iter = await mergeAsyncIterables(persisted, pending);
+ *         const filteredIter = await filterAsyncIterable(
+ *           iter,
+ *           entry => entry[1] !== undefined,
+ *         );
+ *         return filteredIter;
+ *       },
+ * );
+ * ```
+ */
+export declare function makeScanResult<Options extends ScanOptions>(options: Options, getScanIterator: Options extends ScanIndexOptions ? GetIndexScanIterator : GetScanIterator): ScanResult<KeyTypeForScanOptions<Options>, ReadonlyJSONValue>;
+export declare function fromKeyForIndexScan(options: ScanIndexOptions): readonly [secondary: string, primary?: string | undefined];
+export declare function fromKeyForIndexScanInternal(options: ScanIndexOptions): string;
+export {};
+//# sourceMappingURL=scan-iterator.d.ts.map

package/out/replicache/src/scan-iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-iterator.d.ts","sourceRoot":"","sources":["../../../../replicache/src/scan-iterator.ts"],"names":[],"mappings":"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"}