@electron-forge/core-utils 6.0.0-beta.71

package/dist/electron-version.d.ts

@@ -0,0 +1,12 @@
+declare type PackageJSONWithDeps = {
+    devDependencies?: Record<string, string>;
+    dependencies?: Record<string, string>;
+};
+export declare class PackageNotFoundError extends Error {
+    constructor(packageName: string, dir: string);
+}
+export declare function getElectronModulePath(dir: string, packageJSON: PackageJSONWithDeps): Promise<string | undefined>;
+export declare function getElectronVersion(dir: string, packageJSON: PackageJSONWithDeps): Promise<string>;
+export declare function updateElectronDependency(packageJSON: PackageJSONWithDeps, dev: string[], exact: string[]): [string[], string[]];
+export {};
+//# sourceMappingURL=electron-version.d.ts.map

package/dist/electron-version.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.getElectronModulePath = getElectronModulePath;
+exports.getElectronVersion = getElectronVersion;
+exports.updateElectronDependency = updateElectronDependency;
+var _path = _interopRequireDefault(require("path"));
+var _debug = _interopRequireDefault(require("debug"));
+var _findUp = _interopRequireDefault(require("find-up"));
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+var _semver = _interopRequireDefault(require("semver"));
+var _yarnOrNpm = require("./yarn-or-npm");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const d = (0, _debug).default('electron-forge:electron-version');
+const electronPackageNames = [
+    'electron-prebuilt-compile',
+    'electron-prebuilt',
+    'electron-nightly',
+    'electron'
+];
+function findElectronDep(dep) {
+    return electronPackageNames.includes(dep);
+}
+async function findAncestorNodeModulesPath(dir, packageName) {
+    d('Looking for a lock file to indicate the root of the repo');
+    const lockPath = await (0, _findUp).default([
+        'package-lock.json',
+        'yarn.lock',
+        'pnpm-lock.yaml'
+    ], {
+        cwd: dir,
+        type: 'file'
+    });
+    if (lockPath) {
+        d(`Found lock file: ${lockPath}`);
+        const nodeModulesPath = _path.default.join(_path.default.dirname(lockPath), 'node_modules', packageName);
+        if (await _fsExtra.default.pathExists(nodeModulesPath)) {
+            return nodeModulesPath;
+        }
+    }
+    return Promise.resolve(undefined);
+}
+async function determineNodeModulesPath(dir, packageName) {
+    const nodeModulesPath = _path.default.join(dir, 'node_modules', packageName);
+    if (await _fsExtra.default.pathExists(nodeModulesPath)) {
+        return nodeModulesPath;
+    }
+    return findAncestorNodeModulesPath(dir, packageName);
+}
+class PackageNotFoundError extends Error {
+    constructor(packageName, dir){
+        super(`Cannot find the package "${packageName}". Perhaps you need to run "${(0, _yarnOrNpm).safeYarnOrNpm()} install" in "${dir}"?`);
+    }
+}
+exports.PackageNotFoundError = PackageNotFoundError;
+function getElectronModuleName(packageJSON) {
+    if (!packageJSON.devDependencies) {
+        throw new Error('package.json for app does not have any devDependencies');
+    }
+    // Why: checked above
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const packageName = electronPackageNames.find((pkg)=>packageJSON.devDependencies[pkg]
+    );
+    if (packageName === undefined) {
+        throw new Error('Could not find any Electron packages in devDependencies');
+    }
+    return packageName;
+}
+async function getElectronPackageJSONPath(dir, packageName) {
+    const nodeModulesPath = await determineNodeModulesPath(dir, packageName);
+    if (!nodeModulesPath) {
+        throw new PackageNotFoundError(packageName, dir);
+    }
+    const electronPackageJSONPath = _path.default.join(nodeModulesPath, 'package.json');
+    if (await _fsExtra.default.pathExists(electronPackageJSONPath)) {
+        return electronPackageJSONPath;
+    }
+    return undefined;
+}
+async function getElectronModulePath(dir, packageJSON) {
+    const moduleName = getElectronModuleName(packageJSON);
+    const packageJSONPath = await getElectronPackageJSONPath(dir, moduleName);
+    if (packageJSONPath) {
+        return _path.default.dirname(packageJSONPath);
+    }
+    return undefined;
+}
+async function getElectronVersion(dir, packageJSON) {
+    const packageName = getElectronModuleName(packageJSON);
+    // Why: checked in getElectronModuleName
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    let version = packageJSON.devDependencies[packageName];
+    if (!_semver.default.valid(version)) {
+        // It's not an exact version, find it in the actual module
+        const electronPackageJSONPath = await getElectronPackageJSONPath(dir, packageName);
+        if (electronPackageJSONPath) {
+            const electronPackageJSON = await _fsExtra.default.readJson(electronPackageJSONPath);
+            version = electronPackageJSON.version;
+        } else {
+            throw new PackageNotFoundError(packageName, dir);
+        }
+    }
+    return version;
+}
+function updateElectronDependency(packageJSON, dev, exact) {
+    const alteredDev = [].concat(dev);
+    let alteredExact = [].concat(exact);
+    // Why: checked in getElectronModuleName
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    if (Object.keys(packageJSON.devDependencies).find(findElectronDep)) {
+        alteredExact = alteredExact.filter((dep)=>dep !== 'electron'
+        );
+    } else if (packageJSON.dependencies) {
+        const electronKey = Object.keys(packageJSON.dependencies).find(findElectronDep);
+        if (electronKey) {
+            alteredExact = alteredExact.filter((dep)=>dep !== 'electron'
+            );
+            d(`Moving ${electronKey} from dependencies to devDependencies`);
+            alteredDev.push(`${electronKey}@${packageJSON.dependencies[electronKey]}`);
+            delete packageJSON.dependencies[electronKey];
+        }
+    }
+    return [
+        alteredDev,
+        alteredExact
+    ];
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/electron-version.ts"],"sourcesContent":["import path from 'path';\n\nimport debug from 'debug';\nimport findUp from 'find-up';\nimport fs from 'fs-extra';\nimport semver from 'semver';\n\nimport { safeYarnOrNpm } from './yarn-or-npm';\n\nconst d = debug('electron-forge:electron-version');\n\nconst electronPackageNames = ['electron-prebuilt-compile', 'electron-prebuilt', 'electron-nightly', 'electron'];\n\ntype PackageJSONWithDeps = {\n  devDependencies?: Record<string, string>;\n  dependencies?: Record<string, string>;\n};\n\nfunction findElectronDep(dep: string): boolean {\n  return electronPackageNames.includes(dep);\n}\n\nasync function findAncestorNodeModulesPath(dir: string, packageName: string): Promise<string | undefined> {\n  d('Looking for a lock file to indicate the root of the repo');\n  const lockPath = await findUp(['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml'], { cwd: dir, type: 'file' });\n  if (lockPath) {\n    d(`Found lock file: ${lockPath}`);\n    const nodeModulesPath = path.join(path.dirname(lockPath), 'node_modules', packageName);\n    if (await fs.pathExists(nodeModulesPath)) {\n      return nodeModulesPath;\n    }\n  }\n\n  return Promise.resolve(undefined);\n}\n\nasync function determineNodeModulesPath(dir: string, packageName: string): Promise<string | undefined> {\n  const nodeModulesPath: string | undefined = path.join(dir, 'node_modules', packageName);\n  if (await fs.pathExists(nodeModulesPath)) {\n    return nodeModulesPath;\n  }\n  return findAncestorNodeModulesPath(dir, packageName);\n}\n\nexport class PackageNotFoundError extends Error {\n  constructor(packageName: string, dir: string) {\n    super(`Cannot find the package \"${packageName}\". Perhaps you need to run \"${safeYarnOrNpm()} install\" in \"${dir}\"?`);\n  }\n}\n\nfunction getElectronModuleName(packageJSON: PackageJSONWithDeps): string {\n  if (!packageJSON.devDependencies) {\n    throw new Error('package.json for app does not have any devDependencies');\n  }\n\n  // Why: checked above\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  const packageName = electronPackageNames.find((pkg) => packageJSON.devDependencies![pkg]);\n  if (packageName === undefined) {\n    throw new Error('Could not find any Electron packages in devDependencies');\n  }\n\n  return packageName;\n}\n\nasync function getElectronPackageJSONPath(dir: string, packageName: string): Promise<string | undefined> {\n  const nodeModulesPath = await determineNodeModulesPath(dir, packageName);\n  if (!nodeModulesPath) {\n    throw new PackageNotFoundError(packageName, dir);\n  }\n\n  const electronPackageJSONPath = path.join(nodeModulesPath, 'package.json');\n  if (await fs.pathExists(electronPackageJSONPath)) {\n    return electronPackageJSONPath;\n  }\n\n  return undefined;\n}\n\nexport async function getElectronModulePath(dir: string, packageJSON: PackageJSONWithDeps): Promise<string | undefined> {\n  const moduleName = getElectronModuleName(packageJSON);\n  const packageJSONPath = await getElectronPackageJSONPath(dir, moduleName);\n  if (packageJSONPath) {\n    return path.dirname(packageJSONPath);\n  }\n\n  return undefined;\n}\n\nexport async function getElectronVersion(dir: string, packageJSON: PackageJSONWithDeps): Promise<string> {\n  const packageName = getElectronModuleName(packageJSON);\n\n  // Why: checked in getElectronModuleName\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  let version = packageJSON.devDependencies![packageName];\n  if (!semver.valid(version)) {\n    // It's not an exact version, find it in the actual module\n    const electronPackageJSONPath = await getElectronPackageJSONPath(dir, packageName);\n    if (electronPackageJSONPath) {\n      const electronPackageJSON = await fs.readJson(electronPackageJSONPath);\n      version = electronPackageJSON.version;\n    } else {\n      throw new PackageNotFoundError(packageName, dir);\n    }\n  }\n\n  return version;\n}\n\nexport function updateElectronDependency(packageJSON: PackageJSONWithDeps, dev: string[], exact: string[]): [string[], string[]] {\n  const alteredDev = ([] as string[]).concat(dev);\n  let alteredExact = ([] as string[]).concat(exact);\n  // Why: checked in getElectronModuleName\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  if (Object.keys(packageJSON.devDependencies!).find(findElectronDep)) {\n    alteredExact = alteredExact.filter((dep) => dep !== 'electron');\n  } else if (packageJSON.dependencies) {\n    const electronKey = Object.keys(packageJSON.dependencies).find(findElectronDep);\n    if (electronKey) {\n      alteredExact = alteredExact.filter((dep) => dep !== 'electron');\n      d(`Moving ${electronKey} from dependencies to devDependencies`);\n      alteredDev.push(`${electronKey}@${packageJSON.dependencies[electronKey]}`);\n      delete packageJSON.dependencies[electronKey];\n    }\n  }\n\n  return [alteredDev, alteredExact];\n}\n"],"names":["getElectronModulePath","getElectronVersion","updateElectronDependency","d","debug","electronPackageNames","findElectronDep","dep","includes","findAncestorNodeModulesPath","dir","packageName","lockPath","findUp","cwd","type","nodeModulesPath","path","join","dirname","fs","pathExists","Promise","resolve","undefined","determineNodeModulesPath","PackageNotFoundError","Error","safeYarnOrNpm","getElectronModuleName","packageJSON","devDependencies","find","pkg","getElectronPackageJSONPath","electronPackageJSONPath","moduleName","packageJSONPath","version","semver","valid","electronPackageJSON","readJson","dev","exact","alteredDev","concat","alteredExact","Object","keys","filter","dependencies","electronKey","push"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './rebuild';
+export * from './electron-version';
+export * from './yarn-or-npm';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var _exportNames = {};
+var _rebuild = _interopRequireWildcard(require("./rebuild"));
+Object.keys(_rebuild).forEach(function(key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _rebuild[key]) return;
+    Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: function() {
+            return _rebuild[key];
+        }
+    });
+});
+var _electronVersion = _interopRequireWildcard(require("./electron-version"));
+Object.keys(_electronVersion).forEach(function(key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _electronVersion[key]) return;
+    Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: function() {
+            return _electronVersion[key];
+        }
+    });
+});
+var _yarnOrNpm = _interopRequireWildcard(require("./yarn-or-npm"));
+Object.keys(_yarnOrNpm).forEach(function(key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _yarnOrNpm[key]) return;
+    Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: function() {
+            return _yarnOrNpm[key];
+        }
+    });
+});
+function _interopRequireWildcard(obj) {
+    if (obj && obj.__esModule) {
+        return obj;
+    } else {
+        var newObj = {};
+        if (obj != null) {
+            for(var key in obj){
+                if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                    var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
+                    if (desc.get || desc.set) {
+                        Object.defineProperty(newObj, key, desc);
+                    } else {
+                        newObj[key] = obj[key];
+                    }
+                }
+            }
+        }
+        newObj.default = obj;
+        return newObj;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/rebuild.d.ts

@@ -0,0 +1,5 @@
+import { ForgeArch, ForgeListrTask, ForgePlatform } from '@electron-forge/shared-types';
+import { RebuildOptions } from '@electron/rebuild';
+export declare const listrCompatibleRebuildHook: (buildPath: string, electronVersion: string, platform: ForgePlatform, arch: ForgeArch, config: Partial<RebuildOptions> | undefined, task: ForgeListrTask<any>) => Promise<void>;
+export declare const packagerRebuildHook: (buildPath: string, electronVersion: string, _platform: ForgePlatform, arch: ForgeArch, config?: Partial<RebuildOptions>) => Promise<void>;
+//# sourceMappingURL=rebuild.d.ts.map

package/dist/rebuild.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.packagerRebuildHook = exports.listrCompatibleRebuildHook = void 0;
+var cp = _interopRequireWildcard(require("child_process"));
+var path = _interopRequireWildcard(require("path"));
+var _asyncOra = require("@electron-forge/async-ora");
+var _rebuild = require("@electron/rebuild");
+function _interopRequireWildcard(obj) {
+    if (obj && obj.__esModule) {
+        return obj;
+    } else {
+        var newObj = {};
+        if (obj != null) {
+            for(var key in obj){
+                if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                    var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
+                    if (desc.get || desc.set) {
+                        Object.defineProperty(newObj, key, desc);
+                    } else {
+                        newObj[key] = obj[key];
+                    }
+                }
+            }
+        }
+        newObj.default = obj;
+        return newObj;
+    }
+}
+const listrCompatibleRebuildHook = async (buildPath, electronVersion, platform, arch, config = {}, task)=>{
+    var ref, ref1;
+    task.title = 'Preparing native dependencies';
+    const options = {
+        ...config,
+        buildPath,
+        electronVersion,
+        arch
+    };
+    const child = cp.fork(path.resolve(__dirname, 'remote-rebuild.js'), [
+        JSON.stringify(options)
+    ], {
+        stdio: [
+            'pipe',
+            'pipe',
+            'pipe',
+            'ipc'
+        ]
+    });
+    let pendingError;
+    let found = 0;
+    let done = 0;
+    const redraw = ()=>{
+        task.title = `Preparing native dependencies: ${done} / ${found}`;
+    };
+    (ref = child.stdout) === null || ref === void 0 ? void 0 : ref.on('data', (chunk)=>{
+        task.output = chunk.toString();
+    });
+    (ref1 = child.stderr) === null || ref1 === void 0 ? void 0 : ref1.on('data', (chunk)=>{
+        task.output = chunk.toString();
+    });
+    child.on('message', (message)=>{
+        switch(message.msg){
+            case 'module-found':
+                {
+                    found += 1;
+                    redraw();
+                    break;
+                }
+            case 'module-done':
+                {
+                    done += 1;
+                    redraw();
+                    break;
+                }
+            case 'rebuild-error':
+                {
+                    pendingError = new Error(message.err.message);
+                    pendingError.stack = message.err.stack;
+                    break;
+                }
+            case 'rebuild-done':
+                {
+                    task.task.rendererTaskOptions.persistentOutput = false;
+                    break;
+                }
+        }
+    });
+    await new Promise((resolve, reject)=>{
+        child.on('exit', (code)=>{
+            if (code === 0 && !pendingError) {
+                resolve();
+            } else {
+                reject(pendingError || new Error(`Rebuilder failed with exit code: ${code}`));
+            }
+        });
+    });
+};
+exports.listrCompatibleRebuildHook = listrCompatibleRebuildHook;
+const packagerRebuildHook = async (buildPath, electronVersion, _platform, arch, config = {})=>{
+    await (0, _asyncOra).asyncOra('Preparing native dependencies', async (rebuildSpinner)=>{
+        const rebuilder = (0, _rebuild).rebuild({
+            ...config,
+            buildPath,
+            electronVersion,
+            arch
+        });
+        const { lifecycle  } = rebuilder;
+        let found = 0;
+        let done = 0;
+        const redraw = ()=>{
+            rebuildSpinner.text = `Preparing native dependencies: ${done} / ${found}`;
+        };
+        lifecycle.on('module-found', ()=>{
+            found += 1;
+            redraw();
+        });
+        lifecycle.on('module-done', ()=>{
+            done += 1;
+            redraw();
+        });
+        await rebuilder;
+    });
+};
+exports.packagerRebuildHook = packagerRebuildHook;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/rebuild.ts"],"sourcesContent":["import * as cp from 'child_process';\nimport * as path from 'path';\n\nimport { asyncOra } from '@electron-forge/async-ora';\nimport { ForgeArch, ForgeListrTask, ForgePlatform } from '@electron-forge/shared-types';\nimport { rebuild, RebuildOptions } from '@electron/rebuild';\n\nexport const listrCompatibleRebuildHook = async (\n  buildPath: string,\n  electronVersion: string,\n  platform: ForgePlatform,\n  arch: ForgeArch,\n  config: Partial<RebuildOptions> = {},\n  task: ForgeListrTask<any>\n): Promise<void> => {\n  task.title = 'Preparing native dependencies';\n\n  const options: RebuildOptions = {\n    ...config,\n    buildPath,\n    electronVersion,\n    arch,\n  };\n\n  const child = cp.fork(path.resolve(__dirname, 'remote-rebuild.js'), [JSON.stringify(options)], {\n    stdio: ['pipe', 'pipe', 'pipe', 'ipc'],\n  });\n\n  let pendingError: unknown;\n  let found = 0;\n  let done = 0;\n\n  const redraw = () => {\n    task.title = `Preparing native dependencies: ${done} / ${found}`;\n  };\n\n  child.stdout?.on('data', (chunk) => {\n    task.output = chunk.toString();\n  });\n  child.stderr?.on('data', (chunk) => {\n    task.output = chunk.toString();\n  });\n\n  child.on('message', (message: any) => {\n    switch (message.msg) {\n      case 'module-found': {\n        found += 1;\n        redraw();\n        break;\n      }\n      case 'module-done': {\n        done += 1;\n        redraw();\n        break;\n      }\n      case 'rebuild-error': {\n        pendingError = new Error(message.err.message);\n        (pendingError as any).stack = message.err.stack;\n        break;\n      }\n      case 'rebuild-done': {\n        task.task.rendererTaskOptions.persistentOutput = false;\n        break;\n      }\n    }\n  });\n\n  await new Promise<void>((resolve, reject) => {\n    child.on('exit', (code) => {\n      if (code === 0 && !pendingError) {\n        resolve();\n      } else {\n        reject(pendingError || new Error(`Rebuilder failed with exit code: ${code}`));\n      }\n    });\n  });\n};\n\nexport const packagerRebuildHook = async (\n  buildPath: string,\n  electronVersion: string,\n  _platform: ForgePlatform,\n  arch: ForgeArch,\n  config: Partial<RebuildOptions> = {}\n): Promise<void> => {\n  await asyncOra('Preparing native dependencies', async (rebuildSpinner) => {\n    const rebuilder = rebuild({\n      ...config,\n      buildPath,\n      electronVersion,\n      arch,\n    });\n    const { lifecycle } = rebuilder;\n\n    let found = 0;\n    let done = 0;\n\n    const redraw = () => {\n      rebuildSpinner.text = `Preparing native dependencies: ${done} / ${found}`;\n    };\n\n    lifecycle.on('module-found', () => {\n      found += 1;\n      redraw();\n    });\n    lifecycle.on('module-done', () => {\n      done += 1;\n      redraw();\n    });\n\n    await rebuilder;\n  });\n};\n"],"names":["cp","path","listrCompatibleRebuildHook","buildPath","electronVersion","platform","arch","config","task","child","title","options","fork","resolve","__dirname","JSON","stringify","stdio","pendingError","found","done","redraw","stdout","on","chunk","output","toString","stderr","message","msg","Error","err","stack","rendererTaskOptions","persistentOutput","Promise","reject","code","packagerRebuildHook","_platform","asyncOra","rebuildSpinner","rebuilder","rebuild","lifecycle","text"],"mappings":"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"}

package/dist/remote-rebuild.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=remote-rebuild.d.ts.map

package/dist/remote-rebuild.js

@@ -0,0 +1,36 @@
+"use strict";
+var _rebuild = require("@electron/rebuild");
+if (!process.send) {
+    console.error('The remote rebuilder expects to be spawned with an IPC channel');
+    // eslint-disable-next-line no-process-exit
+    process.exit(1);
+}
+const options = JSON.parse(process.argv[2]);
+const rebuilder = (0, _rebuild).rebuild(options);
+rebuilder.lifecycle.on('module-found', ()=>process.send({
+        msg: 'module-found'
+    })
+);
+rebuilder.lifecycle.on('module-done', ()=>process.send({
+        msg: 'module-done'
+    })
+);
+rebuilder.then(()=>{
+    process.send({
+        msg: 'rebuild-done'
+    });
+    // eslint-disable-next-line no-process-exit
+    return process.exit(0);
+}).catch((err)=>{
+    process.send({
+        msg: 'rebuild-error',
+        err: {
+            message: err.message,
+            stack: err.stack
+        }
+    });
+    // eslint-disable-next-line no-process-exit
+    process.exit(0);
+});
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/yarn-or-npm.d.ts

@@ -0,0 +1,5 @@
+import { CrossSpawnArgs, CrossSpawnOptions } from '@malept/cross-spawn-promise';
+export declare const safeYarnOrNpm: () => "yarn" | "npm";
+export declare const yarnOrNpmSpawn: (args?: CrossSpawnArgs, opts?: CrossSpawnOptions | undefined) => Promise<string>;
+export declare const hasYarn: () => boolean;
+//# sourceMappingURL=yarn-or-npm.d.ts.map

package/dist/yarn-or-npm.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.hasYarn = exports.yarnOrNpmSpawn = exports.safeYarnOrNpm = void 0;
+var _crossSpawnPromise = require("@malept/cross-spawn-promise");
+var _chalk = _interopRequireDefault(require("chalk"));
+var _logSymbols = _interopRequireDefault(require("log-symbols"));
+var _yarnOrNpm = _interopRequireDefault(require("yarn-or-npm"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const safeYarnOrNpm = ()=>{
+    const system = (0, _yarnOrNpm).default();
+    switch(process.env.NODE_INSTALLER){
+        case 'yarn':
+        case 'npm':
+            return process.env.NODE_INSTALLER;
+        default:
+            if (process.env.NODE_INSTALLER) {
+                console.warn(_logSymbols.default.warning, _chalk.default.yellow(`Unknown NODE_INSTALLER, using detected installer ${system}`));
+            }
+            return system;
+    }
+};
+exports.safeYarnOrNpm = safeYarnOrNpm;
+const yarnOrNpmSpawn = (args, opts)=>(0, _crossSpawnPromise).spawn(safeYarnOrNpm(), args, opts)
+;
+exports.yarnOrNpmSpawn = yarnOrNpmSpawn;
+const hasYarn = ()=>safeYarnOrNpm() === 'yarn'
+;
+exports.hasYarn = hasYarn;
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@electron-forge/core-utils",
+  "version": "6.0.0-beta.71",
+  "description": "Core utilities for the Electron Forge packages",
+  "repository": "https://github.com/electron-userland/electron-forge",
+  "author": "Samuel Attard",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "dependencies": {
+    "@electron-forge/async-ora": "6.0.0-beta.71",
+    "@electron-forge/shared-types": "6.0.0-beta.71",
+    "@electron/rebuild": "^3.2.10",
+    "@malept/cross-spawn-promise": "^2.0.0",
+    "chalk": "^4.0.0",
+    "debug": "^4.3.1",
+    "find-up": "^5.0.0",
+    "fs-extra": "^10.0.0",
+    "log-symbols": "^4.0.0",
+    "semver": "^7.2.1",
+    "yarn-or-npm": "^3.0.1"
+  },
+  "engines": {
+    "node": ">= 14.17.5"
+  },
+  "devDependencies": {
+    "chai": "^4.3.3"
+  }
+}