@safe-engine/pixi 8.10.2 → 8.10.4

package/dist/packages/pixijs/src/spritesheet/__tests__/Spritesheet.test.js

@@ -1,203 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import path from 'path';
-import { Spritesheet } from '../Spritesheet';
-import { getAsset } from '@test-utils';
-import { ImageSource, Texture } from '~/rendering';
-describe('Spritesheet', () => {
-    let assets;
-    let validate;
-    let parseFrame;
-    beforeAll(() => {
-        assets = getAsset('spritesheet');
-        validate = (spritesheet, done) => {
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            spritesheet.parse().then((textures) => {
-                const id = 'goldmine_10_5.png';
-                const width = Math.floor(spritesheet.data.frames[id].frame.w);
-                const height = Math.floor(spritesheet.data.frames[id].frame.h);
-                expect(Object.keys(textures)).toHaveLength(5);
-                expect(Object.keys(spritesheet.textures)).toHaveLength(5);
-                expect(textures[id]).toBeInstanceOf(Texture);
-                expect(textures[id].width).toEqual(width / spritesheet.resolution);
-                expect(textures[id].height).toEqual(height / spritesheet.resolution);
-                expect(textures[id].defaultAnchor).toBeUndefined();
-                expect(spritesheet.animations.star).toBeArray();
-                expect(spritesheet.animations.star).toHaveLength(4);
-                expect(spritesheet.animations.star[0].defaultAnchor.x).toEqual(0.5);
-                expect(spritesheet.animations.star[0].defaultAnchor.y).toEqual(0.5);
-                spritesheet.destroy(true);
-                expect(spritesheet.textures).toBeNull();
-                expect(spritesheet.textureSource).toBeNull();
-                done();
-            });
-        };
-        parseFrame = (frameData, callback) => {
-            const data = {
-                frames: { frame: frameData },
-                meta: { scale: 1 },
-            };
-            const baseTexture = new Texture({
-                source: new ImageSource({ resource: document.createElement('canvas') })
-            });
-            // @ts-expect-error - hack
-            baseTexture.imageUrl = 'test.png';
-            const sheet = new Spritesheet(baseTexture, data);
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            sheet.parse().then(() => {
-                const { frame } = sheet.textures;
-                expect(frame).toBeInstanceOf(Texture);
-                callback(frame);
-                sheet.destroy(true);
-            });
-        };
-    });
-    it('should exist on PIXI', () => {
-        expect(Spritesheet).toBeInstanceOf(Function);
-        expect(Spritesheet.BATCH_SIZE).toBeNumber();
-    });
-    it('should create an instance', () => {
-        const baseTexture = new Texture();
-        const data = {
-            frames: {},
-            meta: {},
-        };
-        const spritesheet = new Spritesheet(baseTexture, data);
-        expect(spritesheet.data).toEqual(data);
-        expect(spritesheet.textureSource).toEqual(baseTexture.source);
-        expect(spritesheet.resolution).toEqual(1);
-        spritesheet.destroy(true);
-    });
-    it('should create an instance with options', () => {
-        const baseTexture = new Texture();
-        const data = {
-            frames: {},
-            meta: {},
-        };
-        const spritesheet = new Spritesheet({ texture: baseTexture, data });
-        expect(spritesheet.data).toEqual(data);
-        expect(spritesheet['_texture']).toEqual(baseTexture);
-        expect(spritesheet.resolution).toEqual(1);
-        spritesheet.destroy(true);
-    });
-    it('should create instance with scale resolution', () => new Promise((done) => __awaiter(void 0, void 0, void 0, function* () {
-        jest.setTimeout(10000);
-        const data = yield fetch(getAsset('spritesheet/building1.json')).then((res) => res.json());
-        const image = new Image();
-        image.src = path.join(assets, data.meta.image);
-        image.onload = () => {
-            const baseTexture = new Texture({ source: new ImageSource({ resource: image }) });
-            const spritesheet = new Spritesheet(baseTexture, data);
-            expect(data).toBeObject();
-            expect(data.meta.image).toEqual('building1.png');
-            expect(spritesheet.resolution).toEqual(0.5);
-            validate(spritesheet, done);
-        };
-    })));
-    // resolution is not being parsed, remains 1
-    it('should create instance with filename resolution', () => new Promise((done) => __awaiter(void 0, void 0, void 0, function* () {
-        const data = yield fetch(getAsset('spritesheet/building1@2x.json')).then((res) => res.json());
-        const image = new Image();
-        image.src = path.join(assets, data.meta.image);
-        image.onload = () => {
-            const baseTexture = new Texture({
-                source: new ImageSource({ resource: image, resolution: 1 })
-            });
-            const spritesheet = new Spritesheet(baseTexture, data /* , uri*/);
-            expect(data).toBeObject();
-            expect(data.meta.image).toEqual('building1@2x.png');
-            expect(spritesheet.textureSource.resolution).toEqual(2);
-            validate(spritesheet, done);
-        };
-    })));
-    it('should parse full data untrimmed', () => new Promise((done) => {
-        const data = {
-            frame: { x: 0, y: 0, w: 14, h: 16 },
-            rotated: false,
-            trimmed: false,
-            spriteSourceSize: { x: 0, y: 0, w: 14, h: 16 },
-            sourceSize: { w: 14, h: 16 },
-        };
-        parseFrame(data, (texture) => {
-            expect(texture.width).toEqual(14);
-            expect(texture.height).toEqual(16);
-            done();
-        });
-    }));
-    it('should parse texture from trimmed', () => new Promise((done) => {
-        const data = {
-            frame: { x: 0, y: 28, w: 14, h: 14 },
-            rotated: false,
-            trimmed: true,
-            spriteSourceSize: { x: 0, y: 0, w: 40, h: 20 },
-            sourceSize: { w: 40, h: 20 },
-        };
-        parseFrame(data, (texture) => {
-            expect(texture.width).toEqual(40);
-            expect(texture.height).toEqual(20);
-            done();
-        });
-    }));
-    it('should parse texture from minimal data', () => new Promise((done) => {
-        const data = { frame: { x: 0, y: 0, w: 14, h: 14 } };
-        parseFrame(data, (texture) => {
-            expect(texture.width).toEqual(14);
-            expect(texture.height).toEqual(14);
-            done();
-        });
-    }));
-    it('should parse texture without trimmed or sourceSize', () => new Promise((done) => {
-        const data = {
-            frame: { x: 0, y: 14, w: 14, h: 14 },
-            rotated: false,
-            trimmed: false,
-            spriteSourceSize: { x: 0, y: 0, w: 20, h: 30 },
-        };
-        parseFrame(data, (texture) => {
-            expect(texture.width).toEqual(14);
-            expect(texture.height).toEqual(14);
-            done();
-        });
-    }));
-    it('should parse as trimmed if spriteSourceSize is set', () => new Promise((done) => {
-        // shoebox format
-        const data = {
-            frame: { x: 0, y: 0, w: 14, h: 16 },
-            spriteSourceSize: { x: 0, y: 0, w: 120, h: 100 },
-            sourceSize: { w: 120, h: 100 },
-        };
-        parseFrame(data, (texture) => {
-            expect(texture.width).toEqual(120);
-            expect(texture.height).toEqual(100);
-            done();
-        });
-    }));
-    it('should parse scale correctly', () => {
-        [
-            {
-                frames: {},
-                meta: { scale: '1' } // scale can be a string
-            },
-            {
-                frames: {},
-                meta: { scale: 1 } // scale can be a number
-            },
-            {
-                frames: {},
-                meta: {} // if scale not set, default to 1
-            },
-        ].forEach((toTest) => {
-            const baseTexture = new Texture();
-            const spritesheet = new Spritesheet(baseTexture, toTest);
-            expect(spritesheet.resolution).toEqual(1);
-            spritesheet.destroy(true);
-        });
-    });
-});

package/dist/packages/pixijs/src/spritesheet/__tests__/spritesheetAsset.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=spritesheetAsset.test.d.ts.map

package/dist/packages/pixijs/src/spritesheet/__tests__/spritesheetAsset.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"spritesheetAsset.test.d.ts","sourceRoot":"","sources":["../../../../../../packages/pixijs/src/spritesheet/__tests__/spritesheetAsset.test.ts"],"names":[],"mappings":""}

package/dist/packages/pixijs/src/spritesheet/__tests__/spritesheetAsset.test.js

@@ -1,171 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { Spritesheet } from '../Spritesheet';
-import { spritesheetAsset } from '../spritesheetAsset';
-import { basePath } from '@test-utils';
-import { Cache, Loader, loadJson, loadSvg, loadTextures } from '~/assets';
-import { Texture } from '~/rendering';
-describe('spritesheetAsset', () => {
-    let loader;
-    beforeEach(() => {
-        Cache.reset();
-        loader.reset();
-    });
-    beforeAll(() => {
-        loader = new Loader();
-        loader['_parsers'].push(loadJson, loadTextures, spritesheetAsset.loader, loadSvg);
-    });
-    it('should load a spritesheet', () => __awaiter(void 0, void 0, void 0, function* () {
-        const spriteSheet = yield loader.load(`${basePath}spritesheet/spritesheet.json`);
-        const bunnyTexture = spriteSheet.textures['bunny.png'];
-        const senseiTexture = spriteSheet.textures['pic-sensei.jpg'];
-        expect(bunnyTexture).toBeInstanceOf(Texture);
-        expect(senseiTexture).toBeInstanceOf(Texture);
-        expect(bunnyTexture.width).toBe(7);
-        expect(bunnyTexture.height).toBe(10);
-        expect(senseiTexture.width).toBe(125);
-        expect(senseiTexture.height).toBe(125);
-    }));
-    it('should load a spritesheet with cachePrefix and cache parser', () => __awaiter(void 0, void 0, void 0, function* () {
-        const cacheParser = spritesheetAsset.cache;
-        Cache['_parsers'].push(cacheParser);
-        const src = `${basePath}spritesheet/spritesheet.json`;
-        const cachePrefix = 'spritesheet.json/';
-        const data = { cachePrefix };
-        const spriteSheet = yield loader.load({ src, data });
-        Cache.set('spritesheet.json', spriteSheet);
-        const bunnyTexture = spriteSheet.textures['bunny.png'];
-        const senseiTexture = spriteSheet.textures['pic-sensei.jpg'];
-        const cacheTexture1 = Cache.get(`${cachePrefix}bunny.png`);
-        const cacheTexture2 = Cache.get(`${cachePrefix}pic-sensei.jpg`);
-        expect(cacheTexture1).toBeDefined();
-        expect(cacheTexture2).toBeDefined();
-        expect(cacheTexture1).toBe(bunnyTexture);
-        expect(cacheTexture2).toBe(senseiTexture);
-        Cache['_parsers'].splice(Cache['_parsers'].indexOf(cacheParser), 1);
-        yield loader.unload(src);
-    }));
-    it('should do nothing if the resource is not JSON', () => __awaiter(void 0, void 0, void 0, function* () {
-        const spriteSheet = yield loader.load('black.txt');
-        expect(spriteSheet).toBeNull();
-    }));
-    it('should do nothing if the resource is JSON, but improper format', () => __awaiter(void 0, void 0, void 0, function* () {
-        const spriteSheet = yield loader.load(`${basePath}json/test.json`);
-        expect(spriteSheet).not.toBeInstanceOf(Spritesheet);
-        expect(spriteSheet).toEqual({ testNumber: 23, testString: 'Test String 23' });
-    }));
-    it('should load a multi packed spritesheet', () => __awaiter(void 0, void 0, void 0, function* () {
-        Cache['_parsers'].push(spritesheetAsset.cache);
-        const spritesheet = yield loader.load(`${basePath}spritesheet/multi-pack-0.json`);
-        Cache.set('multi-pack-0.json', spritesheet);
-        const pack0 = Cache.get('star1.png');
-        const pack1 = Cache.get('goldmine_10_5.png');
-        expect(pack0).toBeInstanceOf(Texture);
-        expect(pack1).toBeInstanceOf(Texture);
-        expect(pack0.width).toBe(64);
-        expect(pack0.height).toBe(64);
-        expect(pack1.width).toBe(190);
-        expect(pack1.height).toBe(229);
-    }));
-    it('should not create multipack resources when related_multi_packs field is missing or the wrong type', () => __awaiter(void 0, void 0, void 0, function* () {
-        // clear the caches only to avoid cluttering the output
-        Cache.reset();
-        const spritesheet = yield loader.load(`${basePath}spritesheet/building1-1.json`);
-        const spritesheet2 = yield loader.load(`${basePath}spritesheet/atlas-multipack-wrong-type.json`);
-        const spritesheet3 = yield loader.load(`${basePath}spritesheet/atlas-multipack-wrong-array.json`);
-        expect(spritesheet.linkedSheets).toHaveLength(1);
-        expect(spritesheet2.linkedSheets).toHaveLength(0);
-        expect(spritesheet3.linkedSheets).toHaveLength(0);
-    }));
-    it('should unload a spritesheet', () => __awaiter(void 0, void 0, void 0, function* () {
-        const spriteSheet = yield loader.load(`${basePath}spritesheet/spritesheet.json`);
-        yield loader.unload(`${basePath}spritesheet/spritesheet.json`);
-        expect(spriteSheet.textureSource).toBe(null);
-    }));
-    it('should unload and reload spritesheet', () => __awaiter(void 0, void 0, void 0, function* () {
-        const spriteSheet = yield loader.load(`${basePath}spritesheet/spritesheet.json`);
-        yield loader.unload(`${basePath}spritesheet/spritesheet.json`);
-        const textureSource = spriteSheet.textureSource;
-        const spriteSheetReloaded = yield loader.load(`${basePath}spritesheet/spritesheet.json`);
-        expect(spriteSheetReloaded.textureSource).not.toBe(textureSource);
-    }));
-    it('should parse a string sprite sheet correctly', () => {
-        [
-            {
-                url: 'my-sprite-sheet.json',
-                pass: false,
-            },
-            {
-                url: 'my-sprite-sheet@0.5x.webp.json',
-                pass: true,
-                result: {
-                    format: 'webp',
-                    resolution: 0.5,
-                    src: 'my-sprite-sheet@0.5x.webp.json',
-                },
-            },
-            {
-                url: 'my-sprite-sheet@2x.png.json',
-                pass: true,
-                result: {
-                    format: 'png',
-                    resolution: 2,
-                    src: 'my-sprite-sheet@2x.png.json',
-                },
-            },
-            {
-                url: 'my-sprite-sheet@2x.json',
-                pass: false,
-            },
-        ].forEach((toTest) => {
-            const pass = spritesheetAsset.resolver.test(toTest.url);
-            expect(pass).toBe(toTest.pass);
-            if (pass) {
-                expect(spritesheetAsset.resolver.parse(toTest.url)).toEqual(toTest.result);
-            }
-        });
-    });
-    it('should use preloaded texture via data.texture instead of loading texture using imagePath', () => __awaiter(void 0, void 0, void 0, function* () {
-        const spritesheetJsonUrl = `${basePath}spritesheet/spritesheet.json`;
-        const preloadedTexture = new Texture();
-        const json = yield loadJson.load(spritesheetJsonUrl);
-        const spritesheet = yield spritesheetAsset.loader.parse(json, {
-            src: spritesheetJsonUrl,
-            data: { texture: preloadedTexture }
-        });
-        expect(spritesheet.textureSource).toEqual(preloadedTexture.source);
-    }));
-    it('should use image filename via data.imageFilename instead of meta.image', () => __awaiter(void 0, void 0, void 0, function* () {
-        const spritesheetJsonUrl = `${basePath}spritesheet/spritesheet.json`;
-        const customImageFilename = 'multi-pack-1.png';
-        const json = yield loadJson.load(spritesheetJsonUrl);
-        const spritesheet = yield spritesheetAsset.loader.parse(json, {
-            src: spritesheetJsonUrl,
-            data: { imageFilename: customImageFilename }
-        }, loader);
-        const texture = yield loader.load({ src: `${basePath}spritesheet/${customImageFilename}` });
-        expect(spritesheet.textureSource).toEqual(texture.source);
-    }));
-    it('should load a spritesheet where the json file points to an svg', () => __awaiter(void 0, void 0, void 0, function* () {
-        const spriteSheet = yield loader.load(`${basePath}spritesheet/svgSpritesheet.json`);
-        const t1 = spriteSheet.textures['pic1'];
-        const t2 = spriteSheet.textures['pic2'];
-        const t3 = spriteSheet.textures['pic3'];
-        expect(t1).toBeInstanceOf(Texture);
-        expect(t2).toBeInstanceOf(Texture);
-        expect(t3).toBeInstanceOf(Texture);
-        expect(t1.width).toBe(150);
-        expect(t1.height).toBe(150);
-        expect(t2.width).toBe(200);
-        expect(t2.height).toBe(200);
-        expect(t3.width).toBe(210);
-        expect(t3.height).toBe(210);
-    }));
-});

package/dist/packages/pixijs/src/spritesheet/index.d.ts

@@ -1,3 +0,0 @@
-export * from './Spritesheet';
-export * from './spritesheetAsset';
-//# sourceMappingURL=index.d.ts.map

package/dist/packages/pixijs/src/spritesheet/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/pixijs/src/spritesheet/index.ts"],"names":[],"mappings":"AACA,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC"}

package/dist/packages/pixijs/src/spritesheet/index.js

@@ -1,3 +0,0 @@
-// Auto-generated code, do not edit manually
-export * from './Spritesheet';
-export * from './spritesheetAsset';

package/dist/packages/pixijs/src/spritesheet/init.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=init.d.ts.map

package/dist/packages/pixijs/src/spritesheet/init.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../packages/pixijs/src/spritesheet/init.ts"],"names":[],"mappings":""}

package/dist/packages/pixijs/src/spritesheet/init.js

@@ -1,3 +0,0 @@
-import { extensions } from '../extensions/Extensions';
-import { spritesheetAsset } from './spritesheetAsset';
-extensions.add(spritesheetAsset);

package/dist/packages/pixijs/src/spritesheet/spritesheetAsset.d.ts

@@ -1,90 +0,0 @@
-import { LoaderParserPriority } from '../assets/loader/parsers/LoaderParser';
-import { ExtensionType } from '../extensions/Extensions';
-import { Texture } from '../rendering/renderers/shared/texture/Texture';
-import { Spritesheet } from './Spritesheet';
-import type { Loader } from '../assets/loader/Loader';
-import type { ResolvedAsset } from '../assets/types';
-import type { TextureSourceOptions } from '../rendering/renderers/shared/texture/sources/TextureSource';
-import type { SpritesheetData } from './Spritesheet';
-/**
- * Interface for the JSON data structure of a spritesheet.
- * This is used to define the structure of the JSON file that describes a spritesheet.
- * It includes metadata about the spritesheet and the frames it contains.
- * @see {@link Spritesheet}
- * @see {@link SpritesheetData}
- * @category assets
- * @advanced
- */
-export interface SpriteSheetJson extends SpritesheetData {
-    meta: {
-        image: string;
-        scale: string;
-        related_multi_packs?: string[];
-    };
-}
-/**
- * Asset extension for loading spritesheets
- * @example
- * import { Assets } from 'pixi.js';
- *
- * Assets.load({
- *     alias: 'spritesheet',
- *     src: 'path/to/spritesheet.json',
- *     data: {
- *         ignoreMultiPack: true,
- *         textureOptions: {
- *             scaleMode: "nearest"
- *         }
- *     }
- * })
- * @type {AssetExtension}
- * @category assets
- * @advanced
- */
-export declare const spritesheetAsset: {
-    extension: ExtensionType.Asset;
-    /** Handle the caching of the related Spritesheet Textures */
-    cache: {
-        test: (asset: Spritesheet) => boolean;
-        getCacheableAssets: (keys: string[], asset: Spritesheet) => Record<string, any>;
-    };
-    /** Resolve the resolution of the asset. */
-    resolver: {
-        extension: {
-            type: ExtensionType.ResolveParser;
-            name: string;
-        };
-        test: (value: string) => boolean;
-        parse: (value: string) => {
-            resolution: number;
-            format: string;
-            src: string;
-        };
-    };
-    /**
-     * Loader plugin that parses sprite sheets!
-     * once the JSON has been loaded this checks to see if the JSON is spritesheet data.
-     * If it is, we load the spritesheets image and parse the data into Spritesheet
-     * All textures in the sprite sheet are then added to the cache
-     */
-    loader: {
-        /** used for deprecation purposes */
-        name: string;
-        id: string;
-        extension: {
-            type: ExtensionType.LoadParser;
-            priority: LoaderParserPriority;
-            name: string;
-        };
-        testParse(asset: SpriteSheetJson, options: ResolvedAsset): Promise<boolean>;
-        parse<T>(asset: SpriteSheetJson, options: ResolvedAsset<{
-            texture?: Texture;
-            imageFilename?: string;
-            ignoreMultiPack?: boolean;
-            textureOptions?: TextureSourceOptions;
-            cachePrefix?: string;
-        }>, loader?: Loader): Promise<Spritesheet>;
-        unload(spritesheet: Spritesheet, _resolvedAsset: ResolvedAsset<any>, loader: Loader): Promise<void>;
-    };
-};
-//# sourceMappingURL=spritesheetAsset.d.ts.map

package/dist/packages/pixijs/src/spritesheet/spritesheetAsset.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"spritesheetAsset.d.ts","sourceRoot":"","sources":["../../../../../packages/pixijs/src/spritesheet/spritesheetAsset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAG7E,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,+CAA+C,CAAC;AAExE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6DAA6D,CAAC;AACxG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAgB,SAAQ,eAAe;IAEpD,IAAI,EAAE;QACF,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;KAClC,CAAC;CACL;AAkCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gBAAgB;;IAEzB,6DAA6D;;sBAE3C,WAAW;mCACE,MAAM,EAAE,SAAS,WAAW;;IAE3D,2CAA2C;;;;;;sBAMzB,MAAM,KAAG,OAAO;uBASf,MAAM;;;;;;IAWzB;;;;;OAKG;;QAEC,oCAAoC;;;;;;;;yBAUb,eAAe,WAAW,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC;wBAMtE,eAAe,WACb,aAAa,CAAC;YACnB,OAAO,CAAC,EAAE,OAAO,CAAC;YAClB,aAAa,CAAC,EAAE,MAAM,CAAC;YACvB,eAAe,CAAC,EAAE,OAAO,CAAC;YAC1B,cAAc,CAAC,EAAE,oBAAoB,CAAC;YACtC,WAAW,CAAC,EAAE,MAAM,CAAC;SACxB,CAAC,WACO,MAAM,GAChB,OAAO,CAAC,WAAW,CAAC;4BAqFG,WAAW;;CAO6C,CAAC"}

package/dist/packages/pixijs/src/spritesheet/spritesheetAsset.js

@@ -1,171 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { LoaderParserPriority } from '../assets/loader/parsers/LoaderParser';
-import { Resolver } from '../assets/resolver/Resolver';
-import { copySearchParams } from '../assets/utils/copySearchParams';
-import { ExtensionType } from '../extensions/Extensions';
-import { Texture } from '../rendering/renderers/shared/texture/Texture';
-import { path } from '../utils/path';
-import { Spritesheet } from './Spritesheet';
-const validImages = ['jpg', 'png', 'jpeg', 'avif', 'webp',
-    'basis', 'etc2', 'bc7', 'bc6h', 'bc5', 'bc4', 'bc3', 'bc2', 'bc1', 'eac', 'astc'];
-function getCacheableAssets(keys, asset, ignoreMultiPack) {
-    const out = {};
-    keys.forEach((key) => {
-        out[key] = asset;
-    });
-    Object.keys(asset.textures).forEach((key) => {
-        out[`${asset.cachePrefix}${key}`] = asset.textures[key];
-    });
-    if (!ignoreMultiPack) {
-        const basePath = path.dirname(keys[0]);
-        asset.linkedSheets.forEach((item, i) => {
-            const out2 = getCacheableAssets([`${basePath}/${asset.data.meta.related_multi_packs[i]}`], item, true);
-            Object.assign(out, out2);
-        });
-    }
-    return out;
-}
-/**
- * Asset extension for loading spritesheets
- * @example
- * import { Assets } from 'pixi.js';
- *
- * Assets.load({
- *     alias: 'spritesheet',
- *     src: 'path/to/spritesheet.json',
- *     data: {
- *         ignoreMultiPack: true,
- *         textureOptions: {
- *             scaleMode: "nearest"
- *         }
- *     }
- * })
- * @type {AssetExtension}
- * @category assets
- * @advanced
- */
-export const spritesheetAsset = {
-    extension: ExtensionType.Asset,
-    /** Handle the caching of the related Spritesheet Textures */
-    cache: {
-        test: (asset) => asset instanceof Spritesheet,
-        getCacheableAssets: (keys, asset) => getCacheableAssets(keys, asset, false),
-    },
-    /** Resolve the resolution of the asset. */
-    resolver: {
-        extension: {
-            type: ExtensionType.ResolveParser,
-            name: 'resolveSpritesheet',
-        },
-        test: (value) => {
-            const tempURL = value.split('?')[0];
-            const split = tempURL.split('.');
-            const extension = split.pop();
-            const format = split.pop();
-            return extension === 'json' && validImages.includes(format);
-        },
-        parse: (value) => {
-            var _a, _b;
-            const split = value.split('.');
-            return {
-                resolution: parseFloat((_b = (_a = Resolver.RETINA_PREFIX.exec(value)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : '1'),
-                format: split[split.length - 2],
-                src: value,
-            };
-        },
-    },
-    /**
-     * Loader plugin that parses sprite sheets!
-     * once the JSON has been loaded this checks to see if the JSON is spritesheet data.
-     * If it is, we load the spritesheets image and parse the data into Spritesheet
-     * All textures in the sprite sheet are then added to the cache
-     */
-    loader: {
-        /** used for deprecation purposes */
-        name: 'spritesheetLoader',
-        id: 'spritesheet',
-        extension: {
-            type: ExtensionType.LoadParser,
-            priority: LoaderParserPriority.Normal,
-            name: 'spritesheetLoader',
-        },
-        testParse(asset, options) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return (path.extname(options.src).toLowerCase() === '.json' && !!asset.frames);
-            });
-        },
-        parse(asset, options, loader) {
-            return __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c;
-                const { texture: imageTexture, // if user need to use preloaded texture
-                imageFilename, // if user need to use custom filename (not from jsonFile.meta.image)
-                textureOptions, // if user need to set texture options on texture
-                cachePrefix, // if user need to use custom cache prefix
-                 } = (_a = options === null || options === void 0 ? void 0 : options.data) !== null && _a !== void 0 ? _a : {};
-                let basePath = path.dirname(options.src);
-                if (basePath && basePath.lastIndexOf('/') !== (basePath.length - 1)) {
-                    basePath += '/';
-                }
-                let texture;
-                if (imageTexture instanceof Texture) {
-                    texture = imageTexture;
-                }
-                else {
-                    const imagePath = copySearchParams(basePath + (imageFilename !== null && imageFilename !== void 0 ? imageFilename : asset.meta.image), options.src);
-                    const assets = yield loader.load([{ src: imagePath, data: textureOptions }]);
-                    texture = assets[imagePath];
-                }
-                const spritesheet = new Spritesheet({
-                    texture: texture.source,
-                    data: asset,
-                    cachePrefix
-                });
-                yield spritesheet.parse();
-                // Check and add the multi atlas
-                // Heavily influenced and based on https://github.com/rocket-ua/pixi-tps-loader/blob/master/src/ResourceLoader.js
-                const multiPacks = (_b = asset === null || asset === void 0 ? void 0 : asset.meta) === null || _b === void 0 ? void 0 : _b.related_multi_packs;
-                if (Array.isArray(multiPacks)) {
-                    const promises = [];
-                    for (const item of multiPacks) {
-                        if (typeof item !== 'string') {
-                            continue;
-                        }
-                        let itemUrl = basePath + item;
-                        // Check if the file wasn't already added as multipack
-                        if ((_c = options.data) === null || _c === void 0 ? void 0 : _c.ignoreMultiPack) {
-                            continue;
-                        }
-                        itemUrl = copySearchParams(itemUrl, options.src);
-                        promises.push(loader.load({
-                            src: itemUrl,
-                            data: {
-                                textureOptions,
-                                ignoreMultiPack: true,
-                            }
-                        }));
-                    }
-                    const res = yield Promise.all(promises);
-                    spritesheet.linkedSheets = res;
-                    res.forEach((item) => {
-                        item.linkedSheets = [spritesheet].concat(spritesheet.linkedSheets.filter((sp) => (sp !== item)));
-                    });
-                }
-                return spritesheet;
-            });
-        },
-        unload(spritesheet, _resolvedAsset, loader) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield loader.unload(spritesheet.textureSource._sourceOrigin);
-                spritesheet.destroy(false);
-            });
-        },
-    }
-};