@sdeverywhere/runtime 0.2.5 → 0.2.6

package/dist/index.cjs

@@ -251,7 +251,7 @@ function encodeVarIndices(varSpecs, indicesArray) {
   }
 }
 function getEncodedLookupBufferLengths(lookupDefs) {
-  var _a;
+  var _a, _b;
   let lookupIndicesLength = 1;
   let lookupsLength = 0;
   for (const lookupDef of lookupDefs) {
@@ -263,7 +263,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,
@@ -283,10 +283,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) {
@@ -307,10 +312,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: {
@@ -324,11 +333,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,
@@ -884,18 +896,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;
   }
@@ -904,8 +957,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];
@@ -920,11 +973,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) {
@@ -983,10 +1036,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;
     }
@@ -1001,33 +1054,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":
@@ -1039,17 +1093,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];
       }
     }
   }
@@ -1500,7 +1554,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) {
@@ -1629,14 +1684,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);
       }