minerender 2.1.0-alpha.8 → 2.1.0-alpha.9

package/dist/bundle.js

@@ -38,14 +38,6 @@ var MineRender = (() => {
     mod
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-  var __decorateClass = (decorators, target, key, kind) => {
-    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-    for (var i4 = decorators.length - 1, decorator; i4 >= 0; i4--)
-      if (decorator = decorators[i4])
-        result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-    if (kind && result) __defProp(target, key, result);
-    return result;
-  };
 
   // ../../node_modules/esbuild-plugin-polyfill-node/polyfills/__dirname.js
   var init_dirname = __esm({
@@ -47262,11 +47254,14 @@ return ${compiler2.callType("value", tagType)}
     static open(name2) {
       return Env.provider.openCache(name2, _PersistentCache.VERSION);
     }
+    /** Loads a missing entry and stores only non-nullish results. */
     async getOrLoad(key, loader) {
       let v5 = await this.get(key);
       if (typeof v5 === "undefined" || v5 === null) {
         v5 = await loader(key);
-        await this.put(key, v5);
+        if (typeof v5 !== "undefined" && v5 !== null) {
+          await this.put(key, v5);
+        }
       }
       return v5;
     }
@@ -68077,7 +68072,10 @@ return ${compiler2.callType("value", tagType)}
   init_process2();
 
   // src/cache/Caching.ts
-  var Caching = class {
+  var _Caching = class _Caching {
+    static createAssetCache() {
+      return Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+    }
     /** Every cache above, so clear()/end() can never fall out of sync with the field list again. */
     static get all() {
       return [
@@ -68094,7 +68092,10 @@ return ${compiler2.callType("value", tagType)}
         this.rawModelCache,
         this.mergedModelCache,
         this.modelTextureAtlasCache,
-        this.blockStateCache
+        this.blockStateCache,
+        this.listAssetCache,
+        this.defaultBlockStatesCache,
+        this.entityModelsCache
       ];
     }
     static clear() {
@@ -68120,20 +68121,24 @@ return ${compiler2.callType("value", tagType)}
       };
     }
   };
-  Caching.rawImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(5)).buildAsync();
-  Caching.imageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
-  Caching.canvasImageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
-  Caching.wrappedImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
-  Caching.boxGeometryCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(20)).build();
-  Caching.textureCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
-  Caching.materialCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
-  Caching.boxMeshCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
-  Caching.textureAssetCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
-  Caching.textureMetaCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
-  Caching.rawModelCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
-  Caching.mergedModelCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
-  Caching.modelTextureAtlasCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
-  Caching.blockStateCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  _Caching.rawImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(5)).buildAsync();
+  _Caching.imageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
+  _Caching.canvasImageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
+  _Caching.wrappedImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
+  _Caching.boxGeometryCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(20)).build();
+  _Caching.textureCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
+  _Caching.materialCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
+  _Caching.boxMeshCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
+  _Caching.textureAssetCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  _Caching.textureMetaCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  _Caching.rawModelCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  _Caching.mergedModelCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  _Caching.modelTextureAtlasCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  _Caching.blockStateCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  _Caching.listAssetCache = _Caching.createAssetCache();
+  _Caching.defaultBlockStatesCache = _Caching.createAssetCache();
+  _Caching.entityModelsCache = _Caching.createAssetCache();
+  var Caching = _Caching;
 
   // src/Geometries.ts
   var Geometries = class _Geometries {
@@ -68996,95 +69001,6 @@ return ${compiler2.callType("value", tagType)}
     }
   };
 
-  // ../../node_modules/typescript-memoize/dist/es2015/memoize-decorator.js
-  init_dirname();
-  init_buffer2();
-  init_process2();
-  function Memoize(args) {
-    let hashFunction;
-    let duration;
-    let tags;
-    if (typeof args === "object") {
-      hashFunction = args.hashFunction;
-      duration = args.expiring;
-      tags = args.tags;
-    } else {
-      hashFunction = args;
-    }
-    return (target, propertyKey, descriptor) => {
-      if (descriptor.value != null) {
-        descriptor.value = getNewFunction(descriptor.value, hashFunction, duration, tags);
-      } else if (descriptor.get != null) {
-        descriptor.get = getNewFunction(descriptor.get, hashFunction, duration, tags);
-      } else {
-        throw "Only put a Memoize() decorator on a method or get accessor.";
-      }
-    };
-  }
-  var clearCacheTagsMap = /* @__PURE__ */ new Map();
-  function getNewFunction(originalMethod, hashFunction, duration = 0, tags) {
-    const propMapName = Symbol(`__memoized_map__`);
-    return function(...args) {
-      let returnedValue;
-      if (!this.hasOwnProperty(propMapName)) {
-        Object.defineProperty(this, propMapName, {
-          configurable: false,
-          enumerable: false,
-          writable: false,
-          value: /* @__PURE__ */ new Map()
-        });
-      }
-      let myMap = this[propMapName];
-      if (Array.isArray(tags)) {
-        for (const tag of tags) {
-          if (clearCacheTagsMap.has(tag)) {
-            clearCacheTagsMap.get(tag).push(myMap);
-          } else {
-            clearCacheTagsMap.set(tag, [myMap]);
-          }
-        }
-      }
-      if (hashFunction || args.length > 0 || duration > 0) {
-        let hashKey;
-        if (hashFunction === true) {
-          hashKey = args.map((a4) => a4.toString()).join("!");
-        } else if (hashFunction) {
-          hashKey = hashFunction.apply(this, args);
-        } else {
-          hashKey = args[0];
-        }
-        const timestampKey = `${hashKey}__timestamp`;
-        let isExpired = false;
-        if (duration > 0) {
-          if (!myMap.has(timestampKey)) {
-            isExpired = true;
-          } else {
-            let timestamp = myMap.get(timestampKey);
-            isExpired = Date.now() - timestamp > duration;
-          }
-        }
-        if (myMap.has(hashKey) && !isExpired) {
-          returnedValue = myMap.get(hashKey);
-        } else {
-          returnedValue = originalMethod.apply(this, args);
-          myMap.set(hashKey, returnedValue);
-          if (duration > 0) {
-            myMap.set(timestampKey, Date.now());
-          }
-        }
-      } else {
-        const hashKey = this;
-        if (myMap.has(hashKey)) {
-          returnedValue = myMap.get(hashKey);
-        } else {
-          returnedValue = originalMethod.apply(this, args);
-          myMap.set(hashKey, returnedValue);
-        }
-      }
-      return returnedValue;
-    };
-  }
-
   // src/assets/source/parser/AssetParsers.ts
   init_dirname();
   init_buffer2();
@@ -69101,14 +69017,14 @@ return ${compiler2.callType("value", tagType)}
   })(AssetParser || {});
 
   // src/assets/Models.ts
-  var _Models = class _Models {
+  var Models = class _Models {
     // opened lazily: touching the store at import time would hit IndexedDB/disk just for loading
     // the library, and would require an EnvProvider before any entry has had a chance to register
     static get PERSISTENT_CACHE() {
       return this._persistentCache ?? (this._persistentCache = PersistentCache.open("minerender-models"));
     }
     static async getItemList() {
-      return AssetLoader.get(new AssetKey(
+      const key = new AssetKey(
         DEFAULT_NAMESPACE,
         "_list",
         "models",
@@ -69116,7 +69032,10 @@ return ${compiler2.callType("value", tagType)}
         "assets",
         ".json",
         DEFAULT_ROOT
-      ), "list" /* LIST */).then((r5) => r5?.files ?? []);
+      );
+      return Caching.listAssetCache.get(key.serialize(), () => {
+        return AssetLoader.get(key, "list" /* LIST */);
+      }).then((r5) => r5?.files ?? []);
     }
     static async loadAndMerge(key) {
       const model = await this.getRaw(key);
@@ -69163,10 +69082,6 @@ return ${compiler2.callType("value", tagType)}
       return this.PERSISTENT_CACHE.clear();
     }
   };
-  __decorateClass([
-    Memoize()
-  ], _Models, "getItemList", 1);
-  var Models = _Models;
 
   // src/assets/BlockStates.ts
   init_dirname();
@@ -69176,8 +69091,9 @@ return ${compiler2.callType("value", tagType)}
     static get PERSISTENT_CACHE() {
       return this._persistentCache ?? (this._persistentCache = PersistentCache.open("minerender-blockstates"));
     }
+    // BlockState names are hardcoded
     static async getList() {
-      return AssetLoader.get(new AssetKey(
+      const key = new AssetKey(
         DEFAULT_NAMESPACE,
         "_list",
         "blockstates",
@@ -69185,11 +69101,16 @@ return ${compiler2.callType("value", tagType)}
         "assets",
         ".json",
         DEFAULT_ROOT
-      ), "list" /* LIST */).then((r5) => r5?.files ?? []);
+      );
+      return Caching.listAssetCache.get(key.serialize(), () => {
+        return AssetLoader.get(key, "list" /* LIST */);
+      }).then((r5) => r5?.files ?? []);
     }
     static async getDefaultStates() {
       const key = AssetKey.parse("blockstates", "minerender:defaultBlockStates");
-      return AssetLoader.get(key, "json" /* JSON */);
+      return Caching.defaultBlockStatesCache.get(key.serialize(), () => {
+        return AssetLoader.get(key, "json" /* JSON */);
+      });
     }
     static async getDefaultState(key) {
       const defaultStates = await this.getDefaultStates();
@@ -69228,12 +69149,6 @@ return ${compiler2.callType("value", tagType)}
       await this.PERSISTENT_CACHE.clear();
     }
   };
-  __decorateClass([
-    Memoize()
-  ], BlockStates, "getList", 1);
-  __decorateClass([
-    Memoize()
-  ], BlockStates, "getDefaultStates", 1);
   var DefaultBlockStates = class {
   };
 
@@ -79830,12 +79745,16 @@ return ${compiler2.callType("value", tagType)}
     static async getBlockEntityModels() {
       const key = AssetKey.parse("models", "minerender:blockEntityModels");
       console.log(key);
-      return AssetLoader.get(key, "json" /* JSON */);
+      return Caching.entityModelsCache.get(key.serialize(), () => {
+        return AssetLoader.get(key, "json" /* JSON */);
+      });
     }
     static async getEntityModels() {
       const key = AssetKey.parse("models", "minerender:entityModels");
       console.log(key);
-      return AssetLoader.get(key, "json" /* JSON */);
+      return Caching.entityModelsCache.get(key.serialize(), () => {
+        return AssetLoader.get(key, "json" /* JSON */);
+      });
     }
     // BlockEntity names are hardcoded
     static async getBlockList() {
@@ -79881,12 +79800,6 @@ return ${compiler2.callType("value", tagType)}
       };
     }
   };
-  __decorateClass([
-    Memoize()
-  ], Entities, "getBlockEntityModels", 1);
-  __decorateClass([
-    Memoize()
-  ], Entities, "getEntityModels", 1);
   var EntityModels = class {
   };
   var BlockEntityModels = class {