dl-once 0.0.1 → 0.0.2

package/dist/node-fs-cache-storage.js

@@ -0,0 +1,565 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _NodeFsCacheHandle_instances, _NodeFsCacheHandle_storage, _NodeFsCacheHandle_mux, _NodeFsCacheHandle_cacheDir, _NodeFsCacheHandle_assertOk, _NodeFsCacheStorage_instances, _NodeFsCacheStorage_baseDirInput, _NodeFsCacheStorage_baseDir, _NodeFsCacheStorage_mux, _NodeFsCacheStorage_isOpen, _NodeFsCacheStorage_assertOk;
+import { Asyncmux, asyncmux } from "asyncmux";
+import { tryCaptureStackTrace } from "try-capture-stack-trace";
+/**
+ * 動的にインポートされる Node.js 標準モジュールを保持するオブジェクトです。
+ */
+const modules = {};
+/**
+ * 中断理由が設定されていないことを示すための初期値シンボルです。
+ */
+const NONE = Symbol("NONE");
+/**
+ * ベースディレクトリーとキャッシュキーから、安全なキャッシュディレクトリーのパスを計算します。
+ *
+ * @param baseDir ベースとなるディレクトリーのパスです。
+ * @param cacheKey キャッシュを一意に識別するキーです。
+ * @returns 計算されたフルパスです。
+ */
+function getCacheDir(baseDir, cacheKey) {
+    const { path } = modules;
+    // キャッシュキー自体にディレクトリー区切り文字が含まれるのを防ぎます。
+    if (cacheKey.includes(path.sep)) {
+        throw new Error(`Invalid cacheKey: "${cacheKey}". Path separators are not allowed.`);
+    }
+    // フルパスを解決し、ベースディレクトリー配下に収まっているかを検証します（パストラバーサル対策）。
+    const fullPath = path.resolve(baseDir, cacheKey);
+    const relative = path.relative(baseDir, fullPath);
+    const isOutside = relative.startsWith("..");
+    if (isOutside) {
+        throw new Error("Security Error: The generated path is outside of the base directory.");
+    }
+    return fullPath;
+}
+/**
+ * Node.js のファイルシステムを使用してキャッシュを書き込むクラスです。
+ */
+let NodeFsCacheWriter = (() => {
+    var _NodeFsCacheWriter_instances, _a, _NodeFsCacheWriter_storage, _NodeFsCacheWriter_cacheDir, _NodeFsCacheWriter_reason, _NodeFsCacheWriter_isClosed, _NodeFsCacheWriter_chunkCounter, _NodeFsCacheWriter_assertOk;
+    let _instanceExtraInitializers = [];
+    let _write_decorators;
+    let _close_decorators;
+    let _abort_decorators;
+    return _a = class NodeFsCacheWriter {
+            /**
+             * インスタンスを初期化します。
+             *
+             * @param storage 所属するストレージインスタンスです。
+             * @param cacheDir 書き込み対象のディレクトリーパスです。
+             */
+            constructor(storage, cacheDir) {
+                _NodeFsCacheWriter_instances.add(this);
+                /**
+                 * ストレージの本体です。
+                 */
+                _NodeFsCacheWriter_storage.set(this, __runInitializers(this, _instanceExtraInitializers));
+                /**
+                 * 書き込み先のキャッシュディレクトリーです。
+                 */
+                _NodeFsCacheWriter_cacheDir.set(this, void 0);
+                /**
+                 * 中断された際の原因です。
+                 */
+                _NodeFsCacheWriter_reason.set(this, void 0);
+                /**
+                 * ライターが閉じられたかどうかを管理するフラグです。
+                 */
+                _NodeFsCacheWriter_isClosed.set(this, void 0);
+                /**
+                 * 書き込まれたチャンクの数をカウントします。
+                 */
+                _NodeFsCacheWriter_chunkCounter.set(this, void 0);
+                __classPrivateFieldSet(this, _NodeFsCacheWriter_storage, storage, "f");
+                __classPrivateFieldSet(this, _NodeFsCacheWriter_cacheDir, cacheDir, "f");
+                __classPrivateFieldSet(this, _NodeFsCacheWriter_reason, NONE, "f");
+                __classPrivateFieldSet(this, _NodeFsCacheWriter_isClosed, false, "f");
+                __classPrivateFieldSet(this, _NodeFsCacheWriter_chunkCounter, 0, "f");
+            }
+            /**
+             * チャンクデータをファイルとして書き込みます。
+             *
+             * @param chunkData 書き込むデータです。
+             * @returns 書き込み完了を示すプロミスです。
+             */
+            async write(chunkData) {
+                const { fs, path } = modules;
+                __classPrivateFieldGet(this, _NodeFsCacheWriter_instances, "m", _NodeFsCacheWriter_assertOk).call(this);
+                // 現在のカウンター値をインデックスとしてファイル名（0.bin, 1.bin...）を決定します。
+                const index = __classPrivateFieldGet(this, _NodeFsCacheWriter_chunkCounter, "f");
+                const chunkPath = path.join(__classPrivateFieldGet(this, _NodeFsCacheWriter_cacheDir, "f"), `${index}.bin`);
+                // データをファイルに永続化し、カウンターをインクリメントします。
+                await fs.writeFile(chunkPath, chunkData);
+                __classPrivateFieldSet(this, _NodeFsCacheWriter_chunkCounter, __classPrivateFieldGet(this, _NodeFsCacheWriter_chunkCounter, "f") + 1, "f");
+            }
+            /**
+             * 書き込みを完了し、メタデータファイルを生成してライターを閉じます。
+             *
+             * @returns 完了を示すプロミスです。
+             */
+            async close() {
+                const { fs, path } = modules;
+                __classPrivateFieldGet(this, _NodeFsCacheWriter_instances, "m", _NodeFsCacheWriter_assertOk).call(this);
+                // 書き込まれた総チャンク数をメタデータとして保存します。
+                const chunkCount = __classPrivateFieldGet(this, _NodeFsCacheWriter_chunkCounter, "f");
+                const meta = {
+                    chunkCount,
+                };
+                const metaPath = path.join(__classPrivateFieldGet(this, _NodeFsCacheWriter_cacheDir, "f"), "meta.json");
+                await fs.writeFile(metaPath, JSON.stringify(meta), "utf-8");
+                // 内部状態を更新して、以降の操作を受け付けないようにします。
+                __classPrivateFieldSet(this, _NodeFsCacheWriter_isClosed, true, "f");
+                __classPrivateFieldSet(this, _NodeFsCacheWriter_chunkCounter, 0, "f");
+            }
+            /**
+             * 書き込みを中断し、これまでに書き込んだ不完全なチャンクファイルを削除します。
+             *
+             * @param reason 中断した理由（エラーオブジェクトなど）です。
+             * @returns 中断処理完了を示すプロミスです。
+             */
+            async abort(reason) {
+                const { fs, path } = modules;
+                __classPrivateFieldGet(this, _NodeFsCacheWriter_instances, "m", _NodeFsCacheWriter_assertOk).call(this);
+                const chunkCount = __classPrivateFieldGet(this, _NodeFsCacheWriter_chunkCounter, "f");
+                __classPrivateFieldSet(this, _NodeFsCacheWriter_reason, reason, "f");
+                __classPrivateFieldSet(this, _NodeFsCacheWriter_isClosed, true, "f");
+                __classPrivateFieldSet(this, _NodeFsCacheWriter_chunkCounter, 0, "f");
+                // まだ何も書き込まれていない場合は削除処理をスキップします。
+                if (chunkCount === 0) {
+                    return;
+                }
+                // 全てのチャンクファイルを走査して削除します。
+                for (let index = 0; index < chunkCount; index++) {
+                    const chunkPath = path.join(__classPrivateFieldGet(this, _NodeFsCacheWriter_cacheDir, "f"), `${index}.bin`);
+                    await fs.rm(chunkPath, { force: true });
+                }
+            }
+        },
+        _NodeFsCacheWriter_storage = new WeakMap(),
+        _NodeFsCacheWriter_cacheDir = new WeakMap(),
+        _NodeFsCacheWriter_reason = new WeakMap(),
+        _NodeFsCacheWriter_isClosed = new WeakMap(),
+        _NodeFsCacheWriter_chunkCounter = new WeakMap(),
+        _NodeFsCacheWriter_instances = new WeakSet(),
+        _NodeFsCacheWriter_assertOk = function _NodeFsCacheWriter_assertOk() {
+            if (!__classPrivateFieldGet(this, _NodeFsCacheWriter_storage, "f").isOpen) {
+                const error = new Error("NodeFsCacheStorage is closed");
+                tryCaptureStackTrace(error, __classPrivateFieldGet(this, _NodeFsCacheWriter_instances, "m", _NodeFsCacheWriter_assertOk));
+                throw error;
+            }
+            if (__classPrivateFieldGet(this, _NodeFsCacheWriter_isClosed, "f")) {
+                if (__classPrivateFieldGet(this, _NodeFsCacheWriter_reason, "f") === NONE) {
+                    const error = new Error("NodeFsCacheWriter is closed");
+                    tryCaptureStackTrace(error, __classPrivateFieldGet(this, _NodeFsCacheWriter_instances, "m", _NodeFsCacheWriter_assertOk));
+                    throw error;
+                }
+                // 中断理由がある場合は、その理由をそのまま投げます。
+                throw __classPrivateFieldGet(this, _NodeFsCacheWriter_reason, "f");
+            }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _write_decorators = [asyncmux];
+            _close_decorators = [asyncmux];
+            _abort_decorators = [asyncmux];
+            __esDecorate(_a, null, _write_decorators, { kind: "method", name: "write", static: false, private: false, access: { has: obj => "write" in obj, get: obj => obj.write }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _close_decorators, { kind: "method", name: "close", static: false, private: false, access: { has: obj => "close" in obj, get: obj => obj.close }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _abort_decorators, { kind: "method", name: "abort", static: false, private: false, access: { has: obj => "abort" in obj, get: obj => obj.abort }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+/**
+ * 特定のキャッシュキーに対する読み書きを管理するハンドルクラスです。
+ */
+class NodeFsCacheHandle {
+    /**
+     * ハンドルを初期化します。
+     *
+     * @param storage 親ストレージです。
+     * @param mux 同期用ミューテックスです。
+     * @param cacheDir キャッシュパスです。
+     */
+    constructor(storage, mux, cacheDir) {
+        _NodeFsCacheHandle_instances.add(this);
+        /**
+         * 親ストレージインスタンスです。
+         */
+        _NodeFsCacheHandle_storage.set(this, void 0);
+        /**
+         * 排他制御用のミューテックスです。
+         */
+        _NodeFsCacheHandle_mux.set(this, void 0);
+        /**
+         * 対象のキャッシュディレクトリーパスです。
+         */
+        _NodeFsCacheHandle_cacheDir.set(this, void 0);
+        __classPrivateFieldSet(this, _NodeFsCacheHandle_storage, storage, "f");
+        __classPrivateFieldSet(this, _NodeFsCacheHandle_mux, mux, "f");
+        __classPrivateFieldSet(this, _NodeFsCacheHandle_cacheDir, cacheDir, "f");
+    }
+    /**
+     * キャッシュデータを読み取るための非同期ジェネレーターを取得します。
+     *
+     * @param args 読み取りオプション（キャンセル信号など）です。
+     * @returns チャンクを生成するジェネレーター、またはキャッシュが存在しない場合は null です。
+     */
+    async getReader(args) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const { fs, path } = modules;
+            const { signal } = args;
+            // 読み取り用の共有ロックを取得します。
+            const _1 = __addDisposableResource(env_1, await __classPrivateFieldGet(this, _NodeFsCacheHandle_mux, "f").rLock({ signal }), false);
+            __classPrivateFieldGet(this, _NodeFsCacheHandle_instances, "m", _NodeFsCacheHandle_assertOk).call(this);
+            const metaPath = path.join(__classPrivateFieldGet(this, _NodeFsCacheHandle_cacheDir, "f"), "meta.json");
+            let metaJson;
+            try {
+                // メタデータファイルを読み込み、キャッシュの整合性を確認します。
+                metaJson = await fs.readFile(metaPath, { encoding: "utf-8", signal });
+            }
+            catch (ex) {
+                // ファイルが存在しない場合はキャッシュ未作成と判断し、null を返します。
+                if (typeof ex === "object" && ex && "code" in ex && ex.code === "ENOENT") {
+                    return null;
+                }
+                throw ex;
+            }
+            const meta = JSON.parse(metaJson);
+            const chunkCount = meta.chunkCount;
+            const storage = __classPrivateFieldGet(this, _NodeFsCacheHandle_storage, "f");
+            const cacheDir = __classPrivateFieldGet(this, _NodeFsCacheHandle_cacheDir, "f");
+            /**
+             * 各チャンクファイルを順番に読み込むジェネレーター関数です。
+             */
+            async function* createReader() {
+                for (let index = 0; index < chunkCount; index++) {
+                    // 各ループでストレージの状態を再確認します。
+                    if (!storage.isOpen) {
+                        throw new Error("NodeFsCacheStorage is closed");
+                    }
+                    const chunkPath = path.join(cacheDir, `${index}.bin`);
+                    try {
+                        // チャンクファイルをバッファーとして読み込み、Uint8Array に変換して yield します。
+                        const chunkBuffer = await fs.readFile(chunkPath, { signal });
+                        const chunk = new Uint8Array(chunkBuffer.buffer, chunkBuffer.byteOffset, chunkBuffer.byteLength);
+                        yield chunk;
+                    }
+                    catch (ex) {
+                        if (typeof ex === "object" && ex && "code" in ex && ex.code === "ENOENT") {
+                            throw new Error(`Missing chunk at index ${index}`);
+                        }
+                        throw ex;
+                    }
+                }
+            }
+            return createReader();
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    }
+    /**
+     * キャッシュデータを書き込むためのライターを取得します。
+     *
+     * @param args 書き込みオプションです。
+     * @returns 書き込み用のライターインスタンスです。
+     */
+    async getWriter(args) {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const { fs } = modules;
+            const { signal } = args;
+            // 読み取り用ロックを取得（書き込み中でも構造的な競合を避けるため）します。
+            const _1 = __addDisposableResource(env_2, await __classPrivateFieldGet(this, _NodeFsCacheHandle_mux, "f").rLock({ signal }), false);
+            __classPrivateFieldGet(this, _NodeFsCacheHandle_instances, "m", _NodeFsCacheHandle_assertOk).call(this);
+            // キャッシュを格納するためのディレクトリーを作成します。
+            await fs.mkdir(__classPrivateFieldGet(this, _NodeFsCacheHandle_cacheDir, "f"), { recursive: true });
+            return new NodeFsCacheWriter(__classPrivateFieldGet(this, _NodeFsCacheHandle_storage, "f"), __classPrivateFieldGet(this, _NodeFsCacheHandle_cacheDir, "f"));
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
+    }
+}
+_NodeFsCacheHandle_storage = new WeakMap(), _NodeFsCacheHandle_mux = new WeakMap(), _NodeFsCacheHandle_cacheDir = new WeakMap(), _NodeFsCacheHandle_instances = new WeakSet(), _NodeFsCacheHandle_assertOk = function _NodeFsCacheHandle_assertOk() {
+    if (!__classPrivateFieldGet(this, _NodeFsCacheHandle_storage, "f").isOpen) {
+        const error = new Error("NodeFsCacheStorage is closed");
+        tryCaptureStackTrace(error, __classPrivateFieldGet(this, _NodeFsCacheHandle_instances, "m", _NodeFsCacheHandle_assertOk));
+        throw error;
+    }
+};
+/**
+ * Node.js のファイルシステムを基盤としたキャッシュストレージの実装です。
+ */
+export default class NodeFsCacheStorage {
+    /**
+     * インスタンスを生成します。
+     *
+     * @param baseDir キャッシュを保存するベースディレクトリーです。デフォルトは ".dl-once" です。
+     */
+    constructor(baseDir = ".dl-once") {
+        _NodeFsCacheStorage_instances.add(this);
+        /**
+         * ユーザーから渡されたベースディレクトリーの入力値です。
+         */
+        _NodeFsCacheStorage_baseDirInput.set(this, void 0);
+        /**
+         * 解決された絶対パス形式のベースディレクトリーです。
+         */
+        _NodeFsCacheStorage_baseDir.set(this, void 0);
+        /**
+         * 全体的な排他制御を司るミューテックスです。
+         */
+        _NodeFsCacheStorage_mux.set(this, void 0);
+        /**
+         * ストレージが開いているかどうかを保持します。
+         */
+        _NodeFsCacheStorage_isOpen.set(this, void 0);
+        __classPrivateFieldSet(this, _NodeFsCacheStorage_baseDirInput, baseDir, "f");
+        __classPrivateFieldSet(this, _NodeFsCacheStorage_baseDir, "", "f");
+        __classPrivateFieldSet(this, _NodeFsCacheStorage_mux, new Asyncmux(), "f");
+        __classPrivateFieldSet(this, _NodeFsCacheStorage_isOpen, false, "f");
+    }
+    /**
+     * ストレージが現在利用可能（オープン状態）かどうかを取得します。
+     */
+    get isOpen() {
+        return __classPrivateFieldGet(this, _NodeFsCacheStorage_isOpen, "f");
+    }
+    /**
+     * ストレージを初期化し、利用可能な状態にします。
+     *
+     * 必要な Node.js モジュールのインポートとベースディレクトリーの作成を行います。
+     *
+     * @param options オープン時のオプション（タイムアウト用シグナルなど）です。
+     * @returns 完了を示すプロミスです。
+     */
+    async open(options = {}) {
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            const { signal } = options;
+            // 書き込みロックを取得して排他的に初期化を行います。
+            const _ = __addDisposableResource(env_3, await __classPrivateFieldGet(this, _NodeFsCacheStorage_mux, "f").lock({ signal }), false);
+            if (__classPrivateFieldGet(this, _NodeFsCacheStorage_isOpen, "f")) {
+                throw new Error("Storage is already open");
+            }
+            // 実行時に Node.js 標準モジュールをインポートします。
+            const [fs, path] = await Promise.all([import("node:fs/promises"), import("node:path")]);
+            modules.fs = fs;
+            modules.path = path;
+            // ベースディレクトリーのパスを絶対パスとして確定させます。
+            __classPrivateFieldSet(this, _NodeFsCacheStorage_baseDir, path.resolve(__classPrivateFieldGet(this, _NodeFsCacheStorage_baseDirInput, "f")), "f");
+            // ストレージのルートディレクトリーを作成します。
+            await fs.mkdir(__classPrivateFieldGet(this, _NodeFsCacheStorage_baseDir, "f"), { recursive: true });
+            __classPrivateFieldSet(this, _NodeFsCacheStorage_isOpen, true, "f");
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
+        }
+        finally {
+            __disposeResources(env_3);
+        }
+    }
+    /**
+     * ストレージを閉じ、以降の操作を無効化します。
+     *
+     * @param options クローズ時のオプションです。
+     * @returns 完了を示すプロミスです。
+     */
+    async close(options = {}) {
+        const env_4 = { stack: [], error: void 0, hasError: false };
+        try {
+            const { signal } = options;
+            const _ = __addDisposableResource(env_4, await __classPrivateFieldGet(this, _NodeFsCacheStorage_mux, "f").lock({ signal }), false);
+            __classPrivateFieldGet(this, _NodeFsCacheStorage_instances, "m", _NodeFsCacheStorage_assertOk).call(this);
+            __classPrivateFieldSet(this, _NodeFsCacheStorage_isOpen, false, "f");
+        }
+        catch (e_4) {
+            env_4.error = e_4;
+            env_4.hasError = true;
+        }
+        finally {
+            __disposeResources(env_4);
+        }
+    }
+    /**
+     * `using` 構文などで自動的にリソースを解放するためのメソッドです。
+     *
+     * @returns 完了を示すプロミスです。
+     */
+    async [(_NodeFsCacheStorage_baseDirInput = new WeakMap(), _NodeFsCacheStorage_baseDir = new WeakMap(), _NodeFsCacheStorage_mux = new WeakMap(), _NodeFsCacheStorage_isOpen = new WeakMap(), _NodeFsCacheStorage_instances = new WeakSet(), _NodeFsCacheStorage_assertOk = function _NodeFsCacheStorage_assertOk() {
+        if (!this.isOpen) {
+            const error = new Error("NodeFsCacheStorage is closed");
+            tryCaptureStackTrace(error, __classPrivateFieldGet(this, _NodeFsCacheStorage_instances, "m", _NodeFsCacheStorage_assertOk));
+            throw error;
+        }
+    }, Symbol.asyncDispose)]() {
+        const env_5 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_5, await __classPrivateFieldGet(this, _NodeFsCacheStorage_mux, "f").lock(), false);
+            __classPrivateFieldSet(this, _NodeFsCacheStorage_isOpen, false, "f");
+        }
+        catch (e_5) {
+            env_5.error = e_5;
+            env_5.hasError = true;
+        }
+        finally {
+            __disposeResources(env_5);
+        }
+    }
+    /**
+     * キャッシュの削除処理を実際に実行します。
+     *
+     * @param cacheKeyOrOptions キー文字列またはオプションオブジェクトです。
+     * @param options 追加のオプションです。
+     */
+    async clear(cacheKeyOrOptions, options = {}) {
+        const env_6 = { stack: [], error: void 0, hasError: false };
+        try {
+            const { fs } = modules;
+            // 引数の型に応じて正規化し、シグナルとキーを抽出します。
+            const { signal, cacheKey, } = typeof cacheKeyOrOptions === "object"
+                ? cacheKeyOrOptions
+                : {
+                    ...options,
+                    cacheKey: cacheKeyOrOptions,
+                };
+            const _1 = __addDisposableResource(env_6, await __classPrivateFieldGet(this, _NodeFsCacheStorage_mux, "f").lock({ signal }), false);
+            __classPrivateFieldGet(this, _NodeFsCacheStorage_instances, "m", _NodeFsCacheStorage_assertOk).call(this);
+            if (cacheKey !== undefined) {
+                // 特定のキャッシュディレクトリーのみを再帰的に削除します。
+                const cacheDir = getCacheDir(__classPrivateFieldGet(this, _NodeFsCacheStorage_baseDir, "f"), cacheKey);
+                await fs.rm(cacheDir, { recursive: true, force: true });
+            }
+            else {
+                // ストレージ全体を削除し、空のベースディレクトリーを再作成します。
+                await fs.rm(__classPrivateFieldGet(this, _NodeFsCacheStorage_baseDir, "f"), { recursive: true, force: true });
+                await fs.mkdir(__classPrivateFieldGet(this, _NodeFsCacheStorage_baseDir, "f"), { recursive: true });
+            }
+        }
+        catch (e_6) {
+            env_6.error = e_6;
+            env_6.hasError = true;
+        }
+        finally {
+            __disposeResources(env_6);
+        }
+    }
+    /**
+     * 指定されたキーに対応するキャッシュ操作ハンドルを作成します。
+     *
+     * @param key キャッシュを一意に識別するキーです。
+     * @returns キャッシュハンドルインスタンスです。
+     */
+    createCacheHandle(key) {
+        __classPrivateFieldGet(this, _NodeFsCacheStorage_instances, "m", _NodeFsCacheStorage_assertOk).call(this);
+        const cacheDir = getCacheDir(__classPrivateFieldGet(this, _NodeFsCacheStorage_baseDir, "f"), key);
+        return new NodeFsCacheHandle(this, __classPrivateFieldGet(this, _NodeFsCacheStorage_mux, "f"), cacheDir);
+    }
+}

package/dist/sha256-verification-hook.d.ts

@@ -0,0 +1,15 @@
+import HashVerificationHook from "./hash-verification-hook.js";
+/**
+ * ダウンロードされたデータの SHA-256 ハッシュ値を検証するためのフッククラスです。
+ *
+ * `hash-wasm` ライブラリーを使用して、ストリーム読み込みに合わせて逐次的にハッシュ計算を行い、完了時に期待されるハッシュ値と一致するかを判定します。
+ */
+export default class Sha256VerificationHook extends HashVerificationHook {
+    /**
+     * Sha256VerificationHook の新しいインスタンスを生成します。
+     *
+     * @param expectedHash 比較対象となる 16 進数形式の期待されるハッシュ値です。
+     */
+    constructor(expectedHash: string);
+}
+//# sourceMappingURL=sha256-verification-hook.d.ts.map

package/dist/sha256-verification-hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256-verification-hook.d.ts","sourceRoot":"","sources":["../src/sha256-verification-hook.ts"],"names":[],"mappings":"AACA,OAAO,oBAAoB,MAAM,6BAA6B,CAAC;AAE/D;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,oBAAoB;IACtE;;;;OAIG;gBACgB,YAAY,EAAE,MAAM;CAGxC"}

package/dist/sha256-verification-hook.js

@@ -0,0 +1,17 @@
+import { createSHA256 } from "hash-wasm";
+import HashVerificationHook from "./hash-verification-hook.js";
+/**
+ * ダウンロードされたデータの SHA-256 ハッシュ値を検証するためのフッククラスです。
+ *
+ * `hash-wasm` ライブラリーを使用して、ストリーム読み込みに合わせて逐次的にハッシュ計算を行い、完了時に期待されるハッシュ値と一致するかを判定します。
+ */
+export default class Sha256VerificationHook extends HashVerificationHook {
+    /**
+     * Sha256VerificationHook の新しいインスタンスを生成します。
+     *
+     * @param expectedHash 比較対象となる 16 進数形式の期待されるハッシュ値です。
+     */
+    constructor(expectedHash) {
+        super(createSHA256, expectedHash);
+    }
+}

package/package.json

@@ -1,10 +1,49 @@
 {
   "name": "dl-once",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for dl-once",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
+  "version": "0.0.2",
+  "license": "MIT",
+  "description": "Downloads only once",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "package.json",
+    "LICENSE"
+  ],
+  "homepage": "https://github.com/tai-kun/dl-once",
+  "repository": {
+    "url": "https://github.com/tai-kun/dl-once"
+  },
+  "dependencies": {
+    "@logtape/logtape": "^2.0.5",
+    "asyncmux": "^0.0.4",
+    "call-fn-once": "^0.0.4",
+    "hash-wasm": "^4.12.0",
+    "idb": "^8.0.3",
+    "try-capture-stack-trace": "^0.0.2"
+  },
+  "devDependencies": {
+    "@babel/plugin-proposal-decorators": "^7.29.0",
+    "@rolldown/plugin-babel": "^0.2.2",
+    "@tsconfig/node22": "^22.0.5",
+    "@tsconfig/strictest": "^2.0.8",
+    "@types/node": "^22.19.15",
+    "@vitest/browser": "^4.1.2",
+    "@vitest/browser-playwright": "^4.1.2",
+    "dprint": "^0.53.2",
+    "npm-check-updates": "^19.6.6",
+    "playwright": "^1.59.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.2"
+  },
+  "scripts": {
+    "build": "tsc --project ./.config/tsconfig.build.json"
+  }
 }