@loongdotjs/electron-winstaller 5.4.0

package/lib/sign.js

@@ -0,0 +1,189 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetSignTool = exports.createSignTool = void 0;
+var path_1 = __importDefault(require("path"));
+var semver_1 = __importDefault(require("semver"));
+var fs_extra_1 = __importDefault(require("fs-extra"));
+var VENDOR_PATH;
+var ORIGINAL_SIGN_TOOL_PATH;
+var BACKUP_SIGN_TOOL_PATH;
+var SIGN_LOG_PATH;
+/**
+ * This method uses @electron/windows-sign to create a fake signtool.exe
+ * that can be called by Squirrel - but then just calls @electron/windows-sign
+ * to actually perform the signing.
+ *
+ * That's useful for users who need a high degree of customization of the signing
+ * process but still want to use @electron/windows-installer.
+ */
+function createSignTool(options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var createSeaSignTool;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!options.windowsSign) {
+                        throw new Error('Signtool should only be created if windowsSign options are set');
+                    }
+                    VENDOR_PATH = options.vendorDirectory || path_1.default.join(__dirname, '..', 'vendor');
+                    ORIGINAL_SIGN_TOOL_PATH = path_1.default.join(VENDOR_PATH, 'signtool.exe');
+                    BACKUP_SIGN_TOOL_PATH = path_1.default.join(VENDOR_PATH, 'signtool-original.exe');
+                    SIGN_LOG_PATH = path_1.default.join(VENDOR_PATH, 'electron-windows-sign.log');
+                    return [4 /*yield*/, getCreateSeaSignTool()];
+                case 1:
+                    createSeaSignTool = _a.sent();
+                    return [4 /*yield*/, resetSignTool()];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, fs_extra_1.default.remove(SIGN_LOG_PATH)];
+                case 3:
+                    _a.sent();
+                    // Make a backup of signtool.exe
+                    return [4 /*yield*/, fs_extra_1.default.copy(ORIGINAL_SIGN_TOOL_PATH, BACKUP_SIGN_TOOL_PATH, { overwrite: true })];
+                case 4:
+                    // Make a backup of signtool.exe
+                    _a.sent();
+                    // Create a new signtool.exe using @electron/windows-sign
+                    return [4 /*yield*/, createSeaSignTool({
+                            path: ORIGINAL_SIGN_TOOL_PATH,
+                            windowsSign: options.windowsSign
+                        })];
+                case 5:
+                    // Create a new signtool.exe using @electron/windows-sign
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.createSignTool = createSignTool;
+/**
+ * Ensure that signtool.exe is actually the "real" signtool.exe, not our
+ * fake substitute.
+ */
+function resetSignTool() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!fs_extra_1.default.existsSync(BACKUP_SIGN_TOOL_PATH)) return [3 /*break*/, 3];
+                    // Reset the backup of signtool.exe
+                    return [4 /*yield*/, fs_extra_1.default.copy(BACKUP_SIGN_TOOL_PATH, ORIGINAL_SIGN_TOOL_PATH, { overwrite: true })];
+                case 1:
+                    // Reset the backup of signtool.exe
+                    _a.sent();
+                    return [4 /*yield*/, fs_extra_1.default.remove(BACKUP_SIGN_TOOL_PATH)];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.resetSignTool = resetSignTool;
+/**
+ * @electron/windows-installer only requires Node.js >= 8.0.0.
+ * @electron/windows-sign requires Node.js >= 16.0.0.
+ * @electron/windows-sign's "fake signtool.exe" feature requires
+ * Node.js >= 20.0.0, the first version to contain the "single
+ * executable" feature with proper support.
+ *
+ * Since this is overall a very niche feature and only benefits
+ * consumers with rather advanced codesigning needs, we did not
+ * want to make Node.js v18 a hard requirement for @electron/windows-installer.
+ *
+ * Instead, @electron/windows-sign is an optional dependency - and
+ * if it didn't install, we'll throw a useful error here.
+ *
+ * @returns
+ */
+function getCreateSeaSignTool() {
+    return __awaiter(this, void 0, void 0, function () {
+        var createSeaSignTool, error_1, message;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require('@electron/windows-sign')); })];
+                case 1:
+                    createSeaSignTool = (_a.sent()).createSeaSignTool;
+                    return [2 /*return*/, createSeaSignTool];
+                case 2:
+                    error_1 = _a.sent();
+                    message = 'In order to use windowsSign options, @electron/windows-sign must be installed as a dependency.';
+                    if (semver_1.default.lte(process.version, '20.0.0')) {
+                        message += " You are currently using Node.js ".concat(process.version, ". Please upgrade to Node.js 19 or later and reinstall all dependencies to ensure that @electron/windows-sign is available.");
+                    }
+                    else {
+                        message += " ".concat(error_1);
+                    }
+                    throw new Error(message);
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+//# sourceMappingURL=sign.js.map

package/lib/sign.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sign.js","sourceRoot":"","sources":["../src/sign.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,8CAAwB;AACxB,kDAA4B;AAC5B,sDAA0B;AAI1B,IAAI,WAAmB,CAAC;AACxB,IAAI,uBAA+B,CAAC;AACpC,IAAI,qBAA6B,CAAC;AAClC,IAAI,aAAqB,CAAC;AAE1B;;;;;;;GAOG;AACH,SAAsB,cAAc,CAAC,OAA+B;;;;;;oBAClE,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE;wBACxB,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAC;qBACnF;oBAED,WAAW,GAAG,OAAO,CAAC,eAAe,IAAI,cAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;oBAC9E,uBAAuB,GAAG,cAAI,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;oBACjE,qBAAqB,GAAG,cAAI,CAAC,IAAI,CAAC,WAAW,EAAE,uBAAuB,CAAC,CAAC;oBACxE,aAAa,GAAG,cAAI,CAAC,IAAI,CAAC,WAAW,EAAE,2BAA2B,CAAC,CAAC;oBAE1C,qBAAM,oBAAoB,EAAE,EAAA;;oBAAhD,iBAAiB,GAAG,SAA4B;oBAEtD,qBAAM,aAAa,EAAE,EAAA;;oBAArB,SAAqB,CAAC;oBACtB,qBAAM,kBAAE,CAAC,MAAM,CAAC,aAAa,CAAC,EAAA;;oBAA9B,SAA8B,CAAC;oBAE/B,gCAAgC;oBAChC,qBAAM,kBAAE,CAAC,IAAI,CAAC,uBAAuB,EAAE,qBAAqB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,EAAA;;oBADlF,gCAAgC;oBAChC,SAAkF,CAAC;oBAEnF,yDAAyD;oBACzD,qBAAM,iBAAiB,CAAC;4BACtB,IAAI,EAAE,uBAAuB;4BAC7B,WAAW,EAAE,OAAO,CAAC,WAAW;yBACjC,CAAC,EAAA;;oBAJF,yDAAyD;oBACzD,SAGE,CAAC;;;;;CACJ;AAvBD,wCAuBC;AAED;;;GAGG;AACH,SAAsB,aAAa;;;;;yBAC7B,kBAAE,CAAC,UAAU,CAAC,qBAAqB,CAAC,EAApC,wBAAoC;oBACtC,mCAAmC;oBACnC,qBAAM,kBAAE,CAAC,IAAI,CAAC,qBAAqB,EAAE,uBAAuB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,EAAA;;oBADlF,mCAAmC;oBACnC,SAAkF,CAAC;oBACnF,qBAAM,kBAAE,CAAC,MAAM,CAAC,qBAAqB,CAAC,EAAA;;oBAAtC,SAAsC,CAAC;;;;;;CAE1C;AAND,sCAMC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAe,oBAAoB;;;;;;;oBAED,sFAAa,wBAAwB,QAAC;;oBAA5D,iBAAiB,GAAK,CAAA,SAAsC,CAAA,kBAA3C;oBACzB,sBAAO,iBAAiB,EAAC;;;oBAErB,OAAO,GAAI,gGAAgG,CAAC;oBAEhH,IAAI,gBAAM,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE;wBACzC,OAAO,IAAI,2CAAoC,OAAO,CAAC,OAAO,+HAA4H,CAAC;qBAC5L;yBAAM;wBACL,OAAO,IAAI,WAAI,OAAK,CAAE,CAAC;qBACxB;oBAED,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;;;;;CAE5B"}

package/lib/spawn-promise.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { SpawnOptionsWithoutStdio } from 'child_process';
+export default function spawn(exe: string, params: string[], opts?: SpawnOptionsWithoutStdio): Promise<string>;

package/lib/spawn-promise.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var child_process_1 = require("child_process");
+var d = require('debug')('electron-windows-installer:spawn');
+// Public: Maps a process's output into an {Observable}
+//
+// exe - The program to execute
+// params - Arguments passed to the process
+// opts - Options that will be passed to child_process.spawn
+//
+// Returns an {Observable} with a single value, that is the output of the
+// spawned process
+function spawn(exe, params, opts) {
+    return new Promise(function (resolve, reject) {
+        var proc = null;
+        d("Spawning ".concat(exe, " ").concat(params.join(' ')));
+        if (!opts) {
+            proc = (0, child_process_1.spawn)(exe, params);
+        }
+        else {
+            proc = (0, child_process_1.spawn)(exe, params, opts);
+        }
+        // We need to wait until all three events have happened:
+        // * stdout's pipe is closed
+        // * stderr's pipe is closed
+        // * We've got an exit code
+        var rejected = false;
+        var refCount = 3;
+        var stdout = '';
+        var release = function () {
+            if (--refCount <= 0 && !rejected)
+                resolve(stdout);
+        };
+        var bufHandler = function (chunk) {
+            stdout += chunk;
+        };
+        proc.stdout.setEncoding('utf8').on('data', bufHandler);
+        proc.stdout.once('close', release);
+        proc.stderr.setEncoding('utf8').on('data', bufHandler);
+        proc.stderr.once('close', release);
+        proc.on('error', function (e) { return reject(e); });
+        proc.on('close', function (code) {
+            if (code === 0) {
+                release();
+            }
+            else {
+                rejected = true;
+                reject(new Error("Failed with exit code: ".concat(code, "\nOutput:\n").concat(stdout)));
+            }
+        });
+    });
+}
+exports.default = spawn;
+//# sourceMappingURL=spawn-promise.js.map

package/lib/spawn-promise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn-promise.js","sourceRoot":"","sources":["../src/spawn-promise.ts"],"names":[],"mappings":";;AAAA,+CAA2E;AAE3E,IAAM,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,kCAAkC,CAAC,CAAC;AAE/D,uDAAuD;AACvD,EAAE;AACF,+BAA+B;AAC/B,2CAA2C;AAC3C,4DAA4D;AAC5D,EAAE;AACF,yEAAyE;AACzE,kBAAkB;AAClB,SAAwB,KAAK,CAAC,GAAW,EAAE,MAAgB,EAAE,IAA+B;IAC1F,OAAO,IAAI,OAAO,CAAC,UAAC,OAAO,EAAE,MAAM;QACjC,IAAI,IAAI,GAAG,IAAI,CAAC;QAEhB,CAAC,CAAC,mBAAY,GAAG,cAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAE,CAAC,CAAC;QACzC,IAAI,CAAC,IAAI,EAAE;YACT,IAAI,GAAG,IAAA,qBAAO,EAAC,GAAG,EAAE,MAAM,CAAC,CAAC;SAC7B;aAAM;YACL,IAAI,GAAG,IAAA,qBAAO,EAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;SACnC;QAED,wDAAwD;QACxD,4BAA4B;QAC5B,4BAA4B;QAC5B,2BAA2B;QAC3B,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAI,QAAQ,GAAG,CAAC,CAAC;QACjB,IAAI,MAAM,GAAG,EAAE,CAAC;QAEhB,IAAM,OAAO,GAAG;YACd,IAAI,EAAE,QAAQ,IAAI,CAAC,IAAI,CAAC,QAAQ;gBAAE,OAAO,CAAC,MAAM,CAAC,CAAC;QACpD,CAAC,CAAC;QAEF,IAAM,UAAU,GAAG,UAAC,KAAa;YAC/B,MAAM,IAAI,KAAK,CAAC;QAClB,CAAC,CAAC;QAEF,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QACvD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACnC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QACvD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACnC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,UAAC,CAAQ,IAAW,OAAA,MAAM,CAAC,CAAC,CAAC,EAAT,CAAS,CAAC,CAAC;QAEhD,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,UAAC,IAAY;YAC5B,IAAI,IAAI,KAAK,CAAC,EAAE;gBACd,OAAO,EAAE,CAAC;aACX;iBAAM;gBACL,QAAQ,GAAG,IAAI,CAAC;gBAChB,MAAM,CAAC,IAAI,KAAK,CAAC,iCAA0B,IAAI,wBAAc,MAAM,CAAE,CAAC,CAAC,CAAC;aACzE;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AA1CD,wBA0CC"}

package/lib/temp-utils.d.ts

@@ -0,0 +1,3 @@
+import * as temp from 'temp';
+declare const createTempDir: (arg1: string | temp.AffixOptions | undefined) => Promise<string>;
+export { createTempDir };

package/lib/temp-utils.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTempDir = void 0;
+var temp = __importStar(require("temp"));
+var util_1 = require("util");
+temp.track();
+var createTempDir = (0, util_1.promisify)(temp.mkdir);
+exports.createTempDir = createTempDir;
+//# sourceMappingURL=temp-utils.js.map

package/lib/temp-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"temp-utils.js","sourceRoot":"","sources":["../src/temp-utils.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yCAA6B;AAC7B,6BAAiC;AACjC,IAAI,CAAC,KAAK,EAAE,CAAC;AAEb,IAAM,aAAa,GAAG,IAAA,gBAAS,EAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAG1C,sCAAa"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@loongdotjs/electron-winstaller",
+  "version": "5.4.0",
+  "description": "Module to generate Windows installers for Electron apps",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/electron/windows-installer"
+  },
+  "files": [
+    "lib",
+    "resources",
+    "script",
+    "template.nuspectemplate",
+    "vendor",
+    "!vendor/7z.dll",
+    "!vendor/7z.exe"
+  ],
+  "scripts": {
+    "install": "node ./script/select-7z-arch.js",
+    "build": "tsc",
+    "docs": "npx typedoc",
+    "prepublish": "npm run build",
+    "lint": "eslint --ext .ts src spec",
+    "ava": "ava --timeout=60s",
+    "test": "npm run lint && npm run ava",
+    "tdd": "ava --watch"
+  },
+  "dependencies": {
+    "@electron/asar": "^3.2.1",
+    "debug": "^4.1.1",
+    "fs-extra": "^7.0.1",
+    "lodash": "^4.17.21",
+    "temp": "^0.9.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^5.0.5",
+    "@types/lodash": "^4.17.0",
+    "@types/node": "^20.6.0",
+    "@types/temp": "^0.8.34",
+    "@typescript-eslint/eslint-plugin": "^5.62.0",
+    "@typescript-eslint/parser": "^5.62.0",
+    "ava": "^5.1.1",
+    "eslint": "^8.49.0",
+    "eslint-plugin-ava": "^14.0.0",
+    "ts-node": "^10.9.1",
+    "typedoc": "0.25.13",
+    "typescript": "^4.9.3"
+  },
+  "optionalDependencies": {
+    "@electron/windows-sign": "^1.1.2"
+  },
+  "engines": {
+    "node": ">=8.0.0"
+  },
+  "ava": {
+    "extensions": [
+      "ts"
+    ],
+    "files": [
+      "spec/*.ts"
+    ],
+    "require": [
+      "ts-node/register/transpile-only"
+    ]
+  }
+}

package/script/select-7z-arch.js

@@ -0,0 +1,33 @@
+const fs = require('fs');
+const os = require('os');
+
+/**
+ * Even if we're cross-compiling for a different arch like arm64,
+ * we still need to use the 7-Zip executable for the host arch
+ */
+const arch = os.arch;
+const platform = process.platform;
+
+console.log('Selecting 7-Zip for arch ' + arch + ' on platform ' + platform);
+
+// Only copy 7-Zip on Windows platform and for supported architectures
+if (platform === 'win32') {
+  try {
+    fs.copyFileSync('vendor/7z-' + arch + '.exe', 'vendor/7z.exe');
+    console.log(`Successfully copied 7z-${arch}.exe to vendor/7z.exe`);
+  } catch (err) {
+    console.error(`Failed to copy 7z-${arch}.exe:`, err.message);
+    throw err;
+  }
+
+  try {
+    fs.copyFileSync('vendor/7z-' + arch + '.dll', 'vendor/7z.dll');
+    console.log(`Successfully copied 7z-${arch}.dll to vendor/7z.dll`);
+  } catch (err) {
+    console.error(`Failed to copy 7z-${arch}.dll:`, err.message);
+    throw err;
+  }
+} else {
+  console.log(`Skipping 7-Zip selection on non-Windows platform (${platform}). 7-Zip is only required on Windows.`);
+  process.exit(0);
+}

package/spec/convert-version-spec.ts

@@ -0,0 +1,14 @@
+import test from 'ava';
+import { convertVersion } from '../src/index';
+
+test('makes semver versions into valid NuGet versions', (t): void => {
+  t.is(convertVersion('1'), '1');
+  t.is(convertVersion('1.2'), '1.2');
+  t.is(convertVersion('1.2.3'), '1.2.3');
+  t.is(convertVersion('1.2.3-alpha'), '1.2.3-alpha');
+  t.is(convertVersion('1.2.3-alpha.1'), '1.2.3-alpha1');
+  t.is(convertVersion('1.2.3-alpha.1.2'), '1.2.3-alpha12');
+  t.is(convertVersion('1.2.3-alpha-1-2'), '1.2.3-alpha-1-2');
+  t.is(convertVersion('1.2.3-alpha.1.2+build-meta.1.2'), '1.2.3-alpha12');
+  t.is(convertVersion('1.2.3-alpha-1-2+build-meta.1.2'), '1.2.3-alpha-1-2');
+});

package/spec/fixtures/app/resources/app/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "myapp",
+  "productName": "MyApp",
+  "version": "1.0.0",
+  "description": "An app",
+  "authors": "Cyril Figgis"
+}

package/spec/helpers/helpers.ts

@@ -0,0 +1,12 @@
+import path from 'path';
+import fs from 'fs-extra';
+
+import { createTempDir } from '../../src/temp-utils';
+
+export const FIXTURE_APP_DIR = path.join(__dirname, '../fixtures/app');
+
+export async function createTempAppDirectory(): Promise<string> {
+  const appDirectory = await createTempDir('electron-winstaller-ad-');
+  await fs.copy(FIXTURE_APP_DIR, appDirectory);
+  return appDirectory;
+}

package/spec/helpers/windowsSignHook.js

@@ -0,0 +1,8 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+module.exports = function(args) {
+  console.log(...args);
+
+  fs.appendFileSync(path.join(__dirname, 'hook.log'), `${JSON.stringify(args)}\n`);
+};

package/spec/installer-spec.ts

@@ -0,0 +1,70 @@
+import test from 'ava';
+import path from 'path';
+import { createTempDir } from '../src/temp-utils';
+import fs from 'fs-extra';
+import { createWindowsInstaller } from '../src';
+import spawn from '../src/spawn-promise';
+import { createTempAppDirectory } from './helpers/helpers';
+
+const log = require('debug')('electron-windows-installer:spec');
+
+function spawn7z(args: string[]): Promise<string> {
+  const sevenZipPath = path.join(__dirname, '..', 'vendor', '7z.exe');
+  const wineExe = ['arm64', 'x64'].includes(process.arch) ? 'wine64' : 'wine';
+  return process.platform !== 'win32'
+    ? spawn(wineExe, [sevenZipPath, ...args])
+    : spawn(sevenZipPath, args);
+}
+
+
+test.serial('creates a nuget package and installer', async (t): Promise<void> => {
+  const outputDirectory = await createTempDir('ei-');
+  const appDirectory = await createTempAppDirectory();
+  const options = { appDirectory, outputDirectory };
+
+  await createWindowsInstaller(options);
+
+  log(`Verifying assertions on ${outputDirectory}`);
+  log(JSON.stringify(await fs.readdir(outputDirectory)));
+
+  const nupkgPath = path.join(outputDirectory, 'myapp-1.0.0-full.nupkg');
+
+  t.true(await fs.pathExists(nupkgPath));
+  t.true(await fs.pathExists(path.join(outputDirectory, 'MyAppSetup.exe')));
+
+  if (process.platform === 'win32') {
+    t.true(await fs.pathExists(path.join(outputDirectory, 'MyAppSetup.msi')));
+  }
+
+  log('Verifying Update.exe');
+  t.true(await fs.pathExists(path.join(appDirectory, 'Squirrel.exe')));
+
+  log('Verifying contents of .nupkg');
+
+  const packageContents = await spawn7z(['l', nupkgPath]);
+
+  t.true(packageContents.includes('lib\\net45\\vk_swiftshader_icd.json'));
+  t.true(packageContents.includes('lib\\net45\\swiftshader\\libEGL.dll'));
+});
+
+test.serial('creates an installer when swiftshader files are missing', async (t): Promise<void> => {
+  const appDirectory = await createTempAppDirectory();
+  const outputDirectory = await createTempDir('electron-winstaller-test-');
+  const options = { appDirectory, outputDirectory };
+
+  // Remove swiftshader folder and swiftshader json file, simulating Electron < 10.0
+  await fs.remove(path.join(appDirectory, 'swiftshader', 'libEGL.dll'));
+  await fs.remove(path.join(appDirectory, 'swiftshader', 'libGLESv2.dll'));
+  await fs.rmdir(path.join(appDirectory, 'swiftshader'));
+  await fs.remove(path.join(appDirectory, 'vk_swiftshader_icd.json'));
+
+  await createWindowsInstaller(options);
+
+  const nupkgPath = path.join(outputDirectory, 'myapp-1.0.0-full.nupkg');
+
+  log('Verifying contents of .nupkg');
+
+  const packageContents = await spawn7z(['l', nupkgPath]);
+  t.false(packageContents.includes('vk_swiftshader_icd.json'));
+  t.false(packageContents.includes('swiftshader\\'));
+});

package/spec/sign-spec.ts

@@ -0,0 +1,48 @@
+import test from 'ava';
+import path from 'path';
+import { createTempDir } from '../src/temp-utils';
+import fs from 'fs-extra';
+import { createWindowsInstaller } from '../src';
+import { createTempAppDirectory } from './helpers/helpers';
+import { SignToolOptions } from '@electron/windows-sign';
+import semver from 'semver';
+
+const log = require('debug')('electron-windows-installer:spec');
+
+if (process.platform === 'win32' && semver.gte(process.version, '20.0.0')) {
+  test.serial('creates a signtool.exe and uses it to sign', async (t): Promise<void> => {
+
+    const outputDirectory = await createTempDir('ei-');
+    const appDirectory = await createTempAppDirectory();
+    const hookLogPath = path.join(__dirname, './helpers/hook.log');
+    const hookModulePath = path.join(__dirname, './helpers/windowsSignHook.js');
+    const windowsSign: SignToolOptions = { hookModulePath };
+    const options = { appDirectory, outputDirectory, windowsSign };
+
+    // Reset
+    await fs.remove(hookLogPath);
+
+    // Test
+    await createWindowsInstaller(options);
+
+    log(`Verifying assertions on ${outputDirectory}`);
+    log(JSON.stringify(await fs.readdir(outputDirectory)));
+
+    const nupkgPath = path.join(outputDirectory, 'myapp-1.0.0-full.nupkg');
+
+    t.true(await fs.pathExists(nupkgPath));
+    t.true(await fs.pathExists(path.join(outputDirectory, 'MyAppSetup.exe')));
+
+    if (process.platform === 'win32') {
+      t.true(await fs.pathExists(path.join(outputDirectory, 'MyAppSetup.msi')));
+    }
+
+    log('Verifying Update.exe');
+    t.true(await fs.pathExists(path.join(appDirectory, 'Squirrel.exe')));
+
+    log('Verifying that our hook got to "sign" all files');
+    const hookLog = await fs.readFile(hookLogPath, { encoding: 'utf8' });
+    const filesLogged = hookLog.split('\n').filter(v => !!v.trim()).length;
+    t.is(filesLogged, 8);
+  });
+}