glimmervoid 0.29.1 → 0.31.0

package/dist/chunks/json-file-oEH9vt-0.js

@@ -0,0 +1,352 @@
+import { a as isMissingFileError, r as errorMessage } from "./text-DoirglWV.js";
+import { r as nextBackoffMs } from "./backoff-DjVpfHk7.js";
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+//#region server/spawn-gate.ts
+var QUEUE_ADMISSION_TIMED_OUT = "serial-queue-admission-timed-out";
+function isQueueAdmissionTimeout(error) {
+	return error instanceof Error && error.message === "serial-queue-admission-timed-out";
+}
+function createSerialQueue() {
+	let tail = Promise.resolve();
+	function run(fn, options = {}) {
+		let abandoned = false;
+		let started = false;
+		const result = tail.then(() => {
+			if (abandoned) throw new Error(QUEUE_ADMISSION_TIMED_OUT);
+			started = true;
+			return fn();
+		});
+		tail = result.then(() => void 0, () => void 0);
+		const admissionTimeoutMs = options.admissionTimeoutMs;
+		if (admissionTimeoutMs === void 0) return result;
+		return new Promise((resolve, reject) => {
+			const admissionTimer = setTimeout(() => {
+				if (started) return;
+				abandoned = true;
+				reject(/* @__PURE__ */ new Error(QUEUE_ADMISSION_TIMED_OUT));
+			}, admissionTimeoutMs);
+			result.then((value) => {
+				clearTimeout(admissionTimer);
+				resolve(value);
+			}, (error) => {
+				clearTimeout(admissionTimer);
+				reject(error);
+			});
+		});
+	}
+	return {
+		run,
+		idle: () => tail
+	};
+}
+function createKeyedSerialQueue() {
+	const queuesByKey = /* @__PURE__ */ new Map();
+	function run(key, fn) {
+		const entry = queuesByKey.get(key) ?? {
+			queue: createSerialQueue(),
+			pendingCount: 0
+		};
+		queuesByKey.set(key, entry);
+		entry.pendingCount += 1;
+		const result = entry.queue.run(fn);
+		result.then(() => void 0, () => void 0).then(() => {
+			entry.pendingCount -= 1;
+			if (entry.pendingCount === 0 && queuesByKey.get(key) === entry) queuesByKey.delete(key);
+		});
+		return result;
+	}
+	return { run };
+}
+var createSpawnGate = createSerialQueue;
+//#endregion
+//#region server/json-file.ts
+function tmpPathFor(filePath) {
+	return `${filePath}.${process.pid}.${crypto.randomBytes(8).toString("hex")}.tmp`;
+}
+function writeOptions(mode, encoding, exclusive) {
+	return {
+		encoding,
+		...mode == null ? {} : { mode },
+		...exclusive ? { flag: "wx" } : {}
+	};
+}
+var RENAME_RETRY_CODES = /* @__PURE__ */ new Set([
+	"EPERM",
+	"EACCES",
+	"EBUSY"
+]);
+var RENAME_RETRY_BASE_MS = 10;
+var RENAME_RETRY_MAX_MS = 50;
+function renameRetryDelayMs(attempt) {
+	return nextBackoffMs({
+		attempt: attempt + 1,
+		baseMs: RENAME_RETRY_BASE_MS,
+		maxMs: RENAME_RETRY_MAX_MS,
+		jitter: "none"
+	});
+}
+function isRetryableRename(error, attempt) {
+	if (attempt >= 4) return false;
+	const code = error?.code;
+	return typeof code === "string" && RENAME_RETRY_CODES.has(code);
+}
+function sleepSync(ms) {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function renameRetryPlan(error, attempt) {
+	if (!isRetryableRename(error, attempt)) return null;
+	return renameRetryDelayMs(attempt);
+}
+function decodeJsonState(text, parse) {
+	try {
+		const value = parse(JSON.parse(text));
+		if (value !== null) return { value };
+		return { error: /* @__PURE__ */ new Error("the parser rejected the file content") };
+	} catch (error) {
+		return { error };
+	}
+}
+async function loadJsonStateFile({ filePath, fsPromises = fs.promises, parse, nowMs = Date.now, quarantine = true, includeNotDir = true }) {
+	let text;
+	try {
+		text = await fsPromises.readFile(filePath, "utf8");
+	} catch (error) {
+		if (isMissingFileError(error, { includeNotDir })) return { status: "missing" };
+		return {
+			status: "unreadable",
+			error
+		};
+	}
+	const decoded = decodeJsonState(text, parse);
+	if ("value" in decoded) return {
+		status: "loaded",
+		value: decoded.value
+	};
+	if (!quarantine || !fsPromises.rename) return {
+		status: "corrupt",
+		error: decoded.error
+	};
+	const movedTo = `${filePath}.corrupt-${nowMs()}`;
+	try {
+		await fsPromises.rename(filePath, movedTo);
+	} catch (error) {
+		return {
+			status: "unreadable",
+			error
+		};
+	}
+	return {
+		status: "quarantined",
+		movedTo
+	};
+}
+function loadJsonStateFileSync({ filePath, fsSync = fs, parse, nowMs = Date.now, quarantine = true, includeNotDir = true }) {
+	let text;
+	try {
+		text = fsSync.readFileSync(filePath, "utf8");
+	} catch (error) {
+		if (isMissingFileError(error, { includeNotDir })) return { status: "missing" };
+		return {
+			status: "unreadable",
+			error
+		};
+	}
+	const decoded = decodeJsonState(text, parse);
+	if ("value" in decoded) return {
+		status: "loaded",
+		value: decoded.value
+	};
+	if (!quarantine || !fsSync.renameSync) return {
+		status: "corrupt",
+		error: decoded.error
+	};
+	const movedTo = `${filePath}.corrupt-${nowMs()}`;
+	try {
+		fsSync.renameSync(filePath, movedTo);
+	} catch (error) {
+		return {
+			status: "unreadable",
+			error
+		};
+	}
+	return {
+		status: "quarantined",
+		movedTo
+	};
+}
+function loadedJsonValue(outcome) {
+	return outcome.status === "loaded" ? outcome.value : null;
+}
+function jsonStateLoadError(outcome) {
+	if ("error" in outcome) return outcome.error;
+	return /* @__PURE__ */ new Error(`the state file is ${outcome.status}`);
+}
+function renameWithRetrySync(fsSync, tmpPath, filePath) {
+	for (let attempt = 0;; attempt += 1) try {
+		fsSync.renameSync(tmpPath, filePath);
+		return;
+	} catch (error) {
+		const delayMs = renameRetryPlan(error, attempt);
+		if (delayMs === null) throw error;
+		sleepSync(delayMs);
+	}
+}
+async function renameWithRetry(fsPromises, tmpPath, filePath) {
+	for (let attempt = 0;; attempt += 1) try {
+		await fsPromises.rename(tmpPath, filePath);
+		return;
+	} catch (error) {
+		const delayMs = renameRetryPlan(error, attempt);
+		if (delayMs === null) throw error;
+		await new Promise((resolve) => {
+			setTimeout(resolve, delayMs);
+		});
+	}
+}
+function mkdirSyncOf(fsSync) {
+	if (!fsSync.mkdirSync) throw new Error("the file system cannot create directories");
+	return fsSync.mkdirSync;
+}
+function mkdirOf(fsPromises) {
+	if (!fsPromises.mkdir) throw new Error("the file system cannot create directories");
+	return fsPromises.mkdir;
+}
+function appendFileOf(fsPromises) {
+	if (!fsPromises.appendFile) throw new Error("the file system cannot append to files");
+	return fsPromises.appendFile;
+}
+function writeTextAtomicSync(filePath, content, { mode, encoding = "utf8", mkdir = false, exclusive = false, enforceMode = false, fsSync = fs } = {}) {
+	if (mkdir) mkdirSyncOf(fsSync)(path.dirname(filePath), { recursive: true });
+	const tmpPath = tmpPathFor(filePath);
+	try {
+		fsSync.writeFileSync(tmpPath, content, writeOptions(mode, encoding, exclusive));
+		renameWithRetrySync(fsSync, tmpPath, filePath);
+	} catch (error) {
+		try {
+			fsSync.rmSync(tmpPath, { force: true });
+		} catch {}
+		throw error;
+	}
+	if (!enforceMode || mode == null || !fsSync.chmodSync) return;
+	try {
+		fsSync.chmodSync(filePath, mode);
+	} catch {}
+}
+function writeJsonAtomicSync(filePath, value, options) {
+	writeTextAtomicSync(filePath, JSON.stringify(value, null, 2), options);
+}
+async function writeTextAtomic(filePath, content, { mode, encoding = "utf8", mkdir = false, exclusive = false, enforceMode = false, fsPromises = fs.promises } = {}) {
+	if (mkdir) await mkdirOf(fsPromises)(path.dirname(filePath), { recursive: true });
+	const tmpPath = tmpPathFor(filePath);
+	try {
+		await fsPromises.writeFile(tmpPath, content, writeOptions(mode, encoding, exclusive));
+		await renameWithRetry(fsPromises, tmpPath, filePath);
+	} catch (error) {
+		try {
+			await fsPromises.rm(tmpPath, { force: true });
+		} catch {}
+		throw error;
+	}
+	if (!enforceMode || mode == null || !fsPromises.chmod) return;
+	try {
+		await fsPromises.chmod(filePath, mode);
+	} catch {}
+}
+async function writeJsonAtomic(filePath, value, options) {
+	await writeTextAtomic(filePath, JSON.stringify(value, null, 2), options);
+}
+var appendQueue = createKeyedSerialQueue();
+function appendChained(filePath, payload, { fsPromises = fs.promises, mkdir = false, encoding = "utf8", mode } = {}) {
+	return appendQueue.run(filePath, async () => {
+		if (mkdir) await mkdirOf(fsPromises)(path.dirname(filePath), { recursive: true });
+		await appendFileOf(fsPromises)(filePath, payload, writeOptions(mode, encoding, false));
+	});
+}
+function appendJsonLine(filePath, value, options) {
+	return appendChained(filePath, `${JSON.stringify(value)}\n`, options);
+}
+function appendJsonLines(filePath, values, options) {
+	if (values.length === 0) return Promise.resolve();
+	return appendChained(filePath, values.map((value) => `${JSON.stringify(value)}\n`).join(""), options);
+}
+function createJsonStateWriter({ filePath, fsPromises = fs.promises, warn = () => {} }) {
+	let signature = null;
+	const writeQueue = createSerialQueue();
+	async function commit(payload) {
+		try {
+			await writeTextAtomic(filePath, payload, {
+				fsPromises,
+				mkdir: true
+			});
+		} catch (error) {
+			warn(error);
+			signature = null;
+		}
+	}
+	async function write(subject, buildPayload) {
+		const next = JSON.stringify(subject);
+		if (next === signature) return;
+		signature = next;
+		await writeQueue.run(() => commit(buildPayload())).catch(() => {});
+	}
+	function reset() {
+		signature = null;
+	}
+	return {
+		write,
+		reset,
+		idle: () => writeQueue.idle()
+	};
+}
+function createJsonStateStore({ name, filePath, fsPromises = fs.promises, parse, adopt, nowMs = Date.now, warn = () => {} }) {
+	const writer = filePath ? createJsonStateWriter({
+		filePath,
+		fsPromises,
+		warn: (error) => warn(`${name} write failed`, { error: errorMessage(error) })
+	}) : null;
+	let isFileReadable = true;
+	let loadPromise = null;
+	function load() {
+		const statePath = filePath;
+		if (!statePath) return Promise.resolve();
+		if (loadPromise) return loadPromise;
+		loadPromise = (async () => {
+			const outcome = await loadJsonStateFile({
+				filePath: statePath,
+				fsPromises,
+				parse,
+				nowMs
+			});
+			if (outcome.status === "unreadable" || outcome.status === "corrupt") {
+				isFileReadable = false;
+				loadPromise = null;
+				warn(`${name} unreadable`, {
+					path: statePath,
+					error: errorMessage(outcome.error)
+				});
+				return;
+			}
+			if (outcome.status === "quarantined") warn(`${name} quarantined`, {
+				path: statePath,
+				movedTo: outcome.movedTo
+			});
+			isFileReadable = true;
+			adopt(loadedJsonValue(outcome));
+			writer?.reset();
+		})();
+		return loadPromise;
+	}
+	async function write(subject, buildPayload) {
+		if (!writer || !isFileReadable) return;
+		await writer.write(subject, buildPayload);
+	}
+	return {
+		load,
+		write,
+		idle: () => writer ? writer.idle() : Promise.resolve()
+	};
+}
+//#endregion
+export { isQueueAdmissionTimeout as _, jsonStateLoadError as a, loadedJsonValue as c, writeJsonAtomicSync as d, writeTextAtomic as f, createSpawnGate as g, createSerialQueue as h, createJsonStateWriter as i, sleepSync as l, createKeyedSerialQueue as m, appendJsonLines as n, loadJsonStateFile as o, writeTextAtomicSync as p, createJsonStateStore as r, loadJsonStateFileSync as s, appendJsonLine as t, writeJsonAtomic as u };