@woosh/meep-engine 2.102.0 → 2.103.0

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;