mc-assets 0.2.48 → 0.2.50

package/dist/atlasParser.d.ts

@@ -33,7 +33,16 @@ export declare class AtlasParser {
     atlasHasLegacyImage: boolean;
     constructor(atlasJson: any, latestImage: string, legacyImage?: string | undefined);
     get atlas(): ItemsAtlases;
-    getTextureInfo(itemName: string, version?: string): any;
+    getTextureInfo(itemName: string, version?: string): {
+        su: number;
+        sv: number;
+        getLoadedImage: () => Promise<HTMLImageElement>;
+        u: number;
+        v: number;
+        tileIndex: number;
+        imageType: "latest" | "legacy";
+        version: string;
+    } | undefined;
     makeNewAtlas(version: string, getCustomImage?: (itemName: string) => DataUrl | HTMLImageElement | boolean | void, _unusedTileSize?: number, getTextureSortRankOrTopTextures?: string[] | ((key: string) => number), addTextures?: string[]): Promise<{
         canvas: HTMLCanvasElement;
         atlas: import("./atlasCreator").JsonAtlas;

package/dist/itemsRenderer.js

@@ -101,14 +101,37 @@ export class ItemsRenderer {
         let model;
         {
             model = resolveModel(cleanFullModelPath);
-            if (!exactItemResolve) {
-                model ??= resolveModel(itemModelPath);
+            if (!exactItemResolve && !model) {
+                // todo resolve deep!
+                const itemModel = resolveModel(itemModelPath);
+                if (itemModel && itemModel.textures?.layer0) {
+                    model = itemModel;
+                }
             }
             let blockModel = model?.parent?.includes('block/');
             if (!model) {
-                model = resolveModel(blockModelPath);
-                if (model)
-                    blockModel = true;
+                if (onlyResolveBlockModel && !namespace) {
+                    const [resolvedModel] = this.assetsParser.getResolvedModelFirst({ name: name, properties: {} }, true) ?? [];
+                    if (resolvedModel) {
+                        return {
+                            resolvedModel,
+                            get top() {
+                                throw new Error('Was called with onlyResolveBlockModel = true');
+                            },
+                            get left() {
+                                throw new Error('Was called with onlyResolveBlockModel = true');
+                            },
+                            get right() {
+                                throw new Error('Was called with onlyResolveBlockModel = true');
+                            }
+                        };
+                    }
+                }
+                else {
+                    model = resolveModel(blockModelPath);
+                    if (model)
+                        blockModel = true;
+                }
             }
             if (blockModel || model?.elements) {
                 return onlyResolveBlockModel ? this.resolveBlockModel(model, cleanFullModelPath) : this.tryGetFullBlock(model, cleanFullModelPath);

package/dist/itemsRenderer.test.js

@@ -12,8 +12,8 @@ describe('ItemsRenderer', () => {
     const blocksAtlasParser = new AtlasParser(blocksAtlases, '');
     const version = '1.21.4';
     const renderer = new ItemsRenderer(version, blockstatesModels, itemsAtlasParser, blocksAtlasParser);
-    const getItemTexture = (item) => {
-        const result = renderer.getItemTexture(item);
+    const getItemTexture = (item, onlyBlockModel = false) => {
+        const result = renderer.getItemTexture(item, undefined, undefined, onlyBlockModel);
         if (!result)
             return result;
         const replaceSliceDeep = (obj) => {
@@ -23,6 +23,13 @@ describe('ItemsRenderer', () => {
                 obj.slice = obj['slice'].length === 4;
             Object.values(obj).forEach(replaceSliceDeep);
         };
+        if (onlyBlockModel) {
+            delete result['top'];
+            delete result['bottom'];
+            delete result['right'];
+            delete result['left'];
+            result['textures'] = result['resolvedModel']['textures'];
+        }
         replaceSliceDeep(result);
         result['resolvedModel'] = !!result['resolvedModel'];
         return result;
@@ -92,6 +99,18 @@ describe('ItemsRenderer', () => {
               }
             `);
         });
+        it('chest', () => {
+            expect(getItemTexture('chest')).toMatchInlineSnapshot(`undefined`);
+            expect(getItemTexture('chest', true)).toMatchInlineSnapshot(`
+              {
+                "resolvedModel": true,
+                "textures": {
+                  "chest": "block/entity/chest/normal",
+                  "particle": "block/birch_planks",
+                },
+              }
+            `);
+        });
         it('not implemented logic', () => {
             expect(getItemTexture('cut_copper_slab')).toMatchInlineSnapshot(`undefined`);
             expect(getItemTexture('bla_bla')).toMatchInlineSnapshot(`undefined`);

package/dist/versionedStore.d.ts

@@ -11,7 +11,7 @@ export declare class VersionedStore<T = string> {
     get versionsSorted(): string[];
     /** The order is important: from newest to oldest */
     push(version: string, key: string, data: T): void;
-    get(version: string, key: string, inclusive?: boolean): any;
+    get(version: string, key: string, inclusive?: boolean): T | undefined;
     semverToNumber(version: string): number;
     loadData(data: typeof this.data): void;
 }

package/dist/worldBlockProvider.d.ts

@@ -6,11 +6,11 @@ export default function worldBlockProvider(blockstatesModels: any, blocksAtlas:
             faces: {
                 [k: string]: {
                     texture: {
-                        u: any;
-                        v: any;
+                        u: number;
+                        v: number;
                         su: number;
                         sv: number;
-                        tileIndex: any;
+                        tileIndex: number;
                         debugName: string;
                     };
                     uv?: number[];
@@ -46,11 +46,11 @@ export default function worldBlockProvider(blockstatesModels: any, blocksAtlas:
             faces: {
                 [k: string]: {
                     texture: {
-                        u: any;
-                        v: any;
+                        u: number;
+                        v: number;
                         su: number;
                         sv: number;
-                        tileIndex: any;
+                        tileIndex: number;
                         debugName: string;
                     };
                     uv?: number[];
@@ -69,6 +69,15 @@ export default function worldBlockProvider(blockstatesModels: any, blocksAtlas:
             };
         }[];
     } & Omit<T, "textures" | "elements">;
-    getTextureInfo: (textureName: string) => any;
+    getTextureInfo: (textureName: string) => {
+        su: number;
+        sv: number;
+        getLoadedImage: () => Promise<HTMLImageElement>;
+        u: number;
+        v: number;
+        tileIndex: number;
+        imageType: "latest" | "legacy";
+        version: string;
+    } | undefined;
 };
 export type WorldBlockProvider = ReturnType<typeof worldBlockProvider>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mc-assets",
-  "version": "0.2.48",
+  "version": "0.2.50",
   "author": "Vitaly Turovsky <vital2580@icloud.com>",
   "license": "MIT",
   "files": [