@sdeverywhere/plugin-check 0.1.0

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@sdeverywhere/plugin-check",
+  "version": "0.1.0",
+  "files": [
+    "dist/**",
+    "template-bundle/**",
+    "template-report/**",
+    "template-tests/**"
+  ],
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "dependencies": {
+    "@rollup/plugin-node-resolve": "^13.3.0",
+    "@rollup/plugin-replace": "^2.4.1",
+    "@sdeverywhere/build": "^0.1.0",
+    "@sdeverywhere/check-core": "^0.1.0",
+    "@sdeverywhere/check-ui-shell": "^0.1.0",
+    "@sdeverywhere/runtime": "^0.1.0",
+    "@sdeverywhere/runtime-async": "^0.1.0",
+    "assert-never": "^1.2.1",
+    "picocolors": "^1.0.0",
+    "rollup-plugin-node-polyfills": "^0.2.1",
+    "vite": "^2.9.12",
+    "vite-plugin-glob": "^0.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^16.11.7"
+  },
+  "author": "Climate Interactive",
+  "license": "MIT",
+  "homepage": "https://sdeverywhere.org",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/climateinteractive/SDEverywhere.git",
+    "directory": "packages/plugin-check"
+  },
+  "bugs": {
+    "url": "https://github.com/climateinteractive/SDEverywhere/issues"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "lint": "eslint src --ext .ts --max-warnings 0",
+    "prettier:check": "prettier --check .",
+    "prettier:fix": "prettier --write .",
+    "precommit": "../../scripts/precommit",
+    "test": "echo No tests yet",
+    "test:watch": "echo No tests yet",
+    "test:ci": "echo No tests yet",
+    "type-check": "tsc --noEmit -p tsconfig-build.json",
+    "build": "tsup",
+    "ci:build": "run-s clean lint prettier:check test:ci type-check build"
+  }
+}

package/template-bundle/package.json

@@ -0,0 +1,8 @@
+{
+  "dependencies": {
+    "@sdeverywhere/check-core": "^0.1.0",
+    "@sdeverywhere/runtime": "^0.1.0",
+    "@sdeverywhere/runtime-async": "^0.1.0",
+    "assert-never": "^1.2.1"
+  }
+}

package/template-bundle/src/bundle.ts

@@ -0,0 +1,172 @@
+// Copyright (c) 2022 Climate Interactive / New Venture Fund
+
+import type {
+  Bundle,
+  BundleGraphData,
+  BundleModel as CheckBundleModel,
+  Dataset,
+  DatasetKey,
+  DatasetMap,
+  DatasetsResult,
+  LinkItem,
+  ModelSpec,
+  Scenario
+} from '@sdeverywhere/check-core'
+
+import type { InputValue, InputVarId, ModelRunner, Point } from '@sdeverywhere/runtime'
+import { Outputs } from '@sdeverywhere/runtime'
+import { spawnAsyncModelRunner } from '@sdeverywhere/runtime-async'
+
+import type { Input } from './inputs'
+import { getInputVars, setInputsForScenario } from './inputs'
+import { getOutputVars } from './outputs'
+
+import { startTime, endTime, inputSpecs, outputSpecs } from 'virtual:model-spec'
+
+import modelWorkerJs from '@_model_worker_/worker.js?raw'
+
+// The current version of the check bundle format.  This should be
+// incremented when there is an incompatible change to the bundle format.
+// The model-check tools can use this value to skip tests if two bundles
+// have different version numbers.
+const VERSION = 1
+
+// The size (in bytes) of the model file(s), injected at build time.
+const __MODEL_SIZE_IN_BYTES__ = 1
+const modelSizeInBytes = __MODEL_SIZE_IN_BYTES__
+
+// The size (in bytes) of the data file(s), injected at build time.
+const __DATA_SIZE_IN_BYTES__ = 1
+const dataSizeInBytes = __DATA_SIZE_IN_BYTES__
+
+export class BundleModel implements CheckBundleModel {
+  private readonly inputs: InputValue[]
+  private outputs: Outputs
+
+  /**
+   * @param modelSpec The spec for the bundled model.
+   * @param inputMap The model inputs.
+   * @param modelRunner The model runner.
+   */
+  constructor(
+    public readonly modelSpec: ModelSpec,
+    private readonly inputMap: Map<InputVarId, Input>,
+    private readonly modelRunner: ModelRunner
+  ) {
+    // Derive an array of `InputValue` instances that can be passed to the runner
+    this.inputs = [...inputMap.values()].map(input => input.value)
+
+    // Create an `Outputs` instance that is initialized to hold output data
+    // produced by the Wasm model
+    const outputVarIds = outputSpecs.map(o => o.varId)
+    this.outputs = new Outputs(outputVarIds, startTime, endTime)
+  }
+
+  // from CheckBundleModel interface
+  async getDatasetsForScenario(scenario: Scenario, datasetKeys: DatasetKey[]): Promise<DatasetsResult> {
+    const datasetMap: DatasetMap = new Map()
+
+    // Set the input values according to the given scenario
+    setInputsForScenario(this.inputMap, scenario)
+
+    // Run the JS model
+    this.outputs = await this.modelRunner.runModel(this.inputs, this.outputs)
+    const modelRunTime = this.outputs.runTimeInMillis
+
+    // Extract the data for each requested output variable and put it into a map
+    for (const datasetKey of datasetKeys) {
+      // Get the output variable for the given dataset key; if the variable doesn't
+      // exist in this version of the model/bundle, just skip it
+      const outputVar = this.modelSpec.outputVars.get(datasetKey)
+      if (!outputVar) {
+        continue
+      }
+
+      if (outputVar.sourceName === undefined) {
+        // See if we have data for the requested model output variable
+        const series = this.outputs.getSeriesForVar(outputVar.varId)
+        if (series) {
+          datasetMap.set(datasetKey, datasetFromPoints(series.points))
+        }
+      } else {
+        console.error('Static data sources not yet handled in default model check bundle')
+      }
+    }
+
+    return {
+      datasetMap,
+      modelRunTime
+    }
+  }
+
+  // from CheckBundleModel interface
+  // TODO: This function should be optional
+  async getGraphDataForScenario(): Promise<BundleGraphData> {
+    return undefined
+  }
+
+  // from CheckBundleModel interface
+  // TODO: This function should be optional
+  getGraphLinksForScenario(): LinkItem[] {
+    return []
+  }
+}
+
+/**
+ * Initialize a `BundleModel` instance that supports the running the model
+ * under different scenarios.
+ */
+async function initBundleModel(modelSpec: ModelSpec, inputMap: Map<InputVarId, Input>): Promise<BundleModel> {
+  // Initialize the Wasm model asynchronously.  We inline the worker code in the
+  // rolled-up bundle so that we don't have to fetch a separate `worker.js` file
+  const modelRunner = await spawnAsyncModelRunner({ source: modelWorkerJs })
+
+  // Return a `BundleModel` that wraps the underlying config and Wasm model
+  return new BundleModel(modelSpec, inputMap, modelRunner)
+}
+
+/**
+ * Create a `Dataset` containing the given data points from the model.
+ */
+export function datasetFromPoints(points: Point[]): Dataset {
+  const dataMap = new Map()
+  for (const point of points) {
+    // We omit points that have an undefined value.  SDE represents `:NA:` values as
+    // a special value (`-DBL_MAX`); the `runtime` package detects these and converts
+    // them to undefined instead.  We don't need them to appear in graphs, so omit them.
+    if (point.y !== undefined) {
+      dataMap.set(point.x, point.y)
+    }
+  }
+  return dataMap
+}
+
+/**
+ * Return a `Bundle` that can be used for running comparisons between two
+ * bundles containing different versions of the sample model.
+ */
+export function createBundle(): Bundle {
+  // Gather information about the input and output variables used in the model
+  const inputVars = getInputVars(inputSpecs)
+  const outputVars = getOutputVars(outputSpecs)
+
+  const modelSpec: ModelSpec = {
+    modelSizeInBytes,
+    dataSizeInBytes,
+    inputVars,
+    outputVars,
+    implVars: new Map(),
+    inputGroups: new Map(),
+    datasetGroups: new Map(),
+    startTime,
+    endTime
+  }
+
+  return {
+    version: VERSION,
+    modelSpec,
+    initModel: () => {
+      return initBundleModel(modelSpec, inputVars)
+    }
+  }
+}

package/template-bundle/src/empty-model-spec.ts

@@ -0,0 +1,15 @@
+// Copyright (c) 2022 Climate Interactive / New Venture Fund
+
+/*
+ * This no-op module is configured as the default path alias in the tsconfig
+ * files so that TypeScript does not complain.  (The actual module will be set
+ * up using aliases in the Vite config file.)
+ */
+
+import type { InputSpec } from './inputs'
+import type { OutputSpec } from './outputs'
+
+export const startTime = 0
+export const endTime = 0
+export const inputSpecs: InputSpec[] = []
+export const outputSpecs: OutputSpec[] = []

package/template-bundle/src/index.ts

@@ -0,0 +1,3 @@
+// Copyright (c) 2021-2022 Climate Interactive / New Venture Fund
+
+export { createBundle } from './bundle'

package/template-bundle/src/inputs.ts

@@ -0,0 +1,139 @@
+// Copyright (c) 2022 Climate Interactive / New Venture Fund
+
+import { assertNever } from 'assert-never'
+
+import type { InputVar, Scenario } from '@sdeverywhere/check-core'
+import type { InputValue, InputVarId } from '@sdeverywhere/runtime'
+import { createInputValue } from '@sdeverywhere/runtime'
+
+export interface InputSpec {
+  /** The variable identifier (as used by SDEverywhere). */
+  varId: string
+  /** The variable name (as used in the modeling tool). */
+  varName: string
+  /** The default value for the input. */
+  defaultValue: number
+  /** The minimum value for the input. */
+  minValue: number
+  /** The maximum value for the input. */
+  maxValue: number
+}
+
+export interface Input extends InputVar {
+  value: InputValue
+}
+
+/**
+ * Gather the set of input variables used in this version of the model.
+ */
+export function getInputVars(inputSpecs: InputSpec[]): Map<InputVarId, Input> {
+  const inputs: Map<InputVarId, Input> = new Map()
+  for (const inputSpec of inputSpecs) {
+    const varId = inputSpec.varId
+    const input: Input = {
+      varId,
+      varName: inputSpec.varName,
+      defaultValue: inputSpec.defaultValue,
+      minValue: inputSpec.minValue,
+      maxValue: inputSpec.maxValue,
+      value: createInputValue(varId, inputSpec.defaultValue)
+    }
+    inputs.set(varId, input)
+  }
+  return inputs
+}
+
+/**
+ * Set the given `Input` instances according to the given scenario.
+ */
+export function setInputsForScenario(inputs: Map<InputVarId, Input>, scenario: Scenario): void {
+  function setInputToValue(input: Input, value: number): void {
+    if (value < input.minValue) {
+      // TODO: Set an error status so that the scenario is flagged as an
+      // error in the UI (for now, just warn and clamp)
+      console.warn(
+        `WARNING: Scenario input value ${value} is < min value (${input.minValue}) ` + `for input '${input.varName}'`
+      )
+      value = input.minValue
+    } else if (value > input.maxValue) {
+      console.warn(
+        `WARNING: Scenario input value ${value} is > max value (${input.maxValue}) ` + `for input '${input.varName}'`
+      )
+      value = input.maxValue
+    }
+    input.value.set(value)
+  }
+
+  function setInputToDefault(input: Input): void {
+    input.value.reset()
+  }
+  function setInputToMinimum(input: Input): void {
+    input.value.set(input.minValue)
+  }
+  function setInputToMaximum(input: Input): void {
+    input.value.set(input.minValue)
+  }
+
+  function setAllToDefault(): void {
+    inputs.forEach(setInputToDefault)
+  }
+  function setAllToMinimum(): void {
+    inputs.forEach(setInputToMinimum)
+  }
+  function setAllToMaximum(): void {
+    inputs.forEach(setInputToMaximum)
+  }
+
+  // Set inputs according to the given scenario
+  switch (scenario.kind) {
+    case 'all-inputs': {
+      switch (scenario.position) {
+        case 'at-default':
+          setAllToDefault()
+          break
+        case 'at-minimum':
+          setAllToMinimum()
+          break
+        case 'at-maximum':
+          setAllToMaximum()
+          break
+      }
+      break
+    }
+    case 'settings': {
+      setAllToDefault()
+      for (const setting of scenario.settings) {
+        const input = inputs.get(setting.inputVarId)
+        if (input) {
+          switch (setting.kind) {
+            case 'position':
+              switch (setting.position) {
+                case 'at-default':
+                  setInputToDefault(input)
+                  break
+                case 'at-minimum':
+                  setInputToMinimum(input)
+                  break
+                case 'at-maximum':
+                  setInputToMaximum(input)
+                  break
+                default:
+                  assertNever(setting.position)
+              }
+              break
+            case 'value':
+              setInputToValue(input, setting.value)
+              break
+            default:
+              assertNever(setting)
+          }
+        } else {
+          console.log(`No model input for scenario input ${setting.inputVarId}`)
+        }
+      }
+      break
+    }
+    default:
+      assertNever(scenario)
+  }
+}

package/template-bundle/src/outputs.ts

@@ -0,0 +1,36 @@
+// Copyright (c) 2022 Climate Interactive / New Venture Fund
+
+import type { DatasetKey, OutputVar, SourceName } from '@sdeverywhere/check-core'
+import type { OutputVarId } from '@sdeverywhere/runtime'
+
+export interface OutputSpec {
+  /** The variable identifier (as used by SDEverywhere). */
+  varId: string
+  /** The variable name (as used in the modeling tool). */
+  varName: string
+}
+
+/**
+ * Gather the list of output variables (and their related graphs, etc) used
+ * in this version of the model.
+ */
+export function getOutputVars(outputSpecs: OutputSpec[]): Map<DatasetKey, OutputVar> {
+  // Convert the specs to `OutputVar` instances
+  const outputVars: Map<DatasetKey, OutputVar> = new Map()
+
+  for (const outputSpec of outputSpecs) {
+    const varId = outputSpec.varId
+    const datasetKey = datasetKeyForOutputVar(undefined, varId)
+    outputVars.set(datasetKey, {
+      sourceName: undefined,
+      varId,
+      varName: outputSpec.varName
+    })
+  }
+
+  return outputVars
+}
+
+export function datasetKeyForOutputVar(sourceName: SourceName | undefined, varId: OutputVarId): DatasetKey {
+  return `${sourceName || 'Model'}_${varId}`
+}

package/template-bundle/src/worker.js

@@ -0,0 +1,9 @@
+// Copyright (c) 2022 Climate Interactive / New Venture Fund
+
+/*
+ * This no-op module is configured as the default path alias in the tsconfig
+ * files so that TypeScript does not complain.  (The actual module will be set
+ * up using aliases in the Vite config file.)
+ */
+
+export const unused = 0

package/template-bundle/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    // Use "es2020" for dynamic import
+    "module": "es2020",
+    // Emit additional JS to ease support for importing CommonJS modules
+    "esModuleInterop": true,
+    // Use Node.js-style module resolution
+    "moduleResolution": "node",
+    // Enable warnings for transpilation-unsafe code
+    "isolatedModules": true,
+    // Enable strict enforcement of `import type`
+    "importsNotUsedAsValues": "error",
+    "noImplicitAny": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "types": ["vite/client"],
+    // Use placeholders for path aliases that are configured in the Vite
+    // config; this prevents TypeScript from complaining but still allows
+    // for plugging in "real" files later
+    "baseUrl": ".",
+    "paths": {
+      "virtual:model-spec": ["./src/empty-model-spec.ts"],
+      "@_model_worker_": ["./src"]
+    }
+  }
+}

package/template-report/index.html

@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>Model Check</title>
+
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Roboto+Condensed:wght@400&family=Roboto:wght@500;700&display=swap"
+      rel="stylesheet"
+    />
+
+    <script type="module" src="./src/index.ts"></script>
+  </head>
+
+  <body>
+    <div id="app-shell-container"></div>
+    <div id="overlay-container">
+      <div id="overlay-content">
+        <div id="overlay-text"></div>
+      </div>
+    </div>
+  </body>
+</html>

package/template-report/package.json

@@ -0,0 +1,6 @@
+{
+  "dependencies": {
+    "@sdeverywhere/check-core": "^0.1.0",
+    "@sdeverywhere/check-ui-shell": "^0.1.0"
+  }
+}

package/template-report/src/empty-bundle.ts

@@ -0,0 +1,23 @@
+// Copyright (c) 2022 Climate Interactive / New Venture Fund
+
+import type { Bundle } from '@sdeverywhere/check-core'
+
+/*
+ * This module serves two purposes:
+ *
+ * 1. It is configured as the default path alias in the tsconfig files so
+ *    that TypeScript does not complain.  (The actual bundles will be set
+ *    up using aliases in the Vite config file.)
+ *
+ * 2. It is used as a default no-op bundle in the case where a baseline
+ *    bundle is not used (in which case no comparison tests will be run
+ *    and only the current bundle will be checked).
+ */
+
+export function createBundle(): Bundle {
+  return {
+    version: -1,
+    modelSpec: undefined,
+    initModel: () => undefined
+  }
+}

package/template-report/src/empty-test-config.ts

@@ -0,0 +1,24 @@
+// Copyright (c) 2022 Climate Interactive / New Venture Fund
+
+/*
+ * This no-op module is configured as the default path alias in the tsconfig
+ * files so that TypeScript does not complain.  (The actual module will be set
+ * up using aliases in the Vite config file.)
+ */
+
+import type { Bundle, ConfigOptions } from '@sdeverywhere/check-core'
+
+export interface BundleOptions {
+  nameL?: string
+  nameR?: string
+}
+
+export async function getConfigOptions(
+  /* eslint-disable @typescript-eslint/no-unused-vars */
+  _bundleL: Bundle | undefined,
+  _bundleR: Bundle,
+  _opts: BundleOptions
+  /* eslint-enable @typescript-eslint/no-unused-vars */
+): Promise<ConfigOptions> {
+  return undefined
+}

package/template-report/src/env.d.ts

@@ -0,0 +1,7 @@
+// Copyright (c) 2022 Climate Interactive / New Venture Fund
+
+// These values are injected by Vite at build time, so we need to
+// declare types for them here
+declare const __BASELINE_NAME__: string
+declare const __CURRENT_NAME__: string
+declare const __SUITE_SUMMARY_JSON__: string

package/template-report/src/global.css

@@ -0,0 +1,22 @@
+#overlay-content {
+  position: fixed;
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+  bottom: 0;
+  right: 0;
+  margin-right: 1rem;
+  margin-bottom: 1rem;
+  max-width: 80%;
+  max-height: 80%;
+  overflow-y: auto;
+  padding: 1rem;
+  border-radius: 0.5rem;
+  background-color: #ddd;
+  color: #000;
+  box-shadow: 0 3px 6px rgba(0, 0, 0, 0.8);
+}
+
+#overlay-content .overlay-error {
+  color: crimson;
+}

package/template-report/src/index.ts

@@ -0,0 +1,56 @@
+// Copyright (c) 2022 Climate Interactive / New Venture Fund
+
+import type { Bundle, SuiteSummary } from '@sdeverywhere/check-core'
+
+import { initAppShell } from '@sdeverywhere/check-ui-shell'
+import '@sdeverywhere/check-ui-shell/dist/style.css'
+
+import { initOverlay } from './overlay'
+
+import './global.css'
+
+// These aliases are specified in the Vite config to point to the actual bundles
+import { createBundle as createBaselineBundle } from '@_baseline_bundle_'
+import { createBundle as createCurrentBundle } from '@_current_bundle_'
+import { getConfigOptions } from '@_test_config_'
+
+// For "production" builds, load the summary from a JSON file that
+// was generated as part of the build process.  This makes the
+// report load almost immediately instead of running all the checks
+// in the user's browser.
+const suiteSummaryJson = __SUITE_SUMMARY_JSON__
+let suiteSummary: SuiteSummary
+if (suiteSummaryJson) {
+  suiteSummary = JSON.parse(suiteSummaryJson) as SuiteSummary
+}
+
+async function init() {
+  // Load the bundles used by the model check/compare configuration.  We
+  // always initialize the "current" bundle.
+  const bundleR: Bundle = createCurrentBundle()
+
+  // Only initialize the "baseline" bundle if it is defined and the version
+  // is the same as the "current" one.  If the baseline bundle has a different
+  // version, we will skip the comparison tests and only run the checks on the
+  // current bundle.
+  let bundleL: Bundle
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const rawBundleL: any = createBaselineBundle()
+  if (rawBundleL.version === bundleR.version) {
+    bundleL = rawBundleL as Bundle
+  }
+
+  // Prepare the model check/compare configuration
+  const checkOptions = await getConfigOptions(bundleL, bundleR, {
+    nameL: __BASELINE_NAME__ || undefined,
+    nameR: __CURRENT_NAME__
+  })
+
+  // Initialize the root Svelte component
+  initAppShell(checkOptions, suiteSummary)
+
+  // Initialize the overlay element used to show builder messages/errors
+  initOverlay()
+}
+
+init()

package/template-report/src/messages.html

@@ -0,0 +1,6 @@
+<!--
+  NOTE: This file is only referenced by `tsconfig.json` for the purposes of
+  configuring the '@_prep_' path alias; it is not included with the report
+  build.  In the Vite config, we will use a different alias that points to
+  the actual `messages.html` file under the configured sde "prep" directory.
+-->