update electron to v43

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

@@ -1,15 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeNodeModuleFileSets = exports.computeFileSets = exports.transformFiles = exports.copyAppFiles = exports.getDestinationPath = exports.ELECTRON_COMPILE_SHIM_FILENAME = void 0;
-const bluebird_lst_1 = require("bluebird-lst");
+exports.ELECTRON_COMPILE_SHIM_FILENAME = void 0;
+exports.getDestinationPath = getDestinationPath;
+exports.copyAppFiles = copyAppFiles;
+exports.transformFiles = transformFiles;
+exports.computeFileSets = computeFileSets;
+exports.computeNodeModuleFileSets = computeNodeModuleFileSets;
 const builder_util_1 = require("builder-util");
-const fs_1 = require("builder-util/out/fs");
+const fs_extra_1 = require("fs-extra");
 const promises_1 = require("fs/promises");
 const path = require("path");
+const tiny_async_pool_1 = require("tiny-async-pool");
 const unpackDetector_1 = require("../asar/unpackDetector");
 const core_1 = require("../core");
 const fileMatcher_1 = require("../fileMatcher");
 const fileTransformer_1 = require("../fileTransformer");
+const node_module_collector_1 = require("../node-module-collector");
+const moduleManager_1 = require("../node-module-collector/moduleManager");
 const AppFileWalker_1 = require("./AppFileWalker");
 const NodeModuleCopyHelper_1 = require("./NodeModuleCopyHelper");
 const BOWER_COMPONENTS_PATTERN = `${path.sep}bower_components${path.sep}`;
@@ -19,36 +26,21 @@ function getDestinationPath(file, fileSet) {
     if (file === fileSet.src) {
         return fileSet.destination;
     }
-    else {
-        const src = fileSet.src;
-        const dest = fileSet.destination;
-        if (file.length > src.length && file.startsWith(src) && file[src.length] === path.sep) {
-            return dest + file.substring(src.length);
-        }
-        else {
-            // hoisted node_modules
-            // not lastIndexOf, to ensure that nested module (top-level module depends on) copied to parent node_modules, not to top-level directory
-            // project https://github.com/angexis/punchcontrol/commit/cf929aba55c40d0d8901c54df7945e1d001ce022
-            let index = file.indexOf(fileTransformer_1.NODE_MODULES_PATTERN);
-            if (index < 0 && file.endsWith(`${path.sep}node_modules`)) {
-                index = file.length - 13;
-            }
-            if (index < 0) {
-                throw new Error(`File "${file}" not under the source directory "${fileSet.src}"`);
-            }
-            return dest + file.substring(index);
-        }
+    const src = fileSet.src;
+    const dest = fileSet.destination;
+    // get node_modules path relative to src and then append to dest
+    if (file.startsWith(src)) {
+        return path.join(dest, path.relative(src, file));
     }
+    return dest;
 }
-exports.getDestinationPath = getDestinationPath;
 async function copyAppFiles(fileSet, packager, transformer) {
     const metadata = fileSet.metadata;
     // search auto unpacked dir
     const taskManager = new builder_util_1.AsyncTaskManager(packager.cancellationToken);
     const createdParentDirs = new Set();
-    const fileCopier = new fs_1.FileCopier(file => {
-        // https://github.com/electron-userland/electron-builder/issues/3038
-        return !(unpackDetector_1.isLibOrExe(file) || file.endsWith(".node"));
+    const fileCopier = new builder_util_1.FileCopier(file => {
+        return !(0, unpackDetector_1.isLibOrExe)(file);
     }, transformer);
     const links = [];
     for (let i = 0, n = fileSet.files.length; i < n; i++) {
@@ -60,27 +52,24 @@ async function copyAppFiles(fileSet, packager, transformer) {
         }
         const destinationFile = getDestinationPath(sourceFile, fileSet);
         if (stat.isSymbolicLink()) {
-            links.push({ file: destinationFile, link: await promises_1.readlink(sourceFile) });
+            links.push({ file: destinationFile, link: await (0, promises_1.readlink)(sourceFile) });
             continue;
         }
         const fileParent = path.dirname(destinationFile);
         if (!createdParentDirs.has(fileParent)) {
             createdParentDirs.add(fileParent);
-            await promises_1.mkdir(fileParent, { recursive: true });
+            await (0, promises_1.mkdir)(fileParent, { recursive: true });
         }
         taskManager.addTask(fileCopier.copy(sourceFile, destinationFile, stat));
-        if (taskManager.tasks.length > fs_1.MAX_FILE_REQUESTS) {
+        if (taskManager.tasks.length > builder_util_1.MAX_FILE_REQUESTS) {
             await taskManager.awaitTasks();
         }
     }
     if (taskManager.tasks.length > 0) {
         await taskManager.awaitTasks();
     }
-    if (links.length > 0) {
-        await bluebird_lst_1.default.map(links, it => promises_1.symlink(it.link, it.file), fs_1.CONCURRENCY);
-    }
+    await (0, tiny_async_pool_1.default)(builder_util_1.MAX_FILE_REQUESTS, links, it => (0, fs_extra_1.ensureSymlink)(it.link, it.file));
 }
-exports.copyAppFiles = copyAppFiles;
 // used only for ASAR, if no asar, file transformed on the fly
 async function transformFiles(transformer, fileSet) {
     if (transformer == null) {
@@ -92,39 +81,40 @@ async function transformFiles(transformer, fileSet) {
         fileSet.transformedFiles = transformedFiles;
     }
     const metadata = fileSet.metadata;
-    await bluebird_lst_1.default.filter(fileSet.files, (it, index) => {
+    const filesPromise = fileSet.files.map(async (it, index) => {
         const fileStat = metadata.get(it);
         if (fileStat == null || !fileStat.isFile()) {
-            return false;
+            return;
         }
         const transformedValue = transformer(it);
         if (transformedValue == null) {
-            return false;
+            return;
         }
         if (typeof transformedValue === "object" && "then" in transformedValue) {
             return transformedValue.then(it => {
                 if (it != null) {
                     transformedFiles.set(index, it);
                 }
-                return false;
+                return;
             });
         }
         transformedFiles.set(index, transformedValue);
-        return false;
-    }, fs_1.CONCURRENCY);
+        return;
+    });
+    // `asyncPool` doesn't provide `index` in it's handler, so we `map` first before using it
+    await (0, tiny_async_pool_1.default)(builder_util_1.MAX_FILE_REQUESTS, filesPromise, promise => promise);
 }
-exports.transformFiles = transformFiles;
 async function computeFileSets(matchers, transformer, platformPackager, isElectronCompile) {
     const fileSets = [];
     const packager = platformPackager.info;
     for (const matcher of matchers) {
         const fileWalker = new AppFileWalker_1.AppFileWalker(matcher, packager);
-        const fromStat = await fs_1.statOrNull(matcher.from);
+        const fromStat = await (0, builder_util_1.statOrNull)(matcher.from);
         if (fromStat == null) {
             builder_util_1.log.debug({ directory: matcher.from, reason: "doesn't exist" }, `skipped copying`);
             continue;
         }
-        const files = await fs_1.walk(matcher.from, fileWalker.filter, fileWalker);
+        const files = await (0, builder_util_1.walk)(matcher.from, fileWalker.filter, fileWalker);
         const metadata = fileWalker.metadata;
         fileSets.push(validateFileSet({ src: matcher.from, files, metadata, destination: matcher.to }));
     }
@@ -134,7 +124,6 @@ async function computeFileSets(matchers, transformer, platformPackager, isElectr
     }
     return fileSets;
 }
-exports.computeFileSets = computeFileSets;
 function getNodeModuleExcludedExts(platformPackager) {
     // do not exclude *.h files (https://github.com/electron-userland/electron-builder/issues/2852)
     const result = [".o", ".obj"].concat(fileMatcher_1.excludedExts.split(",").map(it => `.${it}`));
@@ -156,45 +145,89 @@ function validateFileSet(fileSet) {
 }
 /** @internal */
 async function computeNodeModuleFileSets(platformPackager, mainMatcher) {
-    const deps = await platformPackager.info.getNodeDependencyInfo(platformPackager.platform).value;
+    const deps = await collectNodeModulesWithLogging(platformPackager);
     const nodeModuleExcludedExts = getNodeModuleExcludedExts(platformPackager);
     // serial execution because copyNodeModules is concurrent and so, no need to increase queue/pressure
     const result = new Array();
     let index = 0;
-    for (const info of deps) {
-        const source = info.dir;
-        const destination = getDestinationPath(source, { src: mainMatcher.from, destination: mainMatcher.to, files: [], metadata: null });
-        // use main matcher patterns, so, user can exclude some files in such hoisted node modules
-        // source here includes node_modules, but pattern base should be without because users expect that pattern "!node_modules/loot-core/src{,/**/*}" will work
-        const matcher = new fileMatcher_1.FileMatcher(path.dirname(source), destination, mainMatcher.macroExpander, mainMatcher.patterns);
+    const NODE_MODULES = "node_modules";
+    const collectNodeModules = async (dep, destination) => {
+        const source = dep.dir;
+        const matcher = new fileMatcher_1.FileMatcher(source, destination, mainMatcher.macroExpander, mainMatcher.patterns);
         const copier = new NodeModuleCopyHelper_1.NodeModuleCopyHelper(matcher, platformPackager.info);
-        const files = await copier.collectNodeModules(source, info.deps.map(it => it.name), nodeModuleExcludedExts);
+        const files = await copier.collectNodeModules(dep, nodeModuleExcludedExts, path.relative(mainMatcher.to, destination));
         result[index++] = validateFileSet({ src: source, destination, files, metadata: copier.metadata });
+        builder_util_1.log.debug({ dep: dep.name, from: builder_util_1.log.filePath(source), to: builder_util_1.log.filePath(destination), filesCount: files.length }, "identified module");
+        if (dep.dependencies) {
+            for (const c of dep.dependencies) {
+                await collectNodeModules(c, path.join(destination, NODE_MODULES, c.name));
+            }
+        }
+    };
+    for (const dep of deps) {
+        const destination = path.join(mainMatcher.to, NODE_MODULES, dep.name);
+        await collectNodeModules(dep, destination);
     }
     return result;
 }
-exports.computeNodeModuleFileSets = computeNodeModuleFileSets;
+async function collectNodeModulesWithLogging(platformPackager) {
+    var _a, _b, _c;
+    const packager = platformPackager.info;
+    const { tempDirManager, appDir, projectDir } = packager;
+    let deps = undefined;
+    const searchDirectories = Array.from(new Set([appDir, projectDir, await packager.getWorkspaceRoot()])).filter((it) => (0, builder_util_1.isEmptyOrSpaces)(it) === false);
+    const pmApproaches = [await packager.getPackageManager(), node_module_collector_1.PM.TRAVERSAL];
+    for (const pm of pmApproaches) {
+        for (const dir of searchDirectories) {
+            builder_util_1.log.info({ pm, searchDir: dir }, "searching for node modules");
+            const collector = (0, node_module_collector_1.getCollectorByPackageManager)(pm, dir, tempDirManager);
+            deps = await collector.getNodeModules({ packageName: packager.nodePackageName });
+            if (deps.nodeModules.length > 0) {
+                break;
+            }
+            const attempt = searchDirectories.indexOf(dir);
+            if (attempt < searchDirectories.length - 1) {
+                builder_util_1.log.info({ searchDir: dir, attempt }, "no node modules found in collection, trying next search directory");
+            }
+        }
+        if ((_a = deps === null || deps === void 0 ? void 0 : deps.nodeModules) === null || _a === void 0 ? void 0 : _a.length) {
+            builder_util_1.log.debug({ pm, nodeModules: deps.nodeModules }, "collected node modules");
+            break;
+        }
+    }
+    if (!((_b = deps === null || deps === void 0 ? void 0 : deps.nodeModules) === null || _b === void 0 ? void 0 : _b.length)) {
+        builder_util_1.log.warn({ searchDirectories: searchDirectories.map(it => builder_util_1.log.filePath(it)) }, "no node modules returned while searching directories");
+        return [];
+    }
+    const summary = Object.entries((_c = deps.logSummary) !== null && _c !== void 0 ? _c : {}).filter(([, dependencies]) => Array.isArray(dependencies) && dependencies.length > 0);
+    for (const [errorMessage, dependencies] of summary) {
+        const logLevel = moduleManager_1.logMessageLevelByKey[errorMessage] || "debug";
+        builder_util_1.log[logLevel]({ dependencies }, errorMessage);
+    }
+    return deps.nodeModules;
+}
 async function compileUsingElectronCompile(mainFileSet, packager) {
     builder_util_1.log.info("compiling using electron-compile");
     const electronCompileCache = await packager.tempDirManager.getTempDir({ prefix: "electron-compile-cache" });
     const cacheDir = path.join(electronCompileCache, ".cache");
     // clear and create cache dir
-    await promises_1.mkdir(cacheDir, { recursive: true });
-    const compilerHost = await fileTransformer_1.createElectronCompilerHost(mainFileSet.src, cacheDir);
+    await (0, promises_1.mkdir)(cacheDir, { recursive: true });
+    const compilerHost = await (0, fileTransformer_1.createElectronCompilerHost)(mainFileSet.src, cacheDir);
     const nextSlashIndex = mainFileSet.src.length + 1;
     // pre-compute electron-compile to cache dir - we need to process only subdirectories, not direct files of app dir
-    await bluebird_lst_1.default.map(mainFileSet.files, file => {
+    const filesPromise = mainFileSet.files.map(file => {
         if (file.includes(fileTransformer_1.NODE_MODULES_PATTERN) ||
             file.includes(BOWER_COMPONENTS_PATTERN) ||
             !file.includes(path.sep, nextSlashIndex) || // ignore not root files
             !mainFileSet.metadata.get(file).isFile()) {
-            return null;
+            return;
         }
-        return compilerHost.compile(file).then(() => null);
-    }, fs_1.CONCURRENCY);
+        return compilerHost.compile(file);
+    });
+    await (0, tiny_async_pool_1.default)(builder_util_1.MAX_FILE_REQUESTS, filesPromise, promise => promise);
     await compilerHost.saveConfiguration();
     const metadata = new Map();
-    const cacheFiles = await fs_1.walk(cacheDir, file => !file.startsWith("."), {
+    const cacheFiles = await (0, builder_util_1.walk)(cacheDir, file => !file.startsWith("."), {
         consume: (file, fileStat) => {
             if (fileStat.isFile()) {
                 metadata.set(file, fileStat);