@woosh/meep-engine 2.113.11 → 2.113.13

package/build/meep.cjs

@@ -248,6 +248,12 @@ class InMemoryDescriptor extends BaseDescription {
     }
 }
 
+/**
+ * @template T
+ * @param {T} a
+ * @param {T} b
+ * @param {string} [m]
+ */
 function equal(a, b, m) {
     if (a !== b) {
         const details = `${a} !== ${b}`;
@@ -257,10 +263,21 @@ function equal(a, b, m) {
     }
 }
 
+/**
+ * @template T
+ * @param {T} a
+ * @param {T} b
+ * @param {string} [m]
+ */
 function notEqual(a, b, m) {
     assert(a !== b, m); // eslint-disable-line eqeqeq
 }
 
+/**
+ *
+ * @param {boolean} t
+ * @param {string} [m]
+ */
 function notOk(t, m) {
     assert(!t, m);
 }
@@ -274,6 +291,11 @@ function notOk(t, m) {
 function logicalEquals(a, b, m) {
 }
 
+/**
+ *
+ * @param {boolean} t
+ * @param {string} [m]
+ */
 function assert(t, m) {
     if (!t) {
         throw new Error(m || 'AssertionError')

package/build/meep.module.js

@@ -246,6 +246,12 @@ class InMemoryDescriptor extends BaseDescription {
     }
 }
 
+/**
+ * @template T
+ * @param {T} a
+ * @param {T} b
+ * @param {string} [m]
+ */
 function equal(a, b, m) {
     if (a !== b) {
         const details = `${a} !== ${b}`;
@@ -255,10 +261,21 @@ function equal(a, b, m) {
     }
 }
 
+/**
+ * @template T
+ * @param {T} a
+ * @param {T} b
+ * @param {string} [m]
+ */
 function notEqual(a, b, m) {
     assert(a !== b, m); // eslint-disable-line eqeqeq
 }
 
+/**
+ *
+ * @param {boolean} t
+ * @param {string} [m]
+ */
 function notOk(t, m) {
     assert(!t, m);
 }
@@ -272,6 +289,11 @@ function notOk(t, m) {
 function logicalEquals(a, b, m) {
 }
 
+/**
+ *
+ * @param {boolean} t
+ * @param {string} [m]
+ */
 function assert(t, m) {
     if (!t) {
         throw new Error(m || 'AssertionError')

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.113.11",
+  "version": "2.113.13",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/assert.d.ts

@@ -1,4 +1,9 @@
-export function assert(t: any, m: any): void;
+/**
+ *
+ * @param {boolean} t
+ * @param {string} [m]
+ */
+export function assert(t: boolean, m?: string): void;
 export namespace assert {
     /**
      * @template T
@@ -121,9 +126,26 @@ export namespace assert {
      */
     export function that<T>(value: T, name: string, matcher: Matcher<T>): void;
 }
-declare function notEqual(a: any, b: any, m: any): void;
-declare function notOk(t: any, m: any): void;
-declare function equal(a: any, b: any, m: any): void;
+/**
+ * @template T
+ * @param {T} a
+ * @param {T} b
+ * @param {string} [m]
+ */
+declare function notEqual<T>(a: T, b: T, m?: string): void;
+/**
+ *
+ * @param {boolean} t
+ * @param {string} [m]
+ */
+declare function notOk(t: boolean, m?: string): void;
+/**
+ * @template T
+ * @param {T} a
+ * @param {T} b
+ * @param {string} [m]
+ */
+declare function equal<T>(a: T, b: T, m?: string): void;
 /**
  *
  * @param {object} a

package/src/core/assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/core/assert.js"],"names":[],"mappings":"AA+BA,6CAIC;;IAsJD;;;;;OAKG;IACH,kEAQC;;;;;;;;;;;;;;;IAmBD;;;;;;OAMG;IACH,uGAGC;IAGD;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,4DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,sEAMC;IAED;;;;OAIG;IACH,4DAKC;IAED;;;;OAIG;IACH,4GAKC;IAGD;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,wDAIC;IAED;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,2DAIC;IAED;;;;OAIG;IACH,mEAIC;IAED;;;;;OAKG;IACH,2EAgBC;;AA/ZD,wDAEC;AAED,6CAEC;AAfD,qDAOC;AAUD;;;;;GAKG;AACH,kCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAIhB;AAQD;;;;;GAKG;AACH,gCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,uCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AA5CD;;;;;GAKG;AACH,6BAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,oCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAKD;;;;;GAKG;AACH,0CAHW,MAAM,cACN,MAAM,QAehB;AAED;;;;;GAKG;AACH,iEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,mEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,+IAFW,MAAM,QAMhB"}
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/core/assert.js"],"names":[],"mappings":"AAgDA;;;;GAIG;AACH,0BAHW,OAAO,MACP,MAAM,QAMhB;;IAsJD;;;;;OAKG;IACH,kEAQC;;;;;;;;;;;;;;;IAmBD;;;;;;OAMG;IACH,uGAGC;IAGD;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,4DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,sEAMC;IAED;;;;OAIG;IACH,4DAKC;IAED;;;;OAIG;IACH,4GAKC;IAGD;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,wDAIC;IAED;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,2DAIC;IAED;;;;OAIG;IACH,mEAIC;IAED;;;;;OAKG;IACH,2EAgBC;;AA/aD;;;;;GAKG;AACH,6CAFW,MAAM,QAIhB;AAED;;;;GAIG;AACH,0BAHW,OAAO,MACP,MAAM,QAIhB;AAhCD;;;;;GAKG;AACH,0CAFW,MAAM,QAShB;AAqBD;;;;;GAKG;AACH,kCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAIhB;AAaD;;;;;GAKG;AACH,gCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,uCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AA5CD;;;;;GAKG;AACH,6BAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,oCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAKD;;;;;GAKG;AACH,0CAHW,MAAM,cACN,MAAM,QAehB;AAED;;;;;GAKG;AACH,iEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,mEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,+IAFW,MAAM,QAMhB"}

package/src/core/assert.js

@@ -2,6 +2,12 @@ import { isArrayEqualStrict } from "./collection/array/isArrayEqualStrict.js";
 import { isTypedArray } from "./collection/array/typed/isTypedArray.js";
 import { InMemoryDescriptor } from "./debug/InMemoryDescriptor.js";
 
+/**
+ * @template T
+ * @param {T} a
+ * @param {T} b
+ * @param {string} [m]
+ */
 function equal(a, b, m) {
     if (a !== b) {
         const details = `${a} !== ${b}`;
@@ -11,10 +17,21 @@ function equal(a, b, m) {
     }
 }
 
+/**
+ * @template T
+ * @param {T} a
+ * @param {T} b
+ * @param {string} [m]
+ */
 function notEqual(a, b, m) {
     assert(a !== b, m) // eslint-disable-line eqeqeq
 }
 
+/**
+ *
+ * @param {boolean} t
+ * @param {string} [m]
+ */
 function notOk(t, m) {
     assert(!t, m)
 }
@@ -29,6 +46,11 @@ function logicalEquals(a, b, m) {
     assert.ok(a.equals(b), m);
 }
 
+/**
+ *
+ * @param {boolean} t
+ * @param {string} [m]
+ */
 function assert(t, m) {
     if (!t) {
         throw new Error(m || 'AssertionError')

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
-     */
-    private initialize;
-    /**
-     *
-     * @type {function(DataView, number, number[]): void}
+     * @deprecated use {@link RowFirstTable.spec.readRowMethod} instead
+     * @return {function(DataView, number, number[]): void}
      */
-    readRowMethod: (arg0: DataView, arg1: number, arg2: number[]) => void;
+    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}
      */
-    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
@@ -144,16 +146,17 @@ export class RowFirstTable {
     equals(other: RowFirstTable): boolean;
     /**
      *
-     * @param {int} index
-     * @param {Array} result where row values are to be stored
+     * @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[];
     /**
      *
      * @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":"AAYA;;;;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,QA8ChB;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,4BAsChB;IAED;;;;OAIG;IACH,gBAHW,MAAM,UACN,MAAM,QAwBhB;IAED;;;;OAIG;IACH,YAFW,aAAa,QAqBvB;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,QAQlB;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,gBApHe,MAAM,WACN,MAAM,EAAE,KACN,MAAM,EAAE,CAkHK;IAC9B;;OAEG;IACH,gBAxGe,MAAM,UACN,MAAM,EAAE,UAuGO;CAT7B;mBA5lBkB,+BAA+B"}

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

@@ -4,8 +4,16 @@ import Signal from "../../events/signal/Signal.js";
 import { max2 } from "../../math/max2.js";
 import { array_copy } from "../array/array_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 +37,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 +49,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 +87,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,29 +121,32 @@ 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;
 
-        const tap_count = 31;
+        let result = byteLength;
 
-        const step_size = max2(
-            Math.floor(byteLength / (tap_count * 4)),
-            1
-        );
 
-        const step_count = Math.floor(byteLength / step_size);
+            const uint32_length = byteLength >> 2;
 
-        const dataView = this.dataView;
+            // to keep hash calculation fast, do a fixed number evenly spaced taps inside the data table
+            const tap_count = 31;
 
-        let result = byteLength;
+            const step_size = max2(
+                Math.floor(uint32_length / tap_count ),
+                1
+            );
 
-        for (let i = 0; i < step_count; i++) {
-            const address = i * step_size * 4;
+            const step_count = Math.floor(uint32_length / step_size);
 
-            result = ((result << 5) - result) + dataView.getUint32(address);
-            result |= 0; // Convert to 32bit integer
-        }
+            for (let i = 0; i < step_count; i++) {
+                const address = (i * step_size) << 2;
+
+                const uint32 = dataView.getUint32(address);
+
+                result = ((result << 5) - result) + uint32;
+            }
 
         return result;
     }
@@ -148,7 +163,6 @@ export class RowFirstTable {
             return;
         }
 
-
         const oldData = this.data;
 
         const bytesPerRecord = this.spec.bytesPerRecord;
@@ -214,40 +228,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 +279,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 +294,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 +310,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 +324,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 +348,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,7 +374,7 @@ 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;
 
@@ -408,6 +432,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');
@@ -425,8 +450,6 @@ export class RowFirstTable {
         // 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
     }
 
     /**
@@ -434,6 +457,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;
         }
@@ -460,13 +493,18 @@ export class RowFirstTable {
 
     /**
      *
-     * @param {int} index
-     * @param {Array} result where row values are to be stored
+     * @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;
     }
 
     /**
@@ -474,10 +512,12 @@ export class RowFirstTable {
      * @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;
+
+        spec.writeRowMethod(this.dataView, spec.bytesPerRecord * index, record);
     }
 
     /**
@@ -539,9 +579,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 +597,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/engine/animation/async/TimeSeries.js

@@ -156,7 +156,7 @@ export class TimeSeries {
      * @returns {Object}
      */
     getSampleObjectByIndex(index) {
-        this.table.getRow(index, scratch_row);
+        this.table.readRow(index, scratch_row);
 
         return this.#row_to_object_allocating(scratch_row);
     }
@@ -230,7 +230,7 @@ export class TimeSeries {
      * @param {number} index
      */
     getSampleByIndex(result, index) {
-        this.table.getRow(index, result)
+        this.table.readRow(index, result)
     }
 
     /**

package/src/engine/ecs/fow/FogOfWar.js

@@ -118,7 +118,7 @@ export class FogOfWar {
 
         for (; i < numRows; i++) {
             //read row
-            fadeMask.getRow(i, fadeRow);
+            fadeMask.readRow(i, fadeRow);
 
             //decode row
             const index = fadeRow[0];

package/src/engine/graphics/particles/particular/engine/MovingBoundingBox.js

@@ -109,7 +109,7 @@ export class MovingBoundingBox {
         );
 
         for (i = 0; i < length; i++) {
-            this.positionSequence.getRow(i, tempSequenceRecord);
+            this.positionSequence.readRow(i, tempSequenceRecord);
 
             const x0 = tempSequenceRecord[1];
             const y0 = tempSequenceRecord[2];