app-builder-lib 26.15.2 → 27.0.0-alpha.0

package/dist/platformPackager.js

@@ -0,0 +1,761 @@
+import { dynamicImport } from "./util/dynamicImport.js";
+import { Arch, asArray, AsyncTaskManager, defaultArchFromString, getArchSuffix, getArtifactArchName, InvalidConfigurationError, isEmptyOrSpaces, log, orIfFileNotExist, sanitizeDirPath, statOrNull, } from "builder-util";
+import { deepAssign } from "builder-util-runtime";
+import { readdir } from "fs/promises";
+import { Lazy } from "lazy-val";
+import * as path from "path";
+import * as fs from "fs/promises";
+import * as os from "os";
+import { AppInfo } from "./appInfo.js";
+import { checkFileInArchive } from "./asar/asarFileChecker.js";
+import { AsarPackager } from "./asar/asarUtil.js";
+import { computeData } from "./asar/integrity.js";
+import { copyFiles, FileMatcher, getFileMatchers, getMainFileMatchers, getNodeModuleFileMatcher } from "./fileMatcher.js";
+import { createTransformer } from "./fileTransformer.js";
+import { isElectronBased } from "./Framework.js";
+import { Platform } from "./core.js";
+import { computeFileSets, computeNodeModuleFileSets, copyAppFiles, transformFiles } from "./util/appFileCopier.js";
+import { convertIcon } from "./util/iconConverter.js";
+import { expandMacro as doExpandMacro } from "./util/macroExpander.js";
+import { generateAssetCatalogForIcon } from "./util/mac/macosIconComposer.js";
+export class PlatformPackager {
+    get packagerOptions() {
+        return this.info.options;
+    }
+    get buildResourcesDir() {
+        return this.info.buildResourcesDir;
+    }
+    get projectDir() {
+        return this.info.projectDir;
+    }
+    get config() {
+        return this.info.config;
+    }
+    /** Platform-level build options (e.g. `config.mac`, `config.win`, `config.linux`). */
+    get platformOptions() {
+        return this.platformSpecificBuildOptions;
+    }
+    /**
+     * Merge platform-level options with target-specific config under `key`.
+     * Replaces the manual `deepAssign({}, packager.platformSpecificBuildOptions, config.X)` pattern.
+     */
+    getOptionsForTarget(key) {
+        return deepAssign({}, this.platformSpecificBuildOptions, this.config[key] ?? {});
+    }
+    get resourceList() {
+        return this._resourceList.value;
+    }
+    constructor(info, platform) {
+        this.info = info;
+        this.platform = platform;
+        this._resourceList = new Lazy(() => orIfFileNotExist(readdir(this.info.buildResourcesDir), []));
+        this.assetCatalogResults = new Map();
+        this.cachedIcnsFromIconFile = new Map();
+        this.platformSpecificBuildOptions = PlatformPackager.normalizePlatformSpecificBuildOptions(this.config[platform.buildConfigurationKey]);
+        this.appInfo = this.prepareAppInfo(info.appInfo);
+    }
+    get compression() {
+        const compression = this.platformSpecificBuildOptions.compression;
+        // explicitly set to null - request to use default value instead of parent (in the config)
+        if (compression === null) {
+            return "normal";
+        }
+        return compression || this.config.compression || "normal";
+    }
+    get debugLogger() {
+        return this.info.debugLogger;
+    }
+    get tempDirManager() {
+        return this.info.tempDirManager;
+    }
+    get metadata() {
+        return this.info.metadata;
+    }
+    get framework() {
+        return this.info.framework;
+    }
+    get cancellationToken() {
+        return this.info.cancellationToken;
+    }
+    get repositoryInfo() {
+        return this.info.repositoryInfo;
+    }
+    get relativeBuildResourcesDirname() {
+        return this.info.relativeBuildResourcesDirname;
+    }
+    get stageDirPathCustomizer() {
+        return this.info.stageDirPathCustomizer;
+    }
+    get areNodeModulesHandledExternally() {
+        return this.info.areNodeModulesHandledExternally;
+    }
+    get isPrepackedAppAsar() {
+        return this.info.isPrepackedAppAsar;
+    }
+    get appDir() {
+        return this.info.appDir;
+    }
+    getWorkspaceRoot() {
+        return this.info.getWorkspaceRoot();
+    }
+    get nodePackageName() {
+        return this.info.nodePackageName;
+    }
+    getPackageManager() {
+        return this.info.getPackageManager();
+    }
+    emitArtifactBuildStarted(event, logFields) {
+        return this.info.emitArtifactBuildStarted(event, logFields);
+    }
+    emitArtifactBuildCompleted(event) {
+        return this.info.emitArtifactBuildCompleted(event);
+    }
+    emitArtifactCreated(event) {
+        return this.info.emitArtifactCreated(event);
+    }
+    emitMsiProjectCreated(path) {
+        return this.info.emitMsiProjectCreated(path);
+    }
+    emitAppxManifestCreated(path) {
+        return this.info.emitAppxManifestCreated(path);
+    }
+    // eslint-disable-next-line
+    prepareAppInfo(appInfo) {
+        return new AppInfo(this.info, null, this.platformSpecificBuildOptions);
+    }
+    static normalizePlatformSpecificBuildOptions(options) {
+        return options == null ? Object.create(null) : options;
+    }
+    getCscPassword() {
+        const password = this.doGetCscPassword();
+        if (isEmptyOrSpaces(password)) {
+            log.info({ reason: "CSC_KEY_PASSWORD is not defined" }, "empty password will be used for code signing");
+            return "";
+        }
+        else {
+            return password.trim();
+        }
+    }
+    getCscLink(extraEnvName) {
+        // allow to specify as empty string
+        const envValue = chooseNotNull(extraEnvName == null ? null : process.env[extraEnvName], process.env.CSC_LINK);
+        return chooseNotNull(chooseNotNull(this.info.config.cscLink, this.platformSpecificBuildOptions.cscLink), envValue);
+    }
+    doGetCscPassword() {
+        // allow to specify as empty string
+        return chooseNotNull(chooseNotNull(this.info.config.cscKeyPassword, this.platformSpecificBuildOptions.cscKeyPassword), process.env.CSC_KEY_PASSWORD);
+    }
+    computeAppOutDir(outDir, arch) {
+        // codeql[js/shell-command-constructed-from-input] - prepackaged and outDir are validated via sanitizeDirPath in the Packager constructor
+        return path.resolve(this.packagerOptions.prepackaged ||
+            path.join(outDir, `${this.platform.buildConfigurationKey}${getArchSuffix(arch, this.platformSpecificBuildOptions.defaultArch)}${this.platform === Platform.MAC ? "" : "-unpacked"}`));
+    }
+    async pack(outDir, arch, targets, taskManager) {
+        const appOutDir = this.computeAppOutDir(outDir, arch);
+        await this.doPack({
+            outDir,
+            appOutDir,
+            platformName: this.platform.nodeName,
+            arch,
+            platformSpecificBuildOptions: this.platformSpecificBuildOptions,
+            targets,
+        });
+        this.packageInDistributableFormat(appOutDir, arch, targets, taskManager);
+    }
+    packageInDistributableFormat(appOutDir, arch, targets, taskManager) {
+        if (targets.find(it => !it.isAsyncSupported) == null) {
+            PlatformPackager.buildAsyncTargets(targets, taskManager, appOutDir, arch);
+            return;
+        }
+        taskManager.add(async () => {
+            // BluebirdPromise.map doesn't invoke target.build immediately, but for RemoteTarget it is very critical to call build() before finishBuild()
+            const subTaskManager = new AsyncTaskManager(this.info.cancellationToken);
+            PlatformPackager.buildAsyncTargets(targets, subTaskManager, appOutDir, arch);
+            await subTaskManager.awaitTasks();
+            for (const target of targets) {
+                if (!target.isAsyncSupported && !this.info.cancellationToken.cancelled) {
+                    await target.build(appOutDir, arch);
+                }
+            }
+        });
+    }
+    static buildAsyncTargets(targets, taskManager, appOutDir, arch) {
+        for (const target of targets) {
+            if (target.isAsyncSupported) {
+                taskManager.addTask(target.build(appOutDir, arch));
+            }
+        }
+    }
+    getExtraFileMatchers(isResources, appOutDir, options) {
+        const outDir = this.platform === Platform.MAC ? path.join(appOutDir, `${this.appInfo.productFilename}.app`, "Contents") : appOutDir;
+        const base = isResources ? this.getResourcesDir(appOutDir) : outDir;
+        return getFileMatchers(this.config, isResources ? "extraResources" : "extraFiles", base, options);
+    }
+    createGetFileMatchersOptions(outDir, arch, customBuildOptions) {
+        return {
+            macroExpander: it => this.expandMacro(it, arch == null ? null : Arch[arch], { "/*": "{,/**/*}" }),
+            customBuildOptions,
+            globalOutDir: outDir,
+            defaultSrc: this.projectDir,
+        };
+    }
+    async doPack(packOptions) {
+        if (this.packagerOptions.prepackaged != null) {
+            return;
+        }
+        if (this.info.cancellationToken.cancelled) {
+            return;
+        }
+        // Due to node-gyp rewriting GYP_MSVS_VERSION when reused across the same session, we must reset the env var: https://github.com/electron-userland/electron-builder/issues/7256
+        delete process.env.GYP_MSVS_VERSION;
+        const { outDir, appOutDir, platformName, arch, platformSpecificBuildOptions, targets, options } = packOptions;
+        await this.info.emitBeforePack({
+            appOutDir,
+            outDir,
+            arch,
+            targets,
+            packager: this,
+            electronPlatformName: platformName,
+        });
+        await this.info.installAppDependencies(this.platform, arch);
+        if (this.info.cancellationToken.cancelled) {
+            return;
+        }
+        const framework = this.info.framework;
+        log.info({
+            platform: platformName,
+            arch: Arch[arch],
+            [`${framework.name}`]: framework.version,
+            appOutDir: log.filePath(appOutDir),
+        }, `packaging`);
+        await framework.prepareApplicationStageDirectory({
+            packager: this,
+            appOutDir,
+            platformName,
+            arch: Arch[arch],
+            version: framework.version,
+        });
+        await this.info.emitAfterExtract({
+            appOutDir,
+            outDir,
+            arch,
+            targets,
+            packager: this,
+            electronPlatformName: platformName,
+        });
+        const excludePatterns = [];
+        const computeParsedPatterns = (patterns) => {
+            if (patterns != null) {
+                for (const pattern of patterns) {
+                    pattern.computeParsedPatterns(excludePatterns, this.info.projectDir);
+                }
+            }
+        };
+        const getFileMatchersOptions = this.createGetFileMatchersOptions(outDir, arch, platformSpecificBuildOptions);
+        const macroExpander = getFileMatchersOptions.macroExpander;
+        const extraResourceMatchers = this.getExtraFileMatchers(true, appOutDir, getFileMatchersOptions);
+        computeParsedPatterns(extraResourceMatchers);
+        const extraFileMatchers = this.getExtraFileMatchers(false, appOutDir, getFileMatchersOptions);
+        computeParsedPatterns(extraFileMatchers);
+        const packContext = {
+            appOutDir,
+            outDir,
+            arch,
+            targets,
+            packager: this,
+            electronPlatformName: platformName,
+        };
+        const asarOptions = await this.computeAsarOptions(platformSpecificBuildOptions);
+        const resourcesPath = this.platform === Platform.MAC
+            ? path.join(appOutDir, framework.distMacOsAppName, "Contents", "Resources")
+            : isElectronBased(framework)
+                ? path.join(appOutDir, "resources")
+                : appOutDir;
+        const taskManager = new AsyncTaskManager(this.info.cancellationToken);
+        this.copyAppFiles(taskManager, asarOptions, resourcesPath, path.join(resourcesPath, "app"), packContext, platformSpecificBuildOptions, excludePatterns, macroExpander);
+        await taskManager.awaitTasks();
+        if (this.info.cancellationToken.cancelled) {
+            return;
+        }
+        if (framework.beforeCopyExtraFiles != null) {
+            const resourcesRelativePath = this.platform === Platform.MAC ? "Resources" : isElectronBased(framework) ? "resources" : "";
+            let asarIntegrity = null;
+            if (!(asarOptions == null || options?.disableAsarIntegrity || asarOptions.disableIntegrity)) {
+                asarIntegrity = await computeData({ resourcesPath, resourcesRelativePath, resourcesDestinationPath: this.getResourcesDir(appOutDir), extraResourceMatchers });
+            }
+            await framework.beforeCopyExtraFiles({
+                packager: this,
+                appOutDir,
+                asarIntegrity,
+                platformName,
+            });
+        }
+        if (this.info.cancellationToken.cancelled) {
+            return;
+        }
+        const transformerForExtraFiles = this.createTransformerForExtraFiles(packContext);
+        await copyFiles(extraResourceMatchers, transformerForExtraFiles);
+        await copyFiles(extraFileMatchers, transformerForExtraFiles);
+        if (this.info.cancellationToken.cancelled) {
+            return;
+        }
+        await this.info.emitAfterPack(packContext);
+        if (framework.afterPack != null) {
+            await framework.afterPack(packContext);
+        }
+        const isAsar = asarOptions != null;
+        await this.sanityCheckPackage(appOutDir, isAsar, framework, !!asarOptions?.disableSanityCheck);
+        if (!options?.disableFuses) {
+            await this.doAddElectronFuses(packContext);
+        }
+        if (options?.sign ?? true) {
+            await this.doSignAfterPack(outDir, appOutDir, platformName, arch, platformSpecificBuildOptions, targets);
+        }
+    }
+    // the fuses MUST be flipped right before signing
+    async doAddElectronFuses(packContext) {
+        if (this.config.electronFuses == null) {
+            return;
+        }
+        const fuseConfig = await this.generateFuseConfig(this.config.electronFuses);
+        await this.addElectronFuses(packContext, fuseConfig);
+    }
+    async generateFuseConfig(fuses) {
+        const { FuseVersion, FuseV1Options } = await dynamicImport("@electron/fuses");
+        const config = {
+            version: FuseVersion.V1,
+            resetAdHocDarwinSignature: fuses.resetAdHocDarwinSignature,
+        };
+        // this is annoying, but we must filter out undefined entries because some older electron versions will receive `the fuse wire in this version of Electron is not long enough` even if entry is set undefined
+        if (fuses.runAsNode != null) {
+            config[FuseV1Options.RunAsNode] = fuses.runAsNode;
+        }
+        if (fuses.enableCookieEncryption != null) {
+            config[FuseV1Options.EnableCookieEncryption] = fuses.enableCookieEncryption;
+        }
+        if (fuses.enableNodeOptionsEnvironmentVariable != null) {
+            config[FuseV1Options.EnableNodeOptionsEnvironmentVariable] = fuses.enableNodeOptionsEnvironmentVariable;
+        }
+        if (fuses.enableNodeCliInspectArguments != null) {
+            config[FuseV1Options.EnableNodeCliInspectArguments] = fuses.enableNodeCliInspectArguments;
+        }
+        if (fuses.enableEmbeddedAsarIntegrityValidation != null) {
+            config[FuseV1Options.EnableEmbeddedAsarIntegrityValidation] = fuses.enableEmbeddedAsarIntegrityValidation;
+        }
+        if (fuses.onlyLoadAppFromAsar != null) {
+            config[FuseV1Options.OnlyLoadAppFromAsar] = fuses.onlyLoadAppFromAsar;
+        }
+        if (fuses.loadBrowserProcessSpecificV8Snapshot != null) {
+            config[FuseV1Options.LoadBrowserProcessSpecificV8Snapshot] = fuses.loadBrowserProcessSpecificV8Snapshot;
+        }
+        if (fuses.grantFileProtocolExtraPrivileges != null) {
+            config[FuseV1Options.GrantFileProtocolExtraPrivileges] = fuses.grantFileProtocolExtraPrivileges;
+        }
+        return config;
+    }
+    /**
+     * Use `AfterPackContext` here to keep available for public API
+     * @param {AfterPackContext} context
+     * @param {FuseConfig} fuses
+     *
+     * Can be used in `afterPack` hook for custom fuse logic like below. It's an alternative approach if one wants to override electron-builder's @electron/fuses version
+     * ```
+     * await context.packager.addElectronFuses(context, { ... })
+     * ```
+     */
+    async addElectronFuses(context, fuses) {
+        const { appOutDir, electronPlatformName } = context;
+        const ext = {
+            darwin: ".app",
+            mas: ".app",
+            win32: ".exe",
+            linux: "",
+        }[electronPlatformName];
+        // `"executableName" in this` instead of `instanceof LinuxPackager` keeps LinuxPackager a
+        // type-only import, avoiding the index.ts → linuxPackager.ts → platformPackager.ts runtime cycle.
+        const executableName = "executableName" in this ? this.executableName : this.appInfo.productFilename;
+        const electronBinaryPath = path.join(appOutDir, `${executableName}${ext}`);
+        log.info({ electronPath: log.filePath(electronBinaryPath) }, "executing @electron/fuses");
+        const { flipFuses } = await dynamicImport("@electron/fuses");
+        return flipFuses(electronBinaryPath, fuses);
+    }
+    async doSignAfterPack(outDir, appOutDir, platformName, arch, platformSpecificBuildOptions, targets) {
+        const asarOptions = await this.computeAsarOptions(platformSpecificBuildOptions);
+        const isAsar = asarOptions != null;
+        const packContext = {
+            appOutDir,
+            outDir,
+            arch,
+            targets,
+            packager: this,
+            electronPlatformName: platformName,
+        };
+        const didSign = await this.signApp(packContext, isAsar);
+        if (didSign) {
+            await this.info.emitAfterSign(packContext);
+        }
+        else if (this.info.filterPackagerEventListeners("afterSign", "user").length) {
+            log.warn(null, `skipping "afterSign" hook as no signing occurred, perhaps you intended "afterPack"?`);
+        }
+    }
+    // eslint-disable-next-line
+    createTransformerForExtraFiles(packContext) {
+        return null;
+    }
+    copyAppFiles(taskManager, asarOptions, resourcePath, defaultDestination, packContext, platformSpecificBuildOptions, excludePatterns, macroExpander) {
+        const appDir = this.info.appDir;
+        const config = this.config;
+        const mainMatchers = getMainFileMatchers(appDir, defaultDestination, macroExpander, platformSpecificBuildOptions, this, packContext.outDir);
+        if (excludePatterns.length > 0) {
+            for (const matcher of mainMatchers) {
+                matcher.excludePatterns = excludePatterns;
+            }
+        }
+        const framework = this.info.framework;
+        const transformer = createTransformer(appDir, config, config.extraMetadata, framework.createTransformer == null ? null : framework.createTransformer());
+        const _computeFileSets = (matchers) => {
+            return computeFileSets(matchers, this.info.isPrepackedAppAsar ? null : transformer, this).then(async (result) => {
+                if (!this.info.isPrepackedAppAsar && !this.info.areNodeModulesHandledExternally) {
+                    const moduleFileMatcher = getNodeModuleFileMatcher(appDir, defaultDestination, macroExpander, platformSpecificBuildOptions, this.info);
+                    result = result.concat(await computeNodeModuleFileSets(this, moduleFileMatcher));
+                }
+                return result.filter(it => it.files.length > 0);
+            });
+        };
+        if (this.info.isPrepackedAppAsar) {
+            taskManager.add(async () => {
+                const fileSets = await _computeFileSets([new FileMatcher(appDir, resourcePath, macroExpander)]);
+                fileSets.forEach(it => taskManager.addTask(copyAppFiles(it, this.info, transformer)));
+                await taskManager.awaitTasks();
+            });
+        }
+        else if (asarOptions == null) {
+            // for ASAR all asar unpacked files will be extra transformed (e.g. sign of EXE and DLL) later,
+            // for prepackaged asar extra transformation not supported yet,
+            // so, extra transform if asar is disabled
+            const transformerForExtraFiles = this.createTransformerForExtraFiles(packContext);
+            const combinedTransformer = file => {
+                if (transformerForExtraFiles != null) {
+                    const result = transformerForExtraFiles(file);
+                    if (result != null) {
+                        return result;
+                    }
+                }
+                return transformer(file);
+            };
+            taskManager.add(async () => {
+                const fileSets = await _computeFileSets(mainMatchers);
+                fileSets.forEach(it => taskManager.addTask(copyAppFiles(it, this.info, combinedTransformer)));
+                await taskManager.awaitTasks();
+            });
+        }
+        else {
+            const unpackPatterns = asarOptions.unpack;
+            let fileMatcher = null;
+            if (unpackPatterns != null) {
+                fileMatcher = new FileMatcher(appDir, defaultDestination, macroExpander);
+                const pats = Array.isArray(unpackPatterns) ? unpackPatterns : [unpackPatterns];
+                pats.forEach(p => fileMatcher.addPattern(p));
+                if (fileMatcher.isEmpty()) {
+                    fileMatcher = null;
+                }
+            }
+            taskManager.addTask(_computeFileSets(mainMatchers).then(async (fileSets) => {
+                for (const fileSet of fileSets) {
+                    await transformFiles(transformer, fileSet);
+                }
+                await new AsarPackager(this, {
+                    defaultDestination,
+                    resourcePath,
+                    options: asarOptions,
+                    unpackPattern: fileMatcher?.createFilter(),
+                }).pack(fileSets);
+            }));
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    signApp(packContext, isAsar) {
+        return Promise.resolve(false);
+    }
+    getIconPath() {
+        return Promise.resolve(null);
+    }
+    async computeAsarOptions(customBuildOptions) {
+        if (!isElectronBased(this.info.framework)) {
+            return null;
+        }
+        const platformSpecific = customBuildOptions.asar;
+        const result = platformSpecific == null ? this.config.asar : platformSpecific;
+        if (result === false) {
+            const appAsarStat = await statOrNull(path.join(this.info.appDir, "app.asar"));
+            //noinspection ES6MissingAwait
+            if (appAsarStat == null || !appAsarStat.isFile()) {
+                log.warn({
+                    solution: "enable asar and use asar.unpack to unpack files that must be externally available",
+                }, "asar usage is disabled — this is strongly not recommended");
+            }
+            return null;
+        }
+        if (result == null || result === true) {
+            return {};
+        }
+        return deepAssign({}, result);
+    }
+    getElectronSrcDir(dist) {
+        return path.resolve(this.projectDir, dist);
+    }
+    getElectronDestinationDir(appOutDir) {
+        return appOutDir;
+    }
+    getResourcesDir(appOutDir) {
+        if (this.platform === Platform.MAC) {
+            return this.getMacOsResourcesDir(appOutDir);
+        }
+        if (isElectronBased(this.info.framework)) {
+            return path.join(appOutDir, "resources");
+        }
+        return appOutDir;
+    }
+    getMacOsElectronFrameworkResourcesDir(appOutDir) {
+        const electronFrameworkName = path.basename(this.info.framework.distMacOsAppName, ".app") + " " + "Framework.framework";
+        return path.join(appOutDir, `${this.appInfo.productFilename}.app`, "Contents", "Frameworks", electronFrameworkName, "Versions", "A", "Resources");
+    }
+    getMacOsResourcesDir(appOutDir) {
+        return path.join(appOutDir, `${this.appInfo.productFilename}.app`, "Contents", "Resources");
+    }
+    async checkFileInPackage(resourcesDir, file, messagePrefix, isAsar, disableSanityCheckAsar) {
+        if (isAsar && disableSanityCheckAsar) {
+            return;
+        }
+        const relativeFile = path.relative(this.info.appDir, path.resolve(this.info.appDir, file));
+        if (isAsar) {
+            await checkFileInArchive(path.join(resourcesDir, "app.asar"), relativeFile, messagePrefix);
+            return;
+        }
+        const pathParsed = path.parse(file);
+        // Even when packaging to asar is disabled, it does not imply that the main file can not be inside an .asar archive.
+        // This may occur when the packaging is done manually before processing with electron-builder.
+        if (pathParsed.dir.includes(".asar")) {
+            // The path needs to be split to the part with an asar archive which acts like a directory and the part with
+            // the path to main file itself. (e.g. path/arch.asar/dir/index.js -> path/arch.asar, dir/index.js)
+            // noinspection TypeScriptValidateJSTypes
+            const pathSplit = pathParsed.dir.split(path.sep);
+            let partWithAsarIndex = 0;
+            pathSplit.some((pathPart, index) => {
+                partWithAsarIndex = index;
+                return pathPart.endsWith(".asar");
+            });
+            const asarPath = path.join(...pathSplit.slice(0, partWithAsarIndex + 1));
+            let mainPath = pathSplit.length > partWithAsarIndex + 1 ? path.join.apply(pathSplit.slice(partWithAsarIndex + 1)) : "";
+            mainPath += path.join(mainPath, pathParsed.base);
+            await checkFileInArchive(path.join(resourcesDir, "app", asarPath), mainPath, messagePrefix);
+        }
+        else {
+            const fullPath = path.join(resourcesDir, "app", relativeFile);
+            const outStat = await statOrNull(fullPath);
+            if (outStat == null) {
+                throw new Error(`${messagePrefix} "${fullPath}" does not exist. Seems like a wrong configuration.`);
+            }
+            else {
+                //noinspection ES6MissingAwait
+                if (!outStat.isFile()) {
+                    throw new Error(`${messagePrefix} "${fullPath}" is not a file. Seems like a wrong configuration.`);
+                }
+            }
+        }
+    }
+    async sanityCheckPackage(appOutDir, isAsar, framework, disableSanityCheckAsar) {
+        const outStat = await statOrNull(appOutDir);
+        if (outStat == null) {
+            throw new Error(`Output directory "${appOutDir}" does not exist. Seems like a wrong configuration.`);
+        }
+        else {
+            //noinspection ES6MissingAwait
+            if (!outStat.isDirectory()) {
+                throw new Error(`Output directory "${appOutDir}" is not a directory. Seems like a wrong configuration.`);
+            }
+        }
+        const resourcesDir = this.getResourcesDir(appOutDir);
+        const mainFile = (framework.getMainFile == null ? null : framework.getMainFile(this.platform)) || this.info.metadata.main || "index.js";
+        await this.checkFileInPackage(resourcesDir, mainFile, "Application entry file", isAsar, disableSanityCheckAsar);
+        await this.checkFileInPackage(resourcesDir, "package.json", "Application", isAsar, disableSanityCheckAsar);
+    }
+    // tslint:disable-next-line:no-invalid-template-strings
+    computeSafeArtifactName(suggestedName, ext, arch, skipDefaultArch = true, defaultArch, safePattern = "${name}-${version}-${arch}.${ext}") {
+        return computeSafeArtifactNameIfNeeded(suggestedName, () => this.computeArtifactName(safePattern, ext, skipDefaultArch && arch === defaultArchFromString(defaultArch) ? null : arch));
+    }
+    expandArtifactNamePattern(targetSpecificOptions, ext, arch, defaultPattern, skipDefaultArch = true, defaultArch) {
+        const { pattern, isUserForced } = this.artifactPatternConfig(targetSpecificOptions, defaultPattern);
+        return this.computeArtifactName(pattern, ext, !isUserForced && skipDefaultArch && arch === defaultArchFromString(defaultArch) ? null : arch);
+    }
+    artifactPatternConfig(targetSpecificOptions, defaultPattern) {
+        const userSpecifiedPattern = targetSpecificOptions?.artifactName || this.platformSpecificBuildOptions.artifactName || this.config.artifactName;
+        return {
+            isUserForced: !!userSpecifiedPattern,
+            pattern: userSpecifiedPattern || defaultPattern || "${productName}-${version}-${arch}.${ext}",
+        };
+    }
+    expandArtifactBeautyNamePattern(targetSpecificOptions, ext, arch) {
+        // tslint:disable-next-line:no-invalid-template-strings
+        return this.expandArtifactNamePattern(targetSpecificOptions, ext, arch, "${productName} ${version} ${arch}.${ext}", true);
+    }
+    computeArtifactName(pattern, ext, arch) {
+        const archName = arch == null ? null : getArtifactArchName(arch, ext);
+        return this.expandMacro(pattern, archName, {
+            ext,
+        });
+    }
+    expandMacro(pattern, arch, extra = {}, isProductNameSanitized = true) {
+        return doExpandMacro(pattern, arch, this.appInfo, { os: this.platform.buildConfigurationKey, ...extra }, isProductNameSanitized);
+    }
+    generateName2(ext, classifier, deployment) {
+        const dotExt = ext == null ? "" : `.${ext}`;
+        const separator = ext === "deb" ? "_" : "-";
+        return `${deployment ? this.appInfo.name : this.appInfo.productFilename}${separator}${this.appInfo.version}${classifier == null ? "" : `${separator}${classifier}`}${dotExt}`;
+    }
+    getTempFile(suffix) {
+        return this.info.tempDirManager.getTempFile({ suffix });
+    }
+    get fileAssociations() {
+        return asArray(this.config.fileAssociations).concat(asArray(this.platformSpecificBuildOptions.fileAssociations));
+    }
+    async getResource(custom, ...names) {
+        const resourcesDir = this.info.buildResourcesDir;
+        if (custom === undefined) {
+            const resourceList = await this.resourceList;
+            for (const name of names) {
+                if (resourceList.includes(name)) {
+                    // sanitizeDirPath with resourcesDir base enforces containment — CodeQL recognises the startsWith check inside as a path-traversal sanitizer
+                    return sanitizeDirPath(path.join(resourcesDir, path.basename(name)), resourcesDir);
+                }
+            }
+        }
+        else if (custom != null && !isEmptyOrSpaces(custom)) {
+            const resourceList = await this.resourceList;
+            if (resourceList.includes(custom)) {
+                return sanitizeDirPath(path.join(resourcesDir, path.basename(custom)), resourcesDir);
+            }
+            // codeql[js/shell-command-constructed-from-input] - intentional: custom may be an absolute path outside the build resources dir; existence is verified below via statOrNull
+            let p = path.resolve(resourcesDir, custom);
+            if ((await statOrNull(p)) == null) {
+                p = path.resolve(this.projectDir, custom);
+                if ((await statOrNull(p)) == null) {
+                    throw new InvalidConfigurationError(`cannot find specified resource "${custom}", nor relative to "${resourcesDir}", neither relative to project dir ("${this.projectDir}")`);
+                }
+            }
+            return p;
+        }
+        return null;
+    }
+    get forceCodeSigning() {
+        const forceCodeSigningPlatform = this.platformSpecificBuildOptions.forceCodeSigning;
+        return (forceCodeSigningPlatform == null ? this.config.forceCodeSigning : forceCodeSigningPlatform) || false;
+    }
+    generateAssetCatalogData(iconPath) {
+        // Cache results
+        const cachedPromise = this.assetCatalogResults.get(iconPath);
+        if (cachedPromise) {
+            return cachedPromise;
+        }
+        const promise = generateAssetCatalogForIcon(iconPath);
+        this.assetCatalogResults.set(iconPath, promise);
+        return promise;
+    }
+    async generateIcnsFromIcon(iconPath) {
+        const cachedPromise = this.cachedIcnsFromIconFile.get(iconPath);
+        if (cachedPromise) {
+            return cachedPromise;
+        }
+        const runner = async () => {
+            const { icnsFile } = await this.generateAssetCatalogData(iconPath);
+            // Generate icns file
+            const tempDir = await fs.mkdtemp(path.resolve(os.tmpdir(), "icon-compile-"));
+            const tempIcnsPath = path.resolve(tempDir, "Icon.icns");
+            await fs.writeFile(tempIcnsPath, icnsFile);
+            return tempIcnsPath;
+        };
+        const promise = runner();
+        this.cachedIcnsFromIconFile.set(iconPath, promise);
+        return promise;
+    }
+    async getOrConvertIcon(format) {
+        if (format === "icns") {
+            const configuredIcon = this.platformSpecificBuildOptions.icon;
+            // If it is a .icon file, generate the icns file and return the path to the icns file
+            if (configuredIcon?.endsWith(".icon")) {
+                const iconPath = await this.getResource(configuredIcon);
+                if (iconPath) {
+                    return this.generateIcnsFromIcon(iconPath);
+                }
+            }
+        }
+        const result = await this.resolveIcon(asArray(this.platformSpecificBuildOptions.icon || this.config.icon), [], format);
+        if (result.length === 0) {
+            const framework = this.info.framework;
+            if (framework.getDefaultIcon != null) {
+                return framework.getDefaultIcon(this.platform);
+            }
+            log.warn({ reason: "application icon is not set" }, `default ${capitalizeFirstLetter(framework.name)} icon is used`);
+            return this.getDefaultFrameworkIcon();
+        }
+        else {
+            return result[0].file;
+        }
+    }
+    getDefaultFrameworkIcon() {
+        const framework = this.info.framework;
+        return framework.getDefaultIcon == null ? null : framework.getDefaultIcon(this.platform);
+    }
+    // convert if need, validate size (it is a reason why tool is called even if file has target extension (already specified as foo.icns for example))
+    async resolveIcon(sources, fallbackSources, outputFormat) {
+        const output = this.expandMacro(this.config.directories.output);
+        const outDir = sanitizeDirPath(path.resolve(this.projectDir, output, `.icon-${outputFormat}`));
+        const roots = [this.buildResourcesDir, this.projectDir];
+        const filteredSources = sources.filter(s => !s.endsWith(".icon"));
+        const filteredFallbacks = fallbackSources.filter(s => !s.endsWith(".icon"));
+        const result = await convertIcon({
+            sources: filteredSources,
+            fallbackSources: filteredFallbacks,
+            roots,
+            format: outputFormat,
+            outDir,
+            iconsToolset: this.info.config.toolsets?.icons,
+            resourcesDir: this.buildResourcesDir,
+        });
+        if (result.error != null) {
+            throw new InvalidConfigurationError(result.error, result.errorCode);
+        }
+        if (result.isFallback) {
+            log.warn({ reason: "application icon is not set" }, `default ${capitalizeFirstLetter(this.info.framework.name)} icon is used`);
+        }
+        return result.icons;
+    }
+}
+export function isSafeGithubName(name) {
+    return /^[0-9A-Za-z._-]+$/.test(name);
+}
+export function computeSafeArtifactNameIfNeeded(suggestedName, safeNameProducer) {
+    // GitHub only allows the listed characters in file names.
+    if (suggestedName != null) {
+        if (isSafeGithubName(suggestedName)) {
+            return null;
+        }
+        // prefer to use suggested name - so, if space is the only problem, just replace only space to dash
+        suggestedName = suggestedName.replace(/ /g, "-");
+        if (isSafeGithubName(suggestedName)) {
+            return suggestedName;
+        }
+    }
+    return safeNameProducer();
+}
+// remove leading dot
+export function normalizeExt(ext) {
+    return ext.startsWith(".") ? ext.substring(1) : ext;
+}
+export function chooseNotNull(v1, v2) {
+    return v1 == null ? v2 : v1;
+}
+function capitalizeFirstLetter(text) {
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
+//# sourceMappingURL=platformPackager.js.map