@woosh/meep-engine 2.102.0 → 2.104.0

package/src/engine/graphics/texture/sampler/distance/computeUnsignedDistanceField.js

@@ -5,6 +5,11 @@ import { computeUnsignedDistanceField_Chamfer } from "./computeUnsignedDistanceF
  * @param {Sampler2D} distanceField
  * @param {number} emptyValue
  */
-export function computeUnsignedDistanceField(source, distanceField, emptyValue) {
+export function computeUnsignedDistanceField(
+    source,
+    distanceField,
+    emptyValue
+) {
+
     computeUnsignedDistanceField_Chamfer(source, distanceField, emptyValue, 1, 1, 255);
 }

package/src/engine/graphics/texture/sampler/distance/computeUnsignedDistanceField_Chamfer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeUnsignedDistanceField_Chamfer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/distance/computeUnsignedDistanceField_Chamfer.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,8GALW,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,QA0HhB"}
+{"version":3,"file":"computeUnsignedDistanceField_Chamfer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/distance/computeUnsignedDistanceField_Chamfer.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,8GALW,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,QAyIhB"}

package/src/engine/graphics/texture/sampler/distance/computeUnsignedDistanceField_Chamfer.js

@@ -1,3 +1,4 @@
+import { assert } from "../../../../../core/assert.js";
 import { max2 } from "../../../../../core/math/max2.js";
 import { min2 } from "../../../../../core/math/min2.js";
 
@@ -10,7 +11,22 @@ import { min2 } from "../../../../../core/math/min2.js";
  * @param {number} d2 distance between two diagonally adjacent pixels
  * @param {number} maxD highest value that distance field can hold
  */
-export function computeUnsignedDistanceField_Chamfer(source, distanceField, emptyValue, d1, d2, maxD) {
+export function computeUnsignedDistanceField_Chamfer(
+    source,
+    distanceField,
+    emptyValue,
+    d1,
+    d2,
+    maxD
+) {
+
+    assert.defined(source, 'source');
+    assert.defined(distanceField, 'distanceField');
+    assert.isNumber(emptyValue, 'emptyValue');
+    assert.isNumber(d1, 'd1');
+    assert.isNumber(d2, 'd2');
+    assert.isNumber(maxD, 'maxD');
+
     const sourceData = source.data;
     const distanceFieldData = distanceField.data;
 

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

@@ -1 +1 @@
-{"version":3,"file":"PointerDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/PointerDevice.js"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,wDAFY,OAAO,EAAE,CAapB;AAiRD;;;;;GAKG;AACH,mDAJW,OAAO,SACP,UAAU,WACV,OAAO,QAejB;AAED;;GAEG;AACH;IAqFI;;;;OAIG;IACH,wBAHW,WAAW,EA0CrB;IA/HD;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;IAczB;;OAEG;IACH;;;;QAII;;WAEG;aADO,OAAO,OAAO,EAAE,CAAC,UAAU,GAAC,UAAU,CAAC,CAAC;;;;;;;;MAUpD;IASF;;;OAGG;IACH,kBAAkB;IAElB;;;;OAIG;IACH,kBAFU,iBAAiB,EAAE,CAEL;IAExB;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,2CAEC;IAeG;;;OAGG;IACH,YAFU,WAAW,CAEO;IA6JhC;;;OAGG;IACH,oBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,qBAFW,OAAO,QAwBjB;IAED;;;;OAIG;IACH,qCAHW,OAAO,SACP,UAAU,GAAC,UAAU,QAI/B;IAED,cAkCC;IAED,aA2BC;;CACJ;oBAlrBmB,+BAA+B;mBADhC,uCAAuC;kCAMxB,wBAAwB"}
+{"version":3,"file":"PointerDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/PointerDevice.js"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,wDAFY,OAAO,EAAE,CAapB;AAiRD;;;;;GAKG;AACH,mDAJW,OAAO,SACP,UAAU,WACV,OAAO,QAejB;AAED;;GAEG;AACH;IA2FI;;;;OAIG;IACH,wBAHW,WAAW,EA0CrB;IArID;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;IAczB;;OAEG;IACH;;;;QAII;;WAEG;aADO,OAAO,OAAO,EAAE,CAAC,UAAU,GAAC,UAAU,CAAC,CAAC;;;;;;;;MAUpD;IAeF;;;OAGG;IACH,kBAAkB;IAElB;;;;OAIG;IACH,kBAFU,iBAAiB,EAAE,CAEL;IAExB;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,2CAEC;IAgLD;;;OAGG;IACH,oBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,6BAsBC;IAED,0BAEC;IAED;;;;OAIG;IACH,qCAHW,OAAO,SACP,UAAU,GAAC,UAAU,QAI/B;IAED,cAkCC;IAED,aA2BC;;CACJ;oBA5rBmB,+BAA+B;mBADhC,uCAAuC;kCAMxB,wBAAwB"}

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

@@ -373,6 +373,12 @@ export class PointerDevice {
      */
     #target = null;
 
+    /**
+     *
+     * @type {Element|null}
+     */
+    #domElement = null;
+
     /**
      * @private
      * @type {boolean}
@@ -427,7 +433,7 @@ export class PointerDevice {
          *
          * @type {EventTarget}
          */
-        this.domElement = domElement;
+        this.#domElement = domElement;
 
 
         this.#touchStart.add((param0, param1, param2) => {
@@ -596,11 +602,11 @@ export class PointerDevice {
      *
      * @param {Element} el
      */
-    setTargetElement(el) {
+    set domElement(el) {
         assert.defined(el, 'el');
         assert.notNull(el, 'el');
 
-        if (this.#target === el) {
+        if (this.#domElement === el) {
             // no change
             return;
         }
@@ -612,7 +618,7 @@ export class PointerDevice {
             this.stop();
         }
 
-        this.#target = el;
+        this.#domElement = el;
 
         if (was_running) {
             // restart to maintain original state
@@ -620,6 +626,10 @@ export class PointerDevice {
         }
     }
 
+    get domElement() {
+        return this.#domElement;
+    }
+
     /**
      *
      * @param {Vector2} result
@@ -639,7 +649,7 @@ export class PointerDevice {
 
         // console.warn("PointerDevice.start");
 
-        const domElement = this.domElement;
+        const domElement = this.#domElement;
 
         assert.notEqual(domElement, null, "domElement is null");
         assert.notEqual(domElement, undefined, "domElement is undefined");

package/src/engine/metrics/GoogleAnalyticsMetrics.d.ts

@@ -1,6 +1,7 @@
 export class GoogleAnalyticsMetrics extends MetricsGateway {
+    constructor(key: any);
     api: {
-        gtag: (...args: any[]) => void;
+        gtag: Function;
     };
     record(type: any, event: any): void;
 }

package/src/engine/metrics/GoogleAnalyticsMetrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GoogleAnalyticsMetrics.d.ts","sourceRoot":"","sources":["../../../../src/engine/metrics/GoogleAnalyticsMetrics.js"],"names":[],"mappings":"AAkCA;IAIQ;;MAEC;IAKL,oCAgBC;CACJ;+BA9D8B,qBAAqB"}
+{"version":3,"file":"GoogleAnalyticsMetrics.d.ts","sourceRoot":"","sources":["../../../../src/engine/metrics/GoogleAnalyticsMetrics.js"],"names":[],"mappings":"AAIA;IACI,sBAOC;IAJG;;MAEC;IAIL,oCAYC;CACJ;+BA1B8B,qBAAqB"}

package/src/engine/metrics/GoogleAnalyticsMetrics.js

@@ -1,46 +1,15 @@
+import { loadGTAG } from "../google/loadGTAG.js";
 import { MetricsGateway } from "./MetricsGateway.js";
 
-// const GOOGLE_ANALYTICS_KEY = 'UA-66021000-1'; //Lazy-Kitty.com
-// const GOOGLE_ANALYTICS_KEY = 'UA-138821093-1'; //Itch.com
-const GOOGLE_ANALYTICS_KEY = 'G-ZBGZD4ZMZ1'; //ASKARA
-
-function loadGTAG(MEASUREMENT_ID) {
-
-    (function (target, s, domTag, sourceURL) {
-
-        const a = s.createElement(domTag);
-        const m = s.getElementsByTagName(domTag)[0];
-
-        a.async = 1;
-        a.src = sourceURL;
-
-        m.parentNode.insertBefore(a, m)
-    })(document, document, 'script', `https://www.googletagmanager.com/gtag/js?id=${MEASUREMENT_ID}`);
-
-
-    window.dataLayer = window.dataLayer || [];
-
-    function gtag() {
-        dataLayer.push(arguments);
-    }
-
-    gtag('js', new Date());
-
-    gtag('config', MEASUREMENT_ID);
-
-
-    return gtag;
-}
 
 export class GoogleAnalyticsMetrics extends MetricsGateway {
-    constructor() {
+    constructor(key) {
         super();
 
         this.api = {
-            gtag: loadGTAG(GOOGLE_ANALYTICS_KEY)
+            gtag: loadGTAG(key)
         };
 
-
     }
 
     record(type, event) {
@@ -54,10 +23,6 @@ export class GoogleAnalyticsMetrics extends MetricsGateway {
             payload.event_label = event.label;
         }
 
-        if (ENV_PRODUCTION) {
-            this.api.gtag('event', type, payload);
-        } else {
-            console.log("[DEBUG] metric would be sent", type, payload);
-        }
+        this.api.gtag('event', type, payload);
     }
 }

package/src/engine/notify/NotificationLog.d.ts

@@ -1,5 +1,4 @@
 export default NotificationLog;
-declare function NotificationLog(): void;
 declare class NotificationLog {
     /**
      * @readonly
@@ -13,7 +12,7 @@ declare class NotificationLog {
     maxLength: number;
     /**
      *
-     * @param {{}} options See Notification.constructor for details
+     * @param {{}} options See {@link Notification.constructor} for details
      * @returns {Notification}
      */
     add(options: {}): Notification;

package/src/engine/notify/NotificationLog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NotificationLog.d.ts","sourceRoot":"","sources":["../../../../src/engine/notify/NotificationLog.js"],"names":[],"mappings":";AASA,yCAYC;;IAXG;;;OAGG;IACH,mBAFU,KAAK,YAAY,CAAC,CAEF;IAE1B;;;OAGG;IACH,WAFU,MAAM,CAEK;IAGzB;;;;OAIG;IACH,aAHW,EAAE,GACA,YAAY,CAQxB;IAED;;;OAGG;IACH,8BAFW,YAAY,QAkBtB;;iBAlDgB,oCAAoC;6BADxB,mBAAmB"}
+{"version":3,"file":"NotificationLog.d.ts","sourceRoot":"","sources":["../../../../src/engine/notify/NotificationLog.js"],"names":[],"mappings":";AASA;IACI;;;OAGG;IACH,mBAFU,KAAK,YAAY,CAAC,CAEN;IAEtB;;;OAGG;IACH,WAFU,MAAM,CAEC;IAEjB;;;;OAIG;IACH,aAHW,EAAE,GACA,YAAY,CAQxB;IAED;;;OAGG;IACH,8BAFW,YAAY,QAmBtB;CACJ;iBAnDgB,oCAAoC;6BACxB,mBAAmB"}

package/src/engine/notify/NotificationLog.js

@@ -3,57 +3,58 @@
  */
 
 
-import { Notification } from './Notification.js';
-import List from '../../core/collection/list/List.js';
 import { assert } from "../../core/assert.js";
+import List from '../../core/collection/list/List.js';
+import { Notification } from './Notification.js';
 
-function NotificationLog() {
+class NotificationLog {
     /**
      * @readonly
      * @type {List<Notification>}
      */
-    this.elements = new List();
+    elements = new List();
 
     /**
      * Once number of entries in the log reaches this amount, the earliest entries will be removed to make space for new ones
      * @type {number}
      */
-    this.maxLength = 1000;
-}
+    maxLength = 1000;
 
-/**
- *
- * @param {{}} options See Notification.constructor for details
- * @returns {Notification}
- */
-NotificationLog.prototype.add = function (options) {
-    const notification = new Notification(options);
+    /**
+     *
+     * @param {{}} options See {@link Notification.constructor} for details
+     * @returns {Notification}
+     */
+    add(options) {
+        const notification = new Notification(options);
 
-    this.addNotification(notification);
+        this.addNotification(notification);
 
-    return notification;
-};
+        return notification;
+    }
 
-/**
- *
- * @param {Notification} notification
- */
-NotificationLog.prototype.addNotification = function (notification) {
-    assert.notEqual(notification, undefined, 'notification is undefined');
-    assert.notEqual(notification, null, 'notification is null');
+    /**
+     *
+     * @param {Notification} notification
+     */
+    addNotification(notification) {
+        assert.defined(notification, 'notification');
+        assert.notNull(notification, 'notification');
 
-    assert.ok(notification.isNotification, 'not a Notification');
+        assert.ok(notification.isNotification, 'not a Notification');
 
-    // Crop notification log to size
-    const length = this.elements.length;
+        // Crop notification log to size
+        const length = this.elements.length;
 
-    const target = this.maxLength - 1;
+        const target = this.maxLength - 1;
 
-    if (length > target) {
-        this.elements.crop(length - target, length);
-    }
+        if (length > target) {
+            // too many elements, drop some
+            this.elements.crop(length - target, length);
+        }
 
-    this.elements.add(notification);
-};
+        this.elements.add(notification);
+    }
+}
 
 export default NotificationLog;

package/src/core/lang/reactive/nearley/Reactive.ne

@@ -1,87 +0,0 @@
-@builtin "whitespace.ne"
-@builtin "number.ne"
-
-expression                      -> binary_expression_add {% id %}
-
-group_expression                -> "(" _ expression _ ")" {% (a) => a[2] %}
-								| atomic {% id %}
-
-#####################
-# Unary Expressions
-#####################
-
-unary_expression_negate         -> "-" _ expression {% (d)=> {return {type:'UnaryNegate', value: d[2]}} %}
-                                | group_expression {% id %}
-
-
-unary_expression_not            -> "!" _ expression {% (d)=> {return {type:'UnaryNot', value: d[2]}} %}
-                                | unary_expression_negate {% id %}
-
-#####################
-# Binary Expressions
-#####################
-
-# Logic
-
-binary_expression_or            -> binary_expression_or _ "||" _ unary_expression_not {% (d)=> {return {type:'BinaryOr', left: d[0], right: d[4]}} %}
-                                |  unary_expression_not {% id %}
-
-binary_expression_and           -> binary_expression_and _ "&&" _ binary_expression_or {% (d)=> {return {type:'BinaryAnd', left: d[0], right: d[4]}} %}
-                                |  binary_expression_or {% id %}
-
-# Equality
-
-binary_expression_equals        -> binary_expression_equals _ "==" _ binary_expression_and {% (d)=> {return {type:'BinaryEqual', left: d[0], right: d[4]}} %}
-                                |  binary_expression_and {% id %}
-
-binary_expression_not_equals    -> binary_expression_not_equals _ "!=" _ binary_expression_equals {% (d)=> {return {type:'BinaryNotEqual', left: d[0], right: d[4]}} %}
-                                |  binary_expression_equals {% id %}
-
-# Comparison
-
-binary_expression_lte           -> binary_expression_lte _ "<=" _ binary_expression_not_equals {% (d)=> {return {type:'BinaryLessOrEqual', left: d[0], right: d[4]}} %}
-                                |  binary_expression_not_equals {% id %}
-
-binary_expression_gte           -> binary_expression_gte _ ">=" _ binary_expression_lte {% (d)=> {return {type:'BinaryGreaterOrEqual', left: d[0], right: d[4]}} %}
-                                |  binary_expression_lte {% id %}
-
-binary_expression_lt            -> binary_expression_lt _ "<" _ binary_expression_gte {% (d)=> {return {type:'BinaryLess', left: d[0], right: d[4]}} %}
-                                |  binary_expression_gte {% id %}
-
-binary_expression_gt            -> binary_expression_gt _ ">" _ binary_expression_lt {% (d)=> {return {type:'BinaryGreater', left: d[0], right: d[4]}} %}
-                                |  binary_expression_lt {% id %}
-
-# Multiplication
-
-binary_expression_multiply      -> binary_expression_multiply _ "*" _ binary_expression_gt {% (d)=> {return {type:'BinaryMultiply', left: d[0], right: d[4]}} %}
-                                |  binary_expression_gt {% id %}
-
-binary_expression_divide        -> binary_expression_divide _ "/" _ binary_expression_multiply {% (d)=> {return {type:'BinaryDivide', left: d[0], right: d[4]}} %}
-                                |  binary_expression_multiply {% id %}
-
-# Addition
-
-binary_expression_subtract      -> binary_expression_subtract _ "-" _ binary_expression_divide {% (d)=> {return {type:'BinarySubtract', left: d[0], right: d[4]}} %}
-                                |  binary_expression_divide {% id %}
-
-binary_expression_add           -> binary_expression_add _ "+" _ binary_expression_subtract {% (d)=> {return {type:'BinaryAdd', left: d[0], right: d[4]}} %}
-                                |  binary_expression_subtract {% id %}
-
-
-#####################
-# Primitives
-#####################
-
-atomic                          -> literal {% id %}
-								| reference {% (d,l,r)=> { return {type:'Reference', value: d[0] } }  %}
-
-reference                       -> identifier ("." identifier {% (a)=>a[1] %}):* {% (a,l,r) => [a[0]].concat(a[1]) %}
-
-identifier                      -> [a-zA-Z_] [a-zA-Z_0-9]:* {% (d,l,r) => { const value =d[0]+d[1].join(""); if(value === 'true' || value === 'false'){return r}else{return value} }  %}
-
-literal                         -> decimal  {% (d)=> {return {type:'LiteralNumber', value: d[0] }} %}
-                                |  literal_boolean {% (d) => { return {type:'LiteralBoolean', value:d[0]} } %}
-
-
-literal_boolean                 -> "true"  {% ()=> true %}
-                                |  "false" {% ()=> false %}

package/src/engine/compression/CompressionService.d.ts

@@ -1,19 +0,0 @@
-export default CompressionService;
-declare class CompressionService {
-    private __incrementRequestCount;
-    private __decrementRequestCount;
-    /**
-     *
-     * @param data
-     * @param level
-     * @returns {Promise}
-     */
-    encode(data: any, level: any): Promise<any>;
-    /**
-     *
-     * @param data
-     * @returns {Promise}
-     */
-    decode(data: any): Promise<any>;
-}
-//# sourceMappingURL=CompressionService.d.ts.map

package/src/engine/compression/CompressionService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CompressionService.d.ts","sourceRoot":"","sources":["../../../../src/engine/compression/CompressionService.js"],"names":[],"mappings":";;IA2FuD,gCAetD;IAMsD,gCAKtD;IAED;;;;;OAKG;IACH,4CAIC;IAED;;;;OAIG;IACH,gCAIC"}

package/src/engine/compression/CompressionService.js

@@ -1,144 +0,0 @@
-/**
- * Created by Alex on 03/11/2016.
- */
-
-
-import WorkerBuilder from '../../core/process/worker/WorkerBuilder.js';
-
-function buildWorker() {
-    const workerBuilder = new WorkerBuilder();
-    workerBuilder.importScript('lib/lzma_worker.js');
-
-    workerBuilder.addMethod('encode', function encode(data, level) {
-        return new Promise(function (resolve, reject) {
-            //Validate data type
-            if (typeof data !== "string" && !(data instanceof Uint8Array)) {
-                reject("data must be a string or a Uint8Array, instead got '" + (typeof data) + "'");
-            }
-
-            let compressionLevel;
-            if (typeof level === 'number') {
-                if (level < 1) {
-                    compressionLevel = 1;
-                    console.warn('Requested compression level(' + level + ') < minimum(1), using 1 instead');
-                } else if (level > 9) {
-                    compressionLevel = 9;
-                    console.warn('Requested compression level(' + level + ') > maximum(9), using 9 instead');
-                } else if (level % 1 !== 0) {
-                    compressionLevel = level | 0;
-                    console.warn('Requested compression level(' + level + ') is not integer, using ' + compressionLevel + ' instead');
-                } else {
-                    compressionLevel = level;
-                }
-            } else {
-                if (level !== undefined && typeof level !== 'number') {
-                    console.warn('Supplied compression level must be a number, was ' + (typeof level) + ' instead. Defaulting to minimum(1)');
-                }
-                //no valid compression level specified
-                compressionLevel = 1;
-            }
-
-            console.time("Compression");
-            LZMA.compress(data, compressionLevel, function on_finish(result, error) {
-                console.timeEnd("Compression");
-                if (error) {
-                    reject(error);
-                } else {
-                    if (result instanceof Array) {
-                        resolve(new Uint8Array(result));
-                    } else {
-                        resolve(result);
-                    }
-                }
-            }, function on_progress(percent) {
-            });
-        });
-    });
-
-    workerBuilder.addMethod('decode', function decode(data) {
-        return new Promise(function (resolve, reject) {
-            LZMA.decompress(data, function on_finish(result, error) {
-                if (error) {
-                    reject(error);
-                } else {
-                    if (result instanceof Array) {
-                        resolve(new Uint8Array(result));
-                    } else {
-                        resolve(result);
-                    }
-                }
-            }, function on_progress(percent) {
-            });
-        });
-    });
-    return workerBuilder.build();
-}
-
-/**
- * @property {WorkerProxy} __workerProxy
- * @property {number} __requestCount
- * @constructor
- */
-const CompressionService = function () {
-    this.__workerProxy = buildWorker();
-    this.__requestCount = 0;
-};
-
-/**
- *
- * @param {Promise} r
- * @private
- */
-CompressionService.prototype.__incrementRequestCount = function (r) {
-    this.__requestCount++;
-
-
-    const self = this;
-
-    function d() {
-        self.__decrementRequestCount();
-    }
-
-    r.then(d, d);
-
-    if (!this.__workerProxy.isRunning()) {
-        this.__workerProxy.start();
-    }
-};
-
-/**
- *
- * @private
- */
-CompressionService.prototype.__decrementRequestCount = function () {
-    this.__requestCount--;
-    if (this.__requestCount <= 0 && this.__workerProxy.isRunning()) {
-        this.__workerProxy.stop();
-    }
-};
-
-/**
- *
- * @param data
- * @param level
- * @returns {Promise}
- */
-CompressionService.prototype.encode = function (data, level) {
-    const result = this.__workerProxy.encode(data, level);
-    this.__incrementRequestCount(result);
-    return result;
-};
-
-/**
- *
- * @param data
- * @returns {Promise}
- */
-CompressionService.prototype.decode = function (data) {
-    const result = this.__workerProxy.decode(data);
-    this.__incrementRequestCount(result);
-    return result;
-};
-
-
-export default CompressionService;