@woosh/meep-engine 2.120.1 → 2.120.3

package/src/engine/graphics/texture/sampler/Sampler2D.d.ts

@@ -1,50 +1,349 @@
-import Vector2 from "../../../../core/geom/Vector2";
-
-export class Sampler2D {
-    constructor(data: ArrayLike<number>, itemSize?: number, width?: number, height?: number)
-
-    readonly height: number
-    readonly width: number
-
-    readonly itemSize: number
-
-    readonly data: ArrayLike<number>
-
-    version: number
-
-    readChannel(x: number, y: number, channel: number): number
-
-    writeChannel(x: number, y: number, channel: number, value: number): void
-
-    channelFill(channelIndex: number, value: number): void
-
-    sampleBilinear(x: number, y: number, result: ArrayLike<number>, result_offset?: number): void
-
-    sampleChannelBilinear(x: number, y: number, channel: number): number
-
-    sampleBicubic(x: number, y: number, result: ArrayLike<number>, result_offset?: number): void
-
-    sampleChannelBicubic(x: number, y: number, channel: number): number
-
-    resize(x: number, y: number, preserveData?: boolean): void
-
-    point2index(x: number, y: number): number
-
-    index2point(index: number, result: Vector2): void
-
-    static uint8clamped(itemSize: number, width: number, height: number): Sampler2D
-
-    static uint8(itemSize: number, width: number, height: number): Sampler2D
-
-    static uint16(itemSize: number, width: number, height: number): Sampler2D
-
-    static uint32(itemSize: number, width: number, height: number): Sampler2D
-
-    static int8(itemSize: number, width: number, height: number): Sampler2D
-
-    static int16(itemSize: number, width: number, height: number): Sampler2D
-
-    static int32(itemSize: number, width: number, height: number): Sampler2D
-
-    static float32(itemSize: number, width: number, height: number): Sampler2D
-}
+/**
+ * Data Texture class, providing an abstraction around 2d numerical arrays, mostly for sampling purposes
+ * Inspired by OpenGL's glsl sampler2d API
+ * @class
+ */
+export class Sampler2D {
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static uint8clamped(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static uint8(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static uint16(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static uint32(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static int8(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static int16(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static int32(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static float32(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static float64(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {ArrayLike<number>|number[]|Uint8ClampedArray|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array} data
+     * @param {number} [itemSize]
+     * @param {number} [width]
+     * @param {number} [height]
+     * @constructor
+     */
+    constructor(data?: ArrayLike<number> | number[] | Uint8ClampedArray | Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array, itemSize?: number, width?: number, height?: number);
+    /**
+     *
+     * @type {number}
+     */
+    width: number;
+    /**
+     *
+     * @type {number}
+     */
+    height: number;
+    /**
+     * Number of channels
+     * @type {number}
+     */
+    itemSize: number;
+    /**
+     *
+     * @type {number[]|Uint8ClampedArray|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array}
+     */
+    data: number[] | Uint8ClampedArray | Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array;
+    /**
+     * Used to tracking changes
+     * @type {number}
+     */
+    version: number;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number[]} result
+     */
+    sampleCatmullRomUV(u: number, v: number, result: number[]): void;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number} channel
+     * @returns {number}
+     */
+    sampleChannelCatmullRomUV(u: number, v: number, channel: number): number;
+    /**
+     *
+     * @see https://gist.github.com/TheRealMJP/c83b8c0f46b63f3a88a5986f4fa982b1
+     * @param {number} x
+     * @param {number} y
+     * @param {number} channel
+     * @returns {number}
+     */
+    sampleChannelCatmullRom(x: number, y: number, channel: number): number;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number[]} result
+     */
+    sampleBicubicUV(u: number, v: number, result: number[]): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number[]|Float32Array|Float64Array} result
+     * @param {number} result_offset
+     */
+    sampleBicubic(x: number, y: number, result: number[] | Float32Array | Float64Array, result_offset: number): void;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number} channel
+     * @returns {number}
+     */
+    sampleChannelBicubicUV(u: number, v: number, channel: number): number;
+    /**
+     *
+     * Bicubic-filtered sampling, note values can be negative due to the nature of the cubic curve
+     * @param {number} x
+     * @param {number} y
+     * @param {number} channel
+     * @returns {number}
+     */
+    sampleChannelBicubic(x: number, y: number, channel: number): number;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number[]|Float32Array} result
+     * @param {number} result_offset
+     */
+    sampleBilinearUV(u: number, v: number, result: number[] | Float32Array, result_offset?: number): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number[]|Float32Array|Float64Array} result
+     * @param {number} result_offset
+     */
+    sampleBilinear(x: number, y: number, result: number[] | Float32Array | Float64Array, result_offset?: number): void;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number} channel
+     * @return {number}
+     */
+    sampleChannelBilinearUV(u: number, v: number, channel: number): number;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} channel
+     * @returns {number}
+     */
+    sampleChannelBilinear(x: number, y: number, channel: number): number;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number[]|ArrayLike<number>} result
+     */
+    sampleNearestUV(u: number, v: number, result: number[] | ArrayLike<number>): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} channel
+     * @returns {number}
+     */
+    readChannel(x: number, y: number, channel: number): number;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number[]} result
+     */
+    read(x: number, y: number, result: number[]): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number[]|ArrayLike<number>} texel
+     */
+    write(x: number, y: number, texel: number[] | ArrayLike<number>): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    point2index(x: number, y: number): number;
+    /**
+     *
+     * @param {number} index
+     * @param {Vector2} result
+     */
+    index2point(index: number, result: Vector2): void;
+    /**
+     * Copy a patch from another sampler
+     * @param {Sampler2D} source where to copy from
+     * @param {Number} sourceX where to start reading from, X coordinate
+     * @param {Number} sourceY where to start reading from, X coordinate
+     * @param {Number} destinationX where to start writing to, X coordinate
+     * @param {Number} destinationY where to start writing to, X coordinate
+     * @param {Number} width size of the patch that is to be copied
+     * @param {Number} height size of the patch that is to be copied
+     */
+    copy(source: Sampler2D, sourceX: number, sourceY: number, destinationX: number, destinationY: number, width: number, height: number): void;
+    /**
+     * Fill data values with zeros for a given area
+     * Specialized version of `fill` method, optimized for speed
+     * @param {Number} x
+     * @param {Number} y
+     * @param {Number} width
+     * @param {Number} height
+     */
+    zeroFill(x: number, y: number, width: number, height: number): void;
+    /**
+     *
+     * @param {number} channel_index
+     * @param {number} value
+     */
+    channelFill(channel_index: number, value: number): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {Array.<number>} value
+     */
+    fill(x: number, y: number, width: number, height: number, value: Array<number>): void;
+    /**
+     * Set channel value of a specific texel
+     * @param {number} x
+     * @param {number} y
+     * @param {number} channel
+     * @param {number} value
+     */
+    writeChannel(x: number, y: number, channel: number, value: number): void;
+    /**
+     * Traverses area inside a circle
+     * NOTE: Based on palm3d answer on stack overflow: https://stackoverflow.com/questions/1201200/fast-algorithm-for-drawing-filled-circles
+     * @param {number} centerX
+     * @param {number} centerY
+     * @param {number} radius
+     * @param {function(x:number,y:number, sampler:Sampler2D)} visitor
+     */
+    traverseCircle(centerX: number, centerY: number, radius: number, visitor: any): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {boolean} [preserveData=true]
+     */
+    resize(x: number, y: number, preserveData?: boolean): void;
+    /**
+     * Estimate memory requirement of the object
+     * @return {number}
+     */
+    computeByteSize(): number;
+    /**
+     *
+     * @param {Sampler2D} other
+     * @return {boolean}
+     */
+    equals(other: Sampler2D): boolean;
+    /**
+     *
+     * @return {number}
+     */
+    hash(): number;
+    /**
+     * @returns {Sampler2D}
+     */
+    clone(): Sampler2D;
+    toJSON(): {
+        height: number;
+        width: number;
+        itemSize: number;
+        type: import("../../../../core/binary/type/BinaryDataType.js").BinaryDataType;
+        data: string;
+    };
+    fromJSON({ height, width, itemSize, type, data }: {
+        height: any;
+        width: any;
+        itemSize: any;
+        type: any;
+        data: any;
+    }): void;
+    /**
+     * @deprecated use {@link write} instead
+     */
+    set: (x: number, y: number, texel: number[] | ArrayLike<number>) => void;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isSampler2D: boolean;
+}
+export namespace Sampler2D {
+    let typeName: string;
+}
+//# sourceMappingURL=Sampler2D.d.ts.map

package/src/engine/input/devices/InputDeviceSwitch.d.ts

@@ -4,4 +4,8 @@ export class InputDeviceSwitch {
     readonly up: Signal
     readonly down: Signal
     readonly is_down: boolean
+    readonly is_up: boolean
+
+    press():void
+    release():void
 }

package/src/engine/input/devices/InputDeviceSwitch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InputDeviceSwitch.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/InputDeviceSwitch.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IAEI;;;;OAIG;IACH,eAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,aAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf;;;OAGG;IACH,aAFa,OAAO,CAInB;IAED;;;OAGG;IACH,cAOC;IAED;;;OAGG;IACH,gBAOC;CACJ;mBA5DkB,uCAAuC"}
+{"version":3,"file":"InputDeviceSwitch.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/InputDeviceSwitch.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IAEI;;;;OAIG;IACH,eAFU,MAAQ,CAEC;IAEnB;;;;OAIG;IACH,aAFU,MAAQ,CAED;IAEjB;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf;;;OAGG;IACH,aAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,cAOC;IAED;;;;OAIG;IACH,gBAOC;CACJ;mBA9DkB,uCAAuC"}

package/src/engine/input/devices/InputDeviceSwitch.js

@@ -8,14 +8,14 @@ export class InputDeviceSwitch {
     /**
      * Switch press
      * @readonly
-     * @type {Signal}
+     * @type {Signal<>}
      */
     down = new Signal()
 
     /**
      * Switch release
      * @readonly
-     * @type {Signal}
+     * @type {Signal<>}
      */
     up = new Signal()
 
@@ -36,6 +36,7 @@ export class InputDeviceSwitch {
     /**
      * Execute press, will trigger {@link down} signal if previous state was up
      * Idempotent
+     * NOTE: make sure you understand the implications of using this
      */
     press() {
         if (this.is_down) {
@@ -49,6 +50,7 @@ export class InputDeviceSwitch {
     /**
      * Execute release, will trigger {@link up} signal if previous state was down
      * Idempotent
+     * NOTE: make sure you understand the implications of using this
      */
     release() {
         if (!this.is_down) {

package/src/engine/input/devices/KeyCodes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KeyCodes.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/KeyCodes.js"],"names":[],"mappings":"uBAEU,MAAM;AAFhB;;;GAGG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqGE"}
+{"version":3,"file":"KeyCodes.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/KeyCodes.js"],"names":[],"mappings":";;;uBAGU,MAAM;AAHhB;;;;GAIG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqGE"}

package/src/engine/input/devices/KeyCodes.js

@@ -1,4 +1,5 @@
 /**
+ * Valid keyboard keys
  * @readonly
  * @enum {number}
  */

package/src/engine/input/devices/KeyboardDevice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KeyboardDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/KeyboardDevice.js"],"names":[],"mappings":";AAYA;IAgBI;;;OAGG;IACH,wBAFW,WAAW,GAAC,OAAO,EA+B7B;IA/CD;;OAEG;IACH;;;MAGE;IAEF;;;OAGG;IACH,mBAAU;IAkBN;;;OAGG;IACH,YAFU,WAAW,CAEO;IAkFhC,cAGC;IAED,aAGC;;CACJ;mBA3IkB,uCAAuC"}
+{"version":3,"file":"KeyboardDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/KeyboardDevice.js"],"names":[],"mappings":";AAYA;;;GAGG;AACH;IA4BI;;;OAGG;IACH,wBAHW,WAAW,GAAC,OAAO,EAgC7B;IA3DD;;OAEG;IACH;QACI;;;WAGG;cADO,MAAM,CAAC,aAAa,CAAC;QAG/B;;;WAGG;YADO,MAAM,CAAC,aAAa,CAAC;MAGjC;IAEF;;;;;;;OAOG;IACH,mBAAU;IAkBN;;;OAGG;IACH,YAFU,WAAW,CAEO;IAkFhC;;;OAGG;IACH,SAFa,IAAI,CAKhB;IAED;;;OAGG;IACH,QAFa,IAAI,CAKhB;;CAEJ;mBApKkB,uCAAuC"}

package/src/engine/input/devices/KeyboardDevice.js

@@ -10,25 +10,41 @@ import { KeyCodes } from './KeyCodes.js';
  */
 const codeToKeyNameMap = [];
 
+/**
+ * Provides keyboard input.
+ * Listens for key events on a DOM element and provides signals and state for key presses.
+ */
 class KeyboardDevice {
 
     /**
      * @readonly
      */
     on = {
+        /**
+         * Fires when any key is pressed
+         * @type {Signal<KeyboardEvent>}
+         */
         down: new Signal(),
+        /**
+         * Fires when any key is released
+         * @type {Signal<KeyboardEvent>}
+         */
         up: new Signal()
     };
 
     /**
+     * See {@link KeyCodes} for valid IDs
      * @readonly
      * @type {Object<InputDeviceSwitch>}
+     *
+     * @example
+     *   const is_enter_pressed = keyboard.keys[KeyCodes.enter].is_down;
      */
     keys = {};
 
     /**
-     *
-     * @param {EventTarget|Element} domElement
+     * @param {EventTarget|Element} domElement The DOM element to listen for keyboard events on.  This element *must* be focusable (e.g., have a `tabindex` attribute).
+     * @throws {TypeError} If the provided `domElement` is not focusable and doesn't have a `tabindex` attribute.
      */
     constructor(domElement) {
 
@@ -43,7 +59,7 @@ class KeyboardDevice {
         }
 
         /**
-         *
+         * The DOM element being listened to.
          * @type {EventTarget}
          */
         this.domElement = domElement;
@@ -128,15 +144,24 @@ class KeyboardDevice {
 
     }
 
+    /**
+     * Starts listening for keyboard events on the associated DOM element.
+     * @returns {void}
+     */
     start() {
         this.domElement.addEventListener(KeyboardEvents.KeyDown, this.#handlerKeyDown);
         this.domElement.addEventListener(KeyboardEvents.KeyUp, this.#handlerKeyUp);
     }
 
+    /**
+     * Stops listening for keyboard events.
+     * @returns {void}
+     */
     stop() {
         this.domElement.removeEventListener(KeyboardEvents.KeyDown, this.#handlerKeyDown);
         this.domElement.removeEventListener(KeyboardEvents.KeyUp, this.#handlerKeyUp);
     }
+
 }
 
 export default KeyboardDevice;

package/src/engine/intelligence/behavior/ecs/DieBehavior.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Makes the entity destroy itself
+ */
 export class DieBehavior extends EntityBehavior {
     static create(): DieBehavior;
     tick(timeDelta: any): BehaviorStatus;

package/src/engine/intelligence/behavior/ecs/DieBehavior.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DieBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/ecs/DieBehavior.js"],"names":[],"mappings":"AAGA;IAGI,6BAEC;IAED,qCASC;CACJ;+BAnB8B,qBAAqB;+BADrB,sBAAsB"}
+{"version":3,"file":"DieBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/ecs/DieBehavior.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IAGI,6BAEC;IAED,qCASC;CACJ;+BAtB8B,qBAAqB;+BADrB,sBAAsB"}

package/src/engine/intelligence/behavior/ecs/DieBehavior.js

@@ -1,6 +1,9 @@
 import { BehaviorStatus } from "../BehaviorStatus.js";
 import { EntityBehavior } from "./EntityBehavior.js";
 
+/**
+ * Makes the entity destroy itself
+ */
 export class DieBehavior extends EntityBehavior {
 
 
@@ -19,3 +22,4 @@ export class DieBehavior extends EntityBehavior {
 
     }
 }
+

package/src/engine/intelligence/behavior/ecs/KillBehavior.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Causes another entity to be destroyed
+ * Will produce a {@link BehaviorStatus.Failed} if entity could not be destroyed, either because it doesn't exist or the reference is stale
+ */
+export class KillBehavior extends EntityBehavior {
+    /**
+     *
+     * @param {EntityReference} ref
+     * @returns {KillBehavior}
+     */
+    static create(ref: EntityReference): KillBehavior;
+    tick(timeDelta: any): BehaviorStatus.Succeeded | BehaviorStatus.Failed;
+    #private;
+}
+import { EntityBehavior } from "./EntityBehavior.js";
+import { BehaviorStatus } from "../BehaviorStatus.js";
+//# sourceMappingURL=KillBehavior.d.ts.map

package/src/engine/intelligence/behavior/ecs/KillBehavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KillBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/ecs/KillBehavior.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IAOI;;;;OAIG;IACH,mBAHW,eAAe,GACb,YAAY,CAYxB;IAED,uEAaC;;CACJ;+BA5C8B,qBAAqB;+BADrB,sBAAsB"}

package/src/engine/intelligence/behavior/ecs/KillBehavior.js

@@ -0,0 +1,47 @@
+import { assert } from "../../../../core/assert.js";
+import { BehaviorStatus } from "../BehaviorStatus.js";
+import { EntityBehavior } from "./EntityBehavior.js";
+
+/**
+ * Causes another entity to be destroyed
+ * Will produce a {@link BehaviorStatus.Failed} if entity could not be destroyed, either because it doesn't exist or the reference is stale
+ */
+export class KillBehavior extends EntityBehavior {
+
+    /**
+     * @type {EntityReference}
+     */
+    #ref;
+
+    /**
+     *
+     * @param {EntityReference} ref
+     * @returns {KillBehavior}
+     */
+    static create(ref) {
+        assert.defined(ref, 'ref');
+        assert.isObject(ref, 'ref');
+        assert.equal(ref.isEntityReference, true, 'ref.isEntityReference !== true');
+
+        const r = new KillBehavior();
+
+        r.#ref = ref;
+
+        return r;
+    }
+
+    tick(timeDelta) {
+
+        const ecd = this.ecd;
+
+        if (this.#ref.destroy(ecd)) {
+
+            return BehaviorStatus.Succeeded;
+
+        } else {
+            // couldn't find
+            return BehaviorStatus.Failed;
+
+        }
+    }
+}

package/src/engine/knowledge/database/StaticKnowledgeDataTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StaticKnowledgeDataTable.d.ts","sourceRoot":"","sources":["../../../../../src/engine/knowledge/database/StaticKnowledgeDataTable.js"],"names":[],"mappings":"AAkCA;;;GAGG;AACH,sCAFa,CAAC;IAIV;;;OAGG;IACH,cAAc;IAEd;;;;OAIG;IACH,kBAHU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAGV;IAEnB;;;;OAIG;IACH,mBAHU,CAAC,EAAE,CAGA;IAEb;;;;OAIG;IACH,2BAHU,OAAO,CAGO;IAExB;;;;OAIG;IACH,+BAHU,MAAM,CAGgB;IAEhC,cAQC;IAED,gBAQC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACL,OAAO,CAIlB;IAGD;;;;OAIG;IACH,QAHW,MAAM,GACJ,CAAC,GAAC,IAAI,CAalB;IAED;;;;;OAKG;IACH,gBAHW,CAAC,EAAE,OADH,QAAQ,QAkBlB;IAGD;;;;OAIG;IACH,kBAHW,CAAS,IAAC,EAAD,CAAC,QAAC,YACX,GAAC,QAYX;IAED;;;;;OAKG;IACH,UAJW,CAAS,IAAC,EAAD,CAAC,KAAE,OAAO,YACnB,GAAC,GACA,CAAC,EAAE,CAkBd;IAED;;;OAGG;IACH,WAFY,CAAC,EAAE,CAId;IAED;;;;OAIG;IACH,UAHW,CAAC,GACC,OAAO,CAenB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACJ,CAAC,GAAC;QAAC,EAAE,EAAC,MAAM,CAAA;KAAC,CAIzB;IAED;;;;;OAKG;IACH,4BAHW,kBAAkB,gBAuF5B;IAED;;;;;;;OAOG;IACH,iBANW,CAAC,QACD,MAAM,YACN,uBAAuB,gBACvB,YAAY,gBAKtB;IAED;;;;;;OAMG;IACH,eALW,uBAAuB,gBACvB,YAAY,YACZ,kBAAkB,gBA0E5B;IAED;;;;;;OAMG;IACH,8CAJW,uBAAuB,uBAErB,OAAO,CAInB;IAED;;;;;OAKG;IACH,mBALW,uBAAuB,gCAGrB,IAAI,CA0DhB;IAIL;;;OAGG;IACH,qCAFU,OAAO,CAE4C;CAP5D;qBAxeoB,gCAAgC;iBACpC,oCAAoC"}
+{"version":3,"file":"StaticKnowledgeDataTable.d.ts","sourceRoot":"","sources":["../../../../../src/engine/knowledge/database/StaticKnowledgeDataTable.js"],"names":[],"mappings":"AAkCA;;;GAGG;AACH,sCAFa,CAAC;IAIV;;;OAGG;IACH,cAAc;IAEd;;;;OAIG;IACH,kBAHU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAGV;IAEnB;;;;OAIG;IACH,mBAHU,CAAC,EAAE,CAGA;IAEb;;;;OAIG;IACH,2BAHU,OAAO,CAGO;IAExB;;;;OAIG;IACH,+BAHU,MAAM,CAGgB;IAEhC,cAQC;IAED,gBAQC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACL,OAAO,CAIlB;IAGD;;;;OAIG;IACH,QAHW,MAAM,GACJ,CAAC,GAAC,IAAI,CAalB;IAED;;;;;OAKG;IACH,gBAHW,CAAC,EAAE,OADH,QAAQ,QAkBlB;IAGD;;;;OAIG;IACH,kBAHW,CAAS,IAAC,EAAD,CAAC,QAAC,YACX,GAAC,QAYX;IAED;;;;;OAKG;IACH,UAJW,CAAS,IAAC,EAAD,CAAC,KAAE,OAAO,YACnB,GAAC,GACA,CAAC,EAAE,CAkBd;IAED;;;OAGG;IACH,WAFY,CAAC,EAAE,CAId;IAED;;;;OAIG;IACH,UAHW,CAAC,GACC,OAAO,CAenB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACJ,CAAC,GAAC;QAAC,EAAE,EAAC,MAAM,CAAA;KAAC,CAIzB;IAED;;;;;OAKG;IACH,4BAHW,kBAAkB,gBA0F5B;IAED;;;;;;;OAOG;IACH,iBANW,CAAC,QACD,MAAM,YACN,uBAAuB,gBACvB,YAAY,gBAKtB;IAED;;;;;;OAMG;IACH,eALW,uBAAuB,gBACvB,YAAY,YACZ,kBAAkB,gBA0E5B;IAED;;;;;;OAMG;IACH,8CAJW,uBAAuB,uBAErB,OAAO,CAInB;IAED;;;;;OAKG;IACH,mBALW,uBAAuB,gCAGrB,IAAI,CA0DhB;IAIL;;;OAGG;IACH,qCAFU,OAAO,CAE4C;CAP5D;qBA3eoB,gCAAgC;iBACpC,oCAAoC"}

package/src/engine/knowledge/database/StaticKnowledgeDataTable.js

@@ -247,6 +247,8 @@ export class StaticKnowledgeDataTable {
 
             if (typeof id !== "string") {
 
+                // TODO consider coercing to string for integer numbers
+
                 if (this.__automatic_ids) {
                     id = generate_id(this);
                 } else {
@@ -262,6 +264,7 @@ export class StaticKnowledgeDataTable {
                     console.warn(`${DATABASE_SERIALIZATION_IGNORE_PROPERTY} flag is present on ${this.__element_type_name} '${id}'. ${DATABASE_SERIALIZATION_IGNORE_PROPERTY} must be a boolean (true/false), instead was '${typeof flag_ignore}'(=${flag_ignore})`);
                 } else if (flag_ignore) {
                     console.warn(`[${this.__element_type_name}:${id}] ${DATABASE_SERIALIZATION_IGNORE_PROPERTY} flag is set to true, skipping`);
+                    return;
                 } else {
                     console.warn(`[${this.__element_type_name}:${id}] ${DATABASE_SERIALIZATION_IGNORE_PROPERTY} flag is set to false and has no effect, please remove this field from JSON`);
                 }

package/src/engine/ui/notification/NotificationManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NotificationManager.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ui/notification/NotificationManager.js"],"names":[],"mappings":"AAoDA;IAEQ;;;OAGG;IACH,UAFU,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAEb;IAEzB;;;OAGG;IACH,UAFU,IAAI,CAAC,UAAU,CAAC,CAEA;IAE1B;;;;OAIG;IACH,oBAA4B;IAE5B;;;OAGG;IACH,KAFU,sBAAsB,GAAC,IAAI,CAEtB;IAGnB;;;OAGG;IACH,uBAFW,MAAM,QAchB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,eAAe,GAAC,SAAS,CAIrC;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,UAAU,EAAE,CAMxB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,+CAmBhB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,eACN,WAAW,2BAsFrB;IAED;;;;OAIG;IACH,8BAHW,YAAY,WACZ,MAAM,QAahB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAchB;CACJ;4BApQ2B,iCAAiC;iBAN5C,uCAAuC;AASxD;IACI;;;;;OAKG;IACH,kDAJW,eAAe,EAsBzB;IAZG,qBAA0C;IAE1C,uBAAuC;IAEvC,SAAc;IACd,iBAA8B;IAE9B;;;OAGG;IACH,WAFU,MAAM,CAEE;IAGtB;;;OAGG;IACH,kBAFW,MAAM,QAMhB;IAED,mBAEC;CACJ"}
+{"version":3,"file":"NotificationManager.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ui/notification/NotificationManager.js"],"names":[],"mappings":"AAqDA;IAEQ;;;OAGG;IACH,UAFU,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAEb;IAEzB;;;OAGG;IACH,UAFU,IAAI,CAAC,UAAU,CAAC,CAEA;IAE1B;;;;OAIG;IACH,oBAA4B;IAE5B;;;OAGG;IACH,KAFU,sBAAsB,GAAC,IAAI,CAEtB;IAGnB;;;OAGG;IACH,uBAFW,MAAM,QAchB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,eAAe,GAAC,SAAS,CAIrC;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,UAAU,EAAE,CAMxB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,+CAmBhB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,eACN,WAAW,2BAsFrB;IAED;;;;OAIG;IACH,8BAHW,YAAY,WACZ,MAAM,QAahB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAchB;CACJ;4BApQ2B,iCAAiC;iBAP5C,uCAAuC;AAUxD;IACI;;;;;OAKG;IACH,kDAJW,eAAe,EAsBzB;IAZG,qBAA0C;IAE1C,uBAAuC;IAEvC,SAAc;IACd,iBAA8B;IAE9B;;;OAGG;IACH,WAFU,MAAM,CAEE;IAGtB;;;OAGG;IACH,kBAFW,MAAM,QAMhB;IAED,mBAEC;CACJ"}