minerender 2.1.0-alpha.12 → 2.1.0-alpha.13

package/dist/bundle.js

@@ -67173,7 +67173,7 @@ return ${compiler2.callType("value", tagType)}
     }
     toString() {
       let a4 = [
-        typeof this.root !== "undefined" || AssetLoader.ROOT !== DEFAULT_ROOT ? this.root ?? AssetLoader.ROOT : "__root__",
+        this.root ?? AssetLoader.ROOT,
         this.rootType ?? "__rootType__",
         this.assetType ?? "__assetType__",
         this.type ?? "__type__",
@@ -67223,6 +67223,7 @@ return ${compiler2.callType("value", tagType)}
       }
       const models = [];
       const parentKey = AssetKey.parse("models", model.parent);
+      parentKey.root = model.key?.root;
       const parentModel = await Models.getRaw(parentKey);
       if (parentModel) {
         models.unshift(parentModel);
@@ -67255,26 +67256,58 @@ return ${compiler2.callType("value", tagType)}
       return this._persistentCache ?? (this._persistentCache = PersistentCache.open("minerender-models"));
     }
     static async getItemList() {
-      const key = new AssetKey(
-        DEFAULT_NAMESPACE,
-        "_list",
-        "models",
-        "item",
-        "assets",
-        ".json",
-        DEFAULT_ROOT
-      );
-      return Caching.listAssetCache.get(key.serialize(), () => {
-        return AssetLoader.get(key, "list" /* LIST */);
+      const key = new AssetKey(DEFAULT_NAMESPACE, "_list", "items");
+      const legacyKey = new AssetKey(DEFAULT_NAMESPACE, "_list", "models", "item");
+      return Caching.listAssetCache.get(key.serialize(), async () => {
+        return (await AssetLoader.getFirst([key, legacyKey], "list" /* LIST */))?.asset;
       }).then((r5) => r5?.files ?? []);
     }
     static async loadAndMerge(key) {
-      const model = await this.getRaw(key);
+      const model = key.type === "item" ? await this.getItemModel(key) : await this.getRaw(key);
       if (!model) {
         return void 0;
       }
       return ModelMerger.mergeWithParents(model);
     }
+    static async getItemModel(key) {
+      const itemKey = new AssetKey(key.namespace, key.path, "items", void 0, key.rootType, ".json", key.root);
+      const model = await this.PERSISTENT_CACHE.getOrLoad(itemKey.serialize(), async () => {
+        const result = await AssetLoader.getFirst([itemKey, key], "json" /* JSON */);
+        if (!result) return void 0;
+        if (result.key.assetType !== "items") return { ...result.asset, key };
+        const reference = this.defaultItemModel(result.asset.model, key);
+        const modelKey = AssetKey.parse("models", reference);
+        modelKey.root = key.root;
+        const model2 = await this.getRaw(modelKey);
+        if (!model2) throw new Error(`Item ${key.toNamespacedString()} references missing model ${reference}`);
+        return model2;
+      });
+      return model ? { ...model, key: Object.assign(new AssetKey("", ""), model.key) } : void 0;
+    }
+    // Item previews use the GUI context, false conditions, and zero numeric properties.
+    static defaultItemModel(node, key) {
+      if (!node || typeof node.type !== "string") {
+        throw new Error(`Unsupported item model definition for ${key.toNamespacedString()}`);
+      }
+      switch (node.type.replace(/^minecraft:/, "")) {
+        case "model":
+          if (typeof node.model === "string" && node.model) return node.model;
+          break;
+        case "condition":
+          return this.defaultItemModel(node.on_false, key);
+        case "select": {
+          const selected = node.property?.replace(/^minecraft:/, "") === "display_context" ? node.cases?.find((entry) => Array.isArray(entry.when) ? entry.when.includes("gui") : entry.when === "gui")?.model : void 0;
+          return this.defaultItemModel(selected ?? node.fallback, key);
+        }
+        case "range_dispatch": {
+          const selected = node.entries?.reduce((match, entry) => {
+            return entry.threshold <= 0 && (!match || entry.threshold >= match.threshold) ? entry : match;
+          }, void 0);
+          return this.defaultItemModel(selected?.model ?? node.fallback, key);
+        }
+      }
+      throw new Error(`Unsupported item model ${node?.type ?? "definition"} for ${key.toNamespacedString()}`);
+    }
     static async getRaw(key) {
       if (!key.assetType) {
         key.assetType = "models";
@@ -67384,7 +67417,7 @@ return ${compiler2.callType("value", tagType)}
   };
 
   // src/assets/Assets.ts
-  var DEFAULT_ROOT = "https://assets.mcasset.cloud/1.17.1";
+  var DEFAULT_ROOT = "https://assets.mcasset.cloud/1.21.11";
   var DEFAULT_NAMESPACE = "minecraft";
   var Assets = class {
     /**
@@ -77317,11 +77350,29 @@ return ${compiler2.callType("value", tagType)}
     }
     /** Returns the first defined result in source-priority order, without merging assets. */
     static async get(key, parser) {
+      const keys = [key];
+      if (key.rootType === "data" && (key.assetType === "structure" || key.assetType === "structures")) {
+        keys.push(new AssetKey(
+          key.namespace,
+          key.path,
+          key.assetType === "structure" ? "structures" : "structure",
+          key.type,
+          key.rootType,
+          key.extension,
+          key.root
+        ));
+      }
+      return (await this.getFirst(keys, parser))?.asset;
+    }
+    /** Tries each path within a source before considering lower-priority sources. */
+    static async getFirst(keys, parser) {
       const sources = [...this._SOURCES];
       for (const source of sources) {
-        const result = await source.source.get(key, parser);
-        if (result !== void 0) {
-          return result;
+        for (const key of keys) {
+          const result = await source.source.get(key, parser);
+          if (result !== void 0) {
+            return { key, asset: result };
+          }
         }
       }
       return void 0;