chore: more refactoring

Signed-off-by: Victor Adossi <vadossi@cosmonic.com>

Author: vados-cosmonic

src/componentize.js

@@ -1,64 +1,46 @@
+import { fileURLToPath } from 'node:url';
+import { cwd, stdout, platform } from 'node:process';
+import { freemem } from 'node:os';
+import { spawnSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { resolve, join, dirname } from 'node:path';
+import { readFile, writeFile, mkdir, rm } from 'node:fs/promises';
+import { rmSync, existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+
 import wizer from '@bytecodealliance/wizer';
 import getWeval from '@bytecodealliance/weval';
 import {
   componentNew,
   metadataAdd,
   preview1AdapterReactorPath,
 } from '@bytecodealliance/jco';
-import { spawnSync } from 'node:child_process';
-import { tmpdir } from 'node:os';
-import { resolve, join, dirname } from 'node:path';
-import { readFile, writeFile, mkdir, rm } from 'node:fs/promises';
-import { rmSync, existsSync } from 'node:fs';
-import { createHash } from 'node:crypto';
+
 import {
   spliceBindings,
   stubWasi,
 } from '../lib/spidermonkey-embedding-splicer.js';
-import { fileURLToPath } from 'node:url';
-import { cwd, stdout, platform } from 'node:process';
+
 export const { version } = JSON.parse(
   await readFile(new URL('../package.json', import.meta.url), 'utf8')
 );
-const isWindows = platform === 'win32';
 
-function maybeWindowsPath(path) {
-  if (!path) return path;
-  if (!isWindows) return resolve(path);
-  return '//?/' + resolve(path).replace(/\\/g, '/');
-}
-
-/**
- * Clean up the given input string by removing the given patterns if
- * found as line prefixes.
- */
-function stripLinesPrefixes(input, prefixPatterns) {
-  return input.split('\n')
-    .map(line => prefixPatterns.reduce((line, n) => line.replace(n, ''), line))
-    .join('\n').trim();
-}
+/** Whether the current platform is windows */
+const IS_WINDOWS = platform === 'win32';
 
-const WizerErrorCause = `Error: the \`componentize.wizer\` function trapped
+/** Prefix into wizer error output that indicates a error/trap */
+const WIZER_ERROR_CAUSE_PREFIX = `Error: the \`componentize.wizer\` function trapped
 
 Caused by:`;
 
-const WizerExitCode = "Exited with i32 exit status";
-
-function parseWizerStderr(stderr) {
-  let output = `${stderr}`;
-  let causeStart = output.indexOf(WizerErrorCause);
-  let exitCodeStart = output.indexOf(WizerExitCode);
-  if (causeStart === -1 || exitCodeStart === -1) {
-    return output;
-  }
-
-  let causeEnd = output.indexOf('\n', exitCodeStart + 1);
-  return `${output.substring(0, causeStart)}${output.substring(causeEnd)}`.trim();
-}
+/** Prefix into wizer error output that indicates exit status */
+const WIZER_EXIT_CODE_PREFIX = 'Exited with i32 exit status';
 
-export async function componentize(opts,
-                                   _deprecatedWitWorldOrOpts = undefined,
-                                   _deprecatedOpts = undefined) {
+export async function componentize(
+  opts,
+  _deprecatedWitWorldOrOpts = undefined,
+  _deprecatedOpts = undefined,
+) {
   let useOriginalSourceFile = true;
   let jsSource;
 
@@ -74,27 +56,19 @@ export async function componentize(opts,
     } else {
       if (typeof _deprecatedWitWorldOrOpts !== 'object') {
         throw new Error(
-          `componentize: second argument must be an object or a string, but is ${typeof _deprecatedWitWorldOrOpts}`
+          `componentize: second argument must be an object or a string, but is ${typeof _deprecatedWitWorldOrOpts}`,
         );
       }
       opts = _deprecatedWitWorldOrOpts;
     }
   }
 
-  const tmpDir = join(
-    tmpdir(),
-    createHash('sha256')
-      .update(Math.random().toString())
-      .digest('hex')
-      .slice(0, 12)
-  );
-  await mkdir(tmpDir);
-  const sourceDir = join(tmpDir, 'sources');
-  await mkdir(sourceDir);
+  // Prepare a working diretory for use during componentization
+  const { sourcesDir, baseDir: tmpDir } = prepWorkDir();
 
   let {
     sourceName = 'source.js',
-    sourcePath = join(sourceDir, sourceName),
+    sourcePath = join(sourcesDir, sourceName),
     preview2Adapter = preview1AdapterReactorPath(),
     witPath,
     witWorld,
@@ -110,40 +84,30 @@ export async function componentize(opts,
     ),
   } = opts;
 
-  const engine =
-    opts.engine ||
-    fileURLToPath(
-      new URL(
-        opts.enableAot
-          ? `../lib/starlingmonkey_embedding_weval.wasm`
-          : `../lib/starlingmonkey_embedding${
-              debugBuild ? '.debug' : ''
-            }.wasm`,
-        import.meta.url
-      )
-    );
+  // Determine the path to the StarlingMonkey binary
+  const engine = getEnginePath(opts);
 
   let { wasm, jsBindings, exports, imports } = spliceBindings(
     await readFile(engine),
     witWorld,
     maybeWindowsPath(witPath),
     worldName,
-    false
+    false,
   );
 
   const input = join(tmpDir, 'in.wasm');
   const output = join(tmpDir, 'out.wasm');
 
   await writeFile(input, Buffer.from(wasm));
-  await writeFile(join(sourceDir, "initializer.js"), jsBindings);
+  await writeFile(join(sourcesDir, 'initializer.js'), jsBindings);
 
   if (debugBindings) {
     console.log('--- JS Bindings ---');
     console.log(
       jsBindings
         .split('\n')
         .map((ln, idx) => `${(idx + 1).toString().padStart(4, ' ')} | ${ln}`)
-        .join('\n')
+        .join('\n'),
     );
     console.log('--- JS Imports ---');
     console.log(imports);
@@ -206,7 +170,7 @@ export async function componentize(opts,
     console.log(env);
   }
 
-  let initializerPath = join(sourceDir, 'initializer.js');
+  let initializerPath = join(sourcesDir, 'initializer.js');
   sourcePath = maybeWindowsPath(sourcePath);
   let workspacePrefix = dirname(sourcePath);
 
@@ -221,7 +185,7 @@ export async function componentize(opts,
   }
   let args = `--initializer-script-path ${initializerPath} ${sourcePath}`;
   runtimeArgs = runtimeArgs ? `${runtimeArgs} ${args}` : args;
-  let preopens = [`--dir ${sourceDir}`];
+  let preopens = [`--dir ${sourcesDir}`];
   if (opts.enableAot) {
     preopens.push(`--dir ${workspacePrefix}`);
   } else {
@@ -252,12 +216,12 @@ export async function componentize(opts,
         `-o ${output}`,
       ],
       {
-        stdio: [null, stdout, "pipe"],
+        stdio: [null, stdout, 'pipe'],
         env,
         input: runtimeArgs,
         shell: true,
         encoding: 'utf-8',
-      }
+      },
     );
   } else {
     wizerProcess = spawnSync(
@@ -273,15 +237,16 @@ export async function componentize(opts,
         input,
       ],
       {
-        stdio: [null, stdout, "pipe"],
+        stdio: [null, stdout, 'pipe'],
         env,
         input: runtimeArgs,
         shell: true,
         encoding: 'utf-8',
-      }
+      },
     );
   }
 
+  // If the wizer (or weval) process failed, parse the output and display to the user
   if (wizerProcess.status !== 0) {
     let wizerErr = parseWizerStderr(wizerProcess.stderr);
     let err = `Failed to initialize component:\n${wizerErr}`;
@@ -413,11 +378,111 @@ export async function componentize(opts,
 
   // convert CABI import conventions to ESM import conventions
   imports = imports.map(([specifier, impt]) =>
-    specifier === '$root' ? [impt, 'default'] : [specifier, impt]
+    specifier === '$root' ? [impt, 'default'] : [specifier, impt],
   );
 
   return {
     component,
     imports,
   };
 }
+
+/**
+ * Calculate the min stack size depending on free memory
+ *
+ * @param {number} freeMemoryBytes - Amount of free memory in the system, in bytes  (if not provided, os.freemem() is used)
+ * @returns {number} The minimum stack size that should be used as a default.
+ */
+function defaultMinStackSize(freeMemoryBytes) {
+  freeMemoryBytes = freeMemoryBytes ?? freemem();
+  return Math.max(8 * 1024 * 1024, Math.floor(freeMemoryBytes * 0.1));
+}
+
+/** Determine the correct path for the engine */
+function getEnginePath(opts) {
+  if (opts.engine) {
+    return opts.engine;
+  }
+  let engineBinaryRelPath = '../lib/starlingmonkey_embedding_weval.wasm';
+  if (opts.enableAot) {
+    engineBinaryRelPath = `../lib/starlingmonkey_embedding${debugBuild ? '.debug' : ''}.wasm`;
+  }
+  return fileURLToPath(new URL(engineBinaryRelPath, import.meta.url));
+}
+
+/**
+ * Parse output of post-processing step (whether Wizer or Weval)
+ *
+ * @param {Stream} stderr
+ * @returns {string} String that can be printed to describe error output
+ */
+function parseWizerStderr(stderr) {
+  let output = `${stderr}`;
+  let causeStart = output.indexOf(WIZER_ERROR_CAUSE_PREFIX);
+  let exitCodeStart = output.indexOf(WIZER_EXIT_CODE_PREFIX);
+  if (causeStart === -1 || exitCodeStart === -1) {
+    return output;
+  }
+
+  let causeEnd = output.indexOf('\n', exitCodeStart + 1);
+  return `${output.substring(0, causeStart)}${output.substring(causeEnd)}`.trim();
+}
+
+/**
+ * Check whether a value is numeric (including BigInt)
+ *
+ * @param {any} n
+ * @returns {boolean} whether the value is numeric
+ */
+function isNumeric(n) {
+  switch (typeof n) {
+    case 'bigint':
+    case 'number':
+      return true;
+    case 'object':
+      return n.constructor == BigInt || n.constructor == Number;
+    default:
+      return false;
+  }
+}
+
+/**
+ * Convert a given path to one that also works on windows
+ *
+ * @param {string} path - A path that may or may not be windows-compatible
+ * @returns {string} The Windows-compatible (if necessary) path
+ */
+function maybeWindowsPath(path) {
+  if (!path) return path;
+  if (!IS_WINDOWS) return resolve(path);
+  return '//?/' + resolve(path).replace(/\\/g, '/');
+}
+
+/**
+ * Clean up the given input string by removing the given patterns if
+ * found as line prefixes.
+ */
+function stripLinesPrefixes(input, prefixPatterns) {
+  return input
+    .split('\n')
+    .map((line) =>
+      prefixPatterns.reduce((line, n) => line.replace(n, ''), line),
+    )
+    .join('\n')
+    .trim();
+}
+
+/** Prepare a work directory for use with componentization */
+async function prepWorkDir() {
+  const tmpDir = join(
+    tmpdir(),
+    createHash('sha256')
+      .update(Math.random().toString())
+      .digest('hex')
+      .slice(0, 12),
+  );
+  await mkdir(tmpDir);
+  const sourcesDir = join(tmpDir, 'sources');
+  await mkdir(sourceDir);
+  return { baseDir, sourcesDir };
+}