@safe-engine/pixi 8.4.1 → 8.4.2

package/src/norender/NoRenderComponent.ts

@@ -1,13 +1,13 @@
-import { FederatedPointerEvent } from 'pixi.js'
 import { NoRenderComponentX } from '../components/BaseComponent'
 import { EventCallbackType, EventMap, NodeComp } from '../components/NodeComp'
+import { Touch } from './Touch'
 
 // export class Touch extends FederatedPointerEvent {
 // declare getLocation: () => Vec2
 // declare getDelta: () => Vec2
 // }
 
-export type TouchEventCallback = (touch?: FederatedPointerEvent, node?: NodeComp) => void
+export type TouchEventCallback = (touch?: Touch, node?: NodeComp) => void
 
 export class EventRegister extends NoRenderComponentX {
   events: EventMap = {}

package/src/norender/NoRenderSystem.ts

@@ -1,13 +1,14 @@
 import { EventManager, EventTypes, System } from 'entityx-ts'
-
 // import { Touch } from '../../polyfills'
 import { Container } from 'pixi.js'
+
 import { NodeComp } from '../components/NodeComp'
 import { ExtraDataComp, TouchEventRegister } from './NoRenderComponent'
+import { Touch } from './Touch'
 
 export class NoRenderSystem implements System {
   configure(event_manager: EventManager) {
-    event_manager.subscribe(EventTypes.ComponentAdded, ExtraDataComp, ({ entity, component }) => {
+    event_manager.subscribe(EventTypes.ComponentAdded, ExtraDataComp, ({ component }) => {
       const { key, value } = component.props
       component.data[key] = value
     })
@@ -19,26 +20,26 @@ export class NoRenderSystem implements System {
       const container: Container = nodeComp.instance
       if (touchComp.props.onTouchStart) {
         container.on('pointerdown', (event) => {
-          touchComp.props.onTouchStart(event, nodeComp)
-        });
+          touchComp.props.onTouchStart(new Touch(event), nodeComp)
+        })
       }
       if (touchComp.props.onTouchMove) {
         container.on('pointermove', (event) => {
-          touchComp.props.onTouchMove(event, nodeComp)
-        });
+          touchComp.props.onTouchMove(new Touch(event), nodeComp)
+        })
       }
       if (touchComp.props.onTouchEnd) {
         container.on('pointerup', (event) => {
-          touchComp.props.onTouchEnd(event, nodeComp)
-        });
+          touchComp.props.onTouchEnd(new Touch(event), nodeComp)
+        })
       }
       if (touchComp.props.onTouchEnd) {
         container.on('pointercancel', (event) => {
-          touchComp.props.onTouchEnd(event, nodeComp)
-        });
+          touchComp.props.onTouchEnd(new Touch(event), nodeComp)
+        })
       }
     })
-    event_manager.subscribe(EventTypes.ComponentRemoved, TouchEventRegister, ({ entity, component }) => {
+    event_manager.subscribe(EventTypes.ComponentRemoved, TouchEventRegister, ({ component }) => {
       console.log('ComponentRemovedEvent TouchEventRegister', event)
       // const ett = event.entity
       // const nodeComp = ett.getComponent(NodeComp)

package/src/norender/Touch.ts

@@ -0,0 +1,37 @@
+import { FederatedPointerEvent } from 'pixi.js'
+
+import { Vec2 } from '..'
+
+export class Touch {
+  private event: FederatedPointerEvent
+  constructor(event) {
+    this.event = event
+  }
+
+  getLocation() {
+    return this.event.global
+  }
+  getLocationX() {
+    return this.event.globalX
+  }
+  getLocationY() {
+    return this.event.globalY
+  }
+  getDelta() {
+    return Vec2(this.event.movementX, this.event.movementY)
+  }
+  getDeltaX() {
+    return this.event.movementX
+  }
+  getDeltaY() {
+    return this.event.movementY
+  }
+  getLocationInView(view: any) {
+    const { x, y } = this.event.global
+    return view.toLocal({ x, y })
+  }
+  getLocationInNode(node: any) {
+    const { x, y } = this.event.global
+    return node.toLocal({ x, y })
+  }
+}

package/src/render/RenderComponent.ts

@@ -1,4 +1,4 @@
-import { Graphics, Point, Sprite, Texture } from 'pixi.js'
+import { Graphics, Sprite, Texture } from 'pixi.js'
 
 import { Color4B, Vec2 } from '..'
 import { ComponentX } from '../components/BaseComponent'
@@ -59,22 +59,17 @@ export class SpriteRender extends ComponentX<SpriteRenderProps & { $ref?: Sprite
 enum PointType {
   Circle,
   Rect,
-};
+}
 interface GraphicsRenderProps {
   lineWidth?: number
   strokeColor?: Color4B
   fillColor?: Color4B
 }
 export class GraphicsRender extends ComponentX<GraphicsRenderProps & { $ref?: GraphicsRender }, Graphics> {
-
-  drawPoint(position: Vec2, pointSize: Float, color: Color4B, pointType = PointType.Rect) {
-
-  }
+  drawPoint(position: Vec2, pointSize: Float, color: Color4B, pointType = PointType.Rect) {}
   // drawPoints(points: Vec2[], color: Color4B) {
   // }
-  drawLine(origin: Vec2, destination: Vec2, color: Color4B, thickness: Float) {
-
-  }
+  drawLine(origin: Vec2, destination: Vec2, color: Color4B, thickness: Float) {}
   drawRect(origin: Vec2, destination: Vec2, color: Color4B) {
     const { x, y } = origin
     const width = destination.x - x
@@ -82,44 +77,43 @@ export class GraphicsRender extends ComponentX<GraphicsRenderProps & { $ref?: Gr
     this.node.instance.rect(x, y, width, height)
     this.node.instance.fill(color)
   }
-  drawSolidRect(origin: Vec2, destination: Vec2, color: Color4B) {
-
-  }
-  drawCircle(center: Vec2, radius: Float, angle?: Float, segments?: Integer, drawLineToCenter?: boolean, scaleX?: Float, scaleY?: Float, color?: Color4B, thickness?: Float) {
+  drawSolidRect(origin: Vec2, destination: Vec2, color: Color4B) {}
+  drawCircle(
+    center: Vec2,
+    radius: Float,
+    angle?: Float,
+    segments?: Integer,
+    drawLineToCenter?: boolean,
+    scaleX?: Float,
+    scaleY?: Float,
+    color?: Color4B,
+    thickness?: Float,
+  ) {
     const { x, y } = center
     this.node.instance.circle(x, y, radius)
     this.node.instance.fill(color)
   }
-  drawSolidCircle(origin: Vec2, destination: Vec2, color: Color4B) {
-
-  }
-  drawQuadBezier(origin: Vec2, destination: Vec2, color: Color4B) {
-
-  }
-  drawCubicBezier(origin: Vec2, destination: Vec2, color: Color4B) {
-
-  }
-  drawCardinalSpline(points: Vec2[], color: Color4B) {
-  }
-  drawCatmullRom(points: Vec2[], color: Color4B) {
-  }
-  drawPoly(points: Vec2[], closedPolygon: boolean, color: Color4B, thickness?: Float) {
-    this.node.instance.poly(points, closedPolygon)
-    this.node.instance.fill(color)
-  }
-  drawSolidPoly(points: Vec2[], color: Color4B) {
-  }
-  drawDot(points: Vec2[], color: Color4B) {
-  }
-  drawSegment(from: Point, to: Point, color?: Color4B) {
-    this.node.instance.moveTo(from.x, from.y);
-    this.node.instance.lineTo(to.x, to.y);
+  drawSolidCircle(origin: Vec2, destination: Vec2, color: Color4B) {}
+  drawQuadBezier(origin: Vec2, destination: Vec2, color: Color4B) {}
+  drawCubicBezier(origin: Vec2, destination: Vec2, color: Color4B) {}
+  drawCardinalSpline(points: Vec2[], color: Color4B) {}
+  drawCatmullRom(points: Vec2[], color: Color4B) {}
+  drawPoly(points: Vec2[], color?: Color4B, thickness?: Float) {
+    this.node.instance.poly(points, true)
+    this.node.instance.fill(color || this.props.fillColor)
+  }
+  drawSolidPoly(points: Vec2[], color: Color4B) {}
+  drawDot(points: Vec2[], color: Color4B) {}
+  drawSegment(from: Vec2, to: Vec2, thickness?: Float, color?: Color4B) {
+    this.node.instance.moveTo(from.x, from.y)
+    this.node.instance.lineTo(to.x, to.y)
     this.node.instance.strokeStyle = {
-      cap: 'round', join: 'round',
-      width: this.props.lineWidth || 36,
+      cap: 'round',
+      join: 'round',
+      width: thickness || this.props.lineWidth || 36,
       color: color || this.props.strokeColor,
     }
-    this.node.instance.stroke();
+    this.node.instance.stroke()
   }
   drawTriangle(p1: Vec2, p2: Vec2, p3: Vec2, color: Color4B) {
     this.node.instance.poly([p1, p2, p3], true)
@@ -135,4 +129,4 @@ interface MaskRenderProps {
   segments?: number
   inverted?: boolean
 }
-export class MaskRender extends ComponentX<MaskRenderProps> { }
+export class MaskRender extends ComponentX<MaskRenderProps> {}

package/src/render/RenderSystem.ts

@@ -1,8 +1,4 @@
-import {
-  EventManager,
-  EventTypes,
-  System
-} from 'entityx-ts'
+import { EventManager, EventTypes, System } from 'entityx-ts'
 import { Container, Graphics, Sprite } from 'pixi.js'
 
 import { NodeComp } from '..'
@@ -42,14 +38,14 @@ export class RenderSystem implements System {
       // component.node.anchorY = 0.5
     })
     event_manager.subscribe(EventTypes.ComponentAdded, MaskRender, ({ component }) => {
-      console.log('MaskRender', component);
+      console.log('MaskRender', component)
       // const { type, segments, inverted } = maskComp
       // const node = new cc.ClippingNode()
       // node.setInverted(inverted)
       // maskComp.node = ett.assign(new NodeComp(node, ett))
     })
     event_manager.subscribe(EventTypes.ComponentAdded, GraphicsRender, ({ entity, component }) => {
-      // const { lineWidth, strokeColor, fillColor } = component
+      // const { lineWidth, strokeColor, fillColor } = component.props
       // console.log('GraphicsRender', component);
       const node = new Graphics()
       component.node = entity.assign(new NodeComp(node, entity))

package/dist/helper/html-text-parser.d.ts

@@ -1,20 +0,0 @@
-interface FontTag {
-    color?: string;
-    size?: number;
-    text: string;
-}
-type ParsedResult = FontTag[];
-type StyledElement = {
-    tag?: string;
-    style?: {
-        color?: string;
-        size?: number;
-    };
-    text: string;
-};
-export declare function parseFontString(input: string): ParsedResult;
-export declare function transformToStyledElements(parsed: ParsedResult): StyledElement[];
-export declare function generateStringFromStyledElements(elements: StyledElement[]): string;
-export declare function generateStylesFromStyledElements(elements: StyledElement[]): {};
-export {};
-//# sourceMappingURL=html-text-parser.d.ts.map

package/dist/helper/html-text-parser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"html-text-parser.d.ts","sourceRoot":"","sources":["../../src/helper/html-text-parser.ts"],"names":[],"mappings":"AAAA,UAAU,OAAO;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAED,KAAK,YAAY,GAAG,OAAO,EAAE,CAAC;AAE9B,KAAK,aAAa,GAAG;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAiC3D;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,YAAY,GAAG,aAAa,EAAE,CAa/E;AAED,wBAAgB,gCAAgC,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,MAAM,CASlF;AAED,wBAAgB,gCAAgC,CAAC,QAAQ,EAAE,aAAa,EAAE,MAWzE"}

package/dist/helper/html-text-parser.js

@@ -1,64 +0,0 @@
-export function parseFontString(input) {
-    const regex = /<font\s+color=['"](#?[0-9a-fA-F]{6})['"](?:\s+size=(\d+))?>(.*?)<\/font>/gi;
-    const results = [];
-    let lastIndex = 0;
-    let match;
-    while ((match = regex.exec(input)) !== null) {
-        // Add plain text before the match if it exists
-        if (match.index > lastIndex) {
-            const plainText = input.slice(lastIndex, match.index);
-            if (plainText) {
-                results.push({ text: plainText });
-            }
-        }
-        const color = match[1];
-        const size = match[2] ? parseInt(match[2], 10) : undefined;
-        const text = match[3];
-        results.push({ color, size, text });
-        lastIndex = regex.lastIndex;
-    }
-    // Add remaining plain text after the last match
-    if (lastIndex < input.length) {
-        const plainText = input.slice(lastIndex);
-        if (plainText) {
-            results.push({ text: plainText });
-        }
-    }
-    return results;
-}
-export function transformToStyledElements(parsed) {
-    return parsed.map((item, index) => {
-        if (item.color || item.size) {
-            return {
-                tag: `b${index + 1}`,
-                style: { color: item.color, size: item.size },
-                text: item.text,
-            };
-        }
-        return {
-            text: item.text,
-        };
-    });
-}
-export function generateStringFromStyledElements(elements) {
-    return elements
-        .map((element) => {
-        if (!element.tag) {
-            return element.text;
-        }
-        return `<${element.tag}>${element.text}</${element.tag}>`;
-    })
-        .join('');
-}
-export function generateStylesFromStyledElements(elements) {
-    const styles = {};
-    elements
-        .forEach((element) => {
-        const { tag, style } = element;
-        if (!tag) {
-            return;
-        }
-        styles[element.tag] = style;
-    });
-    return styles;
-}

package/dist/spine/lib/assets/atlasLoader.d.ts

@@ -1,34 +0,0 @@
-/** ****************************************************************************
- * Spine Runtimes License Agreement
- * Last updated July 28, 2023. Replaces all prior versions.
- *
- * Copyright (c) 2013-2023, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software or
- * otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
- * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-import { TextureSource } from 'pixi.js';
-export interface ISpineAtlasMetadata {
-    imageMetadata?: any;
-    images?: TextureSource | string | Record<string, TextureSource | string>;
-}
-//# sourceMappingURL=atlasLoader.d.ts.map

package/dist/spine/lib/assets/atlasLoader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"atlasLoader.d.ts","sourceRoot":"","sources":["../../../../src/spine/lib/assets/atlasLoader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;+EA2B+E;AAE/E,OAAO,EAQN,aAAa,EACb,MAAM,SAAS,CAAC;AAiHjB,MAAM,WAAW,mBAAmB;IAEnC,aAAa,CAAC,EAAE,GAAG,CAAC;IAGpB,MAAM,CAAC,EAAE,aAAa,GAAG,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAAC,CAAC;CACzE"}

package/dist/spine/lib/assets/atlasLoader.js

@@ -1,122 +0,0 @@
-/** ****************************************************************************
- * Spine Runtimes License Agreement
- * Last updated July 28, 2023. Replaces all prior versions.
- *
- * Copyright (c) 2013-2023, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software or
- * otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
- * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-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 { checkExtension, DOMAdapter, extensions, ExtensionType, LoaderParserPriority, path, Resolver, TextureSource } from 'pixi.js';
-import { SpineTexture } from '../SpineTexture.js';
-import { TextureAtlas } from '@esotericsoftware/spine-core';
-const spineTextureAtlasLoader = {
-    extension: ExtensionType.Asset,
-    resolver: {
-        test: (value) => checkExtension(value, ".atlas"),
-        parse: (value) => {
-            var _a, _b, _c;
-            const split = value.split('.');
-            return {
-                resolution: parseFloat((_c = (_b = (_a = Resolver.RETINA_PREFIX) === null || _a === void 0 ? void 0 : _a.exec(value)) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : '1'),
-                format: split[split.length - 2],
-                src: value,
-            };
-        },
-    },
-    loader: {
-        extension: {
-            type: ExtensionType.LoadParser,
-            priority: LoaderParserPriority.Normal,
-            name: 'spineTextureAtlasLoader',
-        },
-        test(url) {
-            return checkExtension(url, '.atlas');
-        },
-        load(url) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const response = yield DOMAdapter.get().fetch(url);
-                const txt = yield response.text();
-                return txt;
-            });
-        },
-        testParse(asset, options) {
-            const isExtensionRight = checkExtension(options.src, '.atlas');
-            const isString = typeof asset === 'string';
-            return Promise.resolve(isExtensionRight && isString);
-        },
-        unload(atlas) {
-            atlas.dispose();
-        },
-        parse(asset, options, loader) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const metadata = options.data || {};
-                let basePath = path.dirname(options.src);
-                if (basePath && basePath.lastIndexOf('/') !== basePath.length - 1) {
-                    basePath += '/';
-                }
-                // Retval is going to be a texture atlas. However we need to wait for it's callback to resolve this promise.
-                const retval = new TextureAtlas(asset);
-                // If the user gave me only one texture, that one is assumed to be the "first" texture in the atlas
-                if (metadata.images instanceof TextureSource || typeof metadata.images === 'string') {
-                    const pixiTexture = metadata.images;
-                    metadata.images = {};
-                    metadata.images[retval.pages[0].name] = pixiTexture;
-                }
-                // we will wait for all promises for the textures at the same time at the end.
-                const textureLoadingPromises = [];
-                // fill the pages
-                for (const page of retval.pages) {
-                    const pageName = page.name;
-                    const providedPage = (metadata === null || metadata === void 0 ? void 0 : metadata.images) ? metadata.images[pageName] : undefined;
-                    if (providedPage instanceof TextureSource) {
-                        page.setTexture(SpineTexture.from(providedPage));
-                    }
-                    else {
-                        // eslint-disable-next-line max-len
-                        const url = providedPage !== null && providedPage !== void 0 ? providedPage : path.normalize([...basePath.split(path.sep), pageName].join(path.sep));
-                        const assetsToLoadIn = {
-                            src: url,
-                            data: Object.assign(Object.assign({}, metadata.imageMetadata), { alphaMode: page.pma ? 'premultiplied-alpha' : 'premultiply-alpha-on-upload' })
-                        };
-                        const pixiPromise = loader.load(assetsToLoadIn).then((texture) => {
-                            page.setTexture(SpineTexture.from(texture.source));
-                        });
-                        textureLoadingPromises.push(pixiPromise);
-                    }
-                }
-                yield Promise.all(textureLoadingPromises);
-                return retval;
-            });
-        },
-    },
-};
-extensions.add(spineTextureAtlasLoader);

package/dist/spine/lib/assets/skeletonLoader.d.ts

@@ -1,30 +0,0 @@
-/** ****************************************************************************
- * Spine Runtimes License Agreement
- * Last updated July 28, 2023. Replaces all prior versions.
- *
- * Copyright (c) 2013-2023, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software or
- * otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
- * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-export {};
-//# sourceMappingURL=skeletonLoader.d.ts.map

package/dist/spine/lib/assets/skeletonLoader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skeletonLoader.d.ts","sourceRoot":"","sources":["../../../../src/spine/lib/assets/skeletonLoader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;+EA2B+E"}

package/dist/spine/lib/assets/skeletonLoader.js

@@ -1,70 +0,0 @@
-/** ****************************************************************************
- * Spine Runtimes License Agreement
- * Last updated July 28, 2023. Replaces all prior versions.
- *
- * Copyright (c) 2013-2023, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software or
- * otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
- * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-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 { checkExtension, DOMAdapter, extensions, ExtensionType, LoaderParserPriority } from 'pixi.js';
-function isJson(resource) {
-    return Object.prototype.hasOwnProperty.call(resource, 'bones');
-}
-function isBuffer(resource) {
-    return resource instanceof Uint8Array;
-}
-const spineLoaderExtension = {
-    extension: ExtensionType.Asset,
-    loader: {
-        extension: {
-            type: ExtensionType.LoadParser,
-            priority: LoaderParserPriority.Normal,
-            name: 'spineSkeletonLoader',
-        },
-        test(url) {
-            return checkExtension(url, '.skel');
-        },
-        load(url) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const response = yield DOMAdapter.get().fetch(url);
-                const buffer = new Uint8Array(yield response.arrayBuffer());
-                return buffer;
-            });
-        },
-        testParse(asset, options) {
-            const isJsonSpineModel = checkExtension(options.src, '.json') && isJson(asset);
-            const isBinarySpineModel = checkExtension(options.src, '.skel') && isBuffer(asset);
-            return Promise.resolve(isJsonSpineModel || isBinarySpineModel);
-        },
-    },
-};
-extensions.add(spineLoaderExtension);