npm - @rocicorp/zero - Versions diffs - 0.0.0-202410031711 - Mend

@rocicorp/zero 0.0.0-202410031711

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (831) hide show

package/out/replicache/src/btree/write.d.ts ADDED Viewed

@@ -0,0 +1,24 @@
+import type { Write } from '../dag/store.js';
+import type { FormatVersion } from '../format-version.js';
+import type { FrozenJSONValue } from '../frozen-json.js';
+import { type Hash } from '../hash.js';
+import { DataNodeImpl, type Entry, InternalNodeImpl } from './node.js';
+import { BTreeRead } from './read.js';
+export declare class BTreeWrite extends BTreeRead {
+    #private;
+    protected _dagRead: Write;
+    readonly minSize: number;
+    readonly maxSize: number;
+    constructor(dagWrite: Write, formatVersion: FormatVersion, root?: Hash, minSize?: number, maxSize?: number, getEntrySize?: <K, V>(k: K, v: V) => number, chunkHeaderSize?: number);
+    updateNode(node: DataNodeImpl | InternalNodeImpl): void;
+    newInternalNodeImpl(entries: Array<Entry<Hash>>, level: number): InternalNodeImpl;
+    newDataNodeImpl(entries: Entry<FrozenJSONValue>[]): DataNodeImpl;
+    newNodeImpl(entries: Entry<FrozenJSONValue>[], level: number): DataNodeImpl;
+    newNodeImpl(entries: Entry<Hash>[], level: number): InternalNodeImpl;
+    newNodeImpl(entries: Entry<Hash>[] | Entry<FrozenJSONValue>[], level: number): InternalNodeImpl | DataNodeImpl;
+    put(key: string, value: FrozenJSONValue): Promise<void>;
+    del(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    flush(): Promise<Hash>;
+}
+//# sourceMappingURL=write.d.ts.map

package/out/replicache/src/btree/write.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/btree/write.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAC,KAAK,IAAI,EAA2B,MAAM,YAAY,CAAC;AAE/D,OAAO,EACL,YAAY,EACZ,KAAK,KAAK,EACV,gBAAgB,EAOjB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAC,SAAS,EAAC,MAAM,WAAW,CAAC;AAEpC,qBAAa,UAAW,SAAQ,SAAS;;IAoBvC,UAAkB,QAAQ,EAAE,KAAK,CAAC;IAElC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAGvB,QAAQ,EAAE,KAAK,EACf,aAAa,EAAE,aAAa,EAC5B,IAAI,GAAE,IAAgB,EACtB,OAAO,SAAW,EAClB,OAAO,SAAY,EACnB,YAAY,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAuB,EAC3D,eAAe,CAAC,EAAE,MAAM;IAc1B,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,gBAAgB,GAAG,IAAI;IAOvD,mBAAmB,CACjB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAC3B,KAAK,EAAE,MAAM,GACZ,gBAAgB;IAMnB,eAAe,CAAC,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,EAAE,GAAG,YAAY;IAMhE,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY;IAC3E,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,gBAAgB;IACpE,WAAW,CACT,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,eAAe,CAAC,EAAE,EACjD,KAAK,EAAE,MAAM,GACZ,gBAAgB,GAAG,YAAY;IAUlC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BvD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBlC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAyBvB"}

package/out/replicache/src/call-default-fetch.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+import type { HTTPRequestInfo } from './http-request-info.js';
+/**
+ * Helper function for {@link getDefaultPuller} and {@link getDefaultPusher}.
+ */
+export declare function callDefaultFetch<Body>(url: string, auth: string, requestID: string, requestBody: Body): Promise<readonly [Response | undefined, HTTPRequestInfo]>;
+//# sourceMappingURL=call-default-fetch.d.ts.map

package/out/replicache/src/call-default-fetch.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"call-default-fetch.d.ts","sourceRoot":"","sources":["../../../../replicache/src/call-default-fetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,wBAAwB,CAAC;AAE5D;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EACzC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,IAAI,GAChB,OAAO,CAAC,SAAS,CAAC,QAAQ,GAAG,SAAS,EAAE,eAAe,CAAC,CAAC,CAgC3D"}

package/out/replicache/src/config.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { isProd } from '../../shared/src/config.js';
+export { isProd as skipBTreeNodeAsserts, isProd as skipCommitDataAsserts,
+/**
+ * In debug mode we deeply freeze the values we read out of the IDB store and we
+ * deeply freeze the values we put into the stores.
+ */
+isProd as skipFreeze,
+/**
+ * In debug mode we assert that chunks and BTree data is deeply frozen. In
+ * release mode we skip these asserts.
+ */
+isProd as skipFrozenAsserts, isProd as skipGCAsserts, };
+//# sourceMappingURL=config.d.ts.map

package/out/replicache/src/config.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../replicache/src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,sBAAsB,CAAC;AAE5C,OAAO,EACL,MAAM,IAAI,oBAAoB,EAC9B,MAAM,IAAI,qBAAqB;AAC/B;;;GAGG;AACH,MAAM,IAAI,UAAU;AACpB;;;GAGG;AACH,MAAM,IAAI,iBAAiB,EAC3B,MAAM,IAAI,aAAa,GACxB,CAAC"}

package/out/replicache/src/connection-loop-delegates.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import type { ConnectionLoopDelegate } from './connection-loop.js';
+import type { ReplicacheImpl } from './replicache-impl.js';
+declare class ConnectionLoopDelegateImpl {
+    readonly rep: ReplicacheImpl;
+    readonly invokeSend: () => Promise<boolean>;
+    readonly maxConnections = 1;
+    constructor(rep: ReplicacheImpl, invokeSend: () => Promise<boolean>);
+    get maxDelayMs(): number;
+    get minDelayMs(): number;
+}
+export declare class PullDelegate extends ConnectionLoopDelegateImpl implements ConnectionLoopDelegate {
+    readonly debounceDelay = 0;
+    get watchdogTimer(): number | null;
+}
+export declare class PushDelegate extends ConnectionLoopDelegateImpl implements ConnectionLoopDelegate {
+    get debounceDelay(): number;
+    watchdogTimer: null;
+}
+export {};
+//# sourceMappingURL=connection-loop-delegates.d.ts.map

package/out/replicache/src/connection-loop-delegates.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"connection-loop-delegates.d.ts","sourceRoot":"","sources":["../../../../replicache/src/connection-loop-delegates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,sBAAsB,CAAC;AACjE,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,sBAAsB,CAAC;AAEzD,cAAM,0BAA0B;IAC9B,QAAQ,CAAC,GAAG,EAAE,cAAc,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAI5C,QAAQ,CAAC,cAAc,KAAK;gBAEhB,GAAG,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC;IAKnE,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,IAAI,UAAU,IAAI,MAAM,CAEvB;CACF;AAED,qBAAa,YACX,SAAQ,0BACR,YAAW,sBAAsB;IAEjC,QAAQ,CAAC,aAAa,KAAK;IAE3B,IAAI,aAAa,IAAI,MAAM,GAAG,IAAI,CAEjC;CACF;AAED,qBAAa,YACX,SAAQ,0BACR,YAAW,sBAAsB;IAEjC,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,aAAa,OAAQ;CACtB"}

package/out/replicache/src/connection-loop.d.ts ADDED Viewed

@@ -0,0 +1,28 @@
+import type { LogContext } from '@rocicorp/logger';
+import type { DocumentVisibilityWatcher } from '../../shared/src/document-visible.js';
+export declare const DEBOUNCE_DELAY_MS = 10;
+export declare const MIN_DELAY_MS = 30;
+export declare const MAX_DELAY_MS = 60000;
+export interface ConnectionLoopDelegate {
+    invokeSend(): Promise<boolean>;
+    debounceDelay: number;
+    watchdogTimer: number | null;
+    maxConnections: number;
+    maxDelayMs: number;
+    minDelayMs: number;
+}
+export declare class ConnectionLoop {
+    #private;
+    constructor(lc: LogContext, delegate: ConnectionLoopDelegate, visibilityWatcher?: DocumentVisibilityWatcher);
+    close(): void;
+    /**
+     *
+     * @returns Returns undefined if ok, otherwise it return the error that caused
+     * the send to fail.
+     */
+    send(now: boolean): Promise<undefined | {
+        error: unknown;
+    }>;
+    run(): Promise<void>;
+}
+//# sourceMappingURL=connection-loop.d.ts.map

package/out/replicache/src/connection-loop.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"connection-loop.d.ts","sourceRoot":"","sources":["../../../../replicache/src/connection-loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,yBAAyB,EAAC,MAAM,gCAAgC,CAAC;AAG9E,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,eAAO,MAAM,YAAY,KAAK,CAAC;AAC/B,eAAO,MAAM,YAAY,QAAS,CAAC;AAInC,MAAM,WAAW,sBAAsB;IACrC,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;IAEtB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,cAAc;;gBA0DvB,EAAE,EAAE,UAAU,EACd,QAAQ,EAAE,sBAAsB,EAChC,iBAAiB,CAAC,EAAE,yBAAyB;IAQ/C,KAAK,IAAI,IAAI;IAOb;;;;OAIG;IACG,IAAI,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,SAAS,GAAG;QAAC,KAAK,EAAE,OAAO,CAAA;KAAC,CAAC;IAmBzD,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CA+I3B"}

package/out/replicache/src/cookies.d.ts ADDED Viewed

@@ -0,0 +1,29 @@
+import { type ReadonlyJSONValue } from '../../shared/src/json.js';
+import type { FrozenJSONValue } from './frozen-json.js';
+/**
+ * A cookie is a value that is used to determine the order of snapshots. It
+ * needs to be comparable. This can be a `string`, `number` or if you want to
+ * use a more complex value, you can use an object with an `order` property. The
+ * value `null` is considered to be less than any other cookie and it is used
+ * for the first pull when no cookie has been set.
+ *
+ * The order is the natural order of numbers and strings. If one of the cookies
+ * is an object then the value of the `order` property is treated as the cookie
+ * when doing comparison.
+ *
+ * If one of the cookies is a string and the other is a number, the number is
+ * fist converted to a string (using `toString()`).
+ */
+export type Cookie = null | string | number | (ReadonlyJSONValue & {
+    readonly order: number | string;
+});
+export type FrozenCookie = null | string | number | (FrozenJSONValue & {
+    readonly order: number | string;
+});
+/**
+ * Compare two cookies.
+ * `null` is considered to be less than any other cookie.
+ */
+export declare function compareCookies(a: Cookie, b: Cookie): number;
+export declare function assertCookie(v: unknown): asserts v is Cookie;
+//# sourceMappingURL=cookies.d.ts.map

package/out/replicache/src/cookies.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"cookies.d.ts","sourceRoot":"","sources":["../../../../replicache/src/cookies.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAE5E,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,kBAAkB,CAAC;AAEtD;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,MAAM,GACd,IAAI,GACJ,MAAM,GACN,MAAM,GACN,CAAC,iBAAiB,GAAG;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAC,CAAC,CAAC;AAE5D,MAAM,MAAM,YAAY,GACpB,IAAI,GACJ,MAAM,GACN,MAAM,GACN,CAAC,eAAe,GAAG;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAC,CAAC,CAAC;AAE1D;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAoB3D;AAWD,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,IAAI,MAAM,CAW5D"}

package/out/replicache/src/dag/chunk.d.ts ADDED Viewed

@@ -0,0 +1,35 @@
+import type { Hash } from '../hash.js';
+declare const refsTag: unique symbol;
+/**
+ * Opaque type representing a Refs. The reason to use an opaque type here is to
+ * make sure that Refs are always sorted and have no duplicates.
+ */
+export type Refs = [] | readonly [Hash] | (readonly Hash[] & {
+    [refsTag]: true;
+});
+/**
+ * Convert to a Refs when we already know it is sorted and has no duplicates.
+ */
+export declare function asRefs(sortedRefs: Hash[]): Refs;
+/**
+ * Sorts and tags as Refs. If an Array is passed in the array is sorted in
+ * place, otherwise a copy of the iterable is created. This checks for duplicates.
+ */
+export declare function toRefs(refs: Hash[] | Set<Hash>): Refs;
+export declare class Chunk<V = unknown> {
+    readonly hash: Hash;
+    readonly data: V;
+    /**
+     * Meta is an array of refs. If there are no refs we do not write a meta
+     * chunk.
+     */
+    readonly meta: Refs;
+    constructor(hash: Hash, data: V, refs: Refs);
+}
+export declare function assertRefs(v: unknown): asserts v is Refs;
+export declare function createChunk<V>(data: V, refs: Refs, chunkHasher: ChunkHasher): Chunk<V>;
+export type CreateChunk = <V>(data: V, refs: Refs) => Chunk<V>;
+export type ChunkHasher = () => Hash;
+export declare function throwChunkHasher(): Hash;
+export {};
+//# sourceMappingURL=chunk.d.ts.map

package/out/replicache/src/dag/chunk.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/dag/chunk.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,YAAY,CAAC;AAIrC,OAAO,CAAC,MAAM,OAAO,EAAE,OAAO,MAAM,CAAC;AAErC;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG,EAAE,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,IAAI,EAAE,GAAG;IAAC,CAAC,OAAO,CAAC,EAAE,IAAI,CAAA;CAAC,CAAC,CAAC;AAEhF;;GAEG;AACH,wBAAgB,MAAM,CAAC,UAAU,EAAE,IAAI,EAAE,GAAG,IAAI,CAE/C;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAarD;AAED,qBAAa,KAAK,CAAC,CAAC,GAAG,OAAO;IAC5B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IAEjB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;gBAER,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI;CAU5C;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,IAAI,IAAI,CAUxD;AAED,wBAAgB,WAAW,CAAC,CAAC,EAC3B,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,WAAW,GACvB,KAAK,CAAC,CAAC,CAAC,CAGV;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAE/D,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC;AAErC,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC"}

package/out/replicache/src/dag/gc.d.ts ADDED Viewed

@@ -0,0 +1,42 @@
+import type { MaybePromise } from '../../../shared/src/types.js';
+import { type Hash } from '../hash.js';
+export type HeadChange = {
+    new: Hash | undefined;
+    old: Hash | undefined;
+};
+export interface RefCountUpdatesDelegate {
+    getRefCount: (hash: Hash) => MaybePromise<number | undefined>;
+    getRefs: (hash: Hash) => MaybePromise<readonly Hash[] | undefined>;
+    /**
+     * Should be implemented if the store lazily loads refs, returning whether
+     * or not the chunks refs have already been counted (i.e. are reflected
+     * in `getRefCount`).
+     *
+     * If defined then:
+     *  - `getRefs` should return undefined for refs that have not been loaded,
+     *    but should never return undefined for hashes in `putChunks`.
+     *  - it is assumed that chunks in `putChunks` may have been reachable before
+     *    the write, but may not have been counted.  This method is used to
+     *    determine if they have been counted or not.  If they have not been
+     *    counted, and are reachable with the write applied, the returned
+     *    ref count updates will include updates for counting them.
+     *
+     * If undefined then:
+     *  - `getRefs` should never return undefined
+     *  - it is assumed that the refs of any chunks which were reachable before
+     *    the write are already counted
+     */
+    areRefsCounted?: (hash: Hash) => boolean;
+}
+/**
+ * Computes how ref counts should be updated when a dag write is committed.
+ * Does not modify the dag store.
+ * @param headChanges Heads that were changed by the dag write.
+ * @param putChunks Chunks that were put by the dag write.
+ * @param delegate Delegate used for getting ref information from the dag store.
+ * @returns Map from chunk Hash to changed ref counts.  Chunks with a new ref
+ * count of 0 should be deleted.  All hashes in `putChunks` will have an entry
+ * (which will be zero if the newly put chunk is not reachable from any head).
+ */
+export declare function computeRefCountUpdates(headChanges: Iterable<HeadChange>, putChunks: ReadonlySet<Hash>, delegate: RefCountUpdatesDelegate): Promise<Map<Hash, number>>;
+//# sourceMappingURL=gc.d.ts.map

package/out/replicache/src/dag/gc.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"gc.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/dag/gc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAC,KAAK,IAAI,EAAY,MAAM,YAAY,CAAC;AAEhD,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE,IAAI,GAAG,SAAS,CAAC;IACtB,GAAG,EAAE,IAAI,GAAG,SAAS,CAAC;CACvB,CAAC;AAIF,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,YAAY,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC9D,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,YAAY,CAAC,SAAS,IAAI,EAAE,GAAG,SAAS,CAAC,CAAC;IACnE;;;;;;;;;;;;;;;;;;OAkBG;IACH,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC;CAC1C;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,EACjC,SAAS,EAAE,WAAW,CAAC,IAAI,CAAC,EAC5B,QAAQ,EAAE,uBAAuB,GAChC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAE5B"}

package/out/replicache/src/dag/key.d.ts ADDED Viewed

@@ -0,0 +1,26 @@
+import { type Hash } from '../hash.js';
+export declare function chunkDataKey(hash: Hash): string;
+export declare function chunkMetaKey(hash: Hash): string;
+export declare function chunkRefCountKey(hash: Hash): string;
+export declare function headKey(name: string): string;
+export declare const enum KeyType {
+    ChunkData = 0,
+    ChunkMeta = 1,
+    ChunkRefCount = 2,
+    Head = 3
+}
+export type Key = {
+    type: KeyType.ChunkData;
+    hash: Hash;
+} | {
+    type: KeyType.ChunkMeta;
+    hash: Hash;
+} | {
+    type: KeyType.ChunkRefCount;
+    hash: Hash;
+} | {
+    type: KeyType.Head;
+    name: string;
+};
+export declare function parse(key: string): Key;
+//# sourceMappingURL=key.d.ts.map

package/out/replicache/src/dag/key.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/dag/key.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,IAAI,EAAqB,MAAM,YAAY,CAAC;AAEzD,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE/C;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE/C;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAEnD;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,0BAAkB,OAAO;IACvB,SAAS,IAAA;IACT,SAAS,IAAA;IACT,aAAa,IAAA;IACb,IAAI,IAAA;CACL;AAED,MAAM,MAAM,GAAG,GACX;IACE,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC;IACxB,IAAI,EAAE,IAAI,CAAC;CACZ,GACD;IACE,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC;IACxB,IAAI,EAAE,IAAI,CAAC;CACZ,GACD;IACE,IAAI,EAAE,OAAO,CAAC,aAAa,CAAC;IAC5B,IAAI,EAAE,IAAI,CAAC;CACZ,GACD;IACE,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEN,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAuCtC"}

package/out/replicache/src/dag/lazy-store.d.ts ADDED Viewed

@@ -0,0 +1,181 @@
+import type { MaybePromise } from '../../../shared/src/types.js';
+import type { Hash } from '../hash.js';
+import { Chunk, type ChunkHasher, type Refs } from './chunk.js';
+import { type HeadChange, type RefCountUpdatesDelegate } from './gc.js';
+import { type Read, type Store, type Write } from './store.js';
+/**
+ * Dag Store which lazily loads values from a source store and then caches
+ * them in an LRU cache.  The memory cache for chunks from the source store
+ * size is limited to `sourceCacheSizeLimit` bytes, and values are evicted in an
+ * LRU fashion.  The purpose of this store is to avoid holding the entire client
+ * view (i.e. the source store's content) in each tab's JavaScript heap.
+ *
+ * This store's heads are independent from the heads of source store, and are
+ * only stored in memory.
+ *
+ * Chunks which are created via this store's {@link Write} transaction's
+ * {@link createChunk} method are assumed to not be persisted to the source
+ * store and thus are cached separately from the source store chunks.  These
+ * memory-only chunks will not be evicted, and their sizes are not counted
+ * towards the source chunk cache size.  A memory-only chunk will be deleted if
+ * it is no longer reachable from one of this store's heads.
+ *
+ * Writes only manipulate the in memory state of this store and do not alter the
+ * source store.  Thus values must be written to the source store through a
+ * separate process (see {@link persist}).
+ *
+ * Intended use:
+ * 1. source store is the 'perdag', a slower persistent store (i.e.
+ *    dag.StoreImpl using a kv.IDBStore)
+ * 2. this store's 'main' head is initialized to the hash of a chunk containing
+ *    a commit in the source store
+ * 3. reads lazily read chunks from the source store and cache them
+ * 3. writes are initially made to this store with memory-only chunks
+ * 4. writes are asynchronously persisted to the source store through a separate
+ *    process (see {@link persist}}. This process gathers memory-only chunks
+ *    from this store and then writes them to the source store.  It then informs
+ *    this store that these chunks are no longer memory-only by calling
+ *    {@link chunksPersisted}, which move these chunks
+ *    to this store's LRU cache of source chunks (making them eligible for
+ *    eviction).
+ *
+ * @param sourceStore Store to lazy load and cache values from.
+ * @param sourceCacheSizeLimit Size limit in bytes for cache of chunks loaded
+ * from `sourceStore`.  This size of a value is determined using
+ * `getSizeOfValue`.  Keys do not count towards cache size.  Memory-only chunks
+ * do not count towards cache size.
+ * @param getSizeOfValue Function for measuring the size in bytes of a value.
+ */
+export declare class LazyStore implements Store {
+    #private;
+    /** The following are protected so testing subclass can access. */
+    protected readonly _memOnlyChunks: Map<Hash, Chunk<unknown>>;
+    protected readonly _sourceChunksCache: ChunksCache;
+    /**
+     * Ref counts are maintained so that chunks which are unreachable
+     * from this stores heads can be eagerly and deterministically deleted from
+     * `this._memOnlyChunks` and `this._sourceChunksCache`.
+     *
+     * These ref counts are independent from `this._sourceStore`'s ref counts.
+     * These ref counts are based on reachability from `this._heads`.
+     * A chunk is deleted from `this._memOnlyChunks` or
+     * `this._sourceChunksCache` (which ever it is in) when its ref count becomes
+     * zero.
+     * These ref counts count the refs in `this._heads` and `this._refs`.
+     *
+     * Not all reachable chunk's refs are included in `this._refs`, because this
+     * would require loading all chunks reachable in the source store in a
+     * non-lazy manner. `this._refs` contains the refs of all currently reachable
+     * chunks that were ever in `this._memOnlyChunks` or
+     * `this._sourceChunksCache` (even if they have been evicted).  A
+     * chunk's ref information is lazily discovered and stored in `this._refs` and
+     * counted in `this._refCounts`. A chunk's entries in `this._refs` and
+     * `this._refCounts` are only deleted when a chunk is deleted due to it
+     * becoming unreachable (it is not deleted if the chunk is evicted from the
+     * source-store cache).
+     *
+     * The major implication of this lazy discovery of source store refs, is that
+     * a reachable source store chunk may not be cached when loaded, because it is
+     * not known to be reachable because some of the pertinent refs have not been
+     * discovered.  However, in practice chunks are read by traversing the graph
+     * starting from a head, and all pertinent refs are discovered as part of the
+     * traversal.
+     *
+     * These ref counts can be changed in two ways:
+     * 1. A LazyRead has a cache miss and loads a chunk from the source store that
+     * is reachable from this._heads.  If this chunk's refs are not currently
+     * counted, it will not have an entry in `this._refs`.  In this case, the
+     * chunks refs will be put in `this._refs` and `this._refCounts` will be
+     * updated to count them.
+     * 2. A LazyWrite commit updates a head (which can result in increasing or
+     * decreasing ref count) or puts a reachable chunk (either a `memory-only` or
+     * `source` chunk) that references this hash (increasing ref count).  The
+     * computation of these ref count changes is delegated to the
+     * `computeRefCountUpdates` shared with dag.StoreImpl.  In order to
+     * delegate determining reachability to `computeRefCountUpdates` and defer
+     * this determination until commit time, LazyWrite treats cache misses
+     * as a 'put' of the lazily-loaded chunk.
+     *
+     * A chunk's hash may have an entry in `this._refCounts` without that
+     * chunk have ever been in `this._memOnlyChunks` or `this._sourceChunksCache`.
+     * This is the case when a head or a reachable chunk that was ever in
+     * `this._memOnlyChunks` or `this._sourceChunksCache` references a chunk
+     * which is not currently cached (either because it has not been read, or
+     * because it has been evicted).
+     */
+    protected readonly _refCounts: Map<Hash, number>;
+    protected readonly _refs: Map<Hash, readonly Hash[]>;
+    constructor(sourceStore: Store, sourceCacheSizeLimit: number, chunkHasher: ChunkHasher, assertValidHash: (hash: Hash) => void, getSizeOfChunk?: (chunk: Chunk) => number);
+    read(): Promise<LazyRead>;
+    write(): Promise<LazyWrite>;
+    close(): Promise<void>;
+    /**
+     * Does not acquire any lock on the store.
+     */
+    isCached(chunkHash: Hash): boolean;
+    withSuspendedSourceCacheEvictsAndDeletes<T>(fn: () => MaybePromise<T>): Promise<T>;
+}
+export declare class LazyRead implements Read {
+    #private;
+    protected readonly _heads: Map<string, Hash>;
+    protected readonly _memOnlyChunks: Map<Hash, Chunk>;
+    protected readonly _sourceChunksCache: ChunksCache;
+    protected readonly _sourceStore: Store;
+    readonly assertValidHash: (hash: Hash) => void;
+    constructor(heads: Map<string, Hash>, memOnlyChunks: Map<Hash, Chunk>, sourceChunksCache: ChunksCache, sourceStore: Store, release: () => void, assertValidHash: (hash: Hash) => void);
+    isMemOnlyChunkHash(hash: Hash): boolean;
+    hasChunk(hash: Hash): Promise<boolean>;
+    getChunk(hash: Hash): Promise<Chunk | undefined>;
+    mustGetChunk(hash: Hash): Promise<Chunk>;
+    getHead(name: string): Promise<Hash | undefined>;
+    release(): void;
+    get closed(): boolean;
+    protected _getSourceRead(): Promise<Read>;
+}
+export declare class LazyWrite extends LazyRead implements Write, RefCountUpdatesDelegate {
+    #private;
+    protected readonly _pendingHeadChanges: Map<string, HeadChange>;
+    protected readonly _pendingMemOnlyChunks: Map<Hash, Chunk<unknown>>;
+    protected readonly _pendingCachedChunks: Map<Hash, {
+        chunk: Chunk;
+        size: number;
+    }>;
+    constructor(heads: Map<string, Hash>, memOnlyChunks: Map<Hash, Chunk>, sourceChunksCache: ChunksCache, sourceStore: Store, refCounts: Map<Hash, number>, refs: Map<Hash, readonly Hash[]>, release: () => void, chunkHasher: ChunkHasher, assertValidHash: (hash: Hash) => void);
+    createChunk: <V>(data: V, refs: Refs) => Chunk<V>;
+    putChunk<V>(c: Chunk<V>, size?: number): Promise<void>;
+    setHead(name: string, hash: Hash): Promise<void>;
+    removeHead(name: string): Promise<void>;
+    isMemOnlyChunkHash(hash: Hash): boolean;
+    getChunk(hash: Hash): Promise<Chunk | undefined>;
+    getHead(name: string): Promise<Hash | undefined>;
+    commit(): Promise<void>;
+    getRefCount(hash: Hash): number | undefined;
+    getRefs(hash: Hash): readonly Hash[] | undefined;
+    areRefsCounted(hash: Hash): boolean;
+    chunksPersisted(chunkHashes: readonly Hash[]): void;
+}
+type CacheEntry = {
+    chunk: Chunk;
+    size: number;
+};
+declare class ChunksCache {
+    #private;
+    /**
+     * Iteration order is from least to most recently used.
+     *
+     * Public so that testing subclass can access.
+     */
+    readonly cacheEntries: Map<Hash, CacheEntry>;
+    constructor(cacheSizeLimit: number, getSizeOfChunk: (v: Chunk) => number, refCounts: Map<Hash, number>, refs: Map<Hash, readonly Hash[]>);
+    get(hash: Hash): Chunk | undefined;
+    getWithoutUpdatingLRU(hash: Hash): Chunk | undefined;
+    put(chunk: Chunk): void;
+    updateForCommit(chunksToPut: Map<Hash, {
+        chunk: Chunk;
+        size: number;
+    }>, refCountUpdates: Map<Hash, number>): void;
+    persisted(chunks: Iterable<Chunk>): void;
+    withSuspendedEvictsAndDeletes<T>(fn: () => MaybePromise<T>): Promise<T>;
+}
+export {};
+//# sourceMappingURL=lazy-store.d.ts.map

package/out/replicache/src/dag/lazy-store.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

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

package/out/replicache/src/dag/store-impl.d.ts ADDED Viewed

@@ -0,0 +1,38 @@
+import { type Hash } from '../hash.js';
+import type { Read as KVRead, Store as KVStore, Write as KVWrite } from '../kv/store.js';
+import { Chunk, type ChunkHasher, type Refs } from './chunk.js';
+import { type RefCountUpdatesDelegate } from './gc.js';
+import { type Read, type Store, type Write } from './store.js';
+export declare class StoreImpl implements Store {
+    #private;
+    constructor(kv: KVStore, chunkHasher: ChunkHasher, assertValidHash: (hash: Hash) => void);
+    read(): Promise<Read>;
+    write(): Promise<Write>;
+    close(): Promise<void>;
+}
+export declare class ReadImpl implements Read {
+    protected readonly _tx: KVRead;
+    readonly assertValidHash: (hash: Hash) => void;
+    constructor(kv: KVRead, assertValidHash: (hash: Hash) => void);
+    hasChunk(hash: Hash): Promise<boolean>;
+    getChunk(hash: Hash): Promise<Chunk | undefined>;
+    mustGetChunk(hash: Hash): Promise<Chunk>;
+    getHead(name: string): Promise<Hash | undefined>;
+    release(): void;
+    get closed(): boolean;
+}
+export declare class WriteImpl extends ReadImpl implements Write, RefCountUpdatesDelegate {
+    #private;
+    protected readonly _tx: KVWrite;
+    constructor(kvw: KVWrite, chunkHasher: ChunkHasher, assertValidHash: (hash: Hash) => void);
+    createChunk: <V>(data: V, refs: Refs) => Chunk<V>;
+    get kvWrite(): KVWrite;
+    putChunk(c: Chunk): Promise<void>;
+    setHead(name: string, hash: Hash): Promise<void>;
+    removeHead(name: string): Promise<void>;
+    commit(): Promise<void>;
+    getRefCount(hash: Hash): Promise<number | undefined>;
+    getRefs(hash: Hash): Promise<readonly Hash[]>;
+    release(): void;
+}
+//# sourceMappingURL=store-impl.d.ts.map

package/out/replicache/src/dag/store-impl.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"store-impl.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/dag/store-impl.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,KAAK,IAAI,EAAa,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EACV,IAAI,IAAI,MAAM,EACd,KAAK,IAAI,OAAO,EAChB,KAAK,IAAI,OAAO,EACjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,KAAK,EACL,KAAK,WAAW,EAChB,KAAK,IAAI,EAGV,MAAM,YAAY,CAAC;AACpB,OAAO,EAAC,KAAK,uBAAuB,EAAyB,MAAM,SAAS,CAAC;AAE7E,OAAO,EAAC,KAAK,IAAI,EAAE,KAAK,KAAK,EAAE,KAAK,KAAK,EAAe,MAAM,YAAY,CAAC;AAE3E,qBAAa,SAAU,YAAW,KAAK;;gBAMnC,EAAE,EAAE,OAAO,EACX,WAAW,EAAE,WAAW,EACxB,eAAe,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI;IAOjC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC;IAQ7B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAGvB;AAED,qBAAa,QAAS,YAAW,IAAI;IACnC,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;gBAEnC,EAAE,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI;IAK7D,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC;IAIhC,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC;IAiBtD,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC;IAIlC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC;IAStD,OAAO,IAAI,IAAI;IAIf,IAAI,MAAM,IAAI,OAAO,CAEpB;CACF;AAOD,qBAAa,SACX,SAAQ,QACR,YAAW,KAAK,EAAE,uBAAuB;;IAEzC,mBAA2B,GAAG,EAAE,OAAO,CAAC;gBAOtC,GAAG,EAAE,OAAO,EACZ,WAAW,EAAE,WAAW,EACxB,eAAe,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI;IAMvC,WAAW,GAAI,CAAC,QAAQ,CAAC,QAAQ,IAAI,KAAG,KAAK,CAAC,CAAC,CAAC,CACH;IAE7C,IAAI,OAAO,IAAI,OAAO,CAErB;IAEK,QAAQ,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBvC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAIhD,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BjC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAUvB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAcpD,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC;IAgCnD,OAAO,IAAI,IAAI;CAGhB"}

package/out/replicache/src/dag/store.d.ts ADDED Viewed

@@ -0,0 +1,36 @@
+import type { Hash } from '../hash.js';
+import type { Release } from '../with-transactions.js';
+import type { Chunk, Refs } from './chunk.js';
+export interface Store {
+    read(): Promise<Read>;
+    write(): Promise<Write>;
+    close(): Promise<void>;
+}
+interface GetChunk {
+    getChunk(hash: Hash): Promise<Chunk | undefined>;
+}
+export interface MustGetChunk {
+    mustGetChunk(hash: Hash): Promise<Chunk>;
+}
+export interface Read extends GetChunk, MustGetChunk, Release {
+    hasChunk(hash: Hash): Promise<boolean>;
+    getHead(name: string): Promise<Hash | undefined>;
+    get closed(): boolean;
+}
+export interface Write extends Read {
+    createChunk<V>(data: V, refs: Refs): Chunk<V>;
+    putChunk<V>(c: Chunk<V>): Promise<void>;
+    setHead(name: string, hash: Hash): Promise<void>;
+    removeHead(name: string): Promise<void>;
+    assertValidHash(hash: Hash): void;
+    commit(): Promise<void>;
+}
+export declare class ChunkNotFoundError extends Error {
+    name: string;
+    readonly hash: Hash;
+    constructor(hash: Hash);
+}
+export declare function mustGetChunk(store: GetChunk, hash: Hash): Promise<Chunk>;
+export declare function mustGetHeadHash(name: string, store: Read): Promise<Hash>;
+export {};
+//# sourceMappingURL=store.d.ts.map

package/out/replicache/src/dag/store.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/dag/store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,YAAY,CAAC;AACrC,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,yBAAyB,CAAC;AACrD,OAAO,KAAK,EAAC,KAAK,EAAE,IAAI,EAAC,MAAM,YAAY,CAAC;AAE5C,MAAM,WAAW,KAAK;IACpB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC;IACxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,UAAU,QAAQ;IAChB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;CAClD;AAED,MAAM,WAAW,YAAY;IAC3B,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;CAC1C;AAED,MAAM,WAAW,IAAK,SAAQ,QAAQ,EAAE,YAAY,EAAE,OAAO;IAC3D,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAAC;IACjD,IAAI,MAAM,IAAI,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,KAAM,SAAQ,IAAI;IACjC,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAC9C,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAClC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,IAAI,SAAwB;IAC5B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;gBACR,IAAI,EAAE,IAAI;CAIvB;AAED,wBAAsB,YAAY,CAChC,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,KAAK,CAAC,CAMhB;AAED,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,IAAI,GACV,OAAO,CAAC,IAAI,CAAC,CAIf"}

package/out/replicache/src/dag/visitor.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import type { Hash } from '../hash.js';
+import type { Chunk } from './chunk.js';
+import type { MustGetChunk } from './store.js';
+/**
+ * A visitor walks the DAG starting at a given root and visits each chunk.
+ */
+export declare class Visitor {
+    #private;
+    constructor(dagRead: MustGetChunk);
+    visit(h: Hash): Promise<void>;
+    visitChunk(chunk: Chunk<unknown>): Promise<void>;
+}
+//# sourceMappingURL=visitor.d.ts.map

package/out/replicache/src/dag/visitor.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"visitor.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/dag/visitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,YAAY,CAAC;AACrC,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,YAAY,CAAC;AAE7C;;GAEG;AACH,qBAAa,OAAO;;gBAIN,OAAO,EAAE,YAAY;IAI3B,KAAK,CAAC,CAAC,EAAE,IAAI;IASb,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC;CAGvC"}