@eva/spine-base 2.1.0-beta.1 → 2.1.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eva/spine-base",
-  "version": "2.1.0-beta.1",
+  "version": "2.1.0-beta.3",
   "description": "@eva/spine-base",
   "main": "index.js",
   "module": "dist/spine-base.esm.js",
@@ -18,8 +18,8 @@
   "license": "MIT",
   "homepage": "https://eva.js.org",
   "dependencies": {
-    "@eva/eva.js": "2.1.0-beta.1",
-    "@eva/plugin-renderer": "2.1.0-beta.1",
+    "@eva/eva.js": "2.1.0-beta.3",
+    "@eva/plugin-renderer": "2.1.0-beta.3",
     "@eva/inspector-decorator": "^2.0.0-beta.0",
     "pixi.js": "^8.17.0"
   }

package/dist/EVA.plugin.spineBase.js

@@ -1,687 +0,0 @@
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-globalThis.EVA = globalThis.EVA || {};
-globalThis.EVA.plugin = globalThis.EVA.plugin || {};
-var _EVA_IIFE_spineBase = function (exports, eva_js, pluginRenderer, pixi_js) {
-  'use strict';
-  function __decorate(decorators, target, key, desc) {
-    var c = arguments.length,
-      r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
-      d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-  }
-  function __metadata(metadataKey, metadataValue) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
-  }
-  function __awaiter(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());
-    });
-  }
-  function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
-    }
-    return t;
-  }
-  typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-  };
-  class SymbolKeysNotSupportedError extends Error {
-    constructor() {
-      super('Symbol keys are not supported yet!');
-      Object.setPrototypeOf(this, new.target.prototype);
-    }
-  }
-  const IDE_PROPERTY_METADATA = 'IDE_PROPERTY_METADATA';
-  function transformBasicType(type) {
-    if (type === String) {
-      return 'string';
-    }
-    if (type === Number) {
-      return 'number';
-    }
-    if (type === Boolean) {
-      return 'boolean';
-    }
-    return 'unknown';
-  }
-  function defineLegacyIDEProp(target, propertyKey, patch) {
-    const constructor = target.constructor;
-    const current = constructor.IDEProps || {};
-    current[propertyKey] = _extends(_extends({
-      key: propertyKey
-    }, current[propertyKey]), patch);
-    constructor.IDEProps = current;
-  }
-  function defineTypes(target, key, options, returnTypeFunction) {
-    let type = Reflect.getMetadata('design:type', target, key);
-    let isArray = type === Array;
-    const str = transformBasicType(type);
-    if (str !== 'unknown') {
-      type = str;
-    }
-    if (returnTypeFunction) {
-      const returnType = returnTypeFunction();
-      if (Array.isArray(returnType)) {
-        isArray = true;
-        type = returnType[0];
-      } else {
-        type = returnType;
-      }
-    }
-    const properties = Reflect.getMetadata(IDE_PROPERTY_METADATA, target.constructor) || {};
-    const current = properties[key] || {};
-    const property = _extends(_extends(_extends({}, current), {
-      type,
-      isArray: isArray
-    }), options);
-    properties[key] = property;
-    Reflect.defineMetadata(IDE_PROPERTY_METADATA, properties, target.constructor);
-    const legacyProperty = __rest(property, ["isArray"]);
-    defineLegacyIDEProp(target, key, legacyProperty);
-  }
-  function type(type) {
-    return Field({
-      type
-    });
-  }
-  function getTypeDecoratorParams(returnTypeFuncOrOptions, maybeOptions) {
-    if (typeof returnTypeFuncOrOptions === 'function') {
-      return {
-        returnTypeFunc: returnTypeFuncOrOptions,
-        options: maybeOptions || {}
-      };
-    }
-    return {
-      options: returnTypeFuncOrOptions || {}
-    };
-  }
-  function Field(returnTypeFunction, maybeOptions) {
-    return (target, propertyKey) => {
-      if (typeof propertyKey === 'symbol') {
-        throw new SymbolKeysNotSupportedError();
-      }
-      const {
-        options,
-        returnTypeFunc
-      } = getTypeDecoratorParams(returnTypeFunction, maybeOptions);
-      defineTypes(target, propertyKey, options, returnTypeFunc);
-    };
-  }
-  var ExecuteMode;
-  (function (ExecuteMode) {
-    ExecuteMode[ExecuteMode["Edit"] = 2] = "Edit";
-    ExecuteMode[ExecuteMode["Game"] = 4] = "Game";
-    ExecuteMode[ExecuteMode["All"] = 6] = "All";
-  })(ExecuteMode || (ExecuteMode = {}));
-  class Spine extends eva_js.Component {
-    constructor(params) {
-      super(params);
-      this.resource = '';
-      this.scale = 1;
-      this.animationName = '';
-      this.autoPlay = true;
-      this.keepResource = false;
-      this.timeScale = 1;
-      this.skin = '';
-      this._slotGameObjects = new Map();
-      this._pendingSlotObjects = [];
-      this.waitExecuteInfos = [];
-      this.listenerBound = false;
-      this.paused = false;
-      this.init(params);
-    }
-    set armature(val) {
-      this._armature = val;
-      if (!val) return;
-      this.applyTimeScale();
-      if (this.skin) this.setSkin(this.skin);
-      if (this.autoPlay) {
-        this.play(this.animationName);
-      }
-      for (const info of this.waitExecuteInfos) {
-        if (info.playType) {
-          const {
-            name,
-            loop,
-            track
-          } = info;
-          this.play(name, loop, track);
-        } else {
-          this.stop(info.track);
-        }
-      }
-      this.waitExecuteInfos = [];
-    }
-    get armature() {
-      return this._armature;
-    }
-    init(obj) {
-      if (obj) _extends(this, obj);
-      if (!this.listenerBound) {
-        this.listenerBound = true;
-        this.on('start', event => {
-          var _a;
-          (_a = this.onStart) === null || _a === void 0 ? void 0 : _a.call(this, event);
-        });
-        this.on('complete', event => {
-          var _a;
-          (_a = this.onComplete) === null || _a === void 0 ? void 0 : _a.call(this, event);
-        });
-        this.on('event', (track, event) => {
-          var _a;
-          (_a = this.onEvent) === null || _a === void 0 ? void 0 : _a.call(this, track, event);
-        });
-      }
-    }
-    onDestroy() {
-      this.destroied = true;
-    }
-    load() {
-      return this.armature;
-    }
-    destroy() {
-      this.onDestroy();
-      if (this.armature && !this.armature.destroyed) {
-        this._destroySlotGameObjects();
-        this.armature.destroy({
-          children: true
-        });
-      }
-      this.armature = null;
-    }
-    pause() {
-      this.paused = true;
-      this.applyTimeScale();
-    }
-    resume() {
-      this.paused = false;
-      this.applyTimeScale();
-    }
-    setSkin(name) {
-      var _a, _b, _c, _d, _e;
-      this.skin = name;
-      if (!((_a = this.armature) === null || _a === void 0 ? void 0 : _a.skeleton)) return;
-      if (this.armature.skeleton.setSkinByName) {
-        this.armature.skeleton.setSkinByName(name);
-      } else if (this.armature.skeleton.setSkin) {
-        const skin = ((_c = (_b = this.armature.skeleton.data) === null || _b === void 0 ? void 0 : _b.findSkin) === null || _c === void 0 ? void 0 : _c.call(_b, name)) || name;
-        this.armature.skeleton.setSkin(skin);
-      }
-      (_e = (_d = this.armature.skeleton).setSlotsToSetupPose) === null || _e === void 0 ? void 0 : _e.call(_d);
-    }
-    play(name, loopAnimation, track) {
-      try {
-        const loop = loopAnimation !== null && loopAnimation !== void 0 ? loopAnimation : this.autoPlay;
-        if (name) this.animationName = name;
-        if (!this.armature) {
-          this.waitExecuteInfos.push({
-            playType: true,
-            name,
-            loop,
-            track
-          });
-        } else {
-          if (track === undefined) {
-            track = 0;
-          }
-          this.applyTimeScale();
-          this.armature.state.setAnimation(track, this.animationName, loop);
-        }
-      } catch (e) {
-        console.log(e);
-      }
-    }
-    stop(track) {
-      if (!this.armature) {
-        this.waitExecuteInfos.push({
-          playType: false,
-          track
-        });
-        return;
-      }
-      if (track === undefined) {
-        track = 0;
-      }
-      this.armature.state.setEmptyAnimation(track, 0);
-    }
-    applyTimeScale() {
-      var _a;
-      if (!((_a = this.armature) === null || _a === void 0 ? void 0 : _a.state)) return;
-      this.armature.state.timeScale = this.paused ? 0 : this.timeScale;
-    }
-    addAnimation(name, delay, loop, track) {
-      try {
-        if (!this.armature) {} else {
-          if (track === undefined) {
-            track = 0;
-          }
-          this.armature.state.addAnimation(track, name, loop, delay);
-        }
-      } catch (e) {
-        console.log(e);
-      }
-    }
-    setMix(from, to, duration) {
-      if (!this.armature) ;else {
-        this.armature.state.data.setMix(from, to, duration);
-      }
-    }
-    getAnim(track = 0) {
-      try {
-        if (!this.armature) {} else {
-          return this.armature.state.tracks[track].animation.name;
-        }
-      } catch (e) {
-        console.log(e);
-      }
-    }
-    setDefaultMix(duration) {
-      if (!this.armature) ;else {
-        this.armature.state.data.defaultMix = duration;
-      }
-    }
-    setAttachment(slotName, attachmentName) {
-      if (!this.armature) {
-        return;
-      }
-      this.armature.skeleton.setAttachment(slotName, attachmentName);
-    }
-    getBone(boneName) {
-      if (!this.armature) {
-        return;
-      }
-      return this.armature.skeleton.findBone(boneName);
-    }
-    addSlotObject(slot, gameObject, options) {
-      if (!this.armature) {
-        console.warn('Spine armature is not ready, cannot addSlotObject');
-        return;
-      }
-      if (!this._containerManager) {
-        console.warn('ContainerManager is not available');
-        return;
-      }
-      const container = this._containerManager.getContainer(gameObject.id);
-      if (!container) {
-        this._pendingSlotObjects.push({
-          slot,
-          gameObject,
-          options
-        });
-        return;
-      }
-      this._doAddSlotObject(slot, gameObject, container, options);
-    }
-    _doAddSlotObject(slot, gameObject, container, options) {
-      const wrapper = new pixi_js.Container();
-      wrapper.addChild(container);
-      this.armature.addSlotObject(slot, wrapper, options);
-      this._slotGameObjects.set(gameObject, {
-        slot,
-        wrapper
-      });
-      this._syncTransformTree(gameObject);
-    }
-    _syncTransformTree(gameObject) {
-      var _a;
-      if (!this._containerManager) return;
-      this._containerManager.updateTransform({
-        name: gameObject.id,
-        transform: gameObject.transform
-      });
-      if ((_a = gameObject.transform) === null || _a === void 0 ? void 0 : _a.children) {
-        for (const childTransform of gameObject.transform.children) {
-          if (childTransform.gameObject) {
-            this._syncTransformTree(childTransform.gameObject);
-          }
-        }
-      }
-    }
-    _flushPendingSlotObjects() {
-      if (this._pendingSlotObjects.length === 0) return;
-      if (!this.armature || !this._containerManager) return;
-      const still = [];
-      for (const pending of this._pendingSlotObjects) {
-        const container = this._containerManager.getContainer(pending.gameObject.id);
-        if (container) {
-          this._doAddSlotObject(pending.slot, pending.gameObject, container, pending.options);
-        } else {
-          still.push(pending);
-        }
-      }
-      this._pendingSlotObjects = still;
-    }
-    removeSlotObject(gameObject) {
-      this._pendingSlotObjects = this._pendingSlotObjects.filter(p => p.gameObject !== gameObject);
-      const entry = this._slotGameObjects.get(gameObject);
-      if (entry && this.armature) {
-        this.armature.removeSlotObject(entry.wrapper);
-        entry.wrapper.destroy({
-          children: false
-        });
-      }
-      this._slotGameObjects.delete(gameObject);
-    }
-    _destroySlotGameObjects() {
-      for (const [gameObject, entry] of this._slotGameObjects) {
-        if (!gameObject.destroyed) {
-          if (this.armature) {
-            this.armature.removeSlotObject(entry.wrapper);
-          }
-          entry.wrapper.destroy({
-            children: false
-          });
-          gameObject.destroy();
-        }
-      }
-      this._slotGameObjects.clear();
-      this._pendingSlotObjects = [];
-    }
-  }
-  Spine.componentName = 'Spine';
-  __decorate([type('string'), __metadata("design:type", String)], Spine.prototype, "resource", void 0);
-  __decorate([type('number'), __metadata("design:type", Number)], Spine.prototype, "scale", void 0);
-  __decorate([type('string'), __metadata("design:type", String)], Spine.prototype, "animationName", void 0);
-  __decorate([type('boolean'), __metadata("design:type", Boolean)], Spine.prototype, "autoPlay", void 0);
-  __decorate([type('boolean'), __metadata("design:type", Boolean)], Spine.prototype, "keepResource", void 0);
-  __decorate([type('number'), __metadata("design:type", Number)], Spine.prototype, "timeScale", void 0);
-  __decorate([type('string'), __metadata("design:type", String)], Spine.prototype, "skin", void 0);
-  let dataMap = {};
-  function resolveImageSrc(image) {
-    var _a, _b, _c, _d, _e;
-    if (!image) return '';
-    if (typeof image === 'string') return image;
-    return image.label || ((_a = image.source) === null || _a === void 0 ? void 0 : _a.label) || ((_c = (_b = image.source) === null || _b === void 0 ? void 0 : _b.resource) === null || _c === void 0 ? void 0 : _c.src) || ((_d = image.source) === null || _d === void 0 ? void 0 : _d._sourceOrigin) || image.src || ((_e = image.baseTexture) === null || _e === void 0 ? void 0 : _e.cacheId) || '';
-  }
-  function createSpineData(name, data, scale, pixiSpine) {
-    const skeletonAsset = data.ske;
-    const atlasAsset = data.atlas;
-    const attachmentLoader = new pixiSpine.AtlasAttachmentLoader(atlasAsset);
-    const parser = skeletonAsset instanceof Uint8Array ? new pixiSpine.SkeletonBinary(attachmentLoader) : new pixiSpine.SkeletonJson(attachmentLoader);
-    parser.scale = scale || 1;
-    const skeletonData = parser.readSkeletonData(skeletonAsset);
-    const obj = {
-      spineData: skeletonData,
-      ref: 0,
-      imageSrc: resolveImageSrc(data.image)
-    };
-    dataMap[name] = obj;
-    return obj;
-  }
-  function getSpineData(res, scale, pixiSpine) {
-    return __awaiter(this, void 0, void 0, function* () {
-      let data = dataMap[res.name];
-      if (!data) {
-        if (res.complete) {
-          data = createSpineData(res.name, res.data, scale, pixiSpine);
-        } else if (!data) {
-          return;
-        }
-      }
-      data.ref++;
-      return data.spineData;
-    });
-  }
-  function releaseSpineData(res, _imageSrc) {
-    const resourceName = res.name;
-    const data = dataMap[resourceName];
-    if (!data) {
-      return;
-    }
-    data.ref--;
-    setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-      if (data.ref <= 0) {
-        eva_js.resource.destroy(resourceName);
-        delete dataMap[resourceName];
-      }
-    }), 100);
-  }
-  const MaxRetryCount = 20;
-  let SpineSystem = class SpineSystem extends pluginRenderer.Renderer {
-    constructor() {
-      super(...arguments);
-      this.armatures = {};
-      this._spineComponents = {};
-    }
-    init({
-      pixiSpine
-    }) {
-      this.renderSystem = this.game.getSystem(pluginRenderer.RendererSystem);
-      this.renderSystem.rendererManager.register(this);
-      this.pixiSpine = pixiSpine;
-      this.game.canvas.addEventListener('webglcontextrestored', () => {
-        const objs = this.game.gameObjects;
-        let toAdd = [];
-        for (let k in this.armatures) {
-          const id = +k;
-          for (let i = 0; i < objs.length; ++i) {
-            let obj = objs[i];
-            if (obj.id === id) {
-              let sp = obj.getComponent(Spine);
-              if (sp) {
-                this.remove({
-                  type: eva_js.OBSERVER_TYPE.REMOVE,
-                  gameObject: obj,
-                  component: sp,
-                  componentName: Spine.componentName
-                });
-                toAdd.push({
-                  type: eva_js.OBSERVER_TYPE.ADD,
-                  gameObject: obj,
-                  component: sp,
-                  componentName: Spine.componentName
-                });
-              }
-              break;
-            }
-          }
-        }
-        setTimeout(() => {
-          toAdd.forEach(obj => {
-            this.add(obj);
-          });
-        }, 1000);
-      }, false);
-    }
-    update(e) {
-      super.update();
-      for (let key in this.armatures) {
-        const armature = this.armatures[key];
-        const component = this._spineComponents[key];
-        if (!armature || armature.destroyed || (component === null || component === void 0 ? void 0 : component.destroied)) {
-          delete this.armatures[key];
-          delete this._spineComponents[key];
-          continue;
-        }
-        armature.update(e.deltaTime * 0.001);
-      }
-      for (let key in this._spineComponents) {
-        const component = this._spineComponents[key];
-        if (!component || component.destroied) {
-          delete this._spineComponents[key];
-          continue;
-        }
-        component._flushPendingSlotObjects();
-      }
-    }
-    componentChanged(changed) {
-      return __awaiter(this, void 0, void 0, function* () {
-        if (changed.componentName === 'Spine') {
-          if (changed.type === eva_js.OBSERVER_TYPE.ADD) {
-            this.add(changed);
-          } else if (changed.type === eva_js.OBSERVER_TYPE.CHANGE) {
-            switch (changed.prop.prop[0]) {
-              case 'resource':
-                this.change(changed);
-                break;
-            }
-          } else if (changed.type === eva_js.OBSERVER_TYPE.REMOVE) {
-            this.remove(changed);
-          }
-        }
-      });
-    }
-    add(changed, count) {
-      var _a, _b, _c;
-      return __awaiter(this, void 0, void 0, function* () {
-        const component = changed.component;
-        clearTimeout(component.addHandler);
-        const gameObjectId = changed.gameObject.id;
-        const asyncId = this.increaseAsyncId(gameObjectId);
-        const res = yield eva_js.resource.getResource(component.resource);
-        if (!this.validateAsyncId(gameObjectId, asyncId) || component.destroied || changed.gameObject.destroyed) return;
-        const spineData = yield getSpineData(res, component.scale, this.pixiSpine);
-        if (!this.validateAsyncId(gameObjectId, asyncId) || component.destroied || changed.gameObject.destroyed) return;
-        if (!spineData) {
-          component.addHandler = setTimeout(() => {
-            if (!component.destroied && !changed.gameObject.destroyed) {
-              if (count === undefined) {
-                count = MaxRetryCount;
-              }
-              count--;
-              if (count > 0) {
-                this.add(changed, count);
-              } else {
-                console.log('retry exceed max times', component.resource);
-              }
-            }
-          }, 1000);
-          return;
-        }
-        this.remove(changed);
-        const container = (_b = (_a = this.renderSystem) === null || _a === void 0 ? void 0 : _a.containerManager) === null || _b === void 0 ? void 0 : _b.getContainer(changed.gameObject.id);
-        if (!container || component.destroied || changed.gameObject.destroyed) {
-          return;
-        }
-        component.lastResource = component.resource;
-        const armature = new this.pixiSpine.Spine({
-          skeletonData: spineData,
-          autoUpdate: false
-        });
-        this.armatures[changed.gameObject.id] = armature;
-        this._spineComponents[changed.gameObject.id] = component;
-        if (changed.gameObject && changed.gameObject.transform) {
-          const tran = changed.gameObject.transform;
-          armature.x = tran.size.width * tran.origin.x;
-          armature.y = tran.size.height * tran.origin.y;
-        }
-        container.addChildAt(armature, 0);
-        armature.update();
-        component._containerManager = (_c = this.renderSystem) === null || _c === void 0 ? void 0 : _c.containerManager;
-        component.armature = armature;
-        component.emit('loaded', {
-          resource: component.resource
-        });
-        armature.state.addListener({
-          start: (track, event) => {
-            component.emit('start', {
-              track,
-              name: track.animation.name
-            });
-          },
-          complete: (track, event) => {
-            component.emit('complete', {
-              track,
-              name: track.animation.name
-            });
-          },
-          interrupt: (track, event) => {
-            component.emit('interrupt', {
-              track,
-              name: track.animation.name
-            });
-          },
-          end: (track, event) => {
-            component.emit('end', {
-              track,
-              name: track.animation.name
-            });
-          },
-          event: (track, event) => {
-            component.emit('event', track, event);
-          }
-        });
-      });
-    }
-    change(changed) {
-      this.remove(changed);
-      this.add(changed);
-    }
-    remove(changed) {
-      var _a, _b, _c, _d, _e, _f;
-      return __awaiter(this, void 0, void 0, function* () {
-        const gameObjectId = changed.gameObject.id;
-        this.increaseAsyncId(gameObjectId);
-        const component = changed.component;
-        clearTimeout(component.addHandler);
-        const armature = this.armatures[gameObjectId];
-        const container = (_b = (_a = this.renderSystem) === null || _a === void 0 ? void 0 : _a.containerManager) === null || _b === void 0 ? void 0 : _b.getContainer(gameObjectId);
-        if (container && armature) {
-          container.removeChild(armature);
-        }
-        const componentArmature = component.armature;
-        component.armature = null;
-        delete this.armatures[gameObjectId];
-        delete this._spineComponents[gameObjectId];
-        if (componentArmature) {
-          component._destroySlotGameObjects();
-          if (!componentArmature.destroyed) {
-            componentArmature.destroy({
-              children: true
-            });
-          }
-          if (!component.keepResource && component.lastResource) {
-            try {
-              const res = yield eva_js.resource.getResource(component.lastResource);
-              const imageSrc = ((_d = (_c = res.data) === null || _c === void 0 ? void 0 : _c.image) === null || _d === void 0 ? void 0 : _d.src) || ((_f = (_e = res.data) === null || _e === void 0 ? void 0 : _e.image) === null || _f === void 0 ? void 0 : _f.label);
-              releaseSpineData(res, imageSrc);
-            } catch (error) {
-              console.warn('Failed to release Spine resource', component.lastResource, error);
-            }
-          }
-        }
-        if (changed.type === eva_js.OBSERVER_TYPE.CHANGE) ;
-      });
-    }
-  };
-  SpineSystem.systemName = 'SpineSystem';
-  SpineSystem = __decorate([eva_js.decorators.componentObserver({
-    Spine: ['resource']
-  })], SpineSystem);
-  var SpineSystem$1 = SpineSystem;
-  eva_js.resource.registerResourceType('SPINE');
-  exports.Spine = Spine;
-  exports.SpineSystem = SpineSystem$1;
-  Object.defineProperty(exports, '__esModule', {
-    value: true
-  });
-  return exports;
-}({}, EVA, EVA.plugin.renderer, PIXI);
-globalThis.EVA.plugin.spineBase = globalThis.EVA.plugin.spineBase || _EVA_IIFE_spineBase;