@woosh/meep-engine 2.33.46 → 2.33.50

package/core/model/object/compareValues.js

@@ -0,0 +1,67 @@
+import { compareStrings } from "../../primitives/strings/compareStrings.js";
+import { compareNumbers } from "../../primitives/numbers/compareNumbers.js";
+import { compareBooleans } from "../../primitives/boolean/compareBooleans.js";
+import { extractFunctionBody } from "../../function/extractFunctionBody.js";
+import { compareArrays } from "../../primitives/array/compareArrays.js";
+
+/**
+ *
+ * @param {*} a
+ * @param {*} b
+ * @returns {number}
+ */
+export function compareValues(a, b) {
+    if (a === b) {
+        return 0;
+    }
+
+    const aType = typeof a;
+    const bType = typeof b;
+
+    if (aType !== bType) {
+        return compareStrings(aType, bType);
+    }
+
+    if (aType === "string") {
+        return compareStrings(a, b);
+    } else if (aType === "number") {
+        return compareNumbers(a, b);
+    } else if (aType === "boolean") {
+        return compareBooleans(a, b);
+    } else if (aType === "function") {
+        return compareStrings(extractFunctionBody(a), extractFunctionBody(b));
+    } else if (aType === "object") {
+        if (a === null) {
+            if (b !== null) {
+                return -1;
+            } else {
+                return 0;
+            }
+        } else if (b === null) {
+            return 1;
+        }
+
+        if (Array.isArray(a) && Array.isArray(b)) {
+            return compareArrays(a, b, compareValues);
+        }
+
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+
+        const dKeys = compareArrays(aKeys, bKeys, compareStrings);
+
+        if (dKeys !== 0) {
+            return dKeys;
+        }
+
+        for (let p in a) {
+            const d = compareValues(a[p], b[p]);
+
+            if (d !== 0) {
+                return d;
+            }
+        }
+    }
+
+    return 0;
+}

package/core/model/object/invokeObjectClone.js

@@ -0,0 +1,8 @@
+/**
+ * @template T
+ * @param {T} object
+ * @return {T}
+ */
+export function invokeObjectClone(object) {
+    return object.clone();
+}

package/core/model/{ObjectUtils.spec.js → object/objectDeepEquals.spec.js}

@@ -1,4 +1,4 @@
-import { objectDeepEquals } from "./object/objectDeepEquals.js";
+import { objectDeepEquals } from "./objectDeepEquals.d.ts";
 
 test('objectDeepEquals', () => {
     expect(objectDeepEquals({}, {})).toBe(true);

package/core/model/object/objectShallowCopyByOwnKeys.js

@@ -0,0 +1,17 @@
+/**
+ * @template S,R
+ * @param {S} source
+ * @return {R}
+ */
+export function objectShallowCopyByOwnKeys(source) {
+    const keys = Reflect.ownKeys(source);
+
+    const result = {};
+    const n = keys.length;
+    for (let i = 0; i < n; i++) {
+        const key = keys[i];
+        result[key] = source[key];
+    }
+
+    return result;
+}

package/core/model/object/read_property.d.ts

@@ -0,0 +1 @@
+export function read_property<T>(root: Object, parts: string[], part_offset: number, part_count: number): T | undefined

package/core/model/object/read_property.js

@@ -0,0 +1,37 @@
+import { capitalize } from "../../primitives/strings/StringUtils.js";
+
+/**
+ * @template T
+ * @param {Object} root
+ * @param {string[]} parts
+ * @param {number} part_offset
+ * @param {number} part_count
+ * @returns {undefined|T}
+ */
+export function read_property(root, parts, part_offset, part_count) {
+
+    let thing = root;
+
+    for (let i = 0; i < part_count; i++) {
+
+        const part = parts[i + part_offset];
+
+        if (thing.hasOwnProperty(part)) {
+            thing = thing[part];
+        } else {
+            const getter_name = `get${capitalize(part)}`;
+            const getter = thing[getter_name];
+
+            if (typeof getter === "function") {
+                // resolve via getter
+                thing = getter.call(thing);
+            } else {
+                // no getter
+                return undefined;
+            }
+        }
+
+    }
+
+    return thing;
+}

package/core/model/object/validatedObjectValueByKey.js

@@ -0,0 +1,21 @@
+import { assert } from "../../assert.js";
+
+/**
+ * @template V
+ * @param {Object<V>} object
+ * @param {string} key
+ * @returns {V}
+ * @throws {Error} if such key does not exist
+ */
+export function validatedObjectValueByKey(object, key) {
+
+    assert.typeOf(key, 'string', 'key');
+
+    const value = object[key];
+
+    if (value === undefined) {
+        throw new Error(`Unknown key '${key}', valid keys: [${Object.keys(object).join(', ')}]`);
+    }
+
+    return value;
+}

package/core/model/object/write_property.d.ts

@@ -0,0 +1 @@
+export function write_property<T>(root: Object, parts: string[], part_offset: number, part_count: number, value: T): void

package/core/model/object/write_property.js

@@ -0,0 +1,52 @@
+import { capitalize } from "../../primitives/strings/StringUtils.js";
+
+/**
+ * @template T
+ * @param {Object} root
+ * @param {string[]} parts
+ * @param {number} part_offset
+ * @param {number} part_count
+ * @param {T} value
+ */
+export function write_property(root, parts, part_offset, part_count, value) {
+    let thing = root;
+
+    const last_index = part_offset + part_count - 1;
+
+    for (let i = 0; i < last_index; i++) {
+
+        const part = parts[i + part_offset];
+
+        if (thing.hasOwnProperty(part)) {
+            thing = thing[part];
+        } else {
+
+            const getter_name = `get${capitalize(part)}`;
+            const getter = thing[getter_name];
+
+            if (typeof getter === "function") {
+                // resolve via getter
+                thing = getter.call(thing);
+            } else {
+                // no getter
+                throw new Error(`No no property or getter found for '${part}' on [${i}]'${parts.slice(part_offset, part_offset + part_count).join('/')}'`);
+            }
+        }
+    }
+
+    const last_part = parts[last_index];
+
+    const setter_name = `set${capitalize(last_part)}`;
+    const setter = thing[setter_name];
+
+    if (typeof setter === "function") {
+        // resolve via setter
+        setter.call(thing, value);
+    } else if (thing.hasOwnProperty(last_part)) {
+        thing[last_part] = value;
+    } else {
+        // no setter
+        throw new Error(`No no property or getter found for '${last_part}' on [${part_count - 1}]'${parts.slice(part_offset, part_offset + part_count).join('/')}'`);
+    }
+}
+

package/engine/ecs/EntityComponentDataset.d.ts

@@ -38,4 +38,6 @@ export class EntityComponentDataset {
     public removeEntityEventListener<T>(entity: number, eventName: string, listener: (event: T, entity?: number) => any, thisArg?: any);
 
     public sendEvent<T>(entity: number, name: string, event?: T);
+
+    public getComponentClassByName<T>(name: string): Type<T>;
 }

package/engine/ecs/EntityComponentDataset.js

@@ -1007,10 +1007,10 @@ export class EntityComponentDataset {
     }
 
     /**
-     * @template C
+     * @template T
      * @param {number} entityIndex
-     * @param {Class<C>} klass
-     * @returns {C|undefined}
+     * @param {Class<T>} klass
+     * @returns {T|undefined}
      */
     getComponent(entityIndex, klass) {
         if (!ENV_PRODUCTION) {

package/engine/ecs/binding/ComponentPropertyBinding.js

@@ -15,12 +15,12 @@ export class ComponentPropertyBinding {
     }
 
     /**
-     *
+     * @template T
      * @param {EntityComponentDataset} ecd
      * @param {number} entity
+     * @returns {T}
      */
-    resolve(ecd, entity) {
-
+    __resolve_component(ecd, entity) {
         const className = this.path.component;
         const ComponentClass = ecd.getComponentClassByName(className);
 
@@ -34,6 +34,17 @@ export class ComponentPropertyBinding {
             throw new Error(`Component '${className}' is not found on entity '${entity}'`);
         }
 
+        return component;
+    }
+
+    /**
+     *
+     * @param {EntityComponentDataset} ecd
+     * @param {number} entity
+     */
+    resolve(ecd, entity) {
+        const component = this.__resolve_component(ecd, entity);
+
         const value = resolvePath(component, this.path.path);
 
         if (value === undefined) {

package/engine/ecs/binding/EntityProxyScope.js

@@ -1,11 +1,11 @@
+import { read_property } from "../../../core/model/object/read_property.js";
+
 /**
  *
  * @param {number} entity
  * @param {EntityComponentDataset} ecd
  * @param {string} path
  */
-import { capitalize } from "../../../core/primitives/strings/StringUtils.js";
-
 function resolvePath(entity, ecd, path) {
     if (!ecd.entityExists(entity)) {
         // entity doesn't exist
@@ -37,30 +37,7 @@ function resolvePath(entity, ecd, path) {
         return undefined;
     }
 
-    let thing = component;
-
-    for (let i = 1; i < part_count; i++) {
-
-        const part = parts[i];
-
-        if (thing.hasOwnProperty(part)) {
-            thing = thing[part];
-        } else {
-            const getter_name = `get${capitalize(part)}`;
-            const getter = thing[getter_name];
-
-            if (typeof getter === "function") {
-                // resolve via getter
-                thing = getter.call(thing);
-            } else {
-                // no getter
-                return undefined;
-            }
-        }
-
-    }
-
-    return thing;
+    return read_property(component, parts, 1, part_count - 1);
 }
 
 export class EntityProxyScope {

package/engine/graphics/particles/ecs/ParticleEmitterSystem.d.ts

@@ -0,0 +1,7 @@
+import {System} from "../../../ecs/System";
+import Engine from "../../../Engine";
+import {ParticleEmitter} from "../particular/engine/emitter/ParticleEmitter";
+
+export class ParticleEmitterSystem extends System<ParticleEmitter> {
+    constructor(engine: Engine)
+}

package/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.d.ts

@@ -0,0 +1,2 @@
+export class ParticleEmitter {
+}

package/engine/graphics/particles/particular/engine/utils/volume/AttributeValue.d.ts

@@ -8,6 +8,8 @@ export class AttributeValue {
 
     write_lookup_value(v: number): void
 
+    public lookup_value: number
+
     write_value(v: number[]): void
 
     read_value(destination: number[])

package/engine/graphics/particles/particular/engine/utils/volume/AttributeValue.js

@@ -78,6 +78,10 @@ export class AttributeValue {
         return this.__lut;
     }
 
+    set lookup_value(v) {
+        this.write_lookup_value(v);
+    }
+
     /**
      *
      * @param {number} v

package/engine/graphics/texture/atlas/TextureAtlas.js

@@ -10,8 +10,8 @@ import Signal from "../../../../core/events/signal/Signal.js";
 import { assert } from "../../../../core/assert.js";
 import { DataType } from "../../../../core/collection/table/DataType.js";
 import { DataType2TypedArrayConstructorMapping } from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
-import { invokeObjectClone } from "../../../../core/model/ObjectUtils.js";
 import { AbstractTextureAtlas } from "./AbstractTextureAtlas.js";
+import { invokeObjectClone } from "../../../../core/model/object/invokeObjectClone.js";
 
 export class TextureAtlas extends AbstractTextureAtlas {
     /**

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.46",
+  "version": "2.33.50",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",

package/core/model/ObjectUtils.js

@@ -1,122 +0,0 @@
-/**
- * @template V
- * @param {Object<V>} object
- * @param {V} value
- * @returns {string}
- */
-import { assert } from "../assert.js";
-import { extractFunctionBody } from "../function/extractFunctionBody.js";
-import { compareArrays } from "../primitives/array/compareArrays.js";
-import { compareBooleans } from "../primitives/boolean/compareBooleans.js";
-import { compareNumbers } from "../primitives/numbers/compareNumbers.js";
-import { compareStrings } from "../primitives/strings/compareStrings.js";
-
-/**
- *
- * @param {*} a
- * @param {*} b
- * @returns {number}
- */
-export function compareValues(a, b) {
-    if (a === b) {
-        return 0;
-    }
-
-    const aType = typeof a;
-    const bType = typeof b;
-
-    if (aType !== bType) {
-        return compareStrings(aType, bType);
-    }
-
-    if (aType === "string") {
-        return compareStrings(a, b);
-    } else if (aType === "number") {
-        return compareNumbers(a, b);
-    } else if (aType === "boolean") {
-        return compareBooleans(a, b);
-    } else if (aType === "function") {
-        return compareStrings(extractFunctionBody(a), extractFunctionBody(b));
-    } else if (aType === "object") {
-        if (a === null) {
-            if (b !== null) {
-                return -1;
-            } else {
-                return 0;
-            }
-        } else if (b === null) {
-            return 1;
-        }
-
-        if (Array.isArray(a) && Array.isArray(b)) {
-            return compareArrays(a, b, compareValues);
-        }
-
-        const aKeys = Object.keys(a);
-        const bKeys = Object.keys(b);
-
-        const dKeys = compareArrays(aKeys, bKeys, compareStrings);
-
-        if (dKeys !== 0) {
-            return dKeys;
-        }
-
-        for (let p in a) {
-            const d = compareValues(a[p], b[p]);
-
-            if (d !== 0) {
-                return d;
-            }
-        }
-    }
-
-    return 0;
-}
-
-/**
- * @template V
- * @param {Object<V>} object
- * @param {string} key
- * @returns {V}
- * @throws {Error} if such key does not exist
- */
-export function validatedObjectValueByKey(object, key) {
-
-    assert.typeOf(key, 'string', 'key');
-
-    const value = object[key];
-
-    if (value === undefined) {
-        throw new Error(`Unknown key '${key}', valid keys: [${Object.keys(object).join(', ')}]`);
-    }
-
-    return value;
-}
-
-/**
- * @template T
- * @param {T} object
- * @return {T}
- */
-export function invokeObjectClone(object) {
-    return object.clone();
-}
-
-
-/**
- * @template S,R
- * @param {S} source
- * @return {R}
- */
-export function objectShallowCopyByOwnKeys(source) {
-    const keys = Reflect.ownKeys(source);
-
-    const result = {};
-    const n = keys.length;
-    for (let i = 0; i < n; i++) {
-        const key = keys[i];
-        result[key] = source[key];
-    }
-
-    return result;
-}