@sdeverywhere/runtime 0.2.5 → 0.2.6

package/dist/index.d.cts

@@ -180,15 +180,16 @@ interface LookupDef {
     /** The reference that identifies the lookup or data variable to be modified. */
     varRef: VarRef;
     /** The lookup data as a flat array of (x,y) pairs. */
-    points: Float64Array;
+    points?: Float64Array;
 }
 /**
  * Create a `LookupDef` instance from the given array of `Point` objects.
  *
  * @param varRef The reference to the lookup or data variable to be modified.
- * @param points The lookup data as an array of `Point` objects.
+ * @param points The lookup data as an array of `Point` objects.  This can be
+ * undefined, in which case the lookup data will be reset to the original data.
  */
-declare function createLookupDef(varRef: VarRef, points: Point[]): LookupDef;
+declare function createLookupDef(varRef: VarRef, points: Point[] | undefined): LookupDef;
 
 /**
  * Return the length of the array that is required to store the variable
@@ -567,19 +568,60 @@ type JsModelLookupMode = 'interpolate' | 'forward' | 'backward';
  * @hidden This is not yet part of the public API; for internal use only.
  */
 declare class JsModelLookup {
-    private readonly n;
-    private readonly data;
+    /** The original data passed to the constructor. */
+    private readonly originalData;
+    /** The size (i.e., number of pairs) of the original data. */
+    private readonly originalSize;
+    /**
+     * The dynamic data array.  This will be undefined initially, and the array
+     * will be allocated (or grown) by `setData`.
+     */
+    private dynamicData;
+    /** The size (i.e., number of pairs) of the dynamic data. */
+    private dynamicSize;
+    /**
+     * The active data array.  This will be the same as either `originalData`
+     * or `dynamicData`, depending on whether the lookup data is overridden
+     * at runtime using `setData`.
+     */
+    private activeData;
+    /** The size (i.e., number of pairs) of the active data. */
+    private activeSize;
+    /**
+     * The inverted version of the active data array.  This is allocated on demand
+     * only in the case of `LOOKUP INVERT` function calls.
+     */
     private invertedData?;
+    /**
+     * The input value for the last hit.  This is cached for performance so that we
+     * can reduce the amount of linear searching in the common case where `LOOKUP`
+     * input values are monotonically increasing.
+     */
     private lastInput;
+    /** The index for the last hit (see `lastInput`). */
     private lastHitIndex;
     /**
-     * @param n The number of (x,y) pairs in the lookup.
+     * @param size The number of (x,y) pairs in the lookup.
      * @param data The lookup data, as (x,y) pairs.  The length of the array must be
      * >= 2*n.  Note that the data will be stored by reference, so if there is a chance
      * that the array will be reused or modified by other code, be sure to pass in a
      * copy of the array.
      */
-    constructor(n: number, data: number[] | Float64Array);
+    constructor(size: number, data: number[] | Float64Array | undefined);
+    /**
+     * Set new data for this lookup instance, or restore the original data.
+     *
+     * If `data` is undefined, the original data that was supplied to the constructor will
+     * be restored as the "active" data.  Otherwise, `data` will be copied to an internal
+     * data buffer, which will be the "active" data.  If `size` is greater than the size
+     * passed to previous calls, the internal data buffer will be grown as needed.
+     *
+     * @param size The number of (x,y) pairs in the lookup.
+     * @param data The lookup data, as (x,y) pairs.  The length of the array must be
+     * >= 2*n.  Note that the data will be copied into an internal data buffer, so it
+     * is not necessary to defensively copy data before calling this method.
+     */
+    setData(size: number, data: Float64Array | undefined): void;
     getValueForX(x: number, mode: JsModelLookupMode): number;
     getValueForY(y: number): number;
     /**
@@ -716,7 +758,7 @@ interface JsModel {
     /** @hidden */
     setInputs(inputValue: (index: number) => number): void;
     /** @hidden */
-    setLookup(varSpec: VarSpec, points: Float64Array): void;
+    setLookup(varSpec: VarSpec, points: Float64Array | undefined): void;
     /** @hidden */
     storeOutputs(storeValue: (value: number) => void): void;
     /** @hidden */
@@ -787,7 +829,7 @@ declare class MockJsModel implements JsModel {
     setModelFunctions(fns: JsModelFunctions): void;
     setTime(time: number): void;
     setInputs(): void;
-    setLookup(varSpec: VarSpec, points: Float64Array): void;
+    setLookup(varSpec: VarSpec, points: Float64Array | undefined): void;
     storeOutputs(storeValue: (value: number) => void): void;
     storeOutput(varSpec: VarSpec, storeValue: (value: number) => void): void;
     initConstants(): void;

package/dist/index.d.ts

@@ -180,15 +180,16 @@ interface LookupDef {
     /** The reference that identifies the lookup or data variable to be modified. */
     varRef: VarRef;
     /** The lookup data as a flat array of (x,y) pairs. */
-    points: Float64Array;
+    points?: Float64Array;
 }
 /**
  * Create a `LookupDef` instance from the given array of `Point` objects.
  *
  * @param varRef The reference to the lookup or data variable to be modified.
- * @param points The lookup data as an array of `Point` objects.
+ * @param points The lookup data as an array of `Point` objects.  This can be
+ * undefined, in which case the lookup data will be reset to the original data.
  */
-declare function createLookupDef(varRef: VarRef, points: Point[]): LookupDef;
+declare function createLookupDef(varRef: VarRef, points: Point[] | undefined): LookupDef;
 
 /**
  * Return the length of the array that is required to store the variable
@@ -567,19 +568,60 @@ type JsModelLookupMode = 'interpolate' | 'forward' | 'backward';
  * @hidden This is not yet part of the public API; for internal use only.
  */
 declare class JsModelLookup {
-    private readonly n;
-    private readonly data;
+    /** The original data passed to the constructor. */
+    private readonly originalData;
+    /** The size (i.e., number of pairs) of the original data. */
+    private readonly originalSize;
+    /**
+     * The dynamic data array.  This will be undefined initially, and the array
+     * will be allocated (or grown) by `setData`.
+     */
+    private dynamicData;
+    /** The size (i.e., number of pairs) of the dynamic data. */
+    private dynamicSize;
+    /**
+     * The active data array.  This will be the same as either `originalData`
+     * or `dynamicData`, depending on whether the lookup data is overridden
+     * at runtime using `setData`.
+     */
+    private activeData;
+    /** The size (i.e., number of pairs) of the active data. */
+    private activeSize;
+    /**
+     * The inverted version of the active data array.  This is allocated on demand
+     * only in the case of `LOOKUP INVERT` function calls.
+     */
     private invertedData?;
+    /**
+     * The input value for the last hit.  This is cached for performance so that we
+     * can reduce the amount of linear searching in the common case where `LOOKUP`
+     * input values are monotonically increasing.
+     */
     private lastInput;
+    /** The index for the last hit (see `lastInput`). */
     private lastHitIndex;
     /**
-     * @param n The number of (x,y) pairs in the lookup.
+     * @param size The number of (x,y) pairs in the lookup.
      * @param data The lookup data, as (x,y) pairs.  The length of the array must be
      * >= 2*n.  Note that the data will be stored by reference, so if there is a chance
      * that the array will be reused or modified by other code, be sure to pass in a
      * copy of the array.
      */
-    constructor(n: number, data: number[] | Float64Array);
+    constructor(size: number, data: number[] | Float64Array | undefined);
+    /**
+     * Set new data for this lookup instance, or restore the original data.
+     *
+     * If `data` is undefined, the original data that was supplied to the constructor will
+     * be restored as the "active" data.  Otherwise, `data` will be copied to an internal
+     * data buffer, which will be the "active" data.  If `size` is greater than the size
+     * passed to previous calls, the internal data buffer will be grown as needed.
+     *
+     * @param size The number of (x,y) pairs in the lookup.
+     * @param data The lookup data, as (x,y) pairs.  The length of the array must be
+     * >= 2*n.  Note that the data will be copied into an internal data buffer, so it
+     * is not necessary to defensively copy data before calling this method.
+     */
+    setData(size: number, data: Float64Array | undefined): void;
     getValueForX(x: number, mode: JsModelLookupMode): number;
     getValueForY(y: number): number;
     /**
@@ -716,7 +758,7 @@ interface JsModel {
     /** @hidden */
     setInputs(inputValue: (index: number) => number): void;
     /** @hidden */
-    setLookup(varSpec: VarSpec, points: Float64Array): void;
+    setLookup(varSpec: VarSpec, points: Float64Array | undefined): void;
     /** @hidden */
     storeOutputs(storeValue: (value: number) => void): void;
     /** @hidden */
@@ -787,7 +829,7 @@ declare class MockJsModel implements JsModel {
     setModelFunctions(fns: JsModelFunctions): void;
     setTime(time: number): void;
     setInputs(): void;
-    setLookup(varSpec: VarSpec, points: Float64Array): void;
+    setLookup(varSpec: VarSpec, points: Float64Array | undefined): void;
     storeOutputs(storeValue: (value: number) => void): void;
     storeOutput(varSpec: VarSpec, storeValue: (value: number) => void): void;
     initConstants(): void;

package/dist/index.js

@@ -207,7 +207,7 @@ function encodeVarIndices(varSpecs, indicesArray) {
   }
 }
 function getEncodedLookupBufferLengths(lookupDefs) {
-  var _a;
+  var _a, _b;
   let lookupIndicesLength = 1;
   let lookupsLength = 0;
   for (const lookupDef of lookupDefs) {
@@ -219,7 +219,7 @@ function getEncodedLookupBufferLengths(lookupDefs) {
     const subCount = ((_a = varSpec.subscriptIndices) == null ? void 0 : _a.length) || 0;
     lookupIndicesLength += subCount;
     lookupIndicesLength += 2;
-    lookupsLength += lookupDef.points.length;
+    lookupsLength += ((_b = lookupDef.points) == null ? void 0 : _b.length) || 0;
   }
   return {
     lookupIndicesLength,
@@ -239,10 +239,15 @@ function encodeLookups(lookupDefs, lookupIndicesArray, lookupsArray) {
     for (let i = 0; i < subCount; i++) {
       lookupIndicesArray[li++] = subs[i];
     }
-    lookupIndicesArray[li++] = lookupDataOffset;
-    lookupIndicesArray[li++] = lookupDef.points.length;
-    lookupsArray == null ? void 0 : lookupsArray.set(lookupDef.points, lookupDataOffset);
-    lookupDataOffset += lookupDef.points.length;
+    if (lookupDef.points !== void 0) {
+      lookupIndicesArray[li++] = lookupDataOffset;
+      lookupIndicesArray[li++] = lookupDef.points.length;
+      lookupsArray == null ? void 0 : lookupsArray.set(lookupDef.points, lookupDataOffset);
+      lookupDataOffset += lookupDef.points.length;
+    } else {
+      lookupIndicesArray[li++] = -1;
+      lookupIndicesArray[li++] = 0;
+    }
   }
 }
 function decodeLookups(lookupIndicesArray, lookupsArray) {
@@ -263,10 +268,14 @@ function decodeLookups(lookupIndicesArray, lookupsArray) {
       subscriptIndices
     };
     let points;
-    if (lookupsArray) {
-      points = lookupsArray.slice(lookupDataOffset, lookupDataOffset + lookupDataLength);
+    if (lookupDataOffset >= 0) {
+      if (lookupsArray) {
+        points = lookupsArray.slice(lookupDataOffset, lookupDataOffset + lookupDataLength);
+      } else {
+        points = new Float64Array(0);
+      }
     } else {
-      points = new Float64Array(0);
+      points = void 0;
     }
     lookupDefs.push({
       varRef: {
@@ -280,11 +289,14 @@ function decodeLookups(lookupIndicesArray, lookupsArray) {
 
 // src/_shared/lookup-def.ts
 function createLookupDef(varRef, points) {
-  const flatPoints = new Float64Array(points.length * 2);
-  let i = 0;
-  for (const p of points) {
-    flatPoints[i++] = p.x;
-    flatPoints[i++] = p.y;
+  let flatPoints;
+  if (points) {
+    flatPoints = new Float64Array(points.length * 2);
+    let i = 0;
+    for (const p of points) {
+      flatPoints[i++] = p.x;
+      flatPoints[i++] = p.y;
+    }
   }
   return {
     varRef,
@@ -840,18 +852,59 @@ var _NA_ = -Number.MAX_VALUE;
 // src/js-model/js-model-lookup.ts
 var JsModelLookup = class {
   /**
-   * @param n The number of (x,y) pairs in the lookup.
+   * @param size The number of (x,y) pairs in the lookup.
    * @param data The lookup data, as (x,y) pairs.  The length of the array must be
    * >= 2*n.  Note that the data will be stored by reference, so if there is a chance
    * that the array will be reused or modified by other code, be sure to pass in a
    * copy of the array.
    */
-  constructor(n, data) {
-    this.n = n;
-    this.data = data;
-    if (data.length < n * 2) {
-      throw new Error(`Lookup data array length must be >= 2*size (length=${data.length} size=${n}`);
+  constructor(size, data) {
+    if (data && data.length < size * 2) {
+      throw new Error(`Lookup data array length must be >= 2*size (length=${data.length} size=${size}`);
+    }
+    this.originalData = data;
+    this.originalSize = size;
+    this.dynamicData = void 0;
+    this.dynamicSize = 0;
+    this.activeData = this.originalData;
+    this.activeSize = this.originalSize;
+    this.lastInput = Number.MAX_VALUE;
+    this.lastHitIndex = 0;
+  }
+  /**
+   * Set new data for this lookup instance, or restore the original data.
+   *
+   * If `data` is undefined, the original data that was supplied to the constructor will
+   * be restored as the "active" data.  Otherwise, `data` will be copied to an internal
+   * data buffer, which will be the "active" data.  If `size` is greater than the size
+   * passed to previous calls, the internal data buffer will be grown as needed.
+   *
+   * @param size The number of (x,y) pairs in the lookup.
+   * @param data The lookup data, as (x,y) pairs.  The length of the array must be
+   * >= 2*n.  Note that the data will be copied into an internal data buffer, so it
+   * is not necessary to defensively copy data before calling this method.
+   */
+  setData(size, data) {
+    if (data) {
+      if (data.length < size * 2) {
+        throw new Error(`Lookup data array length must be >= 2*size (length=${data.length} size=${size}`);
+      }
+      const dataLengthInElems = size * 2;
+      if (this.dynamicData === void 0 || dataLengthInElems > this.dynamicData.length) {
+        this.dynamicData = new Float64Array(dataLengthInElems);
+      }
+      this.dynamicSize = size;
+      if (size > 0) {
+        const subarray = data.subarray(0, dataLengthInElems);
+        this.dynamicData.set(subarray);
+      }
+      this.activeData = this.dynamicData;
+      this.activeSize = this.dynamicSize;
+    } else {
+      this.activeData = this.originalData;
+      this.activeSize = this.originalSize;
     }
+    this.invertedData = void 0;
     this.lastInput = Number.MAX_VALUE;
     this.lastHitIndex = 0;
   }
@@ -860,8 +913,8 @@ var JsModelLookup = class {
   }
   getValueForY(y) {
     if (this.invertedData === void 0) {
-      const numValues = this.n * 2;
-      const normalData = this.data;
+      const numValues = this.activeSize * 2;
+      const normalData = this.activeData;
       const invertedData = Array(numValues);
       for (let i = 0; i < numValues; i += 2) {
         invertedData[i] = normalData[i + 1];
@@ -876,11 +929,11 @@ var JsModelLookup = class {
    * NOTE: The x values are assumed to be monotonically increasing.
    */
   getValue(input, useInvertedData, mode) {
-    if (this.n === 0) {
+    if (this.activeSize === 0) {
       return _NA_;
     }
-    const data = useInvertedData ? this.invertedData : this.data;
-    const max = this.n * 2;
+    const data = useInvertedData ? this.invertedData : this.activeData;
+    const max = this.activeSize * 2;
     const useCachedValues = !useInvertedData;
     let startIndex;
     if (useCachedValues && input >= this.lastInput) {
@@ -939,10 +992,10 @@ var JsModelLookup = class {
    * no points) or if the provided time is earlier than the first data point.
    */
   getValueForGameTime(time, defaultValue) {
-    if (this.n <= 0) {
+    if (this.activeSize <= 0) {
       return defaultValue;
     }
-    const x0 = this.data[0];
+    const x0 = this.activeData[0];
     if (time < x0) {
       return defaultValue;
     }
@@ -957,33 +1010,34 @@ var JsModelLookup = class {
    * lookup behavior, so we implement it as a separate method here.
    */
   getValueBetweenTimes(input, mode) {
-    if (this.n === 0) {
+    if (this.activeSize === 0) {
       return _NA_;
     }
-    const max = this.n * 2;
+    const data = this.activeData;
+    const max = this.activeSize * 2;
     switch (mode) {
       case "forward": {
         input = Math.floor(input);
         for (let xi = 0; xi < max; xi += 2) {
-          const x = this.data[xi];
+          const x = data[xi];
           if (x >= input) {
-            return this.data[xi + 1];
+            return data[xi + 1];
           }
         }
-        return this.data[max - 1];
+        return data[max - 1];
       }
       case "backward": {
         input = Math.floor(input);
         for (let xi = 2; xi < max; xi += 2) {
-          const x = this.data[xi];
+          const x = data[xi];
           if (x >= input) {
-            return this.data[xi - 1];
+            return data[xi - 1];
           }
         }
         if (max >= 4) {
-          return this.data[max - 3];
+          return data[max - 3];
         } else {
-          return this.data[1];
+          return data[1];
         }
       }
       case "interpolate":
@@ -995,17 +1049,17 @@ var JsModelLookup = class {
           throw new Error(msg);
         }
         for (let xi = 2; xi < max; xi += 2) {
-          const x = this.data[xi];
+          const x = data[xi];
           if (x >= input) {
-            const last_x = this.data[xi - 2];
-            const last_y = this.data[xi - 1];
-            const y = this.data[xi + 1];
+            const last_x = data[xi - 2];
+            const last_y = data[xi - 1];
+            const y = data[xi + 1];
             const dx = x - last_x;
             const dy = y - last_y;
             return last_y + dy / dx * (input - last_x);
           }
         }
-        return this.data[max - 1];
+        return data[max - 1];
       }
     }
   }
@@ -1456,7 +1510,8 @@ var MockJsModel = class {
     if (varId === void 0) {
       throw new Error(`No lookup variable found for spec ${varSpec}`);
     }
-    this.lookups.set(varId, new JsModelLookup(points.length / 2, points));
+    const numPoints = points ? points.length / 2 : 0;
+    this.lookups.set(varId, new JsModelLookup(numPoints, points));
   }
   // from JsModel interface
   storeOutputs(storeValue) {
@@ -1585,14 +1640,21 @@ var WasmModel = class {
         } else {
           subIndicesAddress = 0;
         }
-        const numLookupElements = lookupDef.points.length;
-        if (this.lookupDataBuffer === void 0 || this.lookupDataBuffer.numElements < numLookupElements) {
-          (_c = this.lookupDataBuffer) == null ? void 0 : _c.dispose();
-          this.lookupDataBuffer = createFloat64WasmBuffer(this.wasmModule, numLookupElements);
+        let pointsAddress;
+        let numPoints;
+        if (lookupDef.points) {
+          const numLookupElements = lookupDef.points.length;
+          if (this.lookupDataBuffer === void 0 || this.lookupDataBuffer.numElements < numLookupElements) {
+            (_c = this.lookupDataBuffer) == null ? void 0 : _c.dispose();
+            this.lookupDataBuffer = createFloat64WasmBuffer(this.wasmModule, numLookupElements);
+          }
+          this.lookupDataBuffer.getArrayView().set(lookupDef.points);
+          pointsAddress = this.lookupDataBuffer.getAddress();
+          numPoints = numLookupElements / 2;
+        } else {
+          pointsAddress = 0;
+          numPoints = 0;
         }
-        this.lookupDataBuffer.getArrayView().set(lookupDef.points);
-        const pointsAddress = this.lookupDataBuffer.getAddress();
-        const numPoints = numLookupElements / 2;
         const varIndex = varSpec.varIndex;
         this.wasmSetLookup(varIndex, subIndicesAddress, pointsAddress, numPoints);
       }