update electron to v43

electron/node_modules/app-builder-lib/out/util/cacheState.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheState = void 0;
+exports.readCacheStateFile = readCacheStateFile;
+exports.writeCacheState = writeCacheState;
+exports.computeCacheMetadata = computeCacheMetadata;
+exports.validateCacheDirectory = validateCacheDirectory;
+exports.cleanupCacheDirectory = cleanupCacheDirectory;
+const builder_util_1 = require("builder-util");
+const fs = require("fs/promises");
+const path = require("path");
+var CacheState;
+(function (CacheState) {
+    CacheState["pending"] = "pending";
+    CacheState["downloaded"] = "downloaded";
+    CacheState["extracting"] = "extracting";
+    CacheState["extracted"] = "extracted";
+    CacheState["complete"] = "complete";
+    CacheState["corrupted"] = "corrupted";
+})(CacheState || (exports.CacheState = CacheState = {}));
+const STATE_FILE_VERSION = 1;
+const STALE_EXTRACTING_TIMEOUT_MS = 120000; // 120 seconds
+function getStateFilePath(extractDir) {
+    return `${extractDir}.state`;
+}
+async function readCacheStateFile(extractDir) {
+    const stateFile = getStateFilePath(extractDir);
+    let content;
+    try {
+        content = await fs.readFile(stateFile, "utf-8");
+    }
+    catch (e) {
+        if (e.code !== "ENOENT") {
+            builder_util_1.log.warn({ stateFile, error: e.message }, "Failed to read cache state file");
+        }
+        return null;
+    }
+    try {
+        const data = JSON.parse(content);
+        if (data.version !== STATE_FILE_VERSION) {
+            builder_util_1.log.warn({ stateFile, version: data.version, expected: STATE_FILE_VERSION }, "Cache state file version mismatch, ignoring");
+            return null;
+        }
+        if (data.state === CacheState.extracting) {
+            const age = Date.now() - data.timestamp;
+            if (age > STALE_EXTRACTING_TIMEOUT_MS) {
+                builder_util_1.log.warn({ stateFile, age }, "Detected stale extracting state, marking as corrupted");
+                return { ...data, state: CacheState.corrupted };
+            }
+        }
+        return data;
+    }
+    catch (e) {
+        builder_util_1.log.warn({ stateFile, error: e.message }, "Failed to parse cache state file");
+        return null;
+    }
+}
+async function writeCacheState(extractDir, state, metadata, throwOnError = false) {
+    var _a, _b;
+    const stateFile = getStateFilePath(extractDir);
+    const stateData = {
+        version: STATE_FILE_VERSION,
+        state,
+        timestamp: Date.now(),
+        fileCount: (_a = metadata === null || metadata === void 0 ? void 0 : metadata.fileCount) !== null && _a !== void 0 ? _a : 0,
+        extractedSize: (_b = metadata === null || metadata === void 0 ? void 0 : metadata.extractedSize) !== null && _b !== void 0 ? _b : 0,
+    };
+    try {
+        await fs.writeFile(stateFile, JSON.stringify(stateData, null, 2), "utf-8");
+    }
+    catch (e) {
+        builder_util_1.log.warn({ stateFile, error: e.message }, "Failed to write cache state file");
+        if (throwOnError) {
+            throw e;
+        }
+    }
+}
+async function computeCacheMetadata(dir) {
+    let fileCount = 0;
+    let extractedSize = 0;
+    const stack = [dir];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+            }
+            else {
+                fileCount++;
+                if (entry.isFile()) {
+                    try {
+                        const stat = await fs.stat(fullPath);
+                        extractedSize += stat.size;
+                    }
+                    catch {
+                        // ignore stat errors for individual files
+                    }
+                }
+            }
+        }
+    }
+    return { fileCount, extractedSize };
+}
+async function validateCacheDirectory(extractDir, expectedFileCount) {
+    try {
+        const topLevel = await fs.readdir(extractDir);
+        if (topLevel.length === 0) {
+            return false;
+        }
+        if (expectedFileCount != null && expectedFileCount > 0) {
+            const { fileCount: actual } = await computeCacheMetadata(extractDir);
+            if (actual < expectedFileCount) {
+                builder_util_1.log.warn({ extractDir, expected: expectedFileCount, actual }, "Cache file count mismatch (fewer files than expected), treating as invalid");
+                return false;
+            }
+        }
+        return true;
+    }
+    catch (e) {
+        builder_util_1.log.warn({ extractDir, error: e.message }, "Failed to validate cache directory");
+        return false;
+    }
+}
+async function cleanupCacheDirectory(extractDir, { skipLockFiles = false } = {}) {
+    const filesToClean = [extractDir, `${extractDir}.state`, `${extractDir}.tmp`, ...(!skipLockFiles ? [`${extractDir}.lock`, `${extractDir}.tmp.lock`] : [])];
+    for (const file of filesToClean) {
+        try {
+            await fs.rm(file, { recursive: true, force: true });
+        }
+        catch (e) {
+            builder_util_1.log.warn({ file, error: e.message }, "Failed to clean up cache file");
+        }
+    }
+}
+//# sourceMappingURL=cacheState.js.map