Merge pull request #31 from aryanshridhar/Add-DownloadOptions

feat: add installing options for electron binary

Author: VerteDinde

README.md

@@ -78,7 +78,7 @@ const result = await runner.bisect('10.0.0', '13.1.7', path_or_gist_or_git_repo)
 ### Managing Electron Installations
 
 ```ts
-import { Installer } from 'fiddle-core';
+import { Installer, ProgressObject } from 'fiddle-core';
 
 const installer = new Installer();
 installer.on('state-changed', ({version, state}) => {
@@ -89,12 +89,37 @@ installer.on('state-changed', ({version, state}) => {
 await installer.ensureDownloaded('12.0.15');
 // expect(installer.state('12.0.5').toBe('downloaded');
 
+// download a version with callback
+const callback = (progress: ProgressObject) => {
+  const percent = progress.percent * 100;
+  console.log(`Current download progress %: ${percent.toFixed(2)}`);
+};
+await installer.ensureDownloaded('12.0.15', {
+  progressCallback: callback,
+});
+
+// download a version with a specific mirror
+const npmMirrors = {
+  electronMirror: 'https://npmmirror.com/mirrors/electron/',
+  electronNightlyMirror: 'https://npmmirror.com/mirrors/electron-nightly/',
+},
+
+await installer.ensureDownloaded('12.0.15', {
+  mirror: npmMirrors,
+});
+
 // remove a download
 await installer.remove('12.0.15');
 // expect(installer.state('12.0.15').toBe('not-downloaded');
 
 // install a specific version for the runner to use
 const exec = await installer.install('11.4.10');
+
+// Installing with callback and custom mirrors
+await installer.install('11.4.10', {
+  progressCallback: callback,
+  mirror: npmMirrors,
+});
 // expect(installer.state('11.4.10').toBe('installed');
 // expect(fs.accessSync(exec, fs.constants.X_OK)).toBe(true);
 ```

dist/fiddle-core.d.ts

@@ -40,6 +40,18 @@ export declare function compareVersions(a: SemVer, b: SemVer): number;
 
 export declare const DefaultPaths: Paths;
 
+export declare type ProgressObject = { percent: number };
+
+export declare interface Mirrors {
+    electronMirror: string;
+    electronNightlyMirror: string;
+}
+
+interface InstallerParams {
+    progressCallback: (progress: ProgressObject) => void;
+    mirror: Mirrors;
+}
+
 /**
  * Implementation of Versions that self-populates from release information at
  * https://releases.electronjs.org/releases.json .
@@ -106,10 +118,10 @@ export declare class Installer extends EventEmitter {
     private ensureDownloadedImpl;
     /** map of version string to currently-running active Promise */
     private downloading;
-    ensureDownloaded(version: string): Promise<string>;
+    ensureDownloaded(version: string, opts?: Partial<InstallerParams>): Promise<string>;
     /** the currently-installing version, if any */
     private installing;
-    install(version: string): Promise<string>;
+    install(version: string, opts?: Partial<InstallerParams>): Promise<string>;
 }
 
 /**

src/installer.ts

@@ -31,6 +31,16 @@ export interface InstallStateEvent {
   state: InstallState;
 }
 
+export interface Mirrors {
+  electronMirror: string;
+  electronNightlyMirror: string;
+}
+
+interface InstallerParams {
+  progressCallback: (progress: ProgressObject) => void;
+  mirror: Mirrors;
+}
+
 /**
  * Manage downloading and installing Electron versions.
  *
@@ -190,9 +200,16 @@ export class Installer extends EventEmitter {
       if (state === 'installed') return version;
   }
 
-  private async download(version: string): Promise<string> {
+  private async download(
+    version: string,
+    opts?: Partial<InstallerParams>,
+  ): Promise<string> {
     let pctDone = 0;
     const getProgressCallback = (progress: ProgressObject) => {
+      if (opts?.progressCallback) {
+        // Call the user passed callback function
+        opts.progressCallback(progress);
+      }
       const pct = Math.round(progress.percent * 100);
       if (pctDone + 10 <= pct) {
         const emoji = pct >= 100 ? '🏁' : '⏳';
@@ -202,6 +219,10 @@ export class Installer extends EventEmitter {
       }
     };
     const zipFile = await electronDownload(version, {
+      mirrorOptions: {
+        mirror: opts?.mirror?.electronMirror,
+        nightlyMirror: opts?.mirror?.electronNightlyMirror,
+      },
       downloadOptions: {
         quiet: true,
         getProgressCallback,
@@ -210,7 +231,10 @@ export class Installer extends EventEmitter {
     return zipFile;
   }
 
-  private async ensureDownloadedImpl(version: string): Promise<string> {
+  private async ensureDownloadedImpl(
+    version: string,
+    opts?: Partial<InstallerParams>,
+  ): Promise<string> {
     const d = debug(`fiddle-core:Installer:${version}:ensureDownloadedImpl`);
     const { electronDownloads } = this.paths;
     const zipFile = path.join(electronDownloads, getZipName(version));
@@ -219,7 +243,7 @@ export class Installer extends EventEmitter {
     if (state === 'missing') {
       d(`"${zipFile}" does not exist; downloading now`);
       this.setState(version, 'downloading');
-      const tempFile = await this.download(version);
+      const tempFile = await this.download(version, opts);
       await fs.ensureDir(electronDownloads);
       await fs.move(tempFile, zipFile);
       this.setState(version, 'downloaded');
@@ -234,12 +258,15 @@ export class Installer extends EventEmitter {
   /** map of version string to currently-running active Promise */
   private downloading = new Map<string, Promise<string>>();
 
-  public async ensureDownloaded(version: string): Promise<string> {
+  public async ensureDownloaded(
+    version: string,
+    opts?: Partial<InstallerParams>,
+  ): Promise<string> {
     const { downloading: promises } = this;
     let promise = promises.get(version);
     if (promise) return promise;
 
-    promise = this.ensureDownloadedImpl(version).finally(() =>
+    promise = this.ensureDownloadedImpl(version, opts).finally(() =>
       promises.delete(version),
     );
     promises.set(version, promise);
@@ -249,7 +276,10 @@ export class Installer extends EventEmitter {
   /** the currently-installing version, if any */
   private installing: string | undefined;
 
-  public async install(version: string): Promise<string> {
+  public async install(
+    version: string,
+    opts?: Partial<InstallerParams>,
+  ): Promise<string> {
     const d = debug(`fiddle-core:Installer:${version}:install`);
     const { electronInstall } = this.paths;
     const electronExec = Installer.getExecPath(electronInstall);
@@ -262,7 +292,7 @@ export class Installer extends EventEmitter {
     if (installedVersion === version) {
       d(`already installed`);
     } else {
-      const zipFile = await this.ensureDownloaded(version);
+      const zipFile = await this.ensureDownloaded(version, opts);
       this.setState(version, 'installing');
       d(`installing from "${zipFile}"`);
       await fs.emptyDir(electronInstall);

tests/installer.test.ts

@@ -71,21 +71,44 @@ describe('Installer', () => {
   }
 
   async function doInstall(installer: Installer, version: string) {
-    const func = () => installer.install(version);
+    let isDownloaded = false;
+    const progressCallback = () => {
+      isDownloaded = true;
+    };
+
+    // Version is already downloaded and present in local
+    if (installer.state(version) !== 'missing') {
+      isDownloaded = true;
+    }
+    const func = () => installer.install(version, { progressCallback });
     const { events, result } = await listenWhile(installer, func);
     const exec = result as string;
 
+    expect(isDownloaded).toBe(true);
     expect(installer.state(version)).toBe('installed');
     expect(installer.installedVersion).toBe(version);
 
     return { events, exec };
   }
 
   async function doDownload(installer: Installer, version: string) {
-    const func = () => installer.ensureDownloaded(version);
+    let isDownloaded = false;
+    const progressCallback = () => {
+      isDownloaded = true;
+    };
+
+    // Version is already downloaded and present in local
+    if (installer.state(version) !== 'missing') {
+      isDownloaded = true;
+    }
+    const func = () =>
+      installer.ensureDownloaded(version, {
+        progressCallback,
+      });
     const { events, result } = await listenWhile(installer, func);
     const zipfile = result as string;
 
+    expect(isDownloaded).toBe(true);
     expect(fs.existsSync(zipfile)).toBe(true);
     expect(installer.state(version)).toBe('downloaded');