@woosh/meep-engine 2.84.2 → 2.84.4

package/src/view/elements/windrose/WindRoseDiagram.js

@@ -1,10 +1,10 @@
-import View from "../../View.js";
 import { assert } from "../../../core/assert.js";
-import EmptyView from "../EmptyView.js";
+import { isDefined } from "../../../core/process/matcher/isDefined.js";
 import LabelView from "../../common/LabelView.js";
 import SVG from "../../SVG.js";
+import View from "../../View.js";
+import EmptyView from "../EmptyView.js";
 import ImageView from "../image/ImageView.js";
-import { isDefined } from "../../../core/process/matcher/Matchers.js";
 
 export class WindRoseDiagram extends View {
 

package/src/core/math/spline/spline_catmullrom_1d.js

@@ -1,120 +0,0 @@
-
-/**
- *
- * @param {number} p0
- * @param {number} p1
- * @param {number} half_alpha between 0..0.5
- * @returns {number}
- */
-function getT(p0, p1, half_alpha) {
-    const dx = p0 - p1;
-
-    const a = dx * dx;
-
-    return Math.pow(a, half_alpha);
-}
-
-
-/**
- * Alpha assumed to be 0.5
- * @param {number} f
- * @param {number} p0
- * @param {number} p1
- * @param {number} p2
- * @param {number} p3
- * @returns {number}
- */
-export function spline_catmullrom_1d(
-    f,
-    p0, p1, p2, p3
-) {
-    const half_alpha = 0.25;
-
-    // calculate T
-    const t0 = 0;
-    let t_01 = getT(p0, p1, half_alpha);
-    let t_02 = getT(p1, p2, half_alpha);
-    let t_03 = getT(p2, p3, half_alpha);
-
-    // safety check for repeated points, to prevent division by 0
-    if (t_01 < 1e-5) {
-        t_01 = 1;
-    }
-    if (t_02 < 1e-5) {
-        t_02 = t_01;
-    }
-    if (t_03 < 1e-5) {
-        t_03 = t_02;
-    }
-
-    const t1 = t_01 + t0;
-    const t2 = t_02 + t1;
-    const t3 = t_03 + t2;
-
-    /**
-     * Interpolation between points 1 and 2
-     * @type {number}
-     */
-    const t = t1 * (1 - f) + t2 * f;
-
-    /*
-            Vector2 A1 = (t1-t)/(t1-t0)*p0 + (t-t0)/(t1-t0)*p1;
-		    Vector2 A2 = (t2-t)/(t2-t1)*p1 + (t-t1)/(t2-t1)*p2;
-		    Vector2 A3 = (t3-t)/(t3-t2)*p2 + (t-t2)/(t3-t2)*p3;
-
-		    Vector2 B1 = (t2-t)/(t2-t0)*A1 + (t-t0)/(t2-t0)*A2;
-		    Vector2 B2 = (t3-t)/(t3-t1)*A2 + (t-t1)/(t3-t1)*A3;
-
-		    Vector2 C = (t2-t)/(t2-t1)*B1 + (t-t1)/(t2-t1)*B2;
-     */
-
-    const d_t1_t0 = t1 - t0;
-
-    const m_A1_0 = (t1 - t) / d_t1_t0;
-    const m_A1_1 = (t - t0) / d_t1_t0;
-
-    const d_t2_t1 = t2 - t1;
-
-    const m_A2_0 = (t2 - t) / d_t2_t1;
-
-    const d_t_t1 = t - t1;
-
-    const m_A2_1 = d_t_t1 / d_t2_t1;
-
-    const d_t3_t2 = t3 - t2;
-
-    const d_t3_t = t3 - t;
-
-    const m_A3_0 = d_t3_t / d_t3_t2;
-    const m_A3_1 = (t - t2) / d_t3_t2;
-
-    const d_t2_t0 = t2 - t0;
-
-    const m_B1_0 = (t2 - t) / d_t2_t0;
-    const m_B1_1 = (t - t0) / d_t2_t0;
-
-    const d_t3_t1 = t3 - t1;
-
-    const m_B2_0 = d_t3_t / d_t3_t1;
-    const m_B2_1 = d_t_t1 / d_t3_t1;
-
-    const m_C_0 = (t2 - t) / d_t2_t1;
-    const m_C_1 = d_t_t1 / d_t2_t1;
-
-    // read vector values for the dimension
-    const v0 = p0;
-    const v1 = p1;
-    const v2 = p2;
-    const v3 = p3;
-
-    // compute resulting value in this dimension
-    const A1 = m_A1_0 * v0 + m_A1_1 * v1;
-    const A2 = m_A2_0 * v1 + m_A2_1 * v2;
-    const A3 = m_A3_0 * v2 + m_A3_1 * v3;
-
-    const B1 = m_B1_0 * A1 + m_B1_1 * A2;
-    const B2 = m_B2_0 * A2 + m_B2_1 * A3;
-
-    return m_C_0 * B1 + m_C_1 * B2;
-
-}

package/src/core/process/IntervalExecutor.js

@@ -1,78 +0,0 @@
-/**
- * Created by Alex on 22/05/2016.
- */
-
-/**
- *
- * @param {number} quietTime in milliseconds
- * @param {number} workTime in milliseconds
- * @constructor
- */
-function IntervalExecutor(quietTime, workTime) {
-    this.quietTime = quietTime;
-    this.workTime = workTime;
-    this.tasks = [];
-    this.busy = false;
-    this.timeLastWorkDone = 0;
-}
-
-/**
- *
- * @param {function} task
- */
-IntervalExecutor.prototype.add = function (task) {
-    this.tasks.push(task);
-    this.prod();
-};
-
-IntervalExecutor.prototype.prod = function () {
-    const self = this;
-    const tasks = this.tasks;
-
-    function processCycle() {
-        const t = Date.now();
-        let timeNow = t;
-
-        let workTime = 0;
-
-        while (tasks.length > 0) {
-            const task = tasks.shift();
-            task();
-
-            timeNow = Date.now();
-            workTime = timeNow - t;
-            if (workTime >= self.workTime) {
-                //time slice ended
-                break;
-            }
-        }
-
-        self.timeLastWorkDone = timeNow;
-
-        if (tasks.length > 0) {
-            //compute adaptive quiet time based on how long we worked for
-            const workOverBudget = workTime - self.workTime;
-            const sleepTime = self.quietTime + Math.max(workOverBudget, 0);
-
-            //still some tasks left, schedule next slice
-            setTimeout(processCycle, sleepTime);
-        } else {
-            //all tasks done, reset the 'busy' flag
-            self.busy = false;
-        }
-    }
-
-    if (!this.busy && tasks.length > 0) {
-        this.busy = true;
-        const timeSinceLastWork = Date.now() - this.timeLastWorkDone;
-        const quietTimeDelta = this.quietTime - timeSinceLastWork;
-        if (quietTimeDelta < 0) {
-            processCycle();
-        } else {
-            setTimeout(processCycle, quietTimeDelta);
-        }
-    }
-};
-
-
-export default IntervalExecutor;

package/src/core/process/matcher/Matchers.js

@@ -1,145 +0,0 @@
-/**
- * @author Alex Goldring
- * @copyright Alex Goldring 2017
- */
-
-import { assert } from "../../assert.js";
-
-/**
- *
- * @param {*} value
- * @returns {boolean}
- */
-export function isNull(value) {
-    return value === null;
-}
-
-/**
- *
- * @param {*} value
- * @return {boolean}
- */
-export function isDefined(value) {
-    return value !== undefined;
-}
-
-/**
- * performs instanceof match
- * @param {function} type
- * @returns {function(*): boolean}
- */
-export function isInstanceOf(type) {
-    return function (m) {
-        return m instanceof type;
-    }
-}
-
-/**
- * performs typeof match
- * @param {string} type
- * @returns {function(*): boolean}
- */
-export function isTypeOf(type) {
-    assert.notEqual(['number', 'boolean', 'string', 'function', 'object', 'undefined'].indexOf(type), -1, `type must be one of [number, boolean, string, function, object, undefined], instead was '${type}'`);
-
-    return function (m) {
-        return typeof m === type;
-    }
-}
-
-/**
- *
- * @param {number} value
- * @returns {function(*): boolean}
- */
-export function isGreaterThan(value) {
-    return function (x) {
-        return x > value;
-    }
-}
-
-/**
- *
- * @param {number} value
- * @returns {function(*): boolean}
- */
-export function isGreaterThanOrEqualTo(value) {
-    return function (x) {
-        return x >= value;
-    }
-}
-
-/**
- *
- * @param {number} value
- * @returns {function(*): boolean}
- */
-export function isLessThan(value) {
-    return function (x) {
-        return x < value;
-    }
-}
-
-/**
- *
- * @param {number} value
- * @returns {function(*): boolean}
- */
-export function isLessThanOrEqualTo(value) {
-    return function (x) {
-        return x <= value;
-    }
-}
-
-/**
- *
- * @param {number} value
- * @returns {function(*): boolean}
- */
-export function isEqualTo(value) {
-    return function (x) {
-        return x === value;
-    }
-}
-
-
-/**
- *
- * @param {function} m
- * @returns {function(*): boolean}
- */
-export function not(m) {
-    return function (v) {
-        return !m(v);
-    }
-}
-
-/**
- * Joins two matchers via AND
- * @param {function(*):boolean} a
- * @param {function(*):boolean} b
- * @returns {function(*):boolean}
- */
-export function and(a, b) {
-    assert.typeOf(a, 'function', 'a');
-    assert.typeOf(b, 'function', 'b');
-
-    return function (m) {
-        return a(m) && b(m);
-    }
-}
-
-/**
- * Joins two matchers via OR
- * @param {function(*):boolean} a
- * @param {function(*):boolean} b
- * @returns {function(*):boolean}
- */
-export function or(a, b) {
-    assert.typeOf(a, 'function', 'a');
-    assert.typeOf(b, 'function', 'b');
-
-    return function (m) {
-        return a(m) || b(m);
-    }
-}