build: enable JS semicolons (#22783)

spec-main/api-context-bridge-spec.ts

@@ -1,22 +1,22 @@
-import { contextBridge, BrowserWindow, ipcMain } from 'electron'
-import { expect } from 'chai'
-import * as fs from 'fs-extra'
-import * as os from 'os'
-import * as path from 'path'
+import { contextBridge, BrowserWindow, ipcMain } from 'electron';
+import { expect } from 'chai';
+import * as fs from 'fs-extra';
+import * as os from 'os';
+import * as path from 'path';
 
-import { closeWindow } from './window-helpers'
-import { emittedOnce } from './events-helpers'
+import { closeWindow } from './window-helpers';
+import { emittedOnce } from './events-helpers';
 
-const fixturesPath = path.resolve(__dirname, 'fixtures', 'api', 'context-bridge')
+const fixturesPath = path.resolve(__dirname, 'fixtures', 'api', 'context-bridge');
 
 describe('contextBridge', () => {
-  let w: BrowserWindow
-  let dir: string
+  let w: BrowserWindow;
+  let dir: string;
 
   afterEach(async () => {
-    await closeWindow(w)
-    if (dir) await fs.remove(dir)
-  })
+    await closeWindow(w);
+    if (dir) await fs.remove(dir);
+  });
 
   it('should not be accessible when contextIsolation is disabled', async () => {
     w = new BrowserWindow({
@@ -25,10 +25,10 @@ describe('contextBridge', () => {
         contextIsolation: false,
         preload: path.resolve(fixturesPath, 'can-bind-preload.js')
       }
-    })
-    const [, bound] = await emittedOnce(ipcMain, 'context-bridge-bound', () => w.loadFile(path.resolve(fixturesPath, 'empty.html')))
-    expect(bound).to.equal(false)
-  })
+    });
+    const [, bound] = await emittedOnce(ipcMain, 'context-bridge-bound', () => w.loadFile(path.resolve(fixturesPath, 'empty.html')));
+    expect(bound).to.equal(false);
+  });
 
   it('should be accessible when contextIsolation is enabled', async () => {
     w = new BrowserWindow({
@@ -37,10 +37,10 @@ describe('contextBridge', () => {
         contextIsolation: true,
         preload: path.resolve(fixturesPath, 'can-bind-preload.js')
       }
-    })
-    const [, bound] = await emittedOnce(ipcMain, 'context-bridge-bound', () => w.loadFile(path.resolve(fixturesPath, 'empty.html')))
-    expect(bound).to.equal(true)
-  })
+    });
+    const [, bound] = await emittedOnce(ipcMain, 'context-bridge-bound', () => w.loadFile(path.resolve(fixturesPath, 'empty.html')));
+    expect(bound).to.equal(true);
+  });
 
   const generateTests = (useSandbox: boolean) => {
     describe(`with sandbox=${useSandbox}`, () => {
@@ -51,10 +51,10 @@ describe('contextBridge', () => {
         electron_1.contextBridge.exposeInMainWorld('GCRunner', {
           run: () => gc()
         });`}
-        (${bindingCreator.toString()})();`
-        const tmpDir = await fs.mkdtemp(path.resolve(os.tmpdir(), 'electron-spec-preload-'))
-        dir = tmpDir
-        await fs.writeFile(path.resolve(tmpDir, 'preload.js'), preloadContent)
+        (${bindingCreator.toString()})();`;
+        const tmpDir = await fs.mkdtemp(path.resolve(os.tmpdir(), 'electron-spec-preload-'));
+        dir = tmpDir;
+        await fs.writeFile(path.resolve(tmpDir, 'preload.js'), preloadContent);
         w = new BrowserWindow({
           show: false,
           webPreferences: {
@@ -63,12 +63,12 @@ describe('contextBridge', () => {
             sandbox: useSandbox,
             preload: path.resolve(tmpDir, 'preload.js')
           }
-        })
-        await w.loadFile(path.resolve(fixturesPath, 'empty.html'))
-      }
+        });
+        await w.loadFile(path.resolve(fixturesPath, 'empty.html'));
+      };
 
       const callWithBindings = (fn: Function) =>
-        w.webContents.executeJavaScript(`(${fn.toString()})(window)`)
+        w.webContents.executeJavaScript(`(${fn.toString()})(window)`);
 
       const getGCInfo = async (): Promise<{
         functionCount: number
@@ -76,140 +76,140 @@ describe('contextBridge', () => {
         liveFromValues: number
         liveProxyValues: number
       }> => {
-        const [, info] = await emittedOnce(ipcMain, 'gc-info', () => w.webContents.send('get-gc-info'))
-        return info
-      }
+        const [, info] = await emittedOnce(ipcMain, 'gc-info', () => w.webContents.send('get-gc-info'));
+        return info;
+      };
 
       it('should proxy numbers', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             myNumber: 123
-          })
-        })
+          });
+        });
         const result = await callWithBindings((root: any) => {
-          return root.example.myNumber
-        })
-        expect(result).to.equal(123)
-      })
+          return root.example.myNumber;
+        });
+        expect(result).to.equal(123);
+      });
 
       it('should make properties unwriteable', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             myNumber: 123
-          })
-        })
+          });
+        });
         const result = await callWithBindings((root: any) => {
-          root.example.myNumber = 456
-          return root.example.myNumber
-        })
-        expect(result).to.equal(123)
-      })
+          root.example.myNumber = 456;
+          return root.example.myNumber;
+        });
+        expect(result).to.equal(123);
+      });
 
       it('should proxy strings', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             myString: 'my-words'
-          })
-        })
+          });
+        });
         const result = await callWithBindings((root: any) => {
-          return root.example.myString
-        })
-        expect(result).to.equal('my-words')
-      })
+          return root.example.myString;
+        });
+        expect(result).to.equal('my-words');
+      });
 
       it('should proxy arrays', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             myArr: [123, 'my-words']
-          })
-        })
+          });
+        });
         const result = await callWithBindings((root: any) => {
-          return root.example.myArr
-        })
-        expect(result).to.deep.equal([123, 'my-words'])
-      })
+          return root.example.myArr;
+        });
+        expect(result).to.deep.equal([123, 'my-words']);
+      });
 
       it('should make arrays immutable', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             myArr: [123, 'my-words']
-          })
-        })
+          });
+        });
         const immutable = await callWithBindings((root: any) => {
           try {
-            root.example.myArr.push(456)
-            return false
+            root.example.myArr.push(456);
+            return false;
           } catch {
-            return true
+            return true;
           }
-        })
-        expect(immutable).to.equal(true)
-      })
+        });
+        expect(immutable).to.equal(true);
+      });
 
       it('should proxy booleans', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             myBool: true
-          })
-        })
+          });
+        });
         const result = await callWithBindings((root: any) => {
-          return root.example.myBool
-        })
-        expect(result).to.equal(true)
-      })
+          return root.example.myBool;
+        });
+        expect(result).to.equal(true);
+      });
 
       it('should proxy promises and resolve with the correct value', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             myPromise: Promise.resolve('i-resolved')
-          })
-        })
+          });
+        });
         const result = await callWithBindings((root: any) => {
-          return root.example.myPromise
-        })
-        expect(result).to.equal('i-resolved')
-      })
+          return root.example.myPromise;
+        });
+        expect(result).to.equal('i-resolved');
+      });
 
       it('should proxy promises and reject with the correct value', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             myPromise: Promise.reject(new Error('i-rejected'))
-          })
-        })
+          });
+        });
         const result = await callWithBindings(async (root: any) => {
           try {
-            await root.example.myPromise
-            return null
+            await root.example.myPromise;
+            return null;
           } catch (err) {
-            return err
+            return err;
           }
-        })
-        expect(result).to.be.an.instanceOf(Error).with.property('message', 'Uncaught Error: i-rejected')
-      })
+        });
+        expect(result).to.be.an.instanceOf(Error).with.property('message', 'Uncaught Error: i-rejected');
+      });
 
       it('should proxy promises and resolve with the correct value if it resolves later', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             myPromise: () => new Promise(resolve => setTimeout(() => resolve('delayed'), 20))
-          })
-        })
+          });
+        });
         const result = await callWithBindings((root: any) => {
-          return root.example.myPromise()
-        })
-        expect(result).to.equal('delayed')
-      })
+          return root.example.myPromise();
+        });
+        expect(result).to.equal('delayed');
+      });
 
       it('should proxy nested promises correctly', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             myPromise: () => new Promise(resolve => setTimeout(() => resolve(Promise.resolve(123)), 20))
-          })
-        })
+          });
+        });
         const result = await callWithBindings((root: any) => {
-          return root.example.myPromise()
-        })
-        expect(result).to.equal(123)
-      })
+          return root.example.myPromise();
+        });
+        expect(result).to.equal(123);
+      });
 
       it('should proxy methods', async () => {
         await makeBindingWindow(() => {
@@ -218,49 +218,49 @@ describe('contextBridge', () => {
             getString: () => 'help',
             getBoolean: () => false,
             getPromise: async () => 'promise'
-          })
-        })
+          });
+        });
         const result = await callWithBindings(async (root: any) => {
-          return [root.example.getNumber(), root.example.getString(), root.example.getBoolean(), await root.example.getPromise()]
-        })
-        expect(result).to.deep.equal([123, 'help', false, 'promise'])
-      })
+          return [root.example.getNumber(), root.example.getString(), root.example.getBoolean(), await root.example.getPromise()];
+        });
+        expect(result).to.deep.equal([123, 'help', false, 'promise']);
+      });
 
       it('should proxy methods that are callable multiple times', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             doThing: () => 123
-          })
-        })
+          });
+        });
         const result = await callWithBindings(async (root: any) => {
-          return [root.example.doThing(), root.example.doThing(), root.example.doThing()]
-        })
-        expect(result).to.deep.equal([123, 123, 123])
-      })
+          return [root.example.doThing(), root.example.doThing(), root.example.doThing()];
+        });
+        expect(result).to.deep.equal([123, 123, 123]);
+      });
 
       it('should proxy methods in the reverse direction', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             callWithNumber: (fn: any) => fn(123)
-          })
-        })
+          });
+        });
         const result = await callWithBindings(async (root: any) => {
-          return root.example.callWithNumber((n: number) => n + 1)
-        })
-        expect(result).to.equal(124)
-      })
+          return root.example.callWithNumber((n: number) => n + 1);
+        });
+        expect(result).to.equal(124);
+      });
 
       it('should proxy promises in the reverse direction', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             getPromiseValue: (p: Promise<any>) => p
-          })
-        })
+          });
+        });
         const result = await callWithBindings((root: any) => {
-          return root.example.getPromiseValue(Promise.resolve('my-proxied-value'))
-        })
-        expect(result).to.equal('my-proxied-value')
-      })
+          return root.example.getPromiseValue(Promise.resolve('my-proxied-value'));
+        });
+        expect(result).to.equal('my-proxied-value');
+      });
 
       it('should proxy objects with number keys', async () => {
         await makeBindingWindow(() => {
@@ -268,151 +268,151 @@ describe('contextBridge', () => {
             1: 123,
             2: 456,
             3: 789
-          })
-        })
+          });
+        });
         const result = await callWithBindings(async (root: any) => {
-          return [root.example[1], root.example[2], root.example[3], Array.isArray(root.example)]
-        })
-        expect(result).to.deep.equal([123, 456, 789, false])
-      })
+          return [root.example[1], root.example[2], root.example[3], Array.isArray(root.example)];
+        });
+        expect(result).to.deep.equal([123, 456, 789, false]);
+      });
 
       it('it should proxy null and undefined correctly', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             values: [null, undefined]
-          })
-        })
+          });
+        });
         const result = await callWithBindings((root: any) => {
           // Convert to strings as although the context bridge keeps the right value
           // IPC does not
-          return root.example.values.map((val: any) => `${val}`)
-        })
-        expect(result).to.deep.equal(['null', 'undefined'])
-      })
+          return root.example.values.map((val: any) => `${val}`);
+        });
+        expect(result).to.deep.equal(['null', 'undefined']);
+      });
 
       it('should proxy typed arrays and regexps through the serializer', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             arr: new Uint8Array(100),
             regexp: /a/g
-          })
-        })
+          });
+        });
         const result = await callWithBindings((root: any) => {
           return [
             Object.getPrototypeOf(root.example.arr) === Uint8Array.prototype,
             Object.getPrototypeOf(root.example.regexp) === RegExp.prototype
-          ]
-        })
-        expect(result).to.deep.equal([true, true])
-      })
+          ];
+        });
+        expect(result).to.deep.equal([true, true]);
+      });
 
       it('it should handle recursive objects', async () => {
         await makeBindingWindow(() => {
-          const o: any = { value: 135 }
-          o.o = o
+          const o: any = { value: 135 };
+          o.o = o;
           contextBridge.exposeInMainWorld('example', {
             o
-          })
-        })
+          });
+        });
         const result = await callWithBindings((root: any) => {
-          return [root.example.o.value, root.example.o.o.value, root.example.o.o.o.value]
-        })
-        expect(result).to.deep.equal([135, 135, 135])
-      })
+          return [root.example.o.value, root.example.o.o.value, root.example.o.o.o.value];
+        });
+        expect(result).to.deep.equal([135, 135, 135]);
+      });
 
       // Can only run tests which use the GCRunner in non-sandboxed environments
       if (!useSandbox) {
         it('should release the global hold on methods sent across contexts', async () => {
           await makeBindingWindow(() => {
-            require('electron').ipcRenderer.on('get-gc-info', e => e.sender.send('gc-info', (contextBridge as any).debugGC()))
+            require('electron').ipcRenderer.on('get-gc-info', e => e.sender.send('gc-info', (contextBridge as any).debugGC()));
             contextBridge.exposeInMainWorld('example', {
               getFunction: () => () => 123
-            })
-          })
-          expect((await getGCInfo()).functionCount).to.equal(2)
+            });
+          });
+          expect((await getGCInfo()).functionCount).to.equal(2);
           await callWithBindings(async (root: any) => {
-            root.x = [root.example.getFunction()]
-          })
-          expect((await getGCInfo()).functionCount).to.equal(3)
+            root.x = [root.example.getFunction()];
+          });
+          expect((await getGCInfo()).functionCount).to.equal(3);
           await callWithBindings(async (root: any) => {
-            root.x = []
-            root.GCRunner.run()
-          })
-          expect((await getGCInfo()).functionCount).to.equal(2)
-        })
+            root.x = [];
+            root.GCRunner.run();
+          });
+          expect((await getGCInfo()).functionCount).to.equal(2);
+        });
       }
 
       it('it should not let you overwrite existing exposed things', async () => {
         await makeBindingWindow(() => {
-          let threw = false
+          let threw = false;
           contextBridge.exposeInMainWorld('example', {
             attempt: 1,
             getThrew: () => threw
-          })
+          });
           try {
             contextBridge.exposeInMainWorld('example', {
               attempt: 2,
               getThrew: () => threw
-            })
+            });
           } catch {
-            threw = true
+            threw = true;
           }
-        })
+        });
         const result = await callWithBindings((root: any) => {
-          return [root.example.attempt, root.example.getThrew()]
-        })
-        expect(result).to.deep.equal([1, true])
-      })
+          return [root.example.attempt, root.example.getThrew()];
+        });
+        expect(result).to.deep.equal([1, true]);
+      });
 
       it('should work with complex nested methods and promises', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             first: (second: Function) => second((fourth: Function) => {
-              return fourth()
+              return fourth();
             })
-          })
-        })
+          });
+        });
         const result = await callWithBindings((root: any) => {
           return root.example.first((third: Function) => {
-            return third(() => Promise.resolve('final value'))
-          })
-        })
-        expect(result).to.equal('final value')
-      })
+            return third(() => Promise.resolve('final value'));
+          });
+        });
+        expect(result).to.equal('final value');
+      });
 
       it('should throw an error when recursion depth is exceeded', async () => {
         await makeBindingWindow(() => {
           contextBridge.exposeInMainWorld('example', {
             doThing: (a: any) => console.log(a)
-          })
-        })
+          });
+        });
         let threw = await callWithBindings((root: any) => {
           try {
-            let a: any = []
+            let a: any = [];
             for (let i = 0; i < 999; i++) {
-              a = [a]
+              a = [a];
             }
-            root.example.doThing(a)
-            return false
+            root.example.doThing(a);
+            return false;
           } catch {
-            return true
+            return true;
           }
-        })
-        expect(threw).to.equal(false)
+        });
+        expect(threw).to.equal(false);
         threw = await callWithBindings((root: any) => {
           try {
-            let a: any = []
+            let a: any = [];
             for (let i = 0; i < 1000; i++) {
-              a = [a]
+              a = [a];
             }
-            root.example.doThing(a)
-            return false
+            root.example.doThing(a);
+            return false;
           } catch {
-            return true
+            return true;
           }
-        })
-        expect(threw).to.equal(true)
-      })
+        });
+        expect(threw).to.equal(true);
+      });
 
       it('should not leak prototypes', async () => {
         await makeBindingWindow(() => {
@@ -435,12 +435,12 @@ describe('contextBridge', () => {
               getPromise: async () => ({ number: 123, string: 'string', boolean: true, fn: () => 'string', arr: [123, 'string', true, ['foo']] })
             },
             receiveArguments: (fn: any) => fn({ key: 'value' })
-          })
-        })
+          });
+        });
         const result = await callWithBindings(async (root: any) => {
-          const { example } = root
-          let arg: any
-          example.receiveArguments((o: any) => { arg = o })
+          const { example } = root;
+          let arg: any;
+          example.receiveArguments((o: any) => { arg = o; });
           const protoChecks = [
             [example, Object],
             [example.number, Number],
@@ -502,17 +502,17 @@ describe('contextBridge', () => {
             [(await example.object.getPromise()).arr[3][0], String],
             [arg, Object],
             [arg.key, String]
-          ]
+          ];
           return {
             protoMatches: protoChecks.map(([a, Constructor]) => Object.getPrototypeOf(a) === Constructor.prototype)
-          }
-        })
+          };
+        });
         // Every protomatch should be true
-        expect(result.protoMatches).to.deep.equal(result.protoMatches.map(() => true))
-      })
-    })
-  }
+        expect(result.protoMatches).to.deep.equal(result.protoMatches.map(() => true));
+      });
+    });
+  };
 
-  generateTests(true)
-  generateTests(false)
-})
+  generateTests(true);
+  generateTests(false);
+});