@electron-forge/maker-base 6.0.0-beta.6 → 6.0.0-beta.63

package/dist/Maker.d.ts

@@ -1,4 +1,5 @@
-import { ForgeArch, ForgeConfig, ForgePlatform } from '@electron-forge/shared-types';
+import { ForgeArch, ForgeConfig, ForgePlatform, IForgeMaker } from '@electron-forge/shared-types';
+export declare type EmptyConfig = Record<string, never>;
 export interface MakerOptions {
     /**
      * The directory containing the packaged Electron application
@@ -26,18 +27,21 @@ export interface MakerOptions {
      */
     forgeConfig: ForgeConfig;
     /**
-     * The applications package.json file
+     * The application's package.json file
      */
     packageJSON: any;
 }
-export default abstract class Maker<C> {
+export default abstract class Maker<C> implements IForgeMaker {
+    private configFetcher;
+    protected providedPlatforms?: string[] | undefined;
     config: C;
-    protected providedPlatforms: ForgePlatform[] | undefined;
     abstract name: string;
     abstract defaultPlatforms: ForgePlatform[];
+    requiredExternalBinaries: string[];
     __isElectronForgeMaker: true;
-    constructor(config?: C, providedPlatforms?: ForgePlatform[] | undefined);
-    readonly platforms: ForgePlatform[];
+    constructor(configFetcher?: C | ((arch: ForgeArch) => C), providedPlatforms?: string[] | undefined);
+    get platforms(): ForgePlatform[];
+    prepareConfig(targetArch: ForgeArch): void;
     /**
      * Makers must implement this method and return true or false indicating whether
      * this maker can be run on the current platform.  Normally this is just a process.platform
@@ -69,9 +73,22 @@ export default abstract class Maker<C> {
      * I.e. If the file already exists it is deleted and the path created
      */
     ensureFile(file: string): Promise<void>;
+    /**
+     * Checks if the specified binaries exist, which are required for the maker to be used.
+     */
+    externalBinariesExist(): boolean;
+    /**
+     * Throws an error if any of the binaries don't exist.
+     */
+    ensureExternalBinariesExist(): void;
     /**
      * Checks if the given module is installed, used for testing if optional dependencies
      * are installed or not
      */
     isInstalled(module: string): boolean;
+    /**
+     * Normalize the given semver-formatted version to a 4-part dot delimited version number without
+     * prerelease information for use in Windows apps.
+     */
+    normalizeWindowsVersion(version: string): string;
 }

package/dist/Maker.js

@@ -11,35 +11,27 @@ var _fsExtra = _interopRequireDefault(require("fs-extra"));
 
 var _path = _interopRequireDefault(require("path"));
 
+var _which = _interopRequireDefault(require("which"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } function _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 class Maker {
-  /* tslint:disable variable-name */
-
-  /* tslint:enable variable-name */
-  constructor(config = {}, providedPlatforms) {
-    this.config = config;
+  constructor(configFetcher = {}, providedPlatforms) {
+    this.configFetcher = configFetcher;
     this.providedPlatforms = providedPlatforms;
-    Object.defineProperty(this, "name", {
-      configurable: true,
-      enumerable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "defaultPlatforms", {
-      configurable: true,
-      enumerable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "__isElectronForgeMaker", {
-      configurable: true,
-      enumerable: true,
-      writable: true,
-      value: void 0
-    });
+
+    _defineProperty(this, "config", void 0);
+
+    _defineProperty(this, "name", void 0);
+
+    _defineProperty(this, "defaultPlatforms", void 0);
+
+    _defineProperty(this, "requiredExternalBinaries", []);
+
+    _defineProperty(this, "__isElectronForgeMaker", void 0);
+
     Object.defineProperty(this, '__isElectronForgeMaker', {
       value: true,
       enumerable: false,
@@ -50,6 +42,16 @@ class Maker {
   get platforms() {
     if (this.providedPlatforms) return this.providedPlatforms;
     return this.defaultPlatforms;
+  } // TODO: Remove this, it is an eye-sore and is a nasty hack to provide forge
+  //       v5 style functionality in the new API
+
+
+  prepareConfig(targetArch) {
+    if (typeof this.configFetcher === 'function') {
+      this.config = this.configFetcher(targetArch);
+    } else {
+      this.config = this.configFetcher;
+    }
   }
   /**
    * Makers must implement this method and return true or false indicating whether
@@ -63,20 +65,25 @@ class Maker {
 
 
   isSupportedOnCurrentPlatform() {
-    throw new Error(`Maker ${this.name} did not implement the isSupportedOnCurrentPlatform method`);
+    if (this.isSupportedOnCurrentPlatform === Maker.prototype.isSupportedOnCurrentPlatform) {
+      throw new Error(`Maker ${this.name} did not implement the isSupportedOnCurrentPlatform method`);
+    }
+
+    return true;
   }
   /**
    * Makers must implement this method and return an array of absolute paths
    * to the artifacts generated by your maker
    */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
 
 
-  make(opts) {
-    var _this = this;
+  async make(opts) {
+    if (this.make === Maker.prototype.make) {
+      throw new Error(`Maker ${this.name} did not implement the make method`);
+    }
 
-    return _asyncToGenerator(function* () {
-      throw new Error(`Maker ${_this.name} did not implement the make method`);
-    })();
+    return [];
   }
   /**
    * Helpers
@@ -90,14 +97,12 @@ class Maker {
    */
 
 
-  ensureDirectory(dir) {
-    return _asyncToGenerator(function* () {
-      if (yield _fsExtra.default.pathExists(dir)) {
-        yield _fsExtra.default.remove(dir);
-      }
+  async ensureDirectory(dir) {
+    if (await _fsExtra.default.pathExists(dir)) {
+      await _fsExtra.default.remove(dir);
+    }
 
-      return _fsExtra.default.mkdirs(dir);
-    })();
+    return _fsExtra.default.mkdirs(dir);
   }
   /**
    * Ensures the path to the file exists and the file does not exist
@@ -106,14 +111,32 @@ class Maker {
    */
 
 
-  ensureFile(file) {
-    return _asyncToGenerator(function* () {
-      if (yield _fsExtra.default.pathExists(file)) {
-        yield _fsExtra.default.remove(file);
-      }
+  async ensureFile(file) {
+    if (await _fsExtra.default.pathExists(file)) {
+      await _fsExtra.default.remove(file);
+    }
 
-      yield _fsExtra.default.mkdirs(_path.default.dirname(file));
-    })();
+    await _fsExtra.default.mkdirs(_path.default.dirname(file));
+  }
+  /**
+   * Checks if the specified binaries exist, which are required for the maker to be used.
+   */
+
+
+  externalBinariesExist() {
+    return this.requiredExternalBinaries.every(binary => _which.default.sync(binary, {
+      nothrow: true
+    }) !== null);
+  }
+  /**
+   * Throws an error if any of the binaries don't exist.
+   */
+
+
+  ensureExternalBinariesExist() {
+    if (!this.externalBinariesExist()) {
+      throw new Error(`Cannot make for ${this.name}, the following external binaries need to be installed: ${this.requiredExternalBinaries.join(', ')}`);
+    }
   }
   /**
    * Checks if the given module is installed, used for testing if optional dependencies
@@ -123,6 +146,7 @@ class Maker {
 
   isInstalled(module) {
     try {
+      // eslint-disable-next-line global-require, import/no-dynamic-require
       require(module);
 
       return true;
@@ -131,8 +155,18 @@ class Maker {
       return false;
     }
   }
+  /**
+   * Normalize the given semver-formatted version to a 4-part dot delimited version number without
+   * prerelease information for use in Windows apps.
+   */
+
+
+  normalizeWindowsVersion(version) {
+    const noPrerelease = version.replace(/-.*/, '');
+    return `${noPrerelease}.0`;
+  }
 
 }
 
 exports.default = Maker;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/Maker.ts"],"names":["Maker","constructor","configFetcher","providedPlatforms","Object","defineProperty","value","enumerable","configurable","platforms","defaultPlatforms","prepareConfig","targetArch","config","isSupportedOnCurrentPlatform","prototype","Error","name","make","opts","ensureDirectory","dir","fs","pathExists","remove","mkdirs","ensureFile","file","path","dirname","externalBinariesExist","requiredExternalBinaries","every","binary","which","sync","nothrow","ensureExternalBinariesExist","join","isInstalled","module","require","e","normalizeWindowsVersion","version","noPrerelease","replace"],"mappings":"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","sourcesContent":["import { ForgeArch, ForgeConfig, ForgePlatform, IForgeMaker } from '@electron-forge/shared-types';\nimport fs from 'fs-extra';\nimport path from 'path';\nimport which from 'which';\n\nexport type EmptyConfig = Record<string, never>;\n\nexport interface MakerOptions {\n  /**\n   * The directory containing the packaged Electron application\n   */\n  dir: string;\n  /**\n   * The directory you should put all your artifacts in (potentially in sub folders)\n   * NOTE: this directory is not guarunteed to already exist\n   */\n  makeDir: string;\n  /**\n   * The resolved human friendly name of the project\n   */\n  appName: string;\n  /**\n   * The target platform you should make for\n   */\n  targetPlatform: ForgePlatform;\n  /**\n   * The target architecture you should make for\n   */\n  targetArch: ForgeArch;\n  /**\n   * Fully resolved forge configuration, you shouldn't really need this\n   */\n  forgeConfig: ForgeConfig;\n  /**\n   * The application's package.json file\n   */\n  packageJSON: any; // eslint-disable-line @typescript-eslint/no-explicit-any\n}\n\nexport default abstract class Maker<C> implements IForgeMaker {\n  public config!: C;\n\n  public abstract name: string;\n\n  public abstract defaultPlatforms: ForgePlatform[];\n\n  public requiredExternalBinaries: string[] = [];\n\n  __isElectronForgeMaker!: true;\n\n  constructor(private configFetcher: C | ((arch: ForgeArch) => C) = {} as C, protected providedPlatforms?: ForgePlatform[]) {\n    Object.defineProperty(this, '__isElectronForgeMaker', {\n      value: true,\n      enumerable: false,\n      configurable: false,\n    });\n  }\n\n  get platforms(): ForgePlatform[] {\n    if (this.providedPlatforms) return this.providedPlatforms;\n    return this.defaultPlatforms;\n  }\n\n  // TODO: Remove this, it is an eye-sore and is a nasty hack to provide forge\n  //       v5 style functionality in the new API\n  prepareConfig(targetArch: ForgeArch): void {\n    if (typeof this.configFetcher === 'function') {\n      this.config = (this.configFetcher as unknown as (arch: ForgeArch) => C)(targetArch);\n    } else {\n      this.config = this.configFetcher as C;\n    }\n  }\n\n  /**\n   * Makers must implement this method and return true or false indicating whether\n   * this maker can be run on the current platform.  Normally this is just a process.platform\n   * check but it can be a deeper check for dependencies like fake-root or other\n   * required external build tools.\n   *\n   * If the issue is a missing dependency you should log out a HELPFUL error message\n   * telling the developer exactly what is missing and if possible how to get it.\n   */\n  isSupportedOnCurrentPlatform(): boolean {\n    if (this.isSupportedOnCurrentPlatform === Maker.prototype.isSupportedOnCurrentPlatform) {\n      throw new Error(`Maker ${this.name} did not implement the isSupportedOnCurrentPlatform method`);\n    }\n    return true;\n  }\n\n  /**\n   * Makers must implement this method and return an array of absolute paths\n   * to the artifacts generated by your maker\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  async make(opts: MakerOptions): Promise<string[]> {\n    if (this.make === Maker.prototype.make) {\n      throw new Error(`Maker ${this.name} did not implement the make method`);\n    }\n    return [];\n  }\n\n  /**\n   * Helpers\n   */\n\n  /**\n   * Ensures the directory exists and is forced to be empty.\n   *\n   * I.e. If the directory already exists it is deleted and recreated, this\n   * is a destructive operation\n   */\n  async ensureDirectory(dir: string): Promise<void> {\n    if (await fs.pathExists(dir)) {\n      await fs.remove(dir);\n    }\n    return fs.mkdirs(dir);\n  }\n\n  /**\n   * Ensures the path to the file exists and the file does not exist\n   *\n   * I.e. If the file already exists it is deleted and the path created\n   */\n  async ensureFile(file: string): Promise<void> {\n    if (await fs.pathExists(file)) {\n      await fs.remove(file);\n    }\n    await fs.mkdirs(path.dirname(file));\n  }\n\n  /**\n   * Checks if the specified binaries exist, which are required for the maker to be used.\n   */\n  externalBinariesExist(): boolean {\n    return this.requiredExternalBinaries.every((binary) => which.sync(binary, { nothrow: true }) !== null);\n  }\n\n  /**\n   * Throws an error if any of the binaries don't exist.\n   */\n  ensureExternalBinariesExist(): void {\n    if (!this.externalBinariesExist()) {\n      throw new Error(`Cannot make for ${this.name}, the following external binaries need to be installed: ${this.requiredExternalBinaries.join(', ')}`);\n    }\n  }\n\n  /**\n   * Checks if the given module is installed, used for testing if optional dependencies\n   * are installed or not\n   */\n  isInstalled(module: string): boolean {\n    try {\n      // eslint-disable-next-line global-require, import/no-dynamic-require\n      require(module);\n      return true;\n    } catch (e) {\n      // Package doesn't exist -- must not be installable on this platform\n      return false;\n    }\n  }\n\n  /**\n   * Normalize the given semver-formatted version to a 4-part dot delimited version number without\n   * prerelease information for use in Windows apps.\n   */\n  normalizeWindowsVersion(version: string): string {\n    const noPrerelease = version.replace(/-.*/, '');\n    return `${noPrerelease}.0`;\n  }\n}\n"]}

package/package.json

@@ -1,24 +1,22 @@
 {
   "name": "@electron-forge/maker-base",
-  "version": "6.0.0-beta.6",
+  "version": "6.0.0-beta.63",
   "description": "Base maker for Electron Forge",
   "repository": "https://github.com/electron-userland/electron-forge",
   "author": "Samuel Attard",
   "license": "MIT",
   "main": "dist/Maker.js",
   "typings": "dist/Maker.d.ts",
-  "scripts": {
-    "test": "mocha --require ts-node/register test/**/*_spec.ts test/**/**/*_spec.ts --opts ../../../mocha.opts"
-  },
   "devDependencies": {
-    "chai": "^4.0.0",
-    "mocha": "^5.0.0"
+    "chai": "^4.3.3",
+    "mocha": "^9.0.1"
   },
   "engines": {
-    "node": ">= 6.0"
+    "node": ">= 12.13.0"
   },
   "dependencies": {
-    "@electron-forge/shared-types": "6.0.0-beta.6",
-    "fs-extra": "^5.0.0"
+    "@electron-forge/shared-types": "6.0.0-beta.63",
+    "fs-extra": "^10.0.0",
+    "which": "^2.0.2"
   }
 }

package/tsconfig.json

@@ -1,23 +1,27 @@
 {
-	"compilerOptions": {
-		"module": "commonjs",
-		"target": "es6",
-		"outDir": "dist",
-		"lib": [
-			"es6",
-			"dom",
-			"es7"
-		],
-		"sourceMap": true,
-		"rootDir": "src",
-		"experimentalDecorators": true,
-		"strict": true,
-		"esModuleInterop": true,
-		"declaration": true
-	},
-	"exclude": [
-		"node_modules",
-		"dist",
-		"test"
-	]
-}
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2019",
+    "outDir": "dist",
+    "lib": [
+      "dom",
+      "es2019"
+    ],
+    "sourceMap": true,
+    "rootDir": ".",
+    "experimentalDecorators": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "typeRoots": [
+      "../../../node_modules/@types",
+      "../../../typings"
+    ]
+  },
+  "exclude": [
+    "node_modules",
+    "dist",
+    "test",
+    "index.ts"
+  ]
+}