@freqhole/reliquary 0.0.0

package/dist/solid/blob-url.js

@@ -0,0 +1,34 @@
+// a solid resource that turns a blob-fetching function into an object url,
+// revoking the previous url whenever a new one replaces it and revoking
+// the current one when the owning computation is disposed.
+//
+// the blob-fetching function is supplied by the caller - this module has
+// no dependency on `./blobs` or any particular blob store, so a consumer
+// wires up its own resolver (a local blob store lookup, a network fetch,
+// whatever it needs).
+import { createEffect, createResource, onCleanup } from "solid-js";
+/**
+ * fetches a blob via `getBlob` and exposes its object url as a solid
+ * resource. `null` while loading, on a null blob, or after an error.
+ * every previous url is revoked as soon as it's superseded (by a refetch)
+ * or the resource is disposed - a caller never needs to manage
+ * `URL.revokeObjectURL` itself.
+ */
+export function createBlobUrl(getBlob) {
+    const [url] = createResource(async () => {
+        const blob = await getBlob();
+        return blob ? URL.createObjectURL(blob) : null;
+    });
+    let previous = null;
+    createEffect(() => {
+        const current = url() ?? null;
+        if (previous && previous !== current)
+            URL.revokeObjectURL(previous);
+        previous = current;
+    });
+    onCleanup(() => {
+        if (previous)
+            URL.revokeObjectURL(previous);
+    });
+    return url;
+}

package/dist/solid/blob-url.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=blob-url.test.d.ts.map

package/dist/solid/blob-url.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob-url.test.d.ts","sourceRoot":"","sources":["../../src/solid/blob-url.test.ts"],"names":[],"mappings":""}

package/dist/solid/blob-url.test.js

@@ -0,0 +1,62 @@
+// @vitest-environment happy-dom
+import { createRoot } from "solid-js";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createBlobUrl } from "./blob-url.js";
+afterEach(() => {
+    vi.unstubAllGlobals();
+});
+function stubObjectUrl() {
+    let counter = 0;
+    const created = [];
+    const revoked = [];
+    vi.stubGlobal("URL", {
+        createObjectURL: vi.fn(() => {
+            const url = `blob:mock-${++counter}`;
+            created.push(url);
+            return url;
+        }),
+        revokeObjectURL: vi.fn((url) => {
+            revoked.push(url);
+        }),
+    });
+    return { created, revoked };
+}
+describe("createBlobUrl", () => {
+    it("resolves to an object url for a non-null blob", async () => {
+        const { created } = stubObjectUrl();
+        let dispose = () => { };
+        let url;
+        createRoot((d) => {
+            dispose = d;
+            url = createBlobUrl(async () => new Blob(["hello"]));
+        });
+        await vi.waitFor(() => expect(url.loading).toBe(false));
+        expect(url()).toBe(created[0]);
+        dispose();
+    });
+    it("resolves to null for a null blob", async () => {
+        stubObjectUrl();
+        let dispose = () => { };
+        let resource;
+        createRoot((d) => {
+            dispose = d;
+            resource = createBlobUrl(async () => null);
+        });
+        await vi.waitFor(() => expect(resource.loading).toBe(false));
+        expect(resource()).toBeNull();
+        dispose();
+    });
+    it("revokes the object url once the owning root is disposed", async () => {
+        const { created, revoked } = stubObjectUrl();
+        let dispose = () => { };
+        let url;
+        createRoot((d) => {
+            dispose = d;
+            url = createBlobUrl(async () => new Blob(["hello"]));
+        });
+        await vi.waitFor(() => expect(url.loading).toBe(false));
+        expect(revoked).not.toContain(created[0]);
+        dispose();
+        expect(revoked).toContain(created[0]);
+    });
+});

package/dist/solid/connection-summary.d.ts

@@ -0,0 +1,25 @@
+import { type Accessor } from "solid-js";
+/** counts describing a network adapter's current peer connections. */
+export interface ConnectionSummaryLike {
+    /** number of peers actively connected. */
+    connected: number;
+    /** number of peers currently reconnecting (in backoff). */
+    reconnecting: number;
+    /** number of peers whose reconnection attempts gave up. */
+    failed: number;
+}
+export interface CreateConnectionSummaryOptions {
+    /** how often to re-read the source, in ms. default 2000. */
+    pollIntervalMs?: number;
+}
+/**
+ * polls `getSource()` on an interval and exposes the result as a reactive
+ * signal. `getSource` may return `null` (adapter not constructed/ready
+ * yet) - the summary then stays at its last known value. the poll is
+ * cleared automatically via `onCleanup` when the owning computation is
+ * disposed.
+ */
+export declare function createConnectionSummary(getSource: () => {
+    getConnectionSummary(): ConnectionSummaryLike;
+} | null, options?: CreateConnectionSummaryOptions): Accessor<ConnectionSummaryLike>;
+//# sourceMappingURL=connection-summary.d.ts.map

package/dist/solid/connection-summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-summary.d.ts","sourceRoot":"","sources":["../../src/solid/connection-summary.ts"],"names":[],"mappings":"AAOA,OAAO,EAA2B,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAElE,sEAAsE;AACtE,MAAM,WAAW,qBAAqB;IACpC,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,YAAY,EAAE,MAAM,CAAC;IACrB,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;CAChB;AAID,MAAM,WAAW,8BAA8B;IAC7C,4DAA4D;IAC5D,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM;IAAE,oBAAoB,IAAI,qBAAqB,CAAA;CAAE,GAAG,IAAI,EACzE,OAAO,GAAE,8BAAmC,GAC3C,QAAQ,CAAC,qBAAqB,CAAC,CAejC"}

package/dist/solid/connection-summary.js

@@ -0,0 +1,29 @@
+// a small reactive summary over a connection/transfer source's live state,
+// refreshed on a fixed poll interval.
+//
+// the "source" is any object exposing a synchronous `getConnectionSummary()`
+// - typically a network adapter - so this module has no dependency on any
+// particular adapter implementation or transport.
+import { createSignal, onCleanup } from "solid-js";
+const EMPTY_SUMMARY = { connected: 0, reconnecting: 0, failed: 0 };
+/**
+ * polls `getSource()` on an interval and exposes the result as a reactive
+ * signal. `getSource` may return `null` (adapter not constructed/ready
+ * yet) - the summary then stays at its last known value. the poll is
+ * cleared automatically via `onCleanup` when the owning computation is
+ * disposed.
+ */
+export function createConnectionSummary(getSource, options = {}) {
+    const [summary, setSummary] = createSignal(EMPTY_SUMMARY);
+    const pollIntervalMs = options.pollIntervalMs ?? 2000;
+    function refresh() {
+        const source = getSource();
+        if (!source)
+            return;
+        setSummary(source.getConnectionSummary());
+    }
+    refresh();
+    const timer = setInterval(refresh, pollIntervalMs);
+    onCleanup(() => clearInterval(timer));
+    return summary;
+}

package/dist/solid/connection-summary.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=connection-summary.test.d.ts.map

package/dist/solid/connection-summary.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-summary.test.d.ts","sourceRoot":"","sources":["../../src/solid/connection-summary.test.ts"],"names":[],"mappings":""}

package/dist/solid/connection-summary.test.js

@@ -0,0 +1,57 @@
+import { createRoot } from "solid-js";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createConnectionSummary } from "./connection-summary.js";
+beforeEach(() => {
+    vi.useFakeTimers();
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+function makeSource(summary) {
+    return { getConnectionSummary: () => summary };
+}
+describe("createConnectionSummary", () => {
+    it("reads the source immediately on creation", () => {
+        createRoot((dispose) => {
+            const source = makeSource({ connected: 2, reconnecting: 1, failed: 0 });
+            const summary = createConnectionSummary(() => source);
+            expect(summary()).toEqual({ connected: 2, reconnecting: 1, failed: 0 });
+            dispose();
+        });
+    });
+    it("stays at the default when the source is not yet available", () => {
+        createRoot((dispose) => {
+            const summary = createConnectionSummary(() => null);
+            expect(summary()).toEqual({ connected: 0, reconnecting: 0, failed: 0 });
+            dispose();
+        });
+    });
+    it("re-polls the source on the configured interval", () => {
+        createRoot((dispose) => {
+            let current = { connected: 0, reconnecting: 0, failed: 0 };
+            const source = { getConnectionSummary: () => current };
+            const summary = createConnectionSummary(() => source, { pollIntervalMs: 1000 });
+            current = { connected: 3, reconnecting: 0, failed: 1 };
+            expect(summary()).toEqual({ connected: 0, reconnecting: 0, failed: 0 });
+            vi.advanceTimersByTime(1000);
+            expect(summary()).toEqual({ connected: 3, reconnecting: 0, failed: 1 });
+            dispose();
+        });
+    });
+    it("stops polling once the owning root is disposed", () => {
+        createRoot((dispose) => {
+            let calls = 0;
+            const source = {
+                getConnectionSummary: () => {
+                    calls++;
+                    return { connected: 0, reconnecting: 0, failed: 0 };
+                },
+            };
+            createConnectionSummary(() => source, { pollIntervalMs: 500 });
+            const callsAtDispose = calls;
+            dispose();
+            vi.advanceTimersByTime(5000);
+            expect(calls).toBe(callsAtDispose);
+        });
+    });
+});

package/dist/solid/doc-store.d.ts

@@ -0,0 +1,29 @@
+import type { Accessor } from "solid-js";
+import type { DocHandle } from "@automerge/automerge-repo";
+export interface DocStore<T> {
+    doc: Accessor<T>;
+    loading: Accessor<boolean>;
+}
+/**
+ * creates a reactive solid store backed by an automerge DocHandle. the doc
+ * accessor is always a caller-validated snapshot - corrupt or
+ * future-versioned peer data degrades to whatever the parse function
+ * returns for unknown/invalid input. loading becomes false once
+ * whenReady() resolves or rejects.
+ *
+ * @param handle - the automerge DocHandle to track
+ * @param parse - a function that converts unknown to T, providing defaults
+ *   for missing/corrupt data (typically a zod schema's parse with a default
+ *   fallback, but any unknown->T function works)
+ */
+export declare function createDocStore<T>(handle: DocHandle<unknown>, parse: (raw: unknown) => T): DocStore<T>;
+/**
+ * convenience wrapper: apply a mutation to an automerge doc handle. the
+ * mutatorFn receives a mutable automerge draft and should modify it in
+ * place (safe to call shared mutation helpers from consuming apps).
+ *
+ * @param handle - the automerge DocHandle to mutate
+ * @param mutatorFn - a function that modifies the doc's draft in place
+ */
+export declare function changeDoc<T>(handle: DocHandle<T>, mutatorFn: (draft: T) => void): void;
+//# sourceMappingURL=doc-store.d.ts.map

package/dist/solid/doc-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-store.d.ts","sourceRoot":"","sources":["../../src/solid/doc-store.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EACV,SAAS,EAGV,MAAM,2BAA2B,CAAC;AAEnC,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IACjB,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,EAC1B,KAAK,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,CAAC,GACzB,QAAQ,CAAC,CAAC,CAAC,CA8Cb;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EACpB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAC5B,IAAI,CAEN"}

package/dist/solid/doc-store.js

@@ -0,0 +1,79 @@
+// a reactive solid adapter over an automerge DocHandle with
+// caller-supplied parsing/validation. this is a generic pattern for
+// building solid signals around any automerge document type - the caller
+// provides the parse function (their own zod validator, or anything else
+// that turns unknown into a safe default), and this module wires the
+// automerge event lifecycle into solid reactivity.
+//
+// usage inside a solid component or reactive root:
+//
+//   const handle = await repo.find<MyDoc>(url);
+//   const { doc, loading } = createDocStore(handle, parseMyDoc);
+//   // doc() is always a caller-parsed MyDoc (defaults on corrupt/missing)
+//   // loading() is true until the handle is ready or terminal
+import { createSignal, onCleanup } from "solid-js";
+/**
+ * creates a reactive solid store backed by an automerge DocHandle. the doc
+ * accessor is always a caller-validated snapshot - corrupt or
+ * future-versioned peer data degrades to whatever the parse function
+ * returns for unknown/invalid input. loading becomes false once
+ * whenReady() resolves or rejects.
+ *
+ * @param handle - the automerge DocHandle to track
+ * @param parse - a function that converts unknown to T, providing defaults
+ *   for missing/corrupt data (typically a zod schema's parse with a default
+ *   fallback, but any unknown->T function works)
+ */
+export function createDocStore(handle, parse) {
+    // try to read whatever the handle has now (may be undefined before ready)
+    let initialRaw;
+    try {
+        initialRaw = handle.doc();
+    }
+    catch {
+        initialRaw = undefined;
+    }
+    const [loading, setLoading] = createSignal(initialRaw === undefined);
+    const [doc, setDoc] = createSignal(parse(initialRaw), { equals: false });
+    // resolve handle readiness in the background
+    handle
+        .whenReady()
+        .then(() => {
+        let current;
+        try {
+            current = handle.doc();
+        }
+        catch {
+            current = undefined;
+        }
+        setLoading(false);
+        setDoc(() => parse(current));
+    })
+        .catch(() => {
+        setLoading(false);
+    });
+    const changeHandler = (payload) => {
+        setDoc(() => parse(payload.doc));
+    };
+    const deleteHandler = (_payload) => {
+        setLoading(false);
+    };
+    handle.on("change", changeHandler);
+    handle.on("delete", deleteHandler);
+    onCleanup(() => {
+        handle.off("change", changeHandler);
+        handle.off("delete", deleteHandler);
+    });
+    return { doc, loading };
+}
+/**
+ * convenience wrapper: apply a mutation to an automerge doc handle. the
+ * mutatorFn receives a mutable automerge draft and should modify it in
+ * place (safe to call shared mutation helpers from consuming apps).
+ *
+ * @param handle - the automerge DocHandle to mutate
+ * @param mutatorFn - a function that modifies the doc's draft in place
+ */
+export function changeDoc(handle, mutatorFn) {
+    handle.change(mutatorFn);
+}

package/dist/solid/doc-store.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=doc-store.test.d.ts.map

package/dist/solid/doc-store.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-store.test.d.ts","sourceRoot":"","sources":["../../src/solid/doc-store.test.ts"],"names":[],"mappings":""}

package/dist/solid/doc-store.test.js

@@ -0,0 +1,234 @@
+// tests for createDocStore solid adapter.
+//
+// uses a lightweight mock DocHandle (no automerge wasm needed) to test
+// the solid reactivity layer independently of any specific doc schema.
+import { describe, it, expect, vi } from "vitest";
+import { createRoot } from "solid-js";
+import { createDocStore, changeDoc } from "./doc-store.js";
+function createMockHandle(initialDoc = undefined) {
+    let currentDoc = initialDoc;
+    const handlers = new Map();
+    let readyResolve;
+    let readyReject;
+    const readyPromise = new Promise((res, rej) => {
+        readyResolve = res;
+        readyReject = rej;
+    });
+    const offSpy = vi.fn();
+    const handle = {
+        doc: () => currentDoc,
+        whenReady: () => readyPromise,
+        on: (event, handler) => {
+            if (!handlers.has(event))
+                handlers.set(event, new Set());
+            handlers.get(event).add(handler);
+        },
+        off: offSpy,
+        change: vi.fn((fn) => {
+            fn(currentDoc);
+            const set = handlers.get("change");
+            if (set) {
+                const payload = {
+                    handle: handle,
+                    doc: currentDoc,
+                    patches: [],
+                    patchInfo: {
+                        before: currentDoc,
+                        after: currentDoc,
+                        source: "change",
+                    },
+                };
+                set.forEach((h) => h(payload));
+            }
+        }),
+    };
+    return {
+        handle,
+        setDoc: (d) => {
+            currentDoc = d;
+        },
+        emitChange: (doc) => {
+            currentDoc = doc;
+            const set = handlers.get("change");
+            if (set) {
+                const payload = {
+                    handle: handle,
+                    doc: doc,
+                    patches: [],
+                    patchInfo: {
+                        before: doc,
+                        after: doc,
+                        source: "change",
+                    },
+                };
+                set.forEach((h) => h(payload));
+            }
+        },
+        emitDelete: () => {
+            const set = handlers.get("delete");
+            if (set) {
+                const payload = {
+                    handle: handle,
+                };
+                set.forEach((h) => h(payload));
+            }
+        },
+        resolveReady: () => readyResolve(),
+        rejectReady: (err) => readyReject(err),
+        offSpy,
+    };
+}
+function parseSimpleDoc(raw) {
+    if (typeof raw === "object" &&
+        raw !== null &&
+        "title" in raw &&
+        typeof raw.title === "string" &&
+        "count" in raw &&
+        typeof raw.count === "number") {
+        return { title: raw.title, count: raw.count };
+    }
+    return { title: "", count: 0 };
+}
+function parseCounterDoc(raw) {
+    if (typeof raw === "object" &&
+        raw !== null &&
+        "count" in raw &&
+        typeof raw.count === "number") {
+        return { count: raw.count };
+    }
+    return { count: 0 };
+}
+describe("createDocStore", () => {
+    it("returns loading=true and default doc when handle doc is undefined", () => {
+        createRoot((dispose) => {
+            const { handle } = createMockHandle(undefined);
+            const { doc, loading } = createDocStore(handle, parseSimpleDoc);
+            expect(loading()).toBe(true);
+            // parse function provides defaults
+            expect(doc().title).toBe("");
+            expect(doc().count).toBe(0);
+            dispose();
+        });
+    });
+    it("returns loading=false immediately when handle already has a doc", () => {
+        createRoot((dispose) => {
+            const initialDoc = { title: "loaded", count: 42 };
+            const { handle } = createMockHandle(initialDoc);
+            const { doc, loading } = createDocStore(handle, parseSimpleDoc);
+            expect(loading()).toBe(false);
+            expect(doc().title).toBe("loaded");
+            expect(doc().count).toBe(42);
+            dispose();
+        });
+    });
+    it("updates doc signal on handle change event", () => {
+        createRoot((dispose) => {
+            const { handle, emitChange } = createMockHandle({
+                title: "original",
+                count: 1,
+            });
+            const { doc } = createDocStore(handle, parseSimpleDoc);
+            expect(doc().title).toBe("original");
+            expect(doc().count).toBe(1);
+            emitChange({ title: "updated", count: 2 });
+            expect(doc().title).toBe("updated");
+            expect(doc().count).toBe(2);
+            dispose();
+        });
+    });
+    it("degrades corrupt doc to parse function defaults on change", () => {
+        createRoot((dispose) => {
+            const { handle, emitChange } = createMockHandle({ title: "ok", count: 1 });
+            const { doc } = createDocStore(handle, parseSimpleDoc);
+            // emit a corrupt doc that fails validation
+            emitChange({ badField: true, wrongType: "not a number" });
+            // parse function degrades to defaults
+            expect(doc().title).toBe("");
+            expect(doc().count).toBe(0);
+            dispose();
+        });
+    });
+    it("sets loading=false when delete event fires", () => {
+        createRoot((dispose) => {
+            const { handle, emitDelete } = createMockHandle(undefined);
+            const { loading } = createDocStore(handle, parseSimpleDoc);
+            expect(loading()).toBe(true);
+            emitDelete();
+            expect(loading()).toBe(false);
+            dispose();
+        });
+    });
+    it("sets loading=false when whenReady resolves", async () => {
+        await createRoot(async (dispose) => {
+            const { handle, resolveReady, setDoc } = createMockHandle(undefined);
+            const { loading } = createDocStore(handle, parseSimpleDoc);
+            expect(loading()).toBe(true);
+            setDoc({ title: "ready", count: 10 });
+            resolveReady();
+            // flush microtasks
+            await Promise.resolve();
+            await Promise.resolve();
+            expect(loading()).toBe(false);
+            dispose();
+        });
+    });
+    it("sets loading=false when whenReady rejects", async () => {
+        await createRoot(async (dispose) => {
+            const { handle, rejectReady } = createMockHandle(undefined);
+            const { loading } = createDocStore(handle, parseSimpleDoc);
+            rejectReady(new Error("unavailable"));
+            await Promise.resolve();
+            await Promise.resolve();
+            expect(loading()).toBe(false);
+            dispose();
+        });
+    });
+    it("unsubscribes handlers on cleanup (off called with correct args)", () => {
+        const { handle, offSpy } = createMockHandle({ title: "test", count: 1 });
+        const dispose = createRoot((disposeRoot) => {
+            createDocStore(handle, parseSimpleDoc);
+            return disposeRoot;
+        });
+        dispose();
+        // off should have been called for both "change" and "delete"
+        expect(offSpy).toHaveBeenCalledWith("change", expect.any(Function));
+        expect(offSpy).toHaveBeenCalledWith("delete", expect.any(Function));
+    });
+    it("degrades null/undefined doc to parse function defaults", () => {
+        createRoot((dispose) => {
+            const { handle, emitChange } = createMockHandle({ title: "ok", count: 1 });
+            const { doc } = createDocStore(handle, parseSimpleDoc);
+            emitChange(null);
+            expect(doc().title).toBe("");
+            expect(doc().count).toBe(0);
+            emitChange(undefined);
+            expect(doc().title).toBe("");
+            expect(doc().count).toBe(0);
+            dispose();
+        });
+    });
+    it("works with a different doc type (CounterDoc) proving genericity", () => {
+        createRoot((dispose) => {
+            const { handle, emitChange } = createMockHandle({ count: 5 });
+            const { doc } = createDocStore(handle, parseCounterDoc);
+            expect(doc().count).toBe(5);
+            emitChange({ count: 10 });
+            expect(doc().count).toBe(10);
+            // corrupt data degrades to parseCounterDoc's defaults
+            emitChange({ wrongField: true });
+            expect(doc().count).toBe(0);
+            dispose();
+        });
+    });
+});
+describe("changeDoc", () => {
+    it("calls handle.change with the mutator function", () => {
+        const mockChange = vi.fn();
+        const handle = {
+            change: mockChange,
+        };
+        const mutator = vi.fn();
+        changeDoc(handle, mutator);
+        expect(mockChange).toHaveBeenCalledWith(mutator);
+    });
+});

package/dist/solid/index.d.ts

@@ -0,0 +1,4 @@
+export { createTransferProgress, type TransferProgress } from "./transfer-progress.js";
+export { createConnectionSummary, type ConnectionSummaryLike, type CreateConnectionSummaryOptions, } from "./connection-summary.js";
+export { createBlobUrl } from "./blob-url.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/solid/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,sBAAsB,EAAE,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AACvF,OAAO,EACL,uBAAuB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,8BAA8B,GACpC,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC"}

package/dist/solid/index.js

@@ -0,0 +1,9 @@
+// thin solid-js reactive wrappers with no business logic of their own:
+// every helper here just adapts a caller-supplied source of truth (a
+// progress map, a connection-summary source, a blob-fetching function)
+// into a solid signal/resource. this is the only subpath besides
+// `./automerge` allowed to depend on a framework - it may import
+// `solid-js`.
+export { createTransferProgress } from "./transfer-progress.js";
+export { createConnectionSummary, } from "./connection-summary.js";
+export { createBlobUrl } from "./blob-url.js";

package/dist/solid/transfer-progress.d.ts

@@ -0,0 +1,21 @@
+import { type Accessor } from "solid-js";
+export interface TransferProgress<TState> {
+    /** current snapshot of tracked keys and their state. reactive - reading
+     *  this inside a solid computation subscribes to every map mutation
+     *  (the underlying signal uses `{ equals: false }` so a mutated map is
+     *  always seen as a change, even when the reference happens to be
+     *  reused). */
+    states: Accessor<ReadonlyMap<string, TState>>;
+    /** set (or clear, with `null`) the state for one key without replacing
+     *  the whole map. */
+    setState(key: string, state: TState | null): void;
+    /** clear every tracked key. */
+    reset(): void;
+}
+/**
+ * creates a reactive `key -> state` map for tracking the progress of any
+ * number of concurrent, independently-keyed operations (blob downloads
+ * keyed by hash, uploads keyed by id, ...).
+ */
+export declare function createTransferProgress<TState>(): TransferProgress<TState>;
+//# sourceMappingURL=transfer-progress.d.ts.map

package/dist/solid/transfer-progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer-progress.d.ts","sourceRoot":"","sources":["../../src/solid/transfer-progress.ts"],"names":[],"mappings":"AAUA,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEvD,MAAM,WAAW,gBAAgB,CAAC,MAAM;IACtC;;;;mBAIe;IACf,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9C;yBACqB;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IAClD,+BAA+B;IAC/B,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,KAAK,gBAAgB,CAAC,MAAM,CAAC,CAiBzE"}

package/dist/solid/transfer-progress.js

@@ -0,0 +1,32 @@
+// a reactive per-key progress/state map: a generalized version of the
+// signal-map pattern used for tracking in-flight blob transfers, where
+// presence in the map means "currently tracked" (in progress, pending, or
+// failed) and absence means "not currently tracked" (either settled/cached
+// already, or never started).
+//
+// the caller supplies the state type - this module has no vocabulary of
+// its own for what a transfer's state looks like (blob download, upload,
+// sync progress, or anything else keyed by a string id).
+import { createSignal } from "solid-js";
+/**
+ * creates a reactive `key -> state` map for tracking the progress of any
+ * number of concurrent, independently-keyed operations (blob downloads
+ * keyed by hash, uploads keyed by id, ...).
+ */
+export function createTransferProgress() {
+    const [states, setStates] = createSignal(new Map(), { equals: false });
+    function setState(key, state) {
+        setStates((prev) => {
+            const next = new Map(prev);
+            if (state === null)
+                next.delete(key);
+            else
+                next.set(key, state);
+            return next;
+        });
+    }
+    function reset() {
+        setStates(new Map());
+    }
+    return { states, setState, reset };
+}

package/dist/solid/transfer-progress.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=transfer-progress.test.d.ts.map