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

package/dist/browser/index.d.mts

@@ -64,6 +64,7 @@ declare abstract class PersistentCache<B = unknown> {
     static open(name: string): PersistentCache;
     protected constructor(backing: B);
     abstract get<T>(key: string): Promise<T>;
+    /** Loads a missing entry and stores only non-nullish results. */
     getOrLoad<T>(key: string, loader: (key: string) => Promise<T>): Promise<T>;
     abstract put<T>(key: string, value: T): Promise<T>;
     abstract delete<T>(key: string): Promise<void>;
@@ -1213,6 +1214,10 @@ declare class Caching {
     static readonly mergedModelCache: AsyncLoadingCache<CacheKey, Model>;
     static readonly modelTextureAtlasCache: AsyncLoadingCache<CacheKey, TextureAtlas>;
     static readonly blockStateCache: AsyncLoadingCache<CacheKey, BlockState>;
+    static readonly listAssetCache: AsyncLoadingCache<CacheKey, ListAsset>;
+    static readonly defaultBlockStatesCache: AsyncLoadingCache<CacheKey, DefaultBlockStates>;
+    static readonly entityModelsCache: AsyncLoadingCache<CacheKey, EntityModels>;
+    private static createAssetCache;
     /** Every cache above, so clear()/end() can never fall out of sync with the field list again. */
     private static get all();
     static clear(): void;

package/dist/browser/index.d.ts

@@ -64,6 +64,7 @@ declare abstract class PersistentCache<B = unknown> {
     static open(name: string): PersistentCache;
     protected constructor(backing: B);
     abstract get<T>(key: string): Promise<T>;
+    /** Loads a missing entry and stores only non-nullish results. */
     getOrLoad<T>(key: string, loader: (key: string) => Promise<T>): Promise<T>;
     abstract put<T>(key: string, value: T): Promise<T>;
     abstract delete<T>(key: string): Promise<void>;
@@ -1213,6 +1214,10 @@ declare class Caching {
     static readonly mergedModelCache: AsyncLoadingCache<CacheKey, Model>;
     static readonly modelTextureAtlasCache: AsyncLoadingCache<CacheKey, TextureAtlas>;
     static readonly blockStateCache: AsyncLoadingCache<CacheKey, BlockState>;
+    static readonly listAssetCache: AsyncLoadingCache<CacheKey, ListAsset>;
+    static readonly defaultBlockStatesCache: AsyncLoadingCache<CacheKey, DefaultBlockStates>;
+    static readonly entityModelsCache: AsyncLoadingCache<CacheKey, EntityModels>;
+    private static createAssetCache;
     /** Every cache above, so clear()/end() can never fall out of sync with the field list again. */
     private static get all();
     static clear(): void;

package/dist/browser/index.js

@@ -28,14 +28,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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 i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
 
 // ../../node_modules/ts-deepmerge/dist/index.js
 var require_dist = __commonJS({
@@ -308,11 +300,14 @@ var _PersistentCache = class _PersistentCache {
   static open(name) {
     return Env.provider.openCache(name, _PersistentCache.VERSION);
   }
+  /** Loads a missing entry and stores only non-nullish results. */
   async getOrLoad(key, loader) {
     let v = await this.get(key);
     if (typeof v === "undefined" || v === null) {
       v = await loader(key);
-      await this.put(key, v);
+      if (typeof v !== "undefined" && v !== null) {
+        await this.put(key, v);
+      }
     }
     return v;
   }
@@ -548,7 +543,10 @@ function serializeMeshKey(key) {
 // src/cache/Caching.ts
 var import_loading_cache = require("@inventivetalent/loading-cache");
 var import_time = require("@inventivetalent/time");
-var Caching = class {
+var _Caching = class _Caching {
+  static createAssetCache() {
+    return import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.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 [
@@ -565,7 +563,10 @@ var Caching = class {
       this.rawModelCache,
       this.mergedModelCache,
       this.modelTextureAtlasCache,
-      this.blockStateCache
+      this.blockStateCache,
+      this.listAssetCache,
+      this.defaultBlockStatesCache,
+      this.entityModelsCache
     ];
   }
   static clear() {
@@ -591,20 +592,24 @@ var Caching = class {
     };
   }
 };
-Caching.rawImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(5)).buildAsync();
-Caching.imageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
-Caching.canvasImageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
-Caching.wrappedImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
-Caching.boxGeometryCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(20)).build();
-Caching.textureCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
-Caching.materialCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
-Caching.boxMeshCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
-Caching.textureAssetCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-Caching.textureMetaCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-Caching.rawModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-Caching.mergedModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-Caching.modelTextureAtlasCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-Caching.blockStateCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+_Caching.rawImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(5)).buildAsync();
+_Caching.imageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
+_Caching.canvasImageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
+_Caching.wrappedImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
+_Caching.boxGeometryCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(20)).build();
+_Caching.textureCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
+_Caching.materialCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
+_Caching.boxMeshCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
+_Caching.textureAssetCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+_Caching.textureMetaCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+_Caching.rawModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+_Caching.mergedModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+_Caching.modelTextureAtlasCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+_Caching.blockStateCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.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 {
@@ -1386,9 +1391,6 @@ var ModelMerger = class {
   }
 };
 
-// src/assets/Models.ts
-var import_typescript_memoize = require("typescript-memoize");
-
 // src/assets/source/parser/AssetParsers.ts
 var AssetParser = /* @__PURE__ */ ((AssetParser2) => {
   AssetParser2["MODEL"] = "model";
@@ -1402,14 +1404,14 @@ var AssetParser = /* @__PURE__ */ ((AssetParser2) => {
 })(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",
@@ -1417,7 +1419,10 @@ var _Models = class _Models {
       "assets",
       ".json",
       DEFAULT_ROOT
-    ), "list" /* LIST */).then((r) => r?.files ?? []);
+    );
+    return Caching.listAssetCache.get(key.serialize(), () => {
+      return AssetLoader.get(key, "list" /* LIST */);
+    }).then((r) => r?.files ?? []);
   }
   static async loadAndMerge(key) {
     const model = await this.getRaw(key);
@@ -1464,19 +1469,15 @@ var _Models = class _Models {
     return this.PERSISTENT_CACHE.clear();
   }
 };
-__decorateClass([
-  (0, import_typescript_memoize.Memoize)()
-], _Models, "getItemList", 1);
-var Models = _Models;
 
 // src/assets/BlockStates.ts
-var import_typescript_memoize2 = require("typescript-memoize");
 var BlockStates = class {
   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",
@@ -1484,11 +1485,16 @@ var BlockStates = class {
       "assets",
       ".json",
       DEFAULT_ROOT
-    ), "list" /* LIST */).then((r) => r?.files ?? []);
+    );
+    return Caching.listAssetCache.get(key.serialize(), () => {
+      return AssetLoader.get(key, "list" /* LIST */);
+    }).then((r) => r?.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();
@@ -1527,12 +1533,6 @@ var BlockStates = class {
     await this.PERSISTENT_CACHE.clear();
   }
 };
-__decorateClass([
-  (0, import_typescript_memoize2.Memoize)()
-], BlockStates, "getList", 1);
-__decorateClass([
-  (0, import_typescript_memoize2.Memoize)()
-], BlockStates, "getDefaultStates", 1);
 var DefaultBlockStates = class {
 };
 
@@ -2582,17 +2582,20 @@ function shutdown() {
 }
 
 // src/assets/Entities.ts
-var import_typescript_memoize3 = require("typescript-memoize");
 var Entities = class {
   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() {
@@ -2638,12 +2641,6 @@ var Entities = class {
     };
   }
 };
-__decorateClass([
-  (0, import_typescript_memoize3.Memoize)()
-], Entities, "getBlockEntityModels", 1);
-__decorateClass([
-  (0, import_typescript_memoize3.Memoize)()
-], Entities, "getEntityModels", 1);
 var EntityModels = class {
 };
 var BlockEntityModels = class {