Don't use top-level await.

Indeed, this doesn't go well with Electron since it uses CommonJS which... yeah, doesn't support top-level await.

Author: agarny

src/preload/index.ts

@@ -11,7 +11,10 @@ import type { ISplashScreenInfo } from '../renderer/src/common/electronApi.ts';
 
 const exec = promisify(_exec);
 
-const _operatingSystem = await (async (): Promise<string> => {
+let _operatingSystem: string | null = null;
+const defaultOperatingSystem = `${process.platform} (${process.arch === 'x64' ? 'Intel' : 'ARM'})`;
+
+const retrieveOperatingSystem = async (): Promise<string> => {
   const safeExec = async (cmd: string): Promise<string | null> => {
     try {
       const { stdout } = await exec(cmd);
@@ -69,8 +72,19 @@ const _operatingSystem = await (async (): Promise<string> => {
 
     operatingSystem = operatingSystem || 'macOS';
   }
-  return `${operatingSystem || process.platform} (${process.arch === 'x64' ? 'Intel' : 'ARM'})`;
-})();
+
+  return operatingSystem ? `${operatingSystem} (${process.arch === 'x64' ? 'Intel' : 'ARM'})` : defaultOperatingSystem;
+};
+
+// Retrieve the version of the operating system.
+
+retrieveOperatingSystem()
+  .then((operatingSystem) => {
+    _operatingSystem = operatingSystem;
+  })
+  .catch(() => {
+    _operatingSystem = defaultOperatingSystem;
+  });
 
 // Some bridging between our main process and renderer process.
 // Note: this must be in sync with src/electronApi.ts.
@@ -79,7 +93,9 @@ electron.contextBridge.exposeInMainWorld('electronApi', {
   // Some general methods.
 
   operatingSystem: () => {
-    return _operatingSystem;
+    // Return a cached version of the operating system if we have it, otherwise return a default value.
+
+    return _operatingSystem || defaultOperatingSystem;
   },
 
   // Splash screen window.

src/renderer/src/common/dependencies.ts

@@ -8,7 +8,7 @@ export let _jsZip: Module = null;
 export let _mathJs: Module = null;
 export let _plotlyJs: Module = null;
 export let _vueTippy: Module = null;
-export const _xxhash = await xxhash();
+export let _xxhash: Module = null;
 
 export const setJsonSchema = (module: Module): void => {
   _jsonSchema = module;
@@ -29,3 +29,9 @@ export const setPlotlyJs = (module: Module): void => {
 export const setVueTippy = (module: Module): void => {
   _vueTippy = module;
 };
+
+export const initialiseXxhash: Promise<Module> = xxhash().then((module: Module) => {
+  _xxhash = module;
+
+  return module;
+});

src/renderer/src/common/initialisation.ts

@@ -45,12 +45,15 @@ const externalDependencies: ExternalDependency[] = [
 ];
 
 // Some variables to keep track of the initialisation progress.
-// Note: the 2 initial steps are to import libOpenCOR's WASM and to instantiate it. Then, we have one or two steps per
-//       external dependency, depending on whether it has an associated CSS file or not.
+// Note: the 2 initial steps are to import libOpenCOR's WASM and to instantiate it. We then have one or two steps per
+//       external dependency, depending on whether it has an associated CSS file or not. Finally, we have one step to
+//       initialise xxHash.
 
 const crtNbOfSteps = vue.ref<number>(0);
 const totalNbOfSteps =
-  (electronApi ? 0 : 2) + externalDependencies.reduce((acc, dep) => acc + (dep.url ? 1 : 0) + (dep.cssUrl ? 1 : 0), 0);
+  (electronApi ? 0 : 2) +
+  externalDependencies.reduce((acc, dep) => acc + (dep.url ? 1 : 0) + (dep.cssUrl ? 1 : 0), 0) +
+  1;
 
 // Retrieve the version of libOpenCOR that is to be used. Two options:
 //  - OpenCOR: libOpenCOR can be accessed using window.locApi, which references our C++ API.
@@ -155,7 +158,7 @@ const initialisationError = (error: unknown): void => {
   failed.value = true;
 };
 
-// Initialise libOpenCOR and then our external dependencies.
+// Initialise libOpenCOR, our external dependencies, and xxHash.
 
 initialiseLocApi().catch((error: unknown) => {
   initialisationError(error);
@@ -172,6 +175,14 @@ for (const externalDependency of externalDependencies) {
   });
 }
 
+dependencies.initialiseXxhash
+  .then(() => {
+    ++crtNbOfSteps.value;
+  })
+  .catch((error: unknown) => {
+    initialisationError(error);
+  });
+
 // Let people know whether initialisation is done and how it's progressing.
 
 export const done = vue.computed(() => {