fundus 0.23.0 → 0.25.0

package/dist/runtime/retained-entry.js

@@ -0,0 +1,61 @@
+import { assertEntryByteSize } from './manifest.js';
+import { acquireSource, releaseSource, resolveRetainedImageSource, resolveRetainedSource } from './preload-registry.js';
+class Handle {
+    entry;
+    /** `null` once released. */
+    #source;
+    constructor(entry, source) {
+        this.entry = entry;
+        this.#source = source;
+    }
+    // A prototype getter, so spreading, proxying or serializing a handle never
+    // reads it — only an explicit access after release throws.
+    get source() {
+        if (this.#source === null) {
+            throw new Error(`EntryHandle "${this.entry.id}" was released.`);
+        }
+        return this.#source;
+    }
+    release = () => {
+        if (this.#source === null)
+            return;
+        this.#source = null;
+        releaseSource(this.entry.src);
+    };
+}
+/**
+ * Take one hold on `entry`'s own source and resolve with a handle to it once
+ * loaded. An already loaded source (e.g. after `manifest.preload()`) resolves
+ * without loading, a source in flight is joined, and an absent one loads via
+ * its kind — deduplicated and cached exactly like `preload()`. Only the
+ * entry's own `src` is retained: a chroma-key-video's `mask` and `fallback`
+ * are separate entries to retain on their own.
+ *
+ * The hold lasts until `release()`, even when the source was already
+ * preloaded; while any holder keeps it, the source object stays the same.
+ * Always release, including when a caller stops waiting for the promise.
+ *
+ * @throws {Error} (rejects) When the entry's `byteSize` is invalid, the load
+ * fails, or an image-backed source cannot be decoded in this environment.
+ * A rejection leaves no hold behind.
+ */
+export async function retainEntry(entry) {
+    const { id, kind, src, byteSize } = entry;
+    assertEntryByteSize(src, byteSize);
+    try {
+        await acquireSource(src, kind, byteSize, entry);
+    }
+    catch (cause) {
+        releaseSource(src);
+        throw cause;
+    }
+    if (kind === 'image' || kind === 'slice') {
+        const source = resolveRetainedImageSource(src);
+        if (source === null) {
+            releaseSource(src);
+            throw new Error(`Cannot retain "${id}": this environment cannot decode ${kind} sources.`);
+        }
+        return new Handle(entry, source);
+    }
+    return new Handle(entry, resolveRetainedSource(src));
+}

package/dist/runtime/retained-entry.svelte.d.ts

@@ -0,0 +1,26 @@
+import type { ManifestEntry } from '../core/index.js';
+import { type RetainedSourceOf } from './retained-entry.js';
+export type RetainedEntryStatus = 'loading' | 'ready' | 'error' | 'released';
+/**
+ * One hold on `entry`'s own source for the lifetime of the constructing
+ * component, shared with manifests and handles exactly like `retainEntry`.
+ * Construct it during component initialisation; the hold is dropped on
+ * destroy, including when the load is still in flight.
+ *
+ * Loading starts on mount, so server rendering never loads and reports
+ * `loading`.
+ *
+ * @throws {Error} When constructed outside component initialisation.
+ */
+export declare class RetainedEntry<E extends ManifestEntry> {
+    #private;
+    readonly entry: E;
+    constructor(entry: E);
+    /** The loaded source; `undefined` while loading, after an error, and after release. */
+    get source(): RetainedSourceOf<E> | undefined;
+    get status(): RetainedEntryStatus;
+    /** The rejection reason while `status` is `error`. */
+    get error(): unknown;
+    /** Drop the hold before destroy. Idempotent; safe to call unbound. */
+    readonly release: () => void;
+}

package/dist/runtime/retained-entry.svelte.js

@@ -0,0 +1,62 @@
+/**
+ * Component-scoped retention: an `EntryHandle` whose lifetime follows the
+ * component that creates it, with the source exposed as reactive state.
+ */
+import { onDestroy, onMount } from 'svelte';
+import { retainEntry } from './retained-entry.js';
+/**
+ * One hold on `entry`'s own source for the lifetime of the constructing
+ * component, shared with manifests and handles exactly like `retainEntry`.
+ * Construct it during component initialisation; the hold is dropped on
+ * destroy, including when the load is still in flight.
+ *
+ * Loading starts on mount, so server rendering never loads and reports
+ * `loading`.
+ *
+ * @throws {Error} When constructed outside component initialisation.
+ */
+export class RetainedEntry {
+    entry;
+    #handle = $state.raw();
+    #status = $state('loading');
+    #error = $state.raw();
+    constructor(entry) {
+        this.entry = entry;
+        onMount(() => {
+            if (this.#status === 'released')
+                return;
+            retainEntry(entry).then((handle) => {
+                if (this.#status === 'released') {
+                    handle.release();
+                    return;
+                }
+                this.#handle = handle;
+                this.#status = 'ready';
+            }, (error) => {
+                // A rejected retain leaves no hold behind.
+                if (this.#status === 'released')
+                    return;
+                this.#error = error;
+                this.#status = 'error';
+            });
+        });
+        onDestroy(this.release);
+    }
+    /** The loaded source; `undefined` while loading, after an error, and after release. */
+    get source() {
+        return this.#handle?.source;
+    }
+    get status() {
+        return this.#status;
+    }
+    /** The rejection reason while `status` is `error`. */
+    get error() {
+        return this.#error;
+    }
+    /** Drop the hold before destroy. Idempotent; safe to call unbound. */
+    release = () => {
+        this.#status = 'released';
+        this.#handle?.release();
+        this.#handle = undefined;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "fundus",
-	"version": "0.23.0",
+	"version": "0.25.0",
 	"type": "module",
 	"repository": {
 		"type": "git",

package/build/client/_app/immutable/entry/start.DfWWrqAi.js

@@ -1 +0,0 @@
-import{c as e,r as t}from"../chunks/Co7xGpqv.js";export{e as load_css,t as start};

package/build/client/_app/immutable/nodes/1.q-uG--Ye.js.br

@@ -1,2 +0,0 @@
-w
`�ۦ�M�uEE
-w�����sm��>�q�N�)����.�M+�

package/build/server/chunks/nodes/1.js-CQ-mFntC.js

@@ -1,7 +0,0 @@
-const index = 1;
-const imports = ["_app/immutable/nodes/1.q-uG--Ye.js","_app/immutable/chunks/DLEDBLL1.js","_app/immutable/chunks/xihTtKlq.js","_app/immutable/chunks/DWHqxOBm.js","_app/immutable/chunks/Co7xGpqv.js"];
-const stylesheets = [];
-const fonts = [];
-
-export { fonts, imports, index, stylesheets };
-//# sourceMappingURL=1.js-CQ-mFntC.js.map

package/build/server/chunks/nodes/3.js-BzUyw6Q9.js

@@ -1,7 +0,0 @@
-const index = 3;
-const imports = ["_app/immutable/nodes/3.D7nMxWez.js","_app/immutable/chunks/DLEDBLL1.js","_app/immutable/chunks/Co7xGpqv.js","_app/immutable/chunks/xihTtKlq.js","_app/immutable/chunks/DWHqxOBm.js","_app/immutable/chunks/Cml0-AYv.js","_app/immutable/chunks/CVeOwywf.js","_app/immutable/chunks/DGYcFVZ3.js","_app/immutable/chunks/CzxolZCO.js"];
-const stylesheets = ["_app/immutable/assets/ManifestSelector.Cue3sCA1.css","_app/immutable/assets/Popover.CCTioPJZ.css","_app/immutable/assets/AssetSourceMenu.DWPxyX6L.css","_app/immutable/assets/3.OulZ54CG.css"];
-const fonts = [];
-
-export { fonts, imports, index, stylesheets };
-//# sourceMappingURL=3.js-BzUyw6Q9.js.map