@woosh/meep-engine 2.55.0 → 2.56.0

package/src/generation/theme/AreaTheme.js

@@ -1,13 +1,12 @@
 import { AreaMask } from "./AreaMask.js";
 
 export class AreaTheme {
-    constructor() {
-        this.mask = new AreaMask();
+    mask = new AreaMask();
+
+    /**
+     *
+     * @type {Theme}
+     */
+    theme = null;
 
-        /**
-         *
-         * @type {Theme}
-         */
-        this.theme = null;
-    }
 }

package/src/generation/theme/TerrainLayerDescription.js

@@ -2,19 +2,17 @@ import { computeStringHash } from "../../core/primitives/strings/computeStringHa
 import Vector2 from "../../core/geom/Vector2.js";
 
 export class TerrainLayerDescription {
-    constructor() {
-        /**
-         * URL to diffuse texture
-         * @type {string}
-         */
-        this.diffuse = '';
+    /**
+     * URL to diffuse texture
+     * @type {string}
+     */
+    diffuse = '';
 
-        /**
-         *
-         * @type {Vector2}
-         */
-        this.size = new Vector2(1, 1);
-    }
+    /**
+     *
+     * @type {Vector2}
+     */
+    size = new Vector2(1, 1);
 
     hash() {
         return computeStringHash(this.diffuse) ^ this.size.hash();

package/src/generation/theme/TerrainLayerRule.js

@@ -2,20 +2,18 @@ import { assert } from "../../core/assert.js";
 import { TerrainLayerDescription } from "./TerrainLayerDescription.js";
 
 export class TerrainLayerRule {
-    constructor() {
-        /**
-         *
-         * @type {CellFilter}
-         */
-        this.filter = null;
-
-        /**
-         *
-         * @type {TerrainLayerDescription}
-         */
-        this.layer = new TerrainLayerDescription();
+    /**
+     *
+     * @type {CellFilter}
+     */
+    filter = null;
+
+    /**
+     *
+     * @type {TerrainLayerDescription}
+     */
+    layer = new TerrainLayerDescription();
 
-    }
 
     /**
      *

package/src/generation/theme/TerrainTheme.js

@@ -2,13 +2,12 @@ import { assert } from "../../core/assert.js";
 import { seededRandom } from "../../core/math/random/seededRandom.js";
 
 export class TerrainTheme {
-    constructor() {
-        /**
-         *
-         * @type {TerrainLayerRule[]}
-         */
-        this.rules = [];
-    }
+    /**
+     *
+     * @type {TerrainLayerRule[]}
+     */
+    rules = [];
+
 
     /**
      *

package/src/generation/theme/Theme.js

@@ -4,26 +4,24 @@ import { CellProcessingRuleSet } from "./cell/CellProcessingRuleSet.js";
 import { assert } from "../../core/assert.js";
 
 export class Theme {
-    constructor() {
 
-        /**
-         *
-         * @type {TerrainTheme}
-         */
-        this.terrain = new TerrainTheme();
+    /**
+     *
+     * @type {TerrainTheme}
+     */
+    terrain = new TerrainTheme();
 
-        /**
-         *
-         * @type {MarkerNodeProcessingRuleSet}
-         */
-        this.nodes = new MarkerNodeProcessingRuleSet();
+    /**
+     *
+     * @type {MarkerNodeProcessingRuleSet}
+     */
+    nodes = new MarkerNodeProcessingRuleSet();
 
-        /**
-         *
-         * @type {CellProcessingRuleSet}
-         */
-        this.cells = new CellProcessingRuleSet();
-    }
+    /**
+     *
+     * @type {CellProcessingRuleSet}
+     */
+    cells = new CellProcessingRuleSet();
 
     /**
      *

package/src/generation/theme/ThemeEngine.js

@@ -55,27 +55,25 @@ function prepare_terrain_for_themes(layer_mapping, themes) {
 }
 
 export class ThemeEngine {
-    constructor() {
 
-        /**
-         *
-         * @type {QuadTreeNode<AreaTheme>}
-         */
-        this.areas = new QuadTreeNode();
+    /**
+     *
+     * @type {QuadTreeNode<AreaTheme>}
+     */
+    areas = new QuadTreeNode();
 
-        /**
-         *
-         * @type {function():number}
-         */
-        this.random = seededRandom(1);
+    /**
+     *
+     * @type {function():number}
+     */
+    random = seededRandom(1);
 
-        /**
-         *
-         * @type {AssetManager}
-         * @private
-         */
-        this.__assetManager = null;
-    }
+    /**
+     *
+     * @type {AssetManager}
+     * @private
+     */
+    __assetManager = null;
 
     set assetManager(v) {
         this.__assetManager = v;

package/src/view/string_tag_to_css_class_name.js

@@ -1,4 +1,4 @@
-import { camelToKebab } from "../core/primitives/strings/StringUtils.js";
+import { string_format_camel_to_kebab } from "../core/primitives/strings/string_format_camel_to_kebab.js";
 
 /**
  *
@@ -6,7 +6,7 @@ import { camelToKebab } from "../core/primitives/strings/StringUtils.js";
  * @returns {string}
  */
 export function string_tag_to_css_class_name(a) {
-    const name = camelToKebab(a);
+    const name = string_format_camel_to_kebab(a);
 
     return `tag-${name}`;
 }

package/src/view/tooltip/gml/TooltipParser.js

@@ -1,8 +1,8 @@
 import { Cache } from "../../../core/cache/Cache.js";
-import { computeUTF8StringByteSize } from "../../../core/primitives/strings/StringUtils.js";
 import { strictEquals } from "../../../core/function/Functions.js";
 import { parseTooltipString } from "./parser/parseTooltipString.js";
 import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+import { string_compute_byte_size } from "../../../core/primitives/strings/string_compute_byte_size.js";
 
 export class TooltipParser {
 
@@ -15,7 +15,7 @@ export class TooltipParser {
          */
         this.__cache = new Cache({
             maxWeight: 1048576,
-            keyWeigher: computeUTF8StringByteSize,
+            keyWeigher: string_compute_byte_size,
             valueWeigher(tokens) {
                 return tokens.length * 256;
             },

package/src/core/cache/PersistentCacheAdapter.js

@@ -1,378 +0,0 @@
-import { IndexedDBStorage } from "../../engine/save/storage/IndexedDBStorage.js";
-import { assert } from "../assert.js";
-import { Base64 } from "../binary/Base64.js";
-import { BinaryBuffer } from "../binary/BinaryBuffer.js";
-
-const scratch_buffer = new BinaryBuffer();
-
-/**
- *
- * @type {number}
- */
-const BUFFER_MAX_RETAINED_SIZE = 131072;
-
-function cleanup_buffer() {
-    if (scratch_buffer.length > BUFFER_MAX_RETAINED_SIZE) {
-        scratch_buffer.position = 0;
-        scratch_buffer.setCapacity(BUFFER_MAX_RETAINED_SIZE);
-    }
-}
-
-/**
- * @template T
- * @param {T} object
- * @param {BinaryClassSerializationAdapter} adapter
- * @returns {string}
- */
-function object2string(object, adapter) {
-
-    scratch_buffer.position = 0;
-
-    // serialize key
-    adapter.serialize(scratch_buffer, object);
-
-    // convert key to string
-    const end = scratch_buffer.position;
-    const array_buffer = scratch_buffer.data.slice(0, end);
-
-    const result = Base64.encode(array_buffer);
-
-    cleanup_buffer();
-
-    return result;
-}
-
-/**
- * @template T
- * @param {string} string
- * @param {BinaryClassSerializationAdapter} adapter
- * @param {Class<T>} klass
- * @returns T
- */
-function string2object(string, adapter, klass) {
-    /**
-     *
-     * @type {T}
-     */
-    const result = new klass();
-
-    const arrayBuffer = Base64.decode(string);
-
-    scratch_buffer.fromArrayBuffer(arrayBuffer);
-
-    adapter.deserialize(scratch_buffer, result);
-
-    cleanup_buffer();
-
-    return result;
-}
-
-/**
- * Attaches to a cache instance and persists all the cache data asynchronously
- * Behaves similarly to WeakMap class with similar interface.
- * @template K,V
- */
-export class PersistentCacheAdapter {
-    /**
-     * @template K,V
-     * @param {string} storageKey
-     * @param {BinaryClassSerializationAdapter} keyAdapter
-     * @param {Class<K>|function} keyClass
-     * @param {BinaryClassSerializationAdapter} valueAdapter
-     * @param {Class<V>|function} valueClass
-     */
-    constructor({
-                    storageKey,
-                    keyAdapter,
-                    keyClass,
-                    valueAdapter,
-                    valueClass
-                }) {
-        assert.typeOf(storageKey, 'string', 'storageKey');
-
-        assert.defined(keyAdapter, 'keyAdapter');
-        assert.notNull(keyAdapter, 'keyAdapter');
-        assert.defined(keyClass, 'keyClass');
-        assert.notNull(keyClass, 'keyClass');
-
-        assert.defined(valueAdapter, 'valueAdapter');
-        assert.notNull(valueAdapter, 'valueAdapter');
-        assert.defined(valueClass, 'valueClass');
-        assert.notNull(valueClass, 'valueClass');
-
-        /**
-         *
-         * @type {string}
-         * @private
-         */
-        this.__storage_key = storageKey;
-        /**
-         *
-         * @type {BinaryClassSerializationAdapter}
-         * @private
-         */
-        this.__key_adapter = keyAdapter;
-        /**
-         *
-         * @type {Class<K>|Function}
-         * @private
-         */
-        this.__key_class = keyClass;
-
-        /**
-         *
-         * @type {BinaryClassSerializationAdapter}
-         * @private
-         */
-        this.__value_adapter = valueAdapter;
-        /**
-         *
-         * @type {Class<V>|Function}
-         * @private
-         */
-        this.__value_class = valueClass;
-
-        /**
-         *
-         * @type {Storage}
-         * @private
-         */
-        this.__storage = new IndexedDBStorage(`meep.core.persistent_cache/${storageKey}`);
-
-        /**
-         *
-         * @type {Cache|null}
-         * @private
-         */
-        this.__cache = null;
-    }
-
-    /**
-     *
-     * @param {Cache<K,V>} cache
-     * @param {boolean} ingest should data stored in the persisted cache be uploaded to the cache or not
-     */
-    async attach(cache, ingest = true) {
-        if (this.__cache !== null) {
-            throw new Error(`Adapted already connected to a cache`);
-        }
-
-        this.__cache = cache;
-
-        // connect signals
-        cache.onSet.add(this.__handle_set, this);
-        cache.onRemoved.add(this.__handle_remove, this);
-
-        if (ingest) {
-            await this.__ingest();
-        }
-    }
-
-    /**
-     *
-     * @return {Promise<void>}
-     * @private
-     */
-    async __ingest() {
-        /**
-         *
-         * @type {string[]}
-         */
-        const keys = await this.__storage.promiseList();
-
-        const key_count = keys.length;
-
-        const pairs = [];
-
-        /**
-         *
-         * @type {Promise[]}
-         */
-        const read_promises = [];
-
-        const start = performance.now();
-
-        for (let i = 0; i < key_count; i++) {
-            const key_string = keys[i];
-
-            const promise = new Promise(async (resolve, reject) => {
-                const key = string2object(key_string, this.__key_adapter, this.__key_class);
-
-                // read value
-                let value;
-
-                try {
-                    value = await this.__get_by_string_unsafe(key_string);
-                } catch (e) {
-
-                    // failed to read value, skip
-                    resolve();
-
-                    return;
-                }
-
-                // first read into temp array to prevent thrashing when adding one thing to cache would cause another thing to be removed
-                pairs.push([key, value]);
-
-                resolve();
-            });
-
-            read_promises.push(promise);
-        }
-
-        await Promise.all(read_promises);
-
-        console.log(`${this.__storage_key} : Ingesting ${key_count} values finished after ${performance.now() - start}ms`);
-
-        const cache = this.__cache;
-
-        // disconnect signals
-        cache.onSet.remove(this.__handle_set, this);
-        cache.onRemoved.remove(this.__handle_remove, this);
-
-        // add to cache
-        for (let i = 0; i < pairs.length; i++) {
-            const [key, value] = pairs[i];
-
-            cache.put(key, value);
-        }
-
-        // reconnect signals
-        cache.onSet.add(this.__handle_set, this);
-        cache.onRemoved.add(this.__handle_remove, this);
-
-    }
-
-    /**
-     *
-     * @param {K} key
-     * @param {V} value
-     * @private
-     */
-    __handle_set(key, value) {
-        this.set(key, value);
-    }
-
-    /**
-     *
-     * @param {K} key
-     * @private
-     */
-    __handle_remove(key) {
-        this.delete(key);
-    }
-
-
-    /**
-     *
-     * @param {K} key
-     * @param {V} value
-     * @private
-     */
-    async set(key, value) {
-        assert.defined(key, 'key');
-        assert.notNull(key, 'key');
-
-        assert.defined(value, 'value');
-        assert.notNull(value, 'value');
-
-        const key_string = object2string(key, this.__key_adapter);
-
-        // serialize value
-        scratch_buffer.position = 0;
-        this.__value_adapter.serialize(scratch_buffer, value);
-
-        cleanup_buffer();
-
-        const value_data = scratch_buffer.data.slice(0, scratch_buffer.position);
-
-        await this.__storage.promiseStoreBinary(key_string, value_data);
-    }
-
-    /**
-     *
-     * @param {K} key
-     * @returns {V|undefined}
-     * @private
-     */
-    async get(key) {
-        assert.defined(key, 'key');
-        assert.notNull(key, 'key');
-
-        const key_string = object2string(key, this.__key_adapter);
-
-        // check if value is present
-        const exists = await this.__storage.promiseContains(key_string);
-
-        if (!exists) {
-            // value doesn't exist
-            return undefined;
-        }
-
-        return this.__get_by_string_unsafe(key_string);
-    }
-
-    /**
-     * @param {string} key_string
-     * @return {Promise<V>}
-     * @private
-     */
-    async __get_by_string_unsafe(key_string) {
-
-        /**
-         *
-         * @type {ArrayBuffer}
-         */
-        const value_data = await this.__storage.promiseLoadBinary(key_string);
-
-        const value = new this.__value_class();
-
-        scratch_buffer.fromArrayBuffer(value_data);
-
-        try {
-            this.__value_adapter.deserialize(scratch_buffer, value);
-        } catch (e) {
-            // failed to deserialize
-            // console.error('Failed to deserialize the value: ', e);
-
-            // delete the value
-            this.__storage.promiseRemove(key_string);
-
-            throw new Error('Failed to deserialize');
-        } finally {
-            cleanup_buffer();
-        }
-
-        return value;
-    }
-
-    /**
-     *
-     * @param {K} key
-     * @returns {boolean}
-     * @private
-     */
-    async has(key) {
-        assert.defined(key, 'key');
-        assert.notNull(key, 'key');
-
-        const key_string = object2string(key, this.__key_adapter);
-
-        return await this.__storage.promiseContains(key_string);
-    }
-
-    /**
-     *
-     * @param {K} key
-     * @private
-     */
-    async delete(key) {
-        assert.defined(key, 'key');
-        assert.notNull(key, 'key');
-
-        const key_string = object2string(key, this.__key_adapter);
-
-        return await this.__storage.promiseRemove(key_string);
-    }
-}
-

package/src/core/primitives/strings/StringUtils.js

@@ -1,105 +0,0 @@
-/**
- * @author Alex Goldring 2018
- * @copyright Alex Goldring 2018
- */
-
-/**
- * Compute byte size of a UTF8 string
- * @param {string} value
- * @returns {number}
- */
-export function computeUTF8StringByteSize(value) {
-    const length = value.length;
-
-    let p = 0;
-
-    for (let i = 0; i < length; i++) {
-        let c = value.charCodeAt(i);
-        while (c > 0xff) {
-            p++;
-            c >>= 8;
-        }
-        p++;
-    }
-
-    return p;
-}
-
-/**
- *
- * @param {string} string
- * @returns {string}
- */
-export function capitalize(string) {
-    const length = string.length;
-
-    if (length === 0) {
-        return string;
-    } else {
-        return string.charAt(0).toLocaleUpperCase() + string.substring(1);
-    }
-}
-
-/**
- * @example: ['abra', 'abc', 'abode'] => 'ab'
- * @param {String[]} strings
- * @returns string
- */
-export function computeCommonPrefix(strings) {
-    let i, j;
-
-    const numInputs = strings.length;
-
-    let result = "";
-
-    if (numInputs === 0) {
-        return result;
-    }
-
-    const firstString = strings[0];
-
-    let lengthLimit = firstString.length;
-
-    for (i = 1; i < numInputs; i++) {
-        lengthLimit = Math.min(strings[i].length, lengthLimit);
-    }
-
-
-    main_loop:for (i = 0; i < lengthLimit; i++) {
-        const letter0 = firstString.charAt(i);
-
-        for (j = 1; j < numInputs; j++) {
-
-            const string = strings[j];
-
-            const letter1 = string.charAt(i);
-
-            if (letter0 !== letter1) {
-                break main_loop;
-            }
-        }
-
-        result += letter0;
-    }
-
-    return result;
-}
-
-/**
- *
- * @param {string} string
- * @returns {string}
- */
-export function camelToKebab(string) {
-    return string.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-}
-
-
-/**
- *
- * @param {string} string
- * @returns {string}
- */
-export function kebabToUnderscore(string) {
-    return string.replace('-', '_');
-}