@sdeverywhere/plugin-check 0.3.0 → 0.3.2

package/dist/index.js

@@ -37,8 +37,8 @@ async function runTestSuite(context, config, verbose) {
           context.log("info", `
 Test suite completed in ${elapsed}s`);
           const allChecksPassed = printCheckSummary(context, report.checkReport, verbose);
-          if (report.compareReport) {
-            printPerfStats(context, config.compare, report.compareReport);
+          if (report.comparisonReport) {
+            printPerfStats(context, config.comparison, report.comparisonReport);
           }
           const suiteSummary = suiteSummaryFromReport(report);
           resolve({
@@ -119,18 +119,18 @@ function printPerfReportLine(context, perfReport) {
   const max = stat("max", perfReport.maxTime);
   context.log("info", `    ${avg} ${min} ${max}`);
 }
-function printPerfStats(context, compareConfig, report) {
+function printPerfStats(context, comparisonConfig, report) {
   context.log("info", "\nPerformance stats:");
-  context.log("info", `  ${compareConfig.bundleL.name}:`);
+  context.log("info", `  ${comparisonConfig.bundleL.name}:`);
   printPerfReportLine(context, report.perfReportL);
-  context.log("info", `  ${compareConfig.bundleR.name}:`);
+  context.log("info", `  ${comparisonConfig.bundleR.name}:`);
   printPerfReportLine(context, report.perfReportR);
   context.log("info", "");
 }
 
 // src/vite-config-for-bundle.ts
 import { existsSync, statSync } from "fs";
-import { dirname, join as joinPath, relative, resolve as resolvePath } from "path";
+import { basename, dirname, join as joinPath, relative, resolve as resolvePath } from "path";
 import { fileURLToPath } from "url";
 import { nodeResolve } from "@rollup/plugin-node-resolve";
 
@@ -152,12 +152,15 @@ function sdeNameForVensimVarName(varName) {
 }
 
 // src/vite-config-for-bundle.ts
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
 function injectModelSpec(prepDir, modelSpec) {
   const inputSpecs = modelSpec.inputs.map((i) => {
+    const varId = sdeNameForVensimVarName(i.varName);
+    const inputId = i.inputId || varId;
     return {
-      varId: sdeNameForVensimVarName(i.varName),
+      inputId,
+      varId,
       ...i
     };
   });
@@ -199,20 +202,58 @@ export const dataSizeInBytes = ${dataSizeInBytes};
     }
   };
 }
+function overrideViteResolvePlugin(viteConfig) {
+  const resolvePlugin = viteConfig.plugins.find((p) => p.name === "vite:resolve");
+  if (resolvePlugin === void 0) {
+    throw new Error("Failed to locate the built-in vite:resolve plugin");
+  }
+  const originalResolveId = resolvePlugin.resolveId;
+  resolvePlugin.resolveId = async function resolveId(id, importer, options) {
+    if (id.startsWith("./implementation") && importer.includes("threads/dist-esm")) {
+      const idFileName = id.replace("./", "");
+      const importerFileName = basename(importer);
+      const resolvedId = importer.replace(importerFileName, `${idFileName}.js`);
+      return {
+        id: resolvedId,
+        moduleSideEffects: false
+      };
+    }
+    return originalResolveId.call(this, id, importer, options);
+  };
+}
 async function createViteConfigForBundle(prepDir, modelSpec) {
-  const root = resolvePath(__dirname, "..", "template-bundle");
+  const root = resolvePath(__dirname2, "..", "template-bundle");
   const outDir = relative(root, prepDir);
   const modelWorkerPath = joinPath(prepDir, "staged", "model", "worker.js?raw");
   return {
+    // Don't use an external config file
     configFile: false,
+    // Use the root directory configured above
     root,
+    // Don't clear the screen in dev mode so that we can see builder output
     clearScreen: false,
+    // TODO: Disable vite output by default?
+    // logLevel: 'silent',
+    // Configure path aliases
     resolve: {
       alias: [
+        // Inject the configured model worker
         {
           find: "@_model_worker_",
           replacement: modelWorkerPath
         },
+        // XXX: Prevent Vite from using the `browser` section of `threads/package.json`
+        // since we want to force the use of the general module (under dist-esm) that chooses
+        // the correct implementation (Web Worker vs worker_threads) at runtime.  Currently
+        // Vite's library mode is browser focused and generally chooses the right imports,
+        // except in the case of the threads package where we want to use the generic
+        // `implementation.js` that chooses between Web Worker and worker_threads at runtime.
+        // Note that we could in theory set `resolve.browserField` to false, but that would
+        // make Vite not use the browser field for all other packages, and there is not
+        // currently a way to tell Vite to use the browser field on a case-by-case basis.
+        // So for now we need this workaround here to make it resolve to `dist-esm`, and then
+        // a second workaround in `overrideViteResolvePlugin` to prevent the resolver from
+        // using the browser field when resolving the threads package.
         {
           find: "threads",
           replacement: "threads",
@@ -229,18 +270,40 @@ async function createViteConfigForBundle(prepDir, modelSpec) {
       ]
     },
     plugins: [
-      injectModelSpec(prepDir, modelSpec)
+      // Use a virtual module plugin to inject the model spec values
+      injectModelSpec(prepDir, modelSpec),
+      // XXX: Install a wrapper around the built-in `vite:resolve` plugin so that we can
+      // override the default resolver behavior that tries to resolve the `browser` section
+      // of the `package.json` for the threads package.
+      {
+        name: "vite-plugin-override-resolve",
+        configResolved(viteConfig) {
+          overrideViteResolvePlugin(viteConfig);
+        }
+      }
     ],
     build: {
+      // Write output files to the configured directory (instead of the default `dist`);
+      // note that this must be relative to the project `root`
       outDir,
       emptyOutDir: false,
+      // Uncomment for debugging purposes
+      // minify: false,
       lib: {
         entry: "./src/index.ts",
         formats: ["es"],
         fileName: () => "check-bundle.js"
       },
       rollupOptions: {
+        // Don't transform Node imports used by threads.js
         external: ["events", "os", "path", "url"],
+        // XXX: Insert custom code at the top of the generated bundle that defines
+        // the special `__non_webpack_require__` function that is used by threads.js
+        // in its Node implementation.  This import ensures that threads.js uses
+        // the native `worker_threads` implementation when using the bundle in a
+        // Node environment.  When importing the bundle for use in the browser,
+        // Vite will transform this import into an empty module due to the empty
+        // polyfill that is configured in `vite-config-for-report.ts`.
         output: {
           banner: `
 import * as worker_threads from 'worker_threads'
@@ -263,17 +326,16 @@ let __non_webpack_require__ = () => {
 import { dirname as dirname2, relative as relative2, join as joinPath2, resolve as resolvePath2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import replace from "@rollup/plugin-replace";
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname2(__filename2);
+var __filename3 = fileURLToPath2(import.meta.url);
+var __dirname3 = dirname2(__filename3);
 function createViteConfigForReport(options, projDir, prepDir, currentBundleName, currentBundlePath, testConfigPath, suiteSummary) {
-  var _a;
-  const root = resolvePath2(__dirname2, "..", "template-report");
+  const root = resolvePath2(__dirname3, "..", "template-report");
   const templateSrcDir = resolvePath2(root, "src");
   const relProjDir = relative2(templateSrcDir, projDir);
   const relProjDirPath = relProjDir.replaceAll("\\", "/");
   const baselinesPath = `${relProjDirPath}/baselines/*.js`;
   let reportPath;
-  if (options == null ? void 0 : options.reportPath) {
+  if (options?.reportPath) {
     reportPath = options.reportPath;
   } else {
     reportPath = joinPath2(prepDir, "check-report");
@@ -293,57 +355,113 @@ function createViteConfigForReport(options, projDir, prepDir, currentBundleName,
     };
   };
   return {
+    // Don't use an external config file
     configFile: false,
+    // Use the root directory configured above
     root,
+    // Use `.` as the base directory (instead of the default `/`); this controls
+    // how the path to the js/css files are generated in `index.html`
     base: "",
+    // Use a custom cache directory under `prepDir`, as otherwise Vite will use
+    // `packages/plugin-check/template-report/node_modules/.vite`, and we want to
+    // avoid generating files in `template-report` (which should be read-only)
     cacheDir: joinPath2(prepDir, ".vite-check-report"),
+    // Load static files from `static` (instead of the default `public`)
+    // publicDir: 'static',
+    // Don't clear the screen in dev mode so that we can see builder output
     clearScreen: false,
+    // TODO
+    // logLevel: 'silent',
     optimizeDeps: {
+      // Prevent Vite from examining other html files when scanning entrypoints
+      // for dependency optimization
       entries: ["index.html"],
+      // XXX: When plugin-check is installed via pnpm, the Vite dev server seems
+      // to have no trouble resolving other dependencies using the optimizeDeps
+      // mechanism.  However, this fails when the package is installed via yarn
+      // or npm (probably due to the fact that the `template-report` directory
+      // is located under the top-level `node_modules` directory); in the browser,
+      // there will be "import not found" errors for the packages referenced below.
+      // As a terrible workaround, explicitly include the direct dependencies so
+      // that Vite optimizes them; this works for pnpm, yarn, and npm.  We should
+      // find a less fragile solution.
       include: [
-        "assert-never",
-        "ajv",
-        "neverthrow",
-        "yaml",
-        "fontfaceobserver",
-        "copy-text-to-clipboard",
-        "chart.js"
+        // from check-core
+        "@sdeverywhere/check-core > assert-never",
+        "@sdeverywhere/check-core > ajv",
+        "@sdeverywhere/check-core > neverthrow",
+        "@sdeverywhere/check-core > yaml",
+        // from check-ui-shell
+        "@sdeverywhere/check-ui-shell > fontfaceobserver",
+        "@sdeverywhere/check-ui-shell > copy-text-to-clipboard",
+        "@sdeverywhere/check-ui-shell > chart.js"
       ],
       exclude: [
-        "tiny-worker",
-        "moment"
+        // XXX: The threads.js implementation references `tiny-worker` as an optional
+        // dependency, but it doesn't get used at runtime, so we can just exclude it
+        // so that Vite doesn't complain in dev mode
+        "tiny-worker"
+        // XXX: Similarly, chart.js treats `moment` as an optional dependency, but we
+        // don't use it at runtime; we need to exclude it here, otherwise Vite will
+        // complain about missing dependencies in dev mode
+        // 'moment'
       ]
     },
+    // Configure path aliases
     resolve: {
       alias: [
-        alias("@_baseline_bundle_", (options == null ? void 0 : options.baseline) ? options.baseline.path : "/src/empty-bundle.ts"),
+        // Use the configured "baseline" bundle if defined, otherwise use the "empty" bundle
+        // (which will cause comparison tests to be skipped)
+        alias("@_baseline_bundle_", options?.baseline ? options.baseline.path : "/src/empty-bundle.ts"),
+        // Use the configured "current" bundle
         alias("@_current_bundle_", currentBundlePath),
+        // Use the configured test config file
         alias("@_test_config_", testConfigPath),
+        // Make the overlay use the `messages.html` file that is written to the prep directory
         alias("@_prep_", prepDir),
+        // XXX: Include no-op polyfills for these modules that are used in the Node-specific
+        // implementation of threads.js; this allows us to use one bundle that works in both
+        // Node and browser environments
         noopPolyfillAlias("events"),
+        noopPolyfillAlias("fs"),
         noopPolyfillAlias("os"),
         noopPolyfillAlias("path"),
-        noopPolyfillAlias("url")
+        noopPolyfillAlias("url"),
+        noopPolyfillAlias("worker_threads")
       ]
     },
+    // Inject special values into the generated JS
     define: {
+      // Inject the summary JSON into the build
       __SUITE_SUMMARY_JSON__: JSON.stringify(suiteSummaryJson),
-      __BASELINE_NAME__: JSON.stringify(((_a = options == null ? void 0 : options.baseline) == null ? void 0 : _a.name) || ""),
+      // Inject the baseline branch name
+      __BASELINE_NAME__: JSON.stringify(options?.baseline?.name || ""),
+      // Inject the current branch name
       __CURRENT_NAME__: JSON.stringify(currentBundleName)
     },
     plugins: [
+      // Inject special values into the generated JS
+      // TODO: We currently have to use `@rollup/plugin-replace` instead of Vite's
+      // built-in `define` feature because the latter does not seem to run before
+      // the glob handler (which requires the glob to be injected as a literal)
       replace({
         preventAssignment: true,
+        delimiters: ["", ""],
         values: {
-          __BASELINE_BUNDLES_PATH__: JSON.stringify(baselinesPath)
+          // Inject the path for baseline bundles
+          "./__BASELINE_BUNDLES_PATH__": baselinesPath
         }
       })
     ],
     build: {
+      // Write output files to the configured directory (instead of the default `dist`);
+      // note that this must be relative to the project `root`
       outDir,
+      // Write js/css files to `public` (instead of the default `<outDir>/assets`)
       assetsDir: "",
       rollupOptions: {
         output: {
+          // XXX: Prevent vite from creating a separate `vendor.js` file
           manualChunks: void 0
         },
         onwarn: (warning, warn) => {
@@ -354,8 +472,14 @@ function createViteConfigForReport(options, projDir, prepDir, currentBundleName,
       }
     },
     server: {
-      port: (options == null ? void 0 : options.serverPort) || 8081,
+      // Run the dev server at `localhost:8081` by default
+      port: options?.serverPort || 8081,
+      // Open the app in the browser by default
       open: "/index.html",
+      // XXX: Add a small delay, otherwise on macOS we sometimes get multiple
+      // change events when a file is saved just once.  That is a relatively
+      // harmless issue except that it causes redundant messages in the console
+      // and can cause extra churn when refreshing the app.
       watch: {
         awaitWriteFinish: {
           stabilityThreshold: 100
@@ -368,23 +492,42 @@ function createViteConfigForReport(options, projDir, prepDir, currentBundleName,
 // src/vite-config-for-tests.ts
 import { dirname as dirname3, relative as relative3, resolve as resolvePath3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-var __filename3 = fileURLToPath3(import.meta.url);
-var __dirname3 = dirname3(__filename3);
+import replace2 from "@rollup/plugin-replace";
+var __filename4 = fileURLToPath3(import.meta.url);
+var __dirname4 = dirname3(__filename4);
 function createViteConfigForTests(projDir, prepDir, mode) {
-  const root = resolvePath3(__dirname3, "..", "template-tests");
+  const root = resolvePath3(__dirname4, "..", "template-tests");
   const templateSrcDir = resolvePath3(root, "src");
   const relProjDir = relative3(templateSrcDir, projDir);
   const relProjDirPath = relProjDir.replaceAll("\\", "/");
   const yamlPath = `${relProjDirPath}/**/*.check.yaml`;
   const outDir = relative3(root, prepDir);
   return {
+    // Don't use an external config file
     configFile: false,
+    // Use the root directory configured above
     root,
+    // Don't clear the screen in dev mode so that we can see builder output
     clearScreen: false,
-    define: {
-      __YAML_PATH__: JSON.stringify(yamlPath)
-    },
+    // TODO: Disable vite output by default?
+    // logLevel: 'silent',
+    plugins: [
+      // Inject special values into the generated JS
+      // TODO: We currently have to use `@rollup/plugin-replace` instead of Vite's
+      // built-in `define` feature because the latter does not seem to run before
+      // the glob handler (which requires the glob to be injected as a literal)
+      replace2({
+        preventAssignment: true,
+        delimiters: ["", ""],
+        values: {
+          // Inject the glob pattern for matching check yaml files
+          "./__YAML_PATH__": yamlPath
+        }
+      })
+    ],
     build: {
+      // Write output files to the configured directory (instead of the default `dist`);
+      // note that this must be relative to the project `root`
       outDir,
       emptyOutDir: false,
       lib: {
@@ -392,8 +535,19 @@ function createViteConfigForTests(projDir, prepDir, mode) {
         formats: ["es"],
         fileName: () => "check-tests.js"
       },
+      // Enable watch mode if requested
       watch: mode === "watch" && {},
-      rollupOptions: {}
+      rollupOptions: {
+        // Prevent dependencies from being included in packaged library
+        // TODO: For now we include check-core in the packaged library so that its
+        // dependencies are correctly resolved at runtime.  Ideally this would only
+        // include a couple functions that are used for defining tests, but Vite 2.x
+        // does not implement tree shaking for ES libraries, which means the generated
+        // library is much larger than it needs to be.  Once we upgrade to Vite 3.x,
+        // the generated library should be smaller; see related fix:
+        //   https://github.com/vitejs/vite/pull/8737
+        // external: Object.keys(pkg.dependencies)
+      }
     }
   };
 }
@@ -408,8 +562,7 @@ var CheckPlugin = class {
     this.firstBuild = true;
   }
   async watch(config) {
-    var _a;
-    if (((_a = this.options) == null ? void 0 : _a.testConfigPath) === void 0) {
+    if (this.options?.testConfigPath === void 0) {
       await this.genTestConfig(config, "watch");
     }
     const testOptions = this.resolveTestOptions(config);
@@ -418,8 +571,12 @@ var CheckPlugin = class {
     await server.listen();
     const baselinesDir = "baselines";
     const watcher = chokidar.watch(baselinesDir, {
+      // Watch paths are resolved relative to the project root directory
       cwd: config.rootDir,
+      // Don't send initial "file added" events
       ignoreInitial: true,
+      // XXX: Include a delay, otherwise on macOS we sometimes get multiple
+      // change events when a file is saved just once
       awaitWriteFinish: {
         stabilityThreshold: 200
       }
@@ -427,18 +584,22 @@ var CheckPlugin = class {
     watcher.on("add", () => server.restart());
     watcher.on("unlink", () => server.restart());
   }
+  // TODO: Note that this plugin runs as a `postBuild` step because it currently
+  // needs to run after other plugins, and those plugins need to run after the
+  // staged files are copied to their final destination(s).  We should probably
+  // make it configurable so that it can either be run as a `postGenerate` or a
+  // `postBuild` step.
   async postBuild(context, modelSpec) {
-    var _a, _b;
     const firstBuild = this.firstBuild;
     this.firstBuild = false;
-    if (((_a = this.options) == null ? void 0 : _a.current) === void 0) {
+    if (this.options?.current === void 0) {
       if (context.config.mode === "development") {
         await this.copyPreviousBundle(context.config);
       }
       context.log("info", "Generating model check bundle...");
       await this.genCurrentBundle(context.config, modelSpec);
     }
-    if (((_b = this.options) == null ? void 0 : _b.testConfigPath) === void 0) {
+    if (this.options?.testConfigPath === void 0) {
       if (context.config.mode === "production" || firstBuild) {
         context.log("info", "Generating model check test configuration...");
         await this.genTestConfig(context.config, "build");
@@ -474,38 +635,42 @@ var CheckPlugin = class {
     await build(viteConfig);
   }
   async runChecks(context, testOptions) {
-    var _a;
     context.log("info", "Running model checks...");
     const moduleR = await import(relativeToSourcePath(testOptions.currentBundlePath));
     const bundleR = moduleR.createBundle();
-    const nameR = testOptions.currentBundleName;
+    const bundleNameR = testOptions.currentBundleName;
     let bundleL;
-    let nameL;
-    if ((_a = this.options) == null ? void 0 : _a.baseline) {
+    let bundleNameL;
+    if (this.options?.baseline) {
       const moduleL = await import(relativeToSourcePath(this.options.baseline.path));
       const rawBundleL = moduleL.createBundle();
       if (rawBundleL.version === bundleR.version) {
         bundleL = rawBundleL;
-        nameL = this.options.baseline.name;
+        bundleNameL = this.options.baseline.name;
       }
     }
     const testConfigModule = await import(relativeToSourcePath(testOptions.testConfigPath));
-    const checkOptions = await testConfigModule.getConfigOptions(bundleL, bundleR, {
-      nameL,
-      nameR
-    });
-    const checkConfig = await createConfig(checkOptions);
-    const result = await runTestSuite(context, checkConfig, false);
+    const configInitOptions = {
+      bundleNameL,
+      bundleNameR
+    };
+    const configOptions = await testConfigModule.getConfigOptions(bundleL, bundleR, configInitOptions);
+    const checkConfig = await createConfig(configOptions);
+    const result = await runTestSuite(
+      context,
+      checkConfig,
+      /*verbose=*/
+      false
+    );
     context.log("info", "Building model check report");
     const viteConfig = this.createViteConfigForReport(context.config, testOptions, result.suiteSummary);
     await build(viteConfig);
     return result.allChecksPassed;
   }
   resolveTestOptions(config) {
-    var _a, _b;
     let currentBundleName;
     let currentBundlePath;
-    if (((_a = this.options) == null ? void 0 : _a.current) === void 0) {
+    if (this.options?.current === void 0) {
       currentBundleName = "current";
       currentBundlePath = joinPath3(config.prepDir, "check-bundle.js");
     } else {
@@ -513,7 +678,7 @@ var CheckPlugin = class {
       currentBundlePath = this.options.current.path;
     }
     let testConfigPath;
-    if (((_b = this.options) == null ? void 0 : _b.testConfigPath) === void 0) {
+    if (this.options?.testConfigPath === void 0) {
       testConfigPath = joinPath3(config.prepDir, "check-tests.js");
     } else {
       testConfigPath = this.options.testConfigPath;