@woosh/meep-engine 2.113.12 → 2.113.14

package/src/core/collection/table/RowFirstTable.d.ts

@@ -1,5 +1,7 @@
 /**
  * Compact binary table storage
+ * Very efficient in terms of memory usage and allocation
+ * You can think of it as an SQL table but only for numbers
  */
 export class RowFirstTable {
     /**
@@ -34,8 +36,12 @@ export class RowFirstTable {
      * @type {DataView}
      */
     dataView: DataView;
+    /**
+     *
+     * @type {{added: Signal}}
+     */
     on: {
-        added: Signal<any, any, any, any, any, any, any, any>;
+        added: Signal;
     };
     /**
      * @deprecated access directly via spec instead
@@ -48,19 +54,15 @@ export class RowFirstTable {
      */
     get bytesPerRecord(): number;
     /**
-     * @private
+     * @deprecated use {@link RowFirstTable.spec.readRowMethod} instead
+     * @return {function(DataView, number, number[]): void}
      */
-    private initialize;
+    get readRowMethod(): (arg0: DataView, arg1: number, arg2: number[]) => void;
     /**
-     *
-     * @type {function(DataView, number, number[]): void}
+     @deprecated use {@link RowFirstTable.spec.writeRowMethod} instead
+     * @return {function(DataView, number, number[]): void}
      */
-    readRowMethod: (arg0: DataView, arg1: number, arg2: number[]) => void;
-    /**
-     *
-     * @type {function(DataView, number, number[]): void}
-     */
-    writeRowMethod: (arg0: DataView, arg1: number, arg2: number[]) => void;
+    get writeRowMethod(): (arg0: DataView, arg1: number, arg2: number[]) => void;
     /**
      * NOTE: capacity is set automatically
      * NOTE: length is not set automatically, you have to do that yourself
@@ -88,31 +90,31 @@ export class RowFirstTable {
     resize(rowCount: number): void;
     /**
      *
-     * @param {number} rowIndex
-     * @param {number} columnIndex
+     * @param {number} row_index
+     * @param {number} column_index
      * @param {number} value
      */
-    writeCellValue(rowIndex: number, columnIndex: number, value: number): void;
+    writeCellValue(row_index: number, column_index: number, value: number): void;
     /**
      * read a single cell value from the table
-     * @param {number} rowIndex
-     * @param {number} columnIndex
+     * @param {number} row_index
+     * @param {number} column_index
      * @returns {number}
      */
-    readCellValue(rowIndex: number, columnIndex: number): number;
+    readCellValue(row_index: number, column_index: number): number;
     /**
      * Remove rows from the table
      * @param {number} index starting row
-     * @param {number} rowCount number of rows to be removed
+     * @param {number} row_count number of rows to be removed
      */
-    removeRows(index: number, rowCount: number): void;
+    removeRows(index: number, row_count: number): void;
     /**
      * Insert a number of blank rows at the given offset
      * NOTE: doesn't send onAdded signal
      * @param {number} index
-     * @param {number} rowCount
+     * @param {number} row_count
      */
-    insertRows(index: number, rowCount: number): void;
+    insertRows(index: number, row_count: number): void;
     /**
      *
      * @param {Array.<number>} values
@@ -143,17 +145,18 @@ export class RowFirstTable {
      */
     equals(other: RowFirstTable): boolean;
     /**
-     *
-     * @param {int} index
-     * @param {Array} result where row values are to be stored
+     * Read a single row of values from the table
+     * @param {number} index
+     * @param {number[]} [result] where row values are to be stored
+     * @returns {number[]} result
      */
-    getRow(index: int, result: any[]): void;
+    readRow(index: number, result?: number[]): number[];
     /**
-     *
+     * Write a single row of values
      * @param {number} index
      * @param {number[]} record
      */
-    setRow(index: number, record: number[]): void;
+    writeRow(index: number, record: number[]): void;
     /**
      * Reverse order of rows, row-0 will end up at and previously last row will become the first row etc.
      */
@@ -176,6 +179,18 @@ export class RowFirstTable {
      * Print the table to console
      */
     printToConsole(): void;
+    /**
+     * @deprecated
+     */
+    initialize(): void;
+    /**
+     * @deprecated use {@link RowFirstTable#readRow} instead
+     */
+    getRow: (index: number, result?: number[]) => number[];
+    /**
+     @deprecated use {@link RowFirstTable#writeRow} instead
+     */
+    setRow: (index: number, record: number[]) => void;
 }
 import Signal from "../../events/signal/Signal.js";
 //# sourceMappingURL=RowFirstTable.d.ts.map

package/src/core/collection/table/RowFirstTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RowFirstTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/table/RowFirstTable.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IACI;;;;;OAKG;IACH,oDAHW,OAAO,EA2CjB;IAnCG;;;OAGG;IACH,wBAAgB;IAEhB;;;OAGG;IACH,MAFU,WAAW,CAEuB;IAE5C;;;OAGG;IACH,QAFU,MAAM,CAED;IAEf;;;OAGG;IACH,UAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,UAFU,QAAQ,CAEE;IAEpB;;MAEC;IAKL;;;OAGG;IACH,8BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;OAEG;IACH,mBAcC;IAXG;;;OAGG;IACH,sBAFmB,QAAQ,QAAE,MAAM,QAAE,MAAM,EAAE,KAAG,IAAI,CAEb;IAEvC;;;OAGG;IACH,uBAFmB,QAAQ,QAAE,MAAM,QAAE,MAAM,EAAE,KAAG,IAAI,CAEX;IAG7C;;;;OAIG;IACH,uDAMC;IAED;;;OAGG;IACH,QAFa,MAAM,CA4BlB;IAED;;;OAGG;IACH,sBAFW,MAAM,QA+ChB;IAED;;OAEG;IACH,aAEC;IAED;;;OAGG;IACH,iBAFW,MAAM,QAchB;IAED;;;;;OAKG;IACH,yBAJW,MAAM,eACN,MAAM,SACN,MAAM,QAchB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAclB;IAED;;;;OAIG;IACH,kBAHW,MAAM,YACN,MAAM,QAyBhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,YACN,MAAM,QAqBhB;IAED;;;;OAIG;IACH,eAHW,MAAO,MAAM,CAAC,GACZ,MAAM,CAiBlB;IAED;;;;OAIG;IACH,eAHW,MAAM,4BAsChB;IAED;;;;OAIG;IACH,gBAHW,MAAM,UACN,MAAM,QAwBhB;IAED;;;;OAIG;IACH,YAFW,aAAa,QAsBvB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,wCAIC;IAED;;;;OAIG;IACH,cAHW,MAAM,UACN,MAAM,EAAE,QAMlB;IAED;;OAEG;IACH,qBA4BC;IAED;;OAEG;IACH,cAIC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,cAFa,MAAM,EAAE,EAAE,CAgBtB;IAED;;OAEG;IACH,uBAIC;CACJ;mBA9iBkB,+BAA+B"}
+{"version":3,"file":"RowFirstTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/table/RowFirstTable.js"],"names":[],"mappings":"AAaA;;;;GAIG;AACH;IACI;;;;;OAKG;IACH,oDAHW,OAAO,EAiDjB;IAzCG;;;OAGG;IACH,wBAAgB;IAEhB;;;OAGG;IACH,MAFU,WAAW,CAE4D;IAEjF;;;OAGG;IACH,QAFU,MAAM,CAED;IAEf;;;OAGG;IACH,UAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,UAFU,QAAQ,CAEqB;IAEvC;;;OAGG;IACH,IAFU;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAOxB;IAIL;;;OAGG;IACH,8BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,4BAFqB,QAAQ,QAAE,MAAM,QAAE,MAAM,EAAE,KAAG,IAAI,CAIrD;IAED;;;OAGG;IACH,6BAFqB,QAAQ,QAAE,MAAM,QAAE,MAAM,EAAE,KAAG,IAAI,CAIrD;IAGD;;;;OAIG;IACH,uDAMC;IAED;;;OAGG;IACH,QAFa,MAAM,CA+BlB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAgDhB;IAED;;OAEG;IACH,aAEC;IAED;;;OAGG;IACH,iBAFW,MAAM,QAchB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,gBACN,MAAM,SACN,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,yBAJW,MAAM,gBACN,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;OAIG;IACH,kBAHW,MAAM,aACN,MAAM,QAyBhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,aACN,MAAM,QAqBhB;IAED;;;;OAIG;IACH,eAHW,MAAO,MAAM,CAAC,GACZ,MAAM,CAiBlB;IAED;;;;OAIG;IACH,eAHW,MAAM,4BA8ChB;IAED;;;;OAIG;IACH,gBAHW,MAAM,UACN,MAAM,QAwBhB;IAED;;;;OAIG;IACH,YAFW,aAAa,QAmBvB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAmCnB;IAED;;;;;OAKG;IACH,eAJW,MAAM,WACN,MAAM,EAAE,GACN,MAAM,EAAE,CAUpB;IAED;;;;OAIG;IACH,gBAHW,MAAM,UACN,MAAM,EAAE,QAUlB;IAED;;OAEG;IACH,qBA4BC;IAED;;OAEG;IACH,cAIC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,cAFa,MAAM,EAAE,EAAE,CAetB;IAED;;OAEG;IACH,uBAIC;IAED;;OAEG;IACH,mBAEC;IAGL;;OAEG;IACH,gBAtHe,MAAM,WACN,MAAM,EAAE,KACN,MAAM,EAAE,CAoHK;IAC9B;;OAEG;IACH,gBA1Ge,MAAM,UACN,MAAM,EAAE,UAyGO;CAT7B;mBAvmBkB,+BAA+B"}

package/src/core/collection/table/RowFirstTable.js

@@ -3,9 +3,18 @@ import { makeArrayBuffer } from "../../binary/makeArrayBuffer.js";
 import Signal from "../../events/signal/Signal.js";
 import { max2 } from "../../math/max2.js";
 import { array_copy } from "../array/array_copy.js";
+import { array_buffer_copy } from "../array/typed/array_buffer_copy.js";
+
+/**
+ * How much space to reserve in a newly created table, counted in ROWs
+ * @type {number}
+ */
+const DEFAULT_CAPACITY = 8
 
 /**
  * Compact binary table storage
+ * Very efficient in terms of memory usage and allocation
+ * You can think of it as an SQL table but only for numbers
  */
 export class RowFirstTable {
     /**
@@ -29,7 +38,7 @@ export class RowFirstTable {
          *
          * @type {ArrayBuffer}
          */
-        this.data = makeArrayBuffer(0, shared_array);
+        this.data = makeArrayBuffer(spec.bytesPerRecord * DEFAULT_CAPACITY, shared_array);
 
         /**
          * number of records
@@ -41,19 +50,25 @@ export class RowFirstTable {
          * capacity in number of records
          * @type {number}
          */
-        this.capacity = 0;
+        this.capacity = DEFAULT_CAPACITY;
 
         /**
          *
          * @type {DataView}
          */
-        this.dataView = null;
+        this.dataView = new DataView(this.data);
 
+        /**
+         *
+         * @type {{added: Signal}}
+         */
         this.on = {
+            /**
+             * @readonly
+             */
             added: new Signal()
         };
 
-        this.initialize();
     }
 
     /**
@@ -73,24 +88,22 @@ export class RowFirstTable {
     }
 
     /**
-     * @private
+     * @deprecated use {@link RowFirstTable.spec.readRowMethod} instead
+     * @return {function(DataView, number, number[]): void}
      */
-    initialize() {
-        const spec = this.spec;
-
-        /**
-         *
-         * @type {function(DataView, number, number[]): void}
-         */
-        this.readRowMethod = spec.readRowMethod;
+    get readRowMethod() {
+        return this.spec.readRowMethod;
+    }
 
-        /**
-         *
-         * @type {function(DataView, number, number[]): void}
-         */
-        this.writeRowMethod = spec.writeRowMethod;
+    /**
+     @deprecated use {@link RowFirstTable.spec.writeRowMethod} instead
+     * @return {function(DataView, number, number[]): void}
+     */
+    get writeRowMethod() {
+        return this.spec.writeRowMethod;
     }
 
+
     /**
      * NOTE: capacity is set automatically
      * NOTE: length is not set automatically, you have to do that yourself
@@ -109,28 +122,31 @@ export class RowFirstTable {
      * @returns {number}
      */
     hash() {
-        // to keep hash calculation fast, do a fixed number evenly spaced taps inside the data table
 
         const byteLength = this.data.byteLength;
+        const dataView = this.dataView;
+
+        let result = byteLength;
+
 
+        const uint32_length = byteLength >> 2;
+
+        // to keep hash calculation fast, do a fixed number evenly spaced taps inside the data table
         const tap_count = 31;
 
         const step_size = max2(
-            Math.floor(byteLength / (tap_count * 4)),
+            Math.floor(uint32_length / tap_count),
             1
         );
 
-        const step_count = Math.floor(byteLength / step_size);
-
-        const dataView = this.dataView;
-
-        let result = byteLength;
+        const step_count = Math.floor(uint32_length / step_size);
 
         for (let i = 0; i < step_count; i++) {
-            const address = i * step_size * 4;
+            const address = (i * step_size) << 2;
+
+            const uint32 = dataView.getUint32(address);
 
-            result = ((result << 5) - result) + dataView.getUint32(address);
-            result |= 0; // Convert to 32bit integer
+            result = ((result << 5) - result) + uint32;
         }
 
         return result;
@@ -148,7 +164,6 @@ export class RowFirstTable {
             return;
         }
 
-
         const oldData = this.data;
 
         const bytesPerRecord = this.spec.bytesPerRecord;
@@ -168,6 +183,8 @@ export class RowFirstTable {
             throw new Error("Generated array was truncated unexpectedly from " + byteSize + " to " + this.data.byteLength);
         }
 
+        // TODO consider using {@link array_buffer_copy} instead for speed
+
         const newArray = new Uint8Array(this.data);
         const oldArray = new Uint8Array(oldData);
 
@@ -214,40 +231,50 @@ export class RowFirstTable {
 
     /**
      *
-     * @param {number} rowIndex
-     * @param {number} columnIndex
+     * @param {number} row_index
+     * @param {number} column_index
      * @param {number} value
      */
-    writeCellValue(rowIndex, columnIndex, value) {
+    writeCellValue(row_index, column_index, value) {
         const spec = this.spec;
 
+        assert.lessThan(column_index, spec.getColumnCount(), 'overflow');
+        assert.isNonNegativeInteger(column_index, 'column_index');
+
+        assert.isNonNegativeInteger(row_index, 'row_index');
+
         const bytesPerRecord = spec.bytesPerRecord;
 
-        const rowAddress = rowIndex * bytesPerRecord;
+        const rowAddress = row_index * bytesPerRecord;
 
         const cellWriters = spec.cellWriters;
 
-        const cellWriter = cellWriters[columnIndex];
+        const cellWriter = cellWriters[column_index];
 
         cellWriter(this.dataView, rowAddress, value);
     }
 
     /**
      * read a single cell value from the table
-     * @param {number} rowIndex
-     * @param {number} columnIndex
+     * @param {number} row_index
+     * @param {number} column_index
      * @returns {number}
      */
-    readCellValue(rowIndex, columnIndex) {
+    readCellValue(row_index, column_index) {
         const spec = this.spec;
 
+        assert.lessThan(column_index, spec.getColumnCount(), 'overflow');
+        assert.isNonNegativeInteger(column_index, 'column_index');
+
+        assert.isNonNegativeInteger(row_index, 'row_index');
+
         const bytesPerRecord = spec.bytesPerRecord;
 
-        const rowAddress = rowIndex * bytesPerRecord;
+        const rowAddress = row_index * bytesPerRecord;
 
         const cellReaders = spec.cellReaders;
 
-        const cellReader = cellReaders[columnIndex];
+        const cellReader = cellReaders[column_index];
 
         return cellReader(this.dataView, rowAddress);
     }
@@ -255,12 +282,12 @@ export class RowFirstTable {
     /**
      * Remove rows from the table
      * @param {number} index starting row
-     * @param {number} rowCount number of rows to be removed
+     * @param {number} row_count number of rows to be removed
      */
-    removeRows(index, rowCount) {
+    removeRows(index, row_count) {
 
         //validate presence to requested rows
-        assert.lessThanOrEqual(index + rowCount, this.length, 'underflow');
+        assert.lessThanOrEqual(index + row_count, this.length, 'underflow');
 
         const data = this.data;
 
@@ -270,13 +297,13 @@ export class RowFirstTable {
 
         //shift tail of the table forward
         const target = index * bytesPerRecord;
-        const start = target + rowCount * bytesPerRecord;
+        const start = target + row_count * bytesPerRecord;
         const end = this.length * bytesPerRecord;
 
         array.copyWithin(target, start, end);
 
         //adjust new length
-        this.length -= rowCount;
+        this.length -= row_count;
 
         //resize table
         this.resize(this.length);
@@ -286,10 +313,10 @@ export class RowFirstTable {
      * Insert a number of blank rows at the given offset
      * NOTE: doesn't send onAdded signal
      * @param {number} index
-     * @param {number} rowCount
+     * @param {number} row_count
      */
-    insertRows(index, rowCount) {
-        const future_length = this.length + rowCount;
+    insertRows(index, row_count) {
+        const future_length = this.length + row_count;
 
         this.resize(future_length);
 
@@ -300,7 +327,7 @@ export class RowFirstTable {
         const array = new Uint8Array(data);
 
         //shift tail of the table forward
-        const target = (index + rowCount) * bytesPerRecord;
+        const target = (index + row_count) * bytesPerRecord;
         const end = future_length * bytesPerRecord;
         const start = index * bytesPerRecord;
 
@@ -324,7 +351,7 @@ export class RowFirstTable {
 
         this.length = newRowCount;
 
-        this.writeRowMethod(this.dataView, this.spec.bytesPerRecord * rowIndex, values);
+        this.spec.writeRowMethod(this.dataView, this.spec.bytesPerRecord * rowIndex, values);
 
         this.on.added.send2(rowIndex, values);
 
@@ -350,18 +377,26 @@ export class RowFirstTable {
 
         const bytesPerRecord = spec.bytesPerRecord;
         const dataView = this.dataView;
-        const writeRowMethod = this.writeRowMethod;
+        const writeRowMethod = this.spec.writeRowMethod;
 
         const onAdded = this.on.added;
 
+        /**
+         *
+         * @param {number} index
+         */
         function addOneSignaling(index) {
             addOneSilent(index);
             onAdded.send2(index, row);
         }
 
-        function addOneSilent(i) {
-            valueSupplier(i, row);
-            writeRowMethod(dataView, bytesPerRecord * i, row);
+        /**
+         *
+         * @param {number} index
+         */
+        function addOneSilent(index) {
+            valueSupplier(index, row);
+            writeRowMethod(dataView, bytesPerRecord * index, row);
         }
 
         //depending on whether signal is being listened, pick signaling or silent generator
@@ -408,6 +443,7 @@ export class RowFirstTable {
      * @param {RowFirstTable} other
      */
     copy(other) {
+
         // check that the spec is equivalent
         if (!this.spec.equals(other.spec)) {
             throw new Error('Different table specs');
@@ -419,14 +455,10 @@ export class RowFirstTable {
 
         this.length = other.length;
 
-        const target = new Uint8Array(this.data);
-        const source = new Uint8Array(other.data);
-
         // copy data
         const data_byte_count = other.spec.bytesPerRecord * record_count;
-        target.set(source.slice(0, data_byte_count));
 
-        // TODO consider if we should invoke onAdded signal
+        array_buffer_copy(other.data, 0, this.data, 0, data_byte_count);
     }
 
     /**
@@ -434,6 +466,16 @@ export class RowFirstTable {
      * @returns {boolean}
      */
     equals(other) {
+        if (other === this) {
+            // shortcut
+            return true;
+        }
+
+        if (other === undefined || other === null) {
+            // this should not generally not happen
+            return false;
+        }
+
         if (!this.spec.equals(other.spec)) {
             return false;
         }
@@ -459,25 +501,34 @@ export class RowFirstTable {
     }
 
     /**
-     *
-     * @param {int} index
-     * @param {Array} result where row values are to be stored
+     * Read a single row of values from the table
+     * @param {number} index
+     * @param {number[]} [result] where row values are to be stored
+     * @returns {number[]} result
      */
-    getRow(index, result) {
+    readRow(index, result = []) {
         assert.isNonNegativeInteger(index, 'index');
 
-        this.readRowMethod(this.dataView, this.spec.bytesPerRecord * index, result);
+        const spec = this.spec;
+
+        spec.readRowMethod(this.dataView, spec.bytesPerRecord * index, result);
+
+        return result;
     }
 
     /**
-     *
+     * Write a single row of values
      * @param {number} index
      * @param {number[]} record
      */
-    setRow(index, record) {
+    writeRow(index, record) {
         assert.isNonNegativeInteger(index, 'index');
 
-        this.writeRowMethod(this.dataView, this.spec.bytesPerRecord * index, record);
+        const spec = this.spec;
+
+        assert.greaterThanOrEqual(record.length, spec.getColumnCount(), 'input record length is too small');
+
+        spec.writeRowMethod(this.dataView, spec.bytesPerRecord * index, record);
     }
 
     /**
@@ -499,8 +550,8 @@ export class RowFirstTable {
 
         const last_row_index = length - 1;
 
-
         const traversal_limit = last_row_index >>> 1;
+
         for (let i = 0; i <= traversal_limit; i++) {
             const address = i * bpr;
             array_copy(wrapper, address, copy_buffer, 0, bpr);
@@ -539,9 +590,8 @@ export class RowFirstTable {
         const result = [];
 
         for (let i = 0; i < this.length; i++) {
-            const row = [];
 
-            this.getRow(i, row);
+            const row = this.readRow(i);
 
             result.push(row);
         }
@@ -558,4 +608,20 @@ export class RowFirstTable {
 
         console.table(rows);
     }
-}
+
+    /**
+     * @deprecated
+     */
+    initialize() {
+        console.warn('deprecated, no longer serves any purpose. Table no longer requires initialization')
+    }
+}
+
+/**
+ * @deprecated use {@link RowFirstTable#readRow} instead
+ */
+RowFirstTable.prototype.getRow = RowFirstTable.prototype.readRow;
+/**
+ @deprecated use {@link RowFirstTable#writeRow} instead
+ */
+RowFirstTable.prototype.setRow = RowFirstTable.prototype.writeRow;

package/src/core/collection/table/deserializeRowFirstTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deserializeRowFirstTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/table/deserializeRowFirstTable.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,2FAqCC"}
+{"version":3,"file":"deserializeRowFirstTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/table/deserializeRowFirstTable.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,2FAoCC"}

package/src/core/collection/table/deserializeRowFirstTable.js

@@ -1,5 +1,5 @@
-import { RowFirstTableSpec } from "./RowFirstTableSpec.js";
 import { computeDataTypeByIndex } from "../../binary/type/computeDataTypeByIndex.js";
+import { RowFirstTableSpec } from "./RowFirstTableSpec.js";
 
 /**
  *
@@ -42,7 +42,6 @@ function deserializeRowFirstTable(buffer, table) {
     table.data = data.buffer;
     table.dataView = new DataView(table.data);
 
-    table.initialize();
 }
 
 export { deserializeRowFirstTable };

package/src/core/math/random/randomIntegerBetween.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"randomIntegerBetween.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/random/randomIntegerBetween.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,4DAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAWlB"}
+{"version":3,"file":"randomIntegerBetween.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/random/randomIntegerBetween.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,4DAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAclB"}

package/src/core/math/random/randomIntegerBetween.js

@@ -15,5 +15,8 @@ export function randomIntegerBetween(random, min, max) {
 
     const roll = random();
 
+    assert.greaterThanOrEqual(roll, 0, 'random should return value between 0 and 1');
+    assert.lessThanOrEqual(roll, 1, 'random should return value between 0 and 1');
+
     return Math.round(roll * span) + min;
 }

package/src/core/model/reactive/model/ReactiveExpression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveExpression.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/reactive/model/ReactiveExpression.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAEQ,0DAA6B;IAGjC,uBAEC;IAED,cAEC;IAED;;;;OAIG;IACH,wCAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,UAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;OAEG;IACH,YAFa,CAAC,GAAC,OAAO,GAAC,MAAM,CAI5B;IAED;;;;OAIG;IACH,4CAEC;IAED;;;OAGG;IACH,mBAFY,MAAM,CAQjB;IAED;;;OAGG;IACH,iCAIC;IAED;;;;OAIG;IACH,sBAFa,OAAO,GAAC,MAAM,GAAC,MAAM,CAIjC;IAGL,cAAqC;IAErC;;;OAGG;IACH,+BAFU,OAAO,CAEgC;CARhD;mBA/FkB,kCAAkC"}
+{"version":3,"file":"ReactiveExpression.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/reactive/model/ReactiveExpression.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAEQ,0DAA6B;IAGjC,uBAEC;IAED,cAEC;IAED;;;;OAIG;IACH,wCAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,UAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;OAEG;IACH,YAFa,CAAC,GAAC,OAAO,GAAC,MAAM,GAAC,MAAM,CAInC;IAED;;;;OAIG;IACH,4CAEC;IAED;;;OAGG;IACH,mBAFY,MAAM,CAQjB;IAED;;;OAGG;IACH,iCAIC;IAED;;;;OAIG;IACH,sBAFa,OAAO,GAAC,MAAM,GAAC,MAAM,CAIjC;IAGL,cAAqC;IAErC;;;OAGG;IACH,+BAFU,OAAO,CAEgC;CARhD;mBA/FkB,kCAAkC"}

package/src/core/model/reactive/model/ReactiveExpression.js

@@ -48,7 +48,7 @@ export class ReactiveExpression {
     }
 
     /**
-     * @returns {T|boolean|number}
+     * @returns {T|boolean|number|string}
      */
     getValue() {
         throw new Error('ReactiveExpression.getValue not overridden');

package/src/core/model/reactive/model/ReactiveUnaryExpression.d.ts

@@ -30,7 +30,11 @@ export class ReactiveUnaryExpression<T, R> extends ReactiveExpression<any> {
      */
     hash(): number;
     getValue(): void;
-    isUnaryExpression: boolean;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isUnaryExpression: boolean;
 }
 import { ReactiveExpression } from "./ReactiveExpression.js";
 //# sourceMappingURL=ReactiveUnaryExpression.d.ts.map

package/src/core/model/reactive/model/ReactiveUnaryExpression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveUnaryExpression.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/reactive/model/ReactiveUnaryExpression.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI,cASC;IANG;;;OAGG;IACH,QAFU,mBAAmB,CAAC,CAAC,CAEb;IAItB,uBAMC;IAED,qBAIC;IAED,2CAIC;IAED,2BAMC;IAED,mBAIC;IAED;;OAEG;IACH,kCAEC;IAED,0BAIC;IAED;;;;OAIG;IACH,wCAFa,OAAO,CAOnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED,iBAEC;IAGL,2BAAmD;CAFlD;mCAvFkC,yBAAyB"}
+{"version":3,"file":"ReactiveUnaryExpression.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/reactive/model/ReactiveUnaryExpression.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI,cASC;IANG;;;OAGG;IACH,QAFU,mBAAmB,CAAC,CAAC,CAEb;IAItB,uBAMC;IAED,qBAIC;IAED,2CAIC;IAED,2BAMC;IAED,mBAIC;IAED;;OAEG;IACH,kCAEC;IAED,0BAIC;IAED;;;;OAIG;IACH,wCAFa,OAAO,CAOnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED,iBAEC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAEkC;CANlD;mCAvFkC,yBAAyB"}

package/src/core/model/reactive/model/ReactiveUnaryExpression.js

@@ -89,4 +89,8 @@ export class ReactiveUnaryExpression extends ReactiveExpression {
     }
 }
 
+/**
+ * @readonly
+ * @type {boolean}
+ */
 ReactiveUnaryExpression.prototype.isUnaryExpression = true;