@milaboratories/pl-drivers 1.11.59 → 1.11.60

package/dist/drivers/download_blob/sparse_cache/cache.cjs

@@ -1,208 +1,179 @@
-'use strict';
-
-var tsHelpers = require('@milaboratories/ts-helpers');
-var fs = require('node:fs');
-var path = require('node:path');
-var ranges = require('./ranges.cjs');
-var file = require('./file.cjs');
-var helpers = require('@milaboratories/helpers');
+const require_runtime = require('../../../_virtual/_rolldown/runtime.cjs');
+const require_ranges = require('./ranges.cjs');
+const require_file = require('./file.cjs');
+let _milaboratories_ts_helpers = require("@milaboratories/ts-helpers");
+let _milaboratories_helpers = require("@milaboratories/helpers");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
 
+//#region src/drivers/download_blob/sparse_cache/cache.ts
 /** The implementer of SparseCacheRanges could throw it if ranges were corrupted. */
-class CorruptedRangesError extends Error {
-    name = "CorruptedRangesError";
-}
+var CorruptedRangesError = class extends Error {
+	name = "CorruptedRangesError";
+};
 /** Stores ranges in a directory as JSON files (the default implementation). */
-class SparseCacheFsRanges {
-    logger;
-    cacheDir;
-    constructor(logger, cacheDir) {
-        this.logger = logger;
-        this.cacheDir = cacheDir;
-    }
-    fPath(key) {
-        return path.join(this.cacheDir, ranges.rangesFileName(key));
-    }
-    async get(key) {
-        return await ranges.readRangesFile(this.logger, this.fPath(key));
-    }
-    async set(key, ranges$1) {
-        return await ranges.writeRangesFile(this.logger, this.fPath(key), ranges$1);
-    }
-    async delete(key) {
-        await fs.promises.rm(this.fPath(key));
-    }
-}
+var SparseCacheFsRanges = class {
+	constructor(logger, cacheDir) {
+		this.logger = logger;
+		this.cacheDir = cacheDir;
+	}
+	fPath(key) {
+		return node_path.default.join(this.cacheDir, require_ranges.rangesFileName(key));
+	}
+	async get(key) {
+		return await require_ranges.readRangesFile(this.logger, this.fPath(key));
+	}
+	async set(key, ranges) {
+		return await require_ranges.writeRangesFile(this.logger, this.fPath(key), ranges);
+	}
+	async delete(key) {
+		await node_fs.promises.rm(this.fPath(key));
+	}
+};
 /** Stores sparse files in a directory (the default implementation). */
-class SparseCacheFsFile {
-    logger;
-    cacheDir;
-    suffix = ".sparse.bin";
-    constructor(logger, cacheDir) {
-        this.logger = logger;
-        this.cacheDir = cacheDir;
-    }
-    async all() {
-        await tsHelpers.ensureDirExists(this.cacheDir);
-        const files = await fs.promises.readdir(this.cacheDir);
-        return files.filter((f) => f.endsWith(this.suffix));
-    }
-    async exists(key) {
-        return await tsHelpers.fileExists(this.path(key));
-    }
-    path(key) {
-        return path.join(this.cacheDir, key + this.suffix);
-    }
-    async write(key, data, from) {
-        await tsHelpers.ensureDirExists(this.cacheDir);
-        await file.writeToSparseFile(this.logger, process.platform, this.path(key), data, from);
-    }
-    async delete(key) {
-        await fs.promises.rm(this.path(key));
-    }
-}
+var SparseCacheFsFile = class {
+	suffix = ".sparse.bin";
+	constructor(logger, cacheDir) {
+		this.logger = logger;
+		this.cacheDir = cacheDir;
+	}
+	async all() {
+		await (0, _milaboratories_ts_helpers.ensureDirExists)(this.cacheDir);
+		return (await node_fs.promises.readdir(this.cacheDir)).filter((f) => f.endsWith(this.suffix));
+	}
+	async exists(key) {
+		return await (0, _milaboratories_ts_helpers.fileExists)(this.path(key));
+	}
+	path(key) {
+		return node_path.default.join(this.cacheDir, key + this.suffix);
+	}
+	async write(key, data, from) {
+		await (0, _milaboratories_ts_helpers.ensureDirExists)(this.cacheDir);
+		await require_file.writeToSparseFile(this.logger, process.platform, this.path(key), data, from);
+	}
+	async delete(key) {
+		await node_fs.promises.rm(this.path(key));
+	}
+};
 /** LRU cache for ranges of sparse files. */
-class SparseCache {
-    logger;
-    maxSize;
-    ranges;
-    storage;
-    /** Fields are public for tests. */
-    /** The lock to make sure cache requests are done one by one. */
-    lock = new helpers.functions.AwaitLock();
-    keyToLastAccessTime = new Map();
-    size = 0;
-    constructor(logger, 
-    /** The hard limit in bytes. */
-    maxSize, ranges, storage) {
-        this.logger = logger;
-        this.maxSize = maxSize;
-        this.ranges = ranges;
-        this.storage = storage;
-    }
-    /** Resets a cache's size by rereading everything we already store.
-     * Safe for concurrent use. */
-    async reset() {
-        await withLock(this.lock, async () => {
-            await this.resetUnsafe();
-        });
-    }
-    /** Returns a path to the key if the range exists in a cache, otherwise returns undefined.
-     * Safe for concurrent use. */
-    async get(key, range) {
-        return await withLock(this.lock, async () => {
-            return await this.getUnsafe(key, range);
-        });
-    }
-    /** Sets data to the cache's file and clear the cache if it's needed.
-     * Safe for concurrent use. */
-    async set(key, range, data) {
-        await withLock(this.lock, async () => {
-            await this.setUnsafe(key, range, data);
-        });
-    }
-    async resetUnsafe() {
-        this.size = 0;
-        this.keyToLastAccessTime = new Map();
-        const now = new Date();
-        // In rmKey method we first deletes the key from a storage and only then from ranges,
-        // so if something goes wrong between 2 operations,
-        // on reset the logic will be correct.
-        for (const key of await this.storage.all()) {
-            const ranges$1 = await this.ranges.get(key);
-            this.size += ranges.rangesSize(ranges$1);
-            this.keyToLastAccessTime.set(key, now);
-        }
-    }
-    async getUnsafe(key, range) {
-        // It first checks the storage, and then the ranges.
-        // In another method, when we remove a key, it first deletes a key from a storage and then from ranges,
-        // so if we don't have a key in storage but have it in ranges, the logic here is correct.
-        // We probably could reverse the operations here and there, and everywhere we work with both storage and ranges.
-        if (await this.storage.exists(key)) {
-            this.keyToLastAccessTime.set(key, new Date());
-            const ranges$1 = await this.getRanges(key);
-            if (ranges.doesRangeExist(ranges$1, range)) {
-                return this.storage.path(key);
-            }
-            return undefined;
-        }
-        return undefined;
-    }
-    async setUnsafe(key, range, data) {
-        await this.setWithoutEviction(key, range, data);
-        await this.ensureEvicted();
-    }
-    /** Sets a key and recalculates a size, but doesn't ensures that the size is less than the hard limit. */
-    async setWithoutEviction(key, range, data) {
-        if (range.to - range.from !== data.length) {
-            throw new Error(`SparseCache.set: trying to set ${key} with wrong range length: ` +
-                `range: ${JSON.stringify(range)}, data: ${data.length}`);
-        }
-        this.keyToLastAccessTime.set(key, new Date());
-        const ranges$1 = await this.getRanges(key);
-        this.size -= ranges.rangesSize(ranges$1);
-        await this.storage.write(key, data, range.from);
-        const newRanges = ranges.addRange(ranges$1, range);
-        this.size += ranges.rangesSize(newRanges);
-        await this.ranges.set(key, newRanges);
-    }
-    /** Ensures the size is less than hard limit by deleting the oldest keys. */
-    async ensureEvicted() {
-        const byTime = tsHelpers.mapEntries(this.keyToLastAccessTime);
-        byTime.sort(([_, aDate], [__, bDate]) => bDate.getTime() - aDate.getTime());
-        while (this.size > this.maxSize) {
-            const keyAndDate = byTime.pop(); // removes the oldest
-            if (!keyAndDate) {
-                break;
-            }
-            const [key, _] = keyAndDate;
-            const ranges$1 = await this.getRanges(key);
-            this.size -= ranges.rangesSize(ranges$1);
-            this.rmKey(key);
-        }
-    }
-    /** Gets ranges and if they were corrupted, then remove the file from the cache and reset the cache's size. */
-    async getRanges(key) {
-        try {
-            return await this.ranges.get(key);
-        }
-        catch (e) {
-            if (e instanceof CorruptedRangesError) {
-                // We need to reset a state of the cache and update current size,
-                // it's the only way to calculate the real size when one of the ranges were corrupted.
-                await this.rmKey(key);
-                await this.resetUnsafe();
-                return await this.ranges.get(key);
-            }
-            throw e;
-        }
-    }
-    /** Removes a key the state of the cache. The size should be updated. */
-    async rmKey(key) {
-        await this.storage.delete(key);
-        await this.ranges.delete(key);
-        this.keyToLastAccessTime.delete(key);
-    }
-    async dispose() {
-        await this.lock.acquireAsync();
-    }
-    async [Symbol.asyncDispose]() {
-        await this.dispose();
-    }
-}
+var SparseCache = class {
+	/** Fields are public for tests. */
+	/** The lock to make sure cache requests are done one by one. */
+	lock = new _milaboratories_helpers.functions.AwaitLock();
+	keyToLastAccessTime = /* @__PURE__ */ new Map();
+	size = 0;
+	constructor(logger, maxSize, ranges, storage) {
+		this.logger = logger;
+		this.maxSize = maxSize;
+		this.ranges = ranges;
+		this.storage = storage;
+	}
+	/** Resets a cache's size by rereading everything we already store.
+	* Safe for concurrent use. */
+	async reset() {
+		await withLock(this.lock, async () => {
+			await this.resetUnsafe();
+		});
+	}
+	/** Returns a path to the key if the range exists in a cache, otherwise returns undefined.
+	* Safe for concurrent use. */
+	async get(key, range) {
+		return await withLock(this.lock, async () => {
+			return await this.getUnsafe(key, range);
+		});
+	}
+	/** Sets data to the cache's file and clear the cache if it's needed.
+	* Safe for concurrent use. */
+	async set(key, range, data) {
+		await withLock(this.lock, async () => {
+			await this.setUnsafe(key, range, data);
+		});
+	}
+	async resetUnsafe() {
+		this.size = 0;
+		this.keyToLastAccessTime = /* @__PURE__ */ new Map();
+		const now = /* @__PURE__ */ new Date();
+		for (const key of await this.storage.all()) {
+			const ranges = await this.ranges.get(key);
+			this.size += require_ranges.rangesSize(ranges);
+			this.keyToLastAccessTime.set(key, now);
+		}
+	}
+	async getUnsafe(key, range) {
+		if (await this.storage.exists(key)) {
+			this.keyToLastAccessTime.set(key, /* @__PURE__ */ new Date());
+			if (require_ranges.doesRangeExist(await this.getRanges(key), range)) return this.storage.path(key);
+			return;
+		}
+	}
+	async setUnsafe(key, range, data) {
+		await this.setWithoutEviction(key, range, data);
+		await this.ensureEvicted();
+	}
+	/** Sets a key and recalculates a size, but doesn't ensures that the size is less than the hard limit. */
+	async setWithoutEviction(key, range, data) {
+		if (range.to - range.from !== data.length) throw new Error(`SparseCache.set: trying to set ${key} with wrong range length: range: ${JSON.stringify(range)}, data: ${data.length}`);
+		this.keyToLastAccessTime.set(key, /* @__PURE__ */ new Date());
+		const ranges = await this.getRanges(key);
+		this.size -= require_ranges.rangesSize(ranges);
+		await this.storage.write(key, data, range.from);
+		const newRanges = require_ranges.addRange(ranges, range);
+		this.size += require_ranges.rangesSize(newRanges);
+		await this.ranges.set(key, newRanges);
+	}
+	/** Ensures the size is less than hard limit by deleting the oldest keys. */
+	async ensureEvicted() {
+		const byTime = (0, _milaboratories_ts_helpers.mapEntries)(this.keyToLastAccessTime);
+		byTime.sort(([_, aDate], [__, bDate]) => bDate.getTime() - aDate.getTime());
+		while (this.size > this.maxSize) {
+			const keyAndDate = byTime.pop();
+			if (!keyAndDate) break;
+			const [key, _] = keyAndDate;
+			const ranges = await this.getRanges(key);
+			this.size -= require_ranges.rangesSize(ranges);
+			this.rmKey(key);
+		}
+	}
+	/** Gets ranges and if they were corrupted, then remove the file from the cache and reset the cache's size. */
+	async getRanges(key) {
+		try {
+			return await this.ranges.get(key);
+		} catch (e) {
+			if (e instanceof CorruptedRangesError) {
+				await this.rmKey(key);
+				await this.resetUnsafe();
+				return await this.ranges.get(key);
+			}
+			throw e;
+		}
+	}
+	/** Removes a key the state of the cache. The size should be updated. */
+	async rmKey(key) {
+		await this.storage.delete(key);
+		await this.ranges.delete(key);
+		this.keyToLastAccessTime.delete(key);
+	}
+	async dispose() {
+		await this.lock.acquireAsync();
+	}
+	async [Symbol.asyncDispose]() {
+		await this.dispose();
+	}
+};
 /** Acquires the lock and executes a callback. */
 async function withLock(lock, cb) {
-    try {
-        await lock.acquireAsync();
-        return await cb();
-    }
-    finally {
-        lock.release();
-    }
+	try {
+		await lock.acquireAsync();
+		return await cb();
+	} finally {
+		lock.release();
+	}
 }
 
+//#endregion
 exports.CorruptedRangesError = CorruptedRangesError;
 exports.SparseCache = SparseCache;
 exports.SparseCacheFsFile = SparseCacheFsFile;
 exports.SparseCacheFsRanges = SparseCacheFsRanges;
-//# sourceMappingURL=cache.cjs.map
+//# sourceMappingURL=cache.cjs.map

package/dist/drivers/download_blob/sparse_cache/cache.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"cache.cjs","sources":["../../../../src/drivers/download_blob/sparse_cache/cache.ts"],"sourcesContent":["import { RangeBytes } from \"@milaboratories/pl-model-common\";\nimport { ensureDirExists, fileExists, mapEntries, MiLogger } from \"@milaboratories/ts-helpers\";\nimport { promises as fs } from \"node:fs\";\nimport path from \"node:path\";\nimport {\n  addRange,\n  doesRangeExist,\n  Ranges,\n  rangesFileName,\n  rangesSize,\n  readRangesFile,\n  writeRangesFile,\n} from \"./ranges\";\nimport { writeToSparseFile } from \"./file\";\nimport { functions } from \"@milaboratories/helpers\";\n\n/** The implementer of SparseCacheRanges could throw it if ranges were corrupted. */\nexport class CorruptedRangesError extends Error {\n  name = \"CorruptedRangesError\";\n}\n\n/** Extracted ranges methods to be able to store ranges somewhere else (e.g. in memory for tests). */\nexport interface SparseCacheRanges {\n  get(key: string): Promise<Ranges>;\n  set(key: string, ranges: Ranges): Promise<void>;\n  delete(key: string): Promise<void>;\n}\n\n/** Stores ranges in a directory as JSON files (the default implementation). */\nexport class SparseCacheFsRanges implements SparseCacheRanges {\n  constructor(\n    private readonly logger: MiLogger,\n    private readonly cacheDir: string,\n  ) {}\n\n  private fPath(key: string): string {\n    return path.join(this.cacheDir, rangesFileName(key));\n  }\n\n  async get(key: string): Promise<Ranges> {\n    return await readRangesFile(this.logger, this.fPath(key));\n  }\n\n  async set(key: string, ranges: Ranges) {\n    return await writeRangesFile(this.logger, this.fPath(key), ranges);\n  }\n\n  async delete(key: string) {\n    await fs.rm(this.fPath(key));\n  }\n}\n\n/** Extracted interface for storing sparse files. */\nexport interface SparseFileStorage {\n  all(): Promise<string[]>;\n  exists(key: string): Promise<boolean>;\n  path(key: string): string;\n  write(key: string, data: Uint8Array, from: number): Promise<void>;\n  delete(key: string): Promise<void>;\n}\n\n/** Stores sparse files in a directory (the default implementation). */\nexport class SparseCacheFsFile implements SparseFileStorage {\n  private readonly suffix = \".sparse.bin\";\n\n  constructor(\n    private readonly logger: MiLogger,\n    private readonly cacheDir: string,\n  ) {}\n\n  async all(): Promise<string[]> {\n    await ensureDirExists(this.cacheDir);\n    const files = await fs.readdir(this.cacheDir);\n    return files.filter((f) => f.endsWith(this.suffix));\n  }\n\n  async exists(key: string): Promise<boolean> {\n    return await fileExists(this.path(key));\n  }\n\n  path(key: string): string {\n    return path.join(this.cacheDir, key + this.suffix);\n  }\n\n  async write(key: string, data: Uint8Array, from: number): Promise<void> {\n    await ensureDirExists(this.cacheDir);\n    await writeToSparseFile(this.logger, process.platform, this.path(key), data, from);\n  }\n\n  async delete(key: string): Promise<void> {\n    await fs.rm(this.path(key));\n  }\n}\n\n/** LRU cache for ranges of sparse files. */\nexport class SparseCache implements AsyncDisposable {\n  /** Fields are public for tests. */\n\n  /** The lock to make sure cache requests are done one by one. */\n  private lock = new functions.AwaitLock();\n\n  public keyToLastAccessTime = new Map<string, Date>();\n  public size = 0;\n\n  constructor(\n    public readonly logger: MiLogger,\n    /** The hard limit in bytes. */\n    public readonly maxSize: number,\n    public readonly ranges: SparseCacheRanges,\n    public readonly storage: SparseFileStorage,\n  ) {}\n\n  /** Resets a cache's size by rereading everything we already store.\n   * Safe for concurrent use. */\n  async reset() {\n    await withLock(this.lock, async () => {\n      await this.resetUnsafe();\n    });\n  }\n\n  /** Returns a path to the key if the range exists in a cache, otherwise returns undefined.\n   * Safe for concurrent use. */\n  async get(key: string, range: RangeBytes): Promise<string | undefined> {\n    return await withLock(this.lock, async () => {\n      return await this.getUnsafe(key, range);\n    });\n  }\n\n  /** Sets data to the cache's file and clear the cache if it's needed.\n   * Safe for concurrent use. */\n  async set(key: string, range: RangeBytes, data: Uint8Array): Promise<void> {\n    await withLock(this.lock, async () => {\n      await this.setUnsafe(key, range, data);\n    });\n  }\n\n  private async resetUnsafe() {\n    this.size = 0;\n    this.keyToLastAccessTime = new Map<string, Date>();\n\n    const now = new Date();\n    // In rmKey method we first deletes the key from a storage and only then from ranges,\n    // so if something goes wrong between 2 operations,\n    // on reset the logic will be correct.\n    for (const key of await this.storage.all()) {\n      const ranges = await this.ranges.get(key);\n      this.size += rangesSize(ranges);\n      this.keyToLastAccessTime.set(key, now);\n    }\n  }\n\n  private async getUnsafe(key: string, range: RangeBytes): Promise<string | undefined> {\n    // It first checks the storage, and then the ranges.\n    // In another method, when we remove a key, it first deletes a key from a storage and then from ranges,\n    // so if we don't have a key in storage but have it in ranges, the logic here is correct.\n    // We probably could reverse the operations here and there, and everywhere we work with both storage and ranges.\n    if (await this.storage.exists(key)) {\n      this.keyToLastAccessTime.set(key, new Date());\n\n      const ranges = await this.getRanges(key);\n      if (doesRangeExist(ranges, range)) {\n        return this.storage.path(key);\n      }\n\n      return undefined;\n    }\n\n    return undefined;\n  }\n\n  private async setUnsafe(key: string, range: { from: number; to: number }, data: Uint8Array) {\n    await this.setWithoutEviction(key, range, data);\n    await this.ensureEvicted();\n  }\n\n  /** Sets a key and recalculates a size, but doesn't ensures that the size is less than the hard limit. */\n  async setWithoutEviction(key: string, range: RangeBytes, data: Uint8Array): Promise<void> {\n    if (range.to - range.from !== data.length) {\n      throw new Error(\n        `SparseCache.set: trying to set ${key} with wrong range length: ` +\n          `range: ${JSON.stringify(range)}, data: ${data.length}`,\n      );\n    }\n\n    this.keyToLastAccessTime.set(key, new Date());\n\n    const ranges = await this.getRanges(key);\n    this.size -= rangesSize(ranges);\n\n    await this.storage.write(key, data, range.from);\n\n    const newRanges = addRange(ranges, range);\n    this.size += rangesSize(newRanges);\n\n    await this.ranges.set(key, newRanges);\n  }\n\n  /** Ensures the size is less than hard limit by deleting the oldest keys. */\n  async ensureEvicted(): Promise<void> {\n    const byTime = mapEntries(this.keyToLastAccessTime);\n    byTime.sort(([_, aDate], [__, bDate]) => bDate.getTime() - aDate.getTime());\n\n    while (this.size > this.maxSize) {\n      const keyAndDate = byTime.pop(); // removes the oldest\n      if (!keyAndDate) {\n        break;\n      }\n      const [key, _] = keyAndDate;\n\n      const ranges = await this.getRanges(key);\n      this.size -= rangesSize(ranges);\n      this.rmKey(key);\n    }\n  }\n\n  /** Gets ranges and if they were corrupted, then remove the file from the cache and reset the cache's size. */\n  private async getRanges(key: string) {\n    try {\n      return await this.ranges.get(key);\n    } catch (e: unknown) {\n      if (e instanceof CorruptedRangesError) {\n        // We need to reset a state of the cache and update current size,\n        // it's the only way to calculate the real size when one of the ranges were corrupted.\n        await this.rmKey(key);\n        await this.resetUnsafe();\n\n        return await this.ranges.get(key);\n      }\n\n      throw e;\n    }\n  }\n\n  /** Removes a key the state of the cache. The size should be updated. */\n  private async rmKey(key: string) {\n    await this.storage.delete(key);\n    await this.ranges.delete(key);\n    this.keyToLastAccessTime.delete(key);\n  }\n\n  async dispose(): Promise<void> {\n    await this.lock.acquireAsync();\n  }\n\n  async [Symbol.asyncDispose](): Promise<void> {\n    await this.dispose();\n  }\n}\n\n/** Acquires the lock and executes a callback. */\nasync function withLock<T>(lock: functions.AwaitLock, cb: () => Promise<T>): Promise<T> {\n  try {\n    await lock.acquireAsync();\n    return await cb();\n  } finally {\n    lock.release();\n  }\n}\n"],"names":["rangesFileName","readRangesFile","ranges","writeRangesFile","fs","ensureDirExists","fileExists","writeToSparseFile","functions","rangesSize","doesRangeExist","addRange","mapEntries"],"mappings":"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"}
+{"version":3,"file":"cache.cjs","names":["path","rangesFileName","readRangesFile","writeRangesFile","fs","writeToSparseFile","functions","rangesSize","doesRangeExist","addRange"],"sources":["../../../../src/drivers/download_blob/sparse_cache/cache.ts"],"sourcesContent":["import { RangeBytes } from \"@milaboratories/pl-model-common\";\nimport { ensureDirExists, fileExists, mapEntries, MiLogger } from \"@milaboratories/ts-helpers\";\nimport { promises as fs } from \"node:fs\";\nimport path from \"node:path\";\nimport {\n  addRange,\n  doesRangeExist,\n  Ranges,\n  rangesFileName,\n  rangesSize,\n  readRangesFile,\n  writeRangesFile,\n} from \"./ranges\";\nimport { writeToSparseFile } from \"./file\";\nimport { functions } from \"@milaboratories/helpers\";\n\n/** The implementer of SparseCacheRanges could throw it if ranges were corrupted. */\nexport class CorruptedRangesError extends Error {\n  name = \"CorruptedRangesError\";\n}\n\n/** Extracted ranges methods to be able to store ranges somewhere else (e.g. in memory for tests). */\nexport interface SparseCacheRanges {\n  get(key: string): Promise<Ranges>;\n  set(key: string, ranges: Ranges): Promise<void>;\n  delete(key: string): Promise<void>;\n}\n\n/** Stores ranges in a directory as JSON files (the default implementation). */\nexport class SparseCacheFsRanges implements SparseCacheRanges {\n  constructor(\n    private readonly logger: MiLogger,\n    private readonly cacheDir: string,\n  ) {}\n\n  private fPath(key: string): string {\n    return path.join(this.cacheDir, rangesFileName(key));\n  }\n\n  async get(key: string): Promise<Ranges> {\n    return await readRangesFile(this.logger, this.fPath(key));\n  }\n\n  async set(key: string, ranges: Ranges) {\n    return await writeRangesFile(this.logger, this.fPath(key), ranges);\n  }\n\n  async delete(key: string) {\n    await fs.rm(this.fPath(key));\n  }\n}\n\n/** Extracted interface for storing sparse files. */\nexport interface SparseFileStorage {\n  all(): Promise<string[]>;\n  exists(key: string): Promise<boolean>;\n  path(key: string): string;\n  write(key: string, data: Uint8Array, from: number): Promise<void>;\n  delete(key: string): Promise<void>;\n}\n\n/** Stores sparse files in a directory (the default implementation). */\nexport class SparseCacheFsFile implements SparseFileStorage {\n  private readonly suffix = \".sparse.bin\";\n\n  constructor(\n    private readonly logger: MiLogger,\n    private readonly cacheDir: string,\n  ) {}\n\n  async all(): Promise<string[]> {\n    await ensureDirExists(this.cacheDir);\n    const files = await fs.readdir(this.cacheDir);\n    return files.filter((f) => f.endsWith(this.suffix));\n  }\n\n  async exists(key: string): Promise<boolean> {\n    return await fileExists(this.path(key));\n  }\n\n  path(key: string): string {\n    return path.join(this.cacheDir, key + this.suffix);\n  }\n\n  async write(key: string, data: Uint8Array, from: number): Promise<void> {\n    await ensureDirExists(this.cacheDir);\n    await writeToSparseFile(this.logger, process.platform, this.path(key), data, from);\n  }\n\n  async delete(key: string): Promise<void> {\n    await fs.rm(this.path(key));\n  }\n}\n\n/** LRU cache for ranges of sparse files. */\nexport class SparseCache implements AsyncDisposable {\n  /** Fields are public for tests. */\n\n  /** The lock to make sure cache requests are done one by one. */\n  private lock = new functions.AwaitLock();\n\n  public keyToLastAccessTime = new Map<string, Date>();\n  public size = 0;\n\n  constructor(\n    public readonly logger: MiLogger,\n    /** The hard limit in bytes. */\n    public readonly maxSize: number,\n    public readonly ranges: SparseCacheRanges,\n    public readonly storage: SparseFileStorage,\n  ) {}\n\n  /** Resets a cache's size by rereading everything we already store.\n   * Safe for concurrent use. */\n  async reset() {\n    await withLock(this.lock, async () => {\n      await this.resetUnsafe();\n    });\n  }\n\n  /** Returns a path to the key if the range exists in a cache, otherwise returns undefined.\n   * Safe for concurrent use. */\n  async get(key: string, range: RangeBytes): Promise<string | undefined> {\n    return await withLock(this.lock, async () => {\n      return await this.getUnsafe(key, range);\n    });\n  }\n\n  /** Sets data to the cache's file and clear the cache if it's needed.\n   * Safe for concurrent use. */\n  async set(key: string, range: RangeBytes, data: Uint8Array): Promise<void> {\n    await withLock(this.lock, async () => {\n      await this.setUnsafe(key, range, data);\n    });\n  }\n\n  private async resetUnsafe() {\n    this.size = 0;\n    this.keyToLastAccessTime = new Map<string, Date>();\n\n    const now = new Date();\n    // In rmKey method we first deletes the key from a storage and only then from ranges,\n    // so if something goes wrong between 2 operations,\n    // on reset the logic will be correct.\n    for (const key of await this.storage.all()) {\n      const ranges = await this.ranges.get(key);\n      this.size += rangesSize(ranges);\n      this.keyToLastAccessTime.set(key, now);\n    }\n  }\n\n  private async getUnsafe(key: string, range: RangeBytes): Promise<string | undefined> {\n    // It first checks the storage, and then the ranges.\n    // In another method, when we remove a key, it first deletes a key from a storage and then from ranges,\n    // so if we don't have a key in storage but have it in ranges, the logic here is correct.\n    // We probably could reverse the operations here and there, and everywhere we work with both storage and ranges.\n    if (await this.storage.exists(key)) {\n      this.keyToLastAccessTime.set(key, new Date());\n\n      const ranges = await this.getRanges(key);\n      if (doesRangeExist(ranges, range)) {\n        return this.storage.path(key);\n      }\n\n      return undefined;\n    }\n\n    return undefined;\n  }\n\n  private async setUnsafe(key: string, range: { from: number; to: number }, data: Uint8Array) {\n    await this.setWithoutEviction(key, range, data);\n    await this.ensureEvicted();\n  }\n\n  /** Sets a key and recalculates a size, but doesn't ensures that the size is less than the hard limit. */\n  async setWithoutEviction(key: string, range: RangeBytes, data: Uint8Array): Promise<void> {\n    if (range.to - range.from !== data.length) {\n      throw new Error(\n        `SparseCache.set: trying to set ${key} with wrong range length: ` +\n          `range: ${JSON.stringify(range)}, data: ${data.length}`,\n      );\n    }\n\n    this.keyToLastAccessTime.set(key, new Date());\n\n    const ranges = await this.getRanges(key);\n    this.size -= rangesSize(ranges);\n\n    await this.storage.write(key, data, range.from);\n\n    const newRanges = addRange(ranges, range);\n    this.size += rangesSize(newRanges);\n\n    await this.ranges.set(key, newRanges);\n  }\n\n  /** Ensures the size is less than hard limit by deleting the oldest keys. */\n  async ensureEvicted(): Promise<void> {\n    const byTime = mapEntries(this.keyToLastAccessTime);\n    byTime.sort(([_, aDate], [__, bDate]) => bDate.getTime() - aDate.getTime());\n\n    while (this.size > this.maxSize) {\n      const keyAndDate = byTime.pop(); // removes the oldest\n      if (!keyAndDate) {\n        break;\n      }\n      const [key, _] = keyAndDate;\n\n      const ranges = await this.getRanges(key);\n      this.size -= rangesSize(ranges);\n      this.rmKey(key);\n    }\n  }\n\n  /** Gets ranges and if they were corrupted, then remove the file from the cache and reset the cache's size. */\n  private async getRanges(key: string) {\n    try {\n      return await this.ranges.get(key);\n    } catch (e: unknown) {\n      if (e instanceof CorruptedRangesError) {\n        // We need to reset a state of the cache and update current size,\n        // it's the only way to calculate the real size when one of the ranges were corrupted.\n        await this.rmKey(key);\n        await this.resetUnsafe();\n\n        return await this.ranges.get(key);\n      }\n\n      throw e;\n    }\n  }\n\n  /** Removes a key the state of the cache. The size should be updated. */\n  private async rmKey(key: string) {\n    await this.storage.delete(key);\n    await this.ranges.delete(key);\n    this.keyToLastAccessTime.delete(key);\n  }\n\n  async dispose(): Promise<void> {\n    await this.lock.acquireAsync();\n  }\n\n  async [Symbol.asyncDispose](): Promise<void> {\n    await this.dispose();\n  }\n}\n\n/** Acquires the lock and executes a callback. */\nasync function withLock<T>(lock: functions.AwaitLock, cb: () => Promise<T>): Promise<T> {\n  try {\n    await lock.acquireAsync();\n    return await cb();\n  } finally {\n    lock.release();\n  }\n}\n"],"mappings":"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"}