@budarin/psw-plugin-opfs-serve-range 1.0.0

package/dist/index.js

@@ -0,0 +1,192 @@
+import { HEADER_RANGE } from '@budarin/http-constants/headers';
+import { MIME_APPLICATION_OCTET_STREAM } from '@budarin/http-constants/mime-types';
+import { OPFS_META_FOOTER_LENGTH, MAX_META_JSON_BYTES, } from './opfsFormat.js';
+import { getOpfsDir, isOpfsAvailable, shouldProcessFile } from './opfsUtil.js';
+import { parseRangeHeader, build206Response } from './opfsRangeUtil.js';
+export { OPFS_META_FOOTER_LENGTH, OPFS_FOLDER_NAME, KILOBYTE, MEGABYTE, GIGABYTE, } from './opfsFormat.js';
+export { getOpfsDir, clearOpfsCache, configureOpfs, isOpfsAvailable, getMaxCacheFraction, } from './opfsUtil.js';
+export { isBlacklisted, addToBlacklist, getStorageEstimate, getCacheLimit } from './opfsLru.js';
+export { OPFS_MSG_QUOTA_EXCEEDED, OPFS_MSG_WRITE_SKIPPED_SIZE, OPFS_MSG_CACHE_LIMIT_REACHED, OPFS_MSG_EVICTION_COMPLETED, OPFS_MSG_WRITE_FAILED, OPFS_MSG_SKIP_QUOTA_EXCEEDED, } from './opfsMessages.js';
+const HEADER_IF_RANGE = 'If-Range';
+const urlToKeyCache = new Map();
+export async function urlToOpfsKey(url) {
+    const cached = urlToKeyCache.get(url);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const bytes = new TextEncoder().encode(url);
+    const hash = await crypto.subtle.digest('SHA-256', bytes);
+    const key = Array.from(new Uint8Array(hash))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+    urlToKeyCache.set(url, key);
+    return key;
+}
+function ifRangeMatches(ifRangeValue, meta) {
+    const value = ifRangeValue.trim();
+    if (!value) {
+        return false;
+    }
+    if (meta.lastModified) {
+        const ifRangeDate = Date.parse(value);
+        if (!Number.isNaN(ifRangeDate)) {
+            const storedDate = Date.parse(meta.lastModified);
+            return !Number.isNaN(storedDate) && ifRangeDate === storedDate;
+        }
+    }
+    if (meta.etag) {
+        const normalizeEtag = (s) => s
+            .replace(/^\s*W\//i, '')
+            .replace(/^"|"$/g, '')
+            .trim();
+        return normalizeEtag(value) === normalizeEtag(meta.etag);
+    }
+    return false;
+}
+async function getMetadataFromFileFooter(file) {
+    const size = file.size;
+    if (size < OPFS_META_FOOTER_LENGTH) {
+        return { metadata: undefined, bodySize: size };
+    }
+    const footerBlob = file.slice(size - OPFS_META_FOOTER_LENGTH, size);
+    const footerBuf = await footerBlob.arrayBuffer();
+    const metaLen = new DataView(footerBuf).getUint32(0, true);
+    if (metaLen === 0 ||
+        metaLen > MAX_META_JSON_BYTES ||
+        metaLen > size - OPFS_META_FOOTER_LENGTH) {
+        return { metadata: undefined, bodySize: size };
+    }
+    try {
+        const jsonBlob = file.slice(size - OPFS_META_FOOTER_LENGTH - metaLen, size - OPFS_META_FOOTER_LENGTH);
+        const text = await jsonBlob.text();
+        const metadata = JSON.parse(text);
+        const bodySize = size - OPFS_META_FOOTER_LENGTH - metaLen;
+        return { metadata, bodySize };
+    }
+    catch {
+        return { metadata: undefined, bodySize: size };
+    }
+}
+async function updateLastAccessedInBackground(handle, metadata, bodySize) {
+    try {
+        const meta = { ...metadata, lastAccessed: Date.now() };
+        const metaJson = JSON.stringify(meta);
+        const metaBytes = new TextEncoder().encode(metaJson);
+        if (metaBytes.length > MAX_META_JSON_BYTES) {
+            return;
+        }
+        const lengthAb = new ArrayBuffer(OPFS_META_FOOTER_LENGTH);
+        new DataView(lengthAb).setUint32(0, metaBytes.length, true);
+        const writable = await handle.createWritable();
+        await writable.seek(bodySize);
+        await writable.write(metaBytes);
+        await writable.write(lengthAb);
+        await writable.truncate(bodySize + metaBytes.length + OPFS_META_FOOTER_LENGTH);
+        await writable.close();
+    }
+    catch {
+    }
+}
+export function opfsServeRange(options = {}) {
+    if (!isOpfsAvailable()) {
+        return undefined;
+    }
+    const { order = -15, enableLogging = false, include, exclude, rangeResponseCacheControl = 'max-age=31536000, immutable', } = options;
+    return {
+        name: 'opfs-serve-range',
+        order,
+        async fetch(event, logger) {
+            const request = event.request;
+            const rangeHeader = request.headers.get(HEADER_RANGE);
+            if (!rangeHeader) {
+                return;
+            }
+            if (request.method !== 'GET') {
+                return;
+            }
+            if (!shouldProcessFile(request.url, include, exclude)) {
+                if (enableLogging) {
+                    logger.debug(`opfsServeRange: skip ${request.url} (filtered by include/exclude)`);
+                }
+                return;
+            }
+            const url = request.url;
+            let key;
+            try {
+                key = await urlToOpfsKey(url);
+            }
+            catch (err) {
+                if (enableLogging) {
+                    logger.error(`opfsServeRange: hash failed for ${url}`, err);
+                }
+                return;
+            }
+            const root = await navigator.storage.getDirectory();
+            let dir;
+            try {
+                dir = await getOpfsDir(root, false);
+            }
+            catch {
+                if (enableLogging) {
+                    logger.debug(`opfsServeRange: no plugin dir in OPFS for ${url}`);
+                }
+                return;
+            }
+            let fileHandle;
+            try {
+                fileHandle = await dir.getFileHandle(key);
+            }
+            catch {
+                if (enableLogging) {
+                    logger.debug(`opfsServeRange: no file in OPFS for ${url}`);
+                }
+                return;
+            }
+            const file = await fileHandle.getFile();
+            const { metadata, bodySize } = await getMetadataFromFileFooter(file);
+            const size = metadata?.size ?? bodySize;
+            const type = metadata?.type ?? MIME_APPLICATION_OCTET_STREAM;
+            const ifRangeHeader = request.headers.get(HEADER_IF_RANGE);
+            if (ifRangeHeader &&
+                metadata &&
+                !ifRangeMatches(ifRangeHeader, metadata)) {
+                if (enableLogging) {
+                    logger.debug(`opfsServeRange: If-Range mismatch for ${url}, passing through`);
+                }
+                return;
+            }
+            try {
+                const range = parseRangeHeader(rangeHeader, size);
+                const blob = file.slice(range.start, range.end + 1);
+                const response = build206Response(blob, range, size, {
+                    type,
+                    ...(metadata?.etag && { etag: metadata.etag }),
+                    ...(metadata?.lastModified && {
+                        lastModified: metadata.lastModified,
+                    }),
+                    ...(rangeResponseCacheControl && {
+                        cacheControl: rangeResponseCacheControl,
+                    }),
+                });
+                if (metadata && event.waitUntil) {
+                    event.waitUntil(updateLastAccessedInBackground(fileHandle, metadata, bodySize));
+                }
+                if (enableLogging) {
+                    logger.debug(`opfsServeRange: 206 for ${url} bytes ${range.start}-${range.end}`);
+                }
+                return response;
+            }
+            catch (err) {
+                if (enableLogging) {
+                    logger.error(`opfsServeRange: error for ${url}`, err);
+                }
+                return;
+            }
+        },
+    };
+}
+export { parseRangeHeader, build206Response, build206ResponseFromStream, createRangeExtractTransform, } from './opfsRangeUtil.js';
+export { writeToOpfs, metadataFromResponse } from './opfsWrite.js';
+export { opfsPrecache } from './opfsPrecache.js';
+export { opfsRangeFromNetworkAndCache } from './opfsRangeFromNetworkAndCache.js';
+export { opfsBackgroundFetch } from './opfsBackgroundFetch.js';

package/dist/opfsBackgroundFetch.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from '@budarin/pluggable-serviceworker';
+export interface OpfsBackgroundFetchOptions {
+    order?: number;
+    include?: string[];
+    exclude?: string[];
+    enableLogging?: boolean;
+}
+export declare function opfsBackgroundFetch(options?: OpfsBackgroundFetchOptions): Plugin | undefined;

package/dist/opfsBackgroundFetch.js

@@ -0,0 +1,75 @@
+import { notifyClients } from '@budarin/pluggable-serviceworker/utils';
+import { getOpfsDir, urlToOpfsKey } from './index.js';
+import { isOpfsAvailable, shouldProcessFile } from './opfsUtil.js';
+import { writeToOpfs, metadataFromResponse } from './opfsWrite.js';
+import { isBlacklisted } from './opfsLru.js';
+import { OPFS_MSG_SKIP_QUOTA_EXCEEDED } from './opfsMessages.js';
+export function opfsBackgroundFetch(options = {}) {
+    if (!isOpfsAvailable()) {
+        return undefined;
+    }
+    const { order = 0, include, exclude, enableLogging = false } = options;
+    return {
+        name: 'opfs-background-fetch',
+        order,
+        async backgroundfetchsuccess(event, logger) {
+            const root = await navigator.storage.getDirectory();
+            const dir = await getOpfsDir(root, true);
+            const records = await event.registration.matchAll();
+            for (const record of records) {
+                const url = record.request.url;
+                if (!shouldProcessFile(url, include, exclude)) {
+                    if (enableLogging) {
+                        logger.debug(`opfsBackgroundFetch: skip ${url} (filtered by include/exclude)`);
+                    }
+                    continue;
+                }
+                if (isBlacklisted(url)) {
+                    notifyClients(OPFS_MSG_SKIP_QUOTA_EXCEEDED, { url });
+                    if (enableLogging) {
+                        logger.debug(`opfsBackgroundFetch: skip ${url} (blacklisted, quota exceeded)`);
+                    }
+                    continue;
+                }
+                const response = await record.responseReady;
+                if (!response.ok || !response.body) {
+                    if (enableLogging) {
+                        logger.debug(`opfsBackgroundFetch: skip ${url} (not ok or no body)`);
+                    }
+                    continue;
+                }
+                try {
+                    const key = await urlToOpfsKey(url);
+                    const metadata = metadataFromResponse(response, url);
+                    await writeToOpfs(dir, key, response.body, metadata, {
+                        url,
+                        ...(metadata.size > 0 && { knownSize: metadata.size }),
+                    });
+                    if (enableLogging) {
+                        logger.debug(`opfsBackgroundFetch: cached ${url} -> ${key} (${metadata.size} bytes)`);
+                    }
+                }
+                catch (err) {
+                    if (enableLogging) {
+                        logger.error(`opfsBackgroundFetch: write failed ${record.request.url}`, err);
+                    }
+                }
+            }
+        },
+        async backgroundfetchfail(event, logger) {
+            if (enableLogging) {
+                logger.warn(`opfsBackgroundFetch: background fetch failed, id=${event.registration.id}`);
+            }
+        },
+        async backgroundfetchabort(event, logger) {
+            if (enableLogging) {
+                logger.debug(`opfsBackgroundFetch: background fetch aborted, id=${event.registration.id}`);
+            }
+        },
+        async backgroundfetchclick(event, logger) {
+            if (enableLogging) {
+                logger.debug(`opfsBackgroundFetch: user clicked download UI, id=${event.registration.id}`);
+            }
+        },
+    };
+}

package/dist/opfsCacheOnFetch.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from '@budarin/pluggable-serviceworker';
+export interface OpfsCacheOnFetchOptions {
+    order?: number;
+    include?: string[];
+    exclude?: string[];
+    enableLogging?: boolean;
+}
+export declare function opfsCacheOnFetch(options?: OpfsCacheOnFetchOptions): Plugin;

package/dist/opfsCacheOnFetch.js

@@ -0,0 +1,153 @@
+import { HEADER_RANGE } from '@budarin/http-constants/headers';
+import { getOpfsDir, urlToOpfsKey } from './index.js';
+import { parseRangeHeader, build206Response, build206ResponseFromStream, createRangeExtractTransform, } from './opfsRangeUtil.js';
+import { writeToOpfs, metadataFromResponse } from './opfsWrite.js';
+import { shouldProcessFile } from './opfsUtil.js';
+const loadingUrls = new Set();
+async function backgroundFullFetchToOpfs(url, logger, enableLogging) {
+    try {
+        const fullRequest = new Request(url, { method: 'GET' });
+        const response = await fetch(fullRequest);
+        if (!response.ok || !response.body) {
+            if (enableLogging) {
+                logger.debug(`opfsCacheOnFetch: background full GET ${url} -> ${response.status}, skip cache`);
+            }
+            return;
+        }
+        if (response.status !== 200) {
+            if (enableLogging) {
+                logger.debug(`opfsCacheOnFetch: background full GET ${url} -> ${response.status}, skip cache`);
+            }
+            return;
+        }
+        const metadata = metadataFromResponse(response);
+        const key = await urlToOpfsKey(url);
+        const root = await navigator.storage.getDirectory();
+        const dir = await getOpfsDir(root, true);
+        await writeToOpfs(dir, key, response.body, metadata);
+        if (enableLogging) {
+            logger.debug(`opfsCacheOnFetch: background cached ${url} -> ${key} (${metadata.size} bytes)`);
+        }
+    }
+    catch (err) {
+        if (enableLogging) {
+            logger.error(`opfsCacheOnFetch: background full GET failed ${url}`, err);
+        }
+    }
+    finally {
+        loadingUrls.delete(url);
+    }
+}
+export function opfsCacheOnFetch(options = {}) {
+    const { order = -10, include, exclude, enableLogging = false, } = options;
+    return {
+        name: 'opfs-cache-on-fetch',
+        order,
+        async fetch(event, logger) {
+            const request = event.request;
+            if (request.method !== 'GET') {
+                return;
+            }
+            if (!shouldProcessFile(request.url, include, exclude)) {
+                return;
+            }
+            const url = request.url;
+            const rangeHeader = request.headers.get(HEADER_RANGE);
+            if (!rangeHeader) {
+                try {
+                    const response = await fetch(request);
+                    if (!response.ok || !response.body) {
+                        return response;
+                    }
+                    if (response.status !== 200) {
+                        return response;
+                    }
+                    const metadata = metadataFromResponse(response);
+                    const key = await urlToOpfsKey(url);
+                    const root = await navigator.storage.getDirectory();
+                    const dir = await getOpfsDir(root, true);
+                    const [branch1, branch2] = response.body.tee();
+                    writeToOpfs(dir, key, branch2, metadata).catch((err) => {
+                        if (enableLogging) {
+                            logger.error(`opfsCacheOnFetch: write failed ${url}`, err);
+                        }
+                    });
+                    if (enableLogging) {
+                        logger.debug(`opfsCacheOnFetch: caching full GET ${url} (${metadata.size} bytes)`);
+                    }
+                    return new Response(branch1, {
+                        status: response.status,
+                        statusText: response.statusText,
+                        headers: response.headers,
+                    });
+                }
+                catch {
+                    return;
+                }
+            }
+            try {
+                const response = await fetch(request);
+                if (!response.body) {
+                    return response;
+                }
+                if (response.status === 206) {
+                    if (!loadingUrls.has(url)) {
+                        loadingUrls.add(url);
+                        backgroundFullFetchToOpfs(url, logger, enableLogging);
+                    }
+                    return new Response(response.body, {
+                        status: response.status,
+                        statusText: response.statusText,
+                        headers: response.headers,
+                    });
+                }
+                if (response.status === 416) {
+                    return response;
+                }
+                if (response.status === 200) {
+                    const contentLength = response.headers.get('Content-Length');
+                    const fullSize = contentLength
+                        ? parseInt(contentLength, 10)
+                        : 0;
+                    const type = response.headers.get('Content-Type') ??
+                        'application/octet-stream';
+                    const etag = response.headers.get('ETag') ?? undefined;
+                    const lastModified = response.headers.get('Last-Modified') ?? undefined;
+                    if (fullSize > 0 &&
+                        Number.isInteger(fullSize)) {
+                        const range = parseRangeHeader(rangeHeader, fullSize);
+                        const metadata = metadataFromResponse(response);
+                        const key = await urlToOpfsKey(url);
+                        const root = await navigator.storage.getDirectory();
+                        const dir = await getOpfsDir(root, true);
+                        const [branch1, branch2] = response.body.tee();
+                        writeToOpfs(dir, key, branch2, metadata).catch((err) => {
+                            if (enableLogging) {
+                                logger.error(`opfsCacheOnFetch: write failed ${url}`, err);
+                            }
+                        });
+                        const rangeStream = branch1.pipeThrough(createRangeExtractTransform(range));
+                        return build206ResponseFromStream(rangeStream, range, fullSize, {
+                            type,
+                            ...(etag && { etag }),
+                            ...(lastModified && { lastModified }),
+                        });
+                    }
+                    const blob = await response.blob();
+                    const size = blob.size;
+                    const range = parseRangeHeader(rangeHeader, size);
+                    const rangeBlob = blob.slice(range.start, range.end + 1);
+                    return build206Response(rangeBlob, range, size, {
+                        type,
+                        ...(etag && { etag }),
+                        ...(lastModified && { lastModified }),
+                    });
+                }
+                return response;
+            }
+            catch {
+                return;
+            }
+        },
+    };
+}

package/dist/opfsFormat.d.ts

@@ -0,0 +1,14 @@
+export declare const OPFS_FOLDER_NAME = "range-requests-cache";
+export declare const OPFS_META_FOOTER_LENGTH = 4;
+export declare const MAX_META_JSON_BYTES = 2048;
+export declare const KILOBYTE = 1024;
+export declare const MEGABYTE: number;
+export declare const GIGABYTE: number;
+export interface OpfsMetadata {
+    url: string;
+    size: number;
+    type?: string;
+    etag?: string;
+    lastModified?: string;
+    lastAccessed?: number;
+}

package/dist/opfsFormat.js

@@ -0,0 +1,6 @@
+export const OPFS_FOLDER_NAME = 'range-requests-cache';
+export const OPFS_META_FOOTER_LENGTH = 4;
+export const MAX_META_JSON_BYTES = 2048;
+export const KILOBYTE = 1024;
+export const MEGABYTE = 1024 * 1024;
+export const GIGABYTE = 1024 * 1024 * 1024;

package/dist/opfsLru.d.ts

@@ -0,0 +1,28 @@
+export interface CacheFileEntry {
+    key: string;
+    size: number;
+    lastAccessed: number;
+}
+export interface StorageEstimate {
+    quota: number;
+    usage: number;
+}
+export declare function isBlacklisted(url: string): boolean;
+export declare function addToBlacklist(url: string): void;
+export declare function getStorageEstimate(): Promise<StorageEstimate>;
+export declare function getCacheLimit(estimate: StorageEstimate): number;
+export declare function listCacheFilesWithMeta(dir: FileSystemDirectoryHandle): Promise<CacheFileEntry[]>;
+export declare function getTotalCacheSize(entries: CacheFileEntry[]): number;
+export declare function computeEvictionSet(entries: CacheFileEntry[], needToFree: number): string[];
+export declare function evictFiles(dir: FileSystemDirectoryHandle, keys: string[]): Promise<void>;
+export type EnsureSpaceResult = {
+    ok: true;
+    evictedKeys?: string[];
+} | {
+    ok: false;
+    reason: string;
+};
+export interface EnsureSpaceOptions {
+    onEvicted?: (keys: string[]) => void;
+}
+export declare function ensureSpaceForWrite(dir: FileSystemDirectoryHandle, newFileSize: number, options?: EnsureSpaceOptions): Promise<EnsureSpaceResult>;

package/dist/opfsLru.js

@@ -0,0 +1,112 @@
+import { OPFS_META_FOOTER_LENGTH, MAX_META_JSON_BYTES, } from './opfsFormat.js';
+import { getMaxCacheFraction } from './opfsUtil.js';
+const blacklist = new Set();
+export function isBlacklisted(url) {
+    return blacklist.has(url);
+}
+export function addToBlacklist(url) {
+    blacklist.add(url);
+}
+export async function getStorageEstimate() {
+    const est = await navigator.storage.estimate();
+    return {
+        quota: est.quota ?? 0,
+        usage: est.usage ?? 0,
+    };
+}
+export function getCacheLimit(estimate) {
+    const fraction = getMaxCacheFraction();
+    const byFraction = Math.floor(estimate.quota * fraction);
+    const byAvailable = estimate.quota - estimate.usage;
+    return Math.max(0, Math.min(byFraction, byAvailable));
+}
+async function readMetaFromFile(file) {
+    const size = file.size;
+    if (size < OPFS_META_FOOTER_LENGTH) {
+        return { size, lastAccessed: 0 };
+    }
+    const footerBlob = file.slice(size - OPFS_META_FOOTER_LENGTH, size);
+    const footerBuf = await footerBlob.arrayBuffer();
+    const metaLen = new DataView(footerBuf).getUint32(0, true);
+    if (metaLen === 0 ||
+        metaLen > MAX_META_JSON_BYTES ||
+        metaLen > size - OPFS_META_FOOTER_LENGTH) {
+        return { size, lastAccessed: 0 };
+    }
+    try {
+        const jsonBlob = file.slice(size - OPFS_META_FOOTER_LENGTH - metaLen, size - OPFS_META_FOOTER_LENGTH);
+        const text = await jsonBlob.text();
+        const metadata = JSON.parse(text);
+        return {
+            size,
+            lastAccessed: metadata.lastAccessed ?? 0,
+        };
+    }
+    catch {
+        return { size, lastAccessed: 0 };
+    }
+}
+export async function listCacheFilesWithMeta(dir) {
+    const entries = [];
+    for await (const [name, handle] of dir.entries()) {
+        if (handle.kind === 'file') {
+            try {
+                const file = await handle.getFile();
+                const { size, lastAccessed } = await readMetaFromFile(file);
+                entries.push({ key: name, size, lastAccessed });
+            }
+            catch {
+            }
+        }
+    }
+    return entries;
+}
+export function getTotalCacheSize(entries) {
+    return entries.reduce((sum, e) => sum + e.size, 0);
+}
+export function computeEvictionSet(entries, needToFree) {
+    if (needToFree <= 0) {
+        return [];
+    }
+    const sorted = [...entries].sort((a, b) => a.lastAccessed - b.lastAccessed);
+    const toDelete = [];
+    let freed = 0;
+    for (const e of sorted) {
+        if (freed >= needToFree) {
+            break;
+        }
+        toDelete.push(e.key);
+        freed += e.size;
+    }
+    return toDelete;
+}
+export async function evictFiles(dir, keys) {
+    for (const key of keys) {
+        try {
+            await dir.removeEntry(key);
+        }
+        catch {
+        }
+    }
+}
+export async function ensureSpaceForWrite(dir, newFileSize, options = {}) {
+    const { onEvicted } = options;
+    const estimate = await getStorageEstimate();
+    const limit = getCacheLimit(estimate);
+    const entries = await listCacheFilesWithMeta(dir);
+    const totalSize = getTotalCacheSize(entries);
+    const needToFree = Math.max(0, totalSize + newFileSize - limit, estimate.usage + newFileSize - estimate.quota);
+    if (needToFree === 0) {
+        return { ok: true };
+    }
+    if (needToFree > totalSize) {
+        return {
+            ok: false,
+            reason: 'File does not fit even after full eviction',
+        };
+    }
+    const keysToDelete = computeEvictionSet(entries, needToFree);
+    await evictFiles(dir, keysToDelete);
+    onEvicted?.(keysToDelete);
+    return { ok: true, evictedKeys: keysToDelete };
+}

package/dist/opfsMessages.d.ts

@@ -0,0 +1,7 @@
+export declare const OPFS_MSG_QUOTA_EXCEEDED = "OPFS_QUOTA_EXCEEDED";
+export declare const OPFS_MSG_WRITE_SKIPPED_SIZE = "OPFS_WRITE_SKIPPED_SIZE";
+export declare const OPFS_MSG_CACHE_LIMIT_REACHED = "OPFS_CACHE_LIMIT_REACHED";
+export declare const OPFS_MSG_EVICTION_COMPLETED = "OPFS_EVICTION_COMPLETED";
+export declare const OPFS_MSG_WRITE_FAILED = "OPFS_WRITE_FAILED";
+export declare const OPFS_MSG_SKIP_QUOTA_EXCEEDED = "OPFS_SKIP_QUOTA_EXCEEDED";
+export type OpfsMessageType = typeof OPFS_MSG_QUOTA_EXCEEDED | typeof OPFS_MSG_WRITE_SKIPPED_SIZE | typeof OPFS_MSG_CACHE_LIMIT_REACHED | typeof OPFS_MSG_EVICTION_COMPLETED | typeof OPFS_MSG_WRITE_FAILED | typeof OPFS_MSG_SKIP_QUOTA_EXCEEDED;

package/dist/opfsMessages.js

@@ -0,0 +1,6 @@
+export const OPFS_MSG_QUOTA_EXCEEDED = 'OPFS_QUOTA_EXCEEDED';
+export const OPFS_MSG_WRITE_SKIPPED_SIZE = 'OPFS_WRITE_SKIPPED_SIZE';
+export const OPFS_MSG_CACHE_LIMIT_REACHED = 'OPFS_CACHE_LIMIT_REACHED';
+export const OPFS_MSG_EVICTION_COMPLETED = 'OPFS_EVICTION_COMPLETED';
+export const OPFS_MSG_WRITE_FAILED = 'OPFS_WRITE_FAILED';
+export const OPFS_MSG_SKIP_QUOTA_EXCEEDED = 'OPFS_SKIP_QUOTA_EXCEEDED';

package/dist/opfsPrecache.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from '@budarin/pluggable-serviceworker';
+export interface OpfsPrecacheOptions {
+    urls: string[] | (() => Promise<string[]>);
+    order?: number;
+    enableLogging?: boolean;
+}
+export declare function opfsPrecache(options: OpfsPrecacheOptions): Plugin | undefined;

package/dist/opfsPrecache.js

@@ -0,0 +1,46 @@
+import { getOpfsDir, urlToOpfsKey } from './index.js';
+import { isOpfsAvailable } from './opfsUtil.js';
+import { writeToOpfs, metadataFromResponse } from './opfsWrite.js';
+export function opfsPrecache(options) {
+    if (!isOpfsAvailable()) {
+        return undefined;
+    }
+    const { urls, order = 0, enableLogging = false } = options;
+    return {
+        name: 'opfs-precache',
+        order,
+        async install(_event, logger) {
+            const list = typeof urls === 'function' ? await urls() : urls;
+            if (list.length === 0) {
+                return;
+            }
+            const root = await navigator.storage.getDirectory();
+            const dir = await getOpfsDir(root, true);
+            for (const url of list) {
+                try {
+                    const response = await fetch(url);
+                    if (!response.ok || !response.body) {
+                        if (enableLogging) {
+                            logger.warn(`opfsPrecache: skip ${url} (status ${response.status} or no body)`);
+                        }
+                        continue;
+                    }
+                    const metadata = metadataFromResponse(response, url);
+                    const key = await urlToOpfsKey(url);
+                    await writeToOpfs(dir, key, response.body, metadata, {
+                        url,
+                        ...(metadata.size > 0 && { knownSize: metadata.size }),
+                    });
+                    if (enableLogging) {
+                        logger.debug(`opfsPrecache: cached ${url} -> ${key} (${metadata.size} bytes)`);
+                    }
+                }
+                catch (err) {
+                    if (enableLogging) {
+                        logger.error(`opfsPrecache: failed ${url}`, err);
+                    }
+                }
+            }
+        },
+    };
+}