Pass model options to FEAScriptWorker (#107)

FEAScriptWorker.setModelConfig now takes the same options as FEAScriptModel (coefficientFunctions, nonlinear, maxIterations, tolerance), so the general form PDE and Euler–Bernoulli beam models can run in a worker and heat conduction uses the given k and Q. Functions cannot be sent to a web worker, so each coefficient function is sent as its source code and rebuilt in the worker; it must therefore be self-contained. solve() now also forwards maxIterations and tolerance.

Tests:
- Add worker options tests (functions are rebuilt and every model gives the same solution as without the worker)
- Merge the unit tests into solvers.test.js (Jacobi, sparse matrix) and model.test.js (boundary conditions, solution format, worker options)
- Rename the regression test folders to camelCase, as the verification and example folders are

Author: nikoscham

dist/feascript-worker.esm.js

@@ -0,0 +1,74 @@
+/**
+ * ════════════════════════════════════════════════════════════════
+ *  FEAScript Core Library
+ *  Finite Element Simulation in JavaScript
+ *  Version: 0.3.0 (RC) | https://feascript.com
+ *  MIT License © 2023–2026 FEAScript
+ * ════════════════════════════════════════════════════════════════
+ */
+
+// Functions cannot be sent to a web worker (structured clone), so they are sent as their source code and
+// rebuilt in the worker. A rebuilt function has no access to the variables around its definition, so it
+// must be self-contained (e.g. `(x, u) => 0.5 * u ** 2` instead of `(x, u) => Da * u ** 2`)
+const functionSourceKey = "__feascriptFunctionSource";
+
+/**
+ * Function to replace the functions of a value (e.g. the model options) with their source code
+ * @param {*} value - The value to serialize; plain objects and arrays are serialized recursively
+ * @returns {*} A copy of the value that can be sent to a web worker
+ * @throws Will throw an error if a function has no source code (native or bound functions)
+ */
+export function serializeFunctions(value) {
+  if (typeof value === "function") {
+    const source = value.toString();
+    if (source.includes("[native code]")) {
+      throw new Error(
+        `FEAScriptWorker: function "${value.name}" cannot be sent to the worker; use a function defined in your own code, e.g. (x) => Math.sin(x) instead of Math.sin.`,
+      );
+    }
+    return { [functionSourceKey]: source };
+  }
+  if (Array.isArray(value)) {
+    return value.map(serializeFunctions);
+  }
+  if (value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, serializeFunctions(entry)]));
+  }
+  return value;
+}
+
+/**
+ * Function to rebuild the functions that serializeFunctions replaced with their source code
+ * @param {*} value - The serialized value
+ * @returns {*} A copy of the value with the functions rebuilt
+ */
+export function deserializeFunctions(value) {
+  if (Array.isArray(value)) {
+    return value.map(deserializeFunctions);
+  }
+  if (value !== null && typeof value === "object") {
+    if (typeof value[functionSourceKey] === "string") {
+      return rebuildFunction(value[functionSourceKey]);
+    }
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, deserializeFunctions(entry)]),
+    );
+  }
+  return value;
+}
+
+/**
+ * Function to rebuild a function from its source code
+ * @param {string} source - The source code of an arrow function, function expression or method
+ * @returns {function} The rebuilt function
+ */
+function rebuildFunction(source) {
+  try {
+    // Arrow functions and function expressions, e.g. "(x) => 1" or "function (x) { return 1; }"
+    return new Function(`"use strict"; return (${source});`)();
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error;
+    // Methods are given without the function keyword, e.g. "A(x) { return 1; }"
+    return new Function(`"use strict"; return Object.values({ ${source} })[0];`)();
+  }
+}

dist/feascript-worker.esm.js.map

@@ -10,6 +10,9 @@
 // External imports
 import * as Comlink from "../vendor/comlink.mjs";
 
+// Internal imports
+import { serializeFunctions } from "./functionSerialization.js";
+
 /**
  * Class to facilitate communication with web workers for FEAScript operations
  */
@@ -93,11 +96,13 @@ export class FEAScriptWorker {
   /**
    * Function to set the model configuration in the worker
    * @param {string} modelConfig - The model configuration to set
+   * @param {object} [options] - Optional additional configuration, as in FEAScriptModel.setModelConfig. The
+   *  coefficient functions are sent to the worker as source code, so they must be self-contained (no outer variables)
    * @returns {Promise<boolean>} Resolves when the configuration is set
    */
-  async setModelConfig(modelConfig) {
+  async setModelConfig(modelConfig, options = {}) {
     await this._ensureReady();
-    return this.feaWorker.setModelConfig(modelConfig);
+    return this.feaWorker.setModelConfig(modelConfig, serializeFunctions(options));
   }
 
   /**
@@ -133,11 +138,12 @@ export class FEAScriptWorker {
 
   /**
    * Function to request the worker to solve the problem
+   * @param {object} [options] - Additional parameters for the solver, such as `maxIterations` and `tolerance`
    * @returns {Promise<object>} Resolves with the solution result
    */
-  async solve() {
+  async solve(options = {}) {
     await this._ensureReady();
-    return this.feaWorker.solve();
+    return this.feaWorker.solve(options);
   }
 
   /**