@eva/plugin-renderer-spine 1.2.7-editor.1 → 1.2.7-editor.2

package/dist/EVA.plugin.renderer.spine.js

@@ -4,9 +4,180 @@ window.EVA = window.EVA || {};
 window.EVA.plugin = window.EVA.plugin || {};
 window.EVA.plugin.renderer = window.EVA.plugin.renderer || {};
 
-var _EVA_IIFE_spine = function (exports, pixi_js, eva_js, pluginRenderer) {
+var _EVA_IIFE_spine = function (exports, eva_js, pluginRenderer, pixi_js) {
   'use strict';
 
+  var _extendStatics$ = function extendStatics$2(d, b) {
+    _extendStatics$ = Object.setPrototypeOf || {
+      __proto__: []
+    } instanceof Array && function (d, b) {
+      d.__proto__ = b;
+    } || function (d, b) {
+      for (var p in b) {
+        if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+      }
+    };
+
+    return _extendStatics$(d, b);
+  };
+
+  function __extends$3(d, b) {
+    if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+
+    _extendStatics$(d, b);
+
+    function __() {
+      this.constructor = d;
+    }
+
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
+
+  var _extendStatics$2 = function extendStatics$1(d, b) {
+    _extendStatics$2 = Object.setPrototypeOf || {
+      __proto__: []
+    } instanceof Array && function (d, b) {
+      d.__proto__ = b;
+    } || function (d, b) {
+      for (var p in b) {
+        if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+      }
+    };
+
+    return _extendStatics$2(d, b);
+  };
+
+  function __extends$2(d, b) {
+    if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+
+    _extendStatics$2(d, b);
+
+    function __() {
+      this.constructor = d;
+    }
+
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
+
+  var _assign = function __assign() {
+    _assign = Object.assign || function __assign(t) {
+      for (var s, i = 1, n = arguments.length; i < n; i++) {
+        s = arguments[i];
+
+        for (var p in s) {
+          if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+      }
+
+      return t;
+    };
+
+    return _assign.apply(this, arguments);
+  };
+
+  var SymbolKeysNotSupportedError = function (_super) {
+    __extends$2(SymbolKeysNotSupportedError, _super);
+
+    function SymbolKeysNotSupportedError() {
+      var _newTarget = this.constructor;
+
+      var _this = _super.call(this, 'Symbol keys are not supported yet!') || this;
+
+      Object.setPrototypeOf(_this, _newTarget.prototype);
+      return _this;
+    }
+
+    return SymbolKeysNotSupportedError;
+  }(Error);
+
+  (function (_super) {
+    __extends$2(StaticGetPropertiesIsNotAFunctionError, _super);
+
+    function StaticGetPropertiesIsNotAFunctionError() {
+      var _newTarget = this.constructor;
+
+      var _this = _super.call(this, 'getProperties is not a function!') || this;
+
+      Object.setPrototypeOf(_this, _newTarget.prototype);
+      return _this;
+    }
+
+    return StaticGetPropertiesIsNotAFunctionError;
+  })(Error);
+
+  var 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 defineTypes(target, key, options, returnTypeFunction) {
+    var type = Reflect.getMetadata('design:type', target, key);
+    var isArray = type === Array;
+    var str = transformBasicType(type);
+
+    if (str !== 'unknown') {
+      type = str;
+    }
+
+    if (returnTypeFunction) {
+      var returnType = returnTypeFunction();
+
+      if (Array.isArray(returnType)) {
+        isArray = true;
+        type = returnType[0];
+      } else {
+        type = returnType;
+      }
+    }
+
+    var properties = Reflect.getMetadata(IDE_PROPERTY_METADATA, target.constructor) || {};
+    properties[key] = _assign({
+      type: type,
+      isArray: isArray
+    }, options);
+    Reflect.defineMetadata(IDE_PROPERTY_METADATA, properties, target.constructor);
+  }
+
+  function getTypeDecoratorParams(returnTypeFuncOrOptions, maybeOptions) {
+    if (typeof returnTypeFuncOrOptions === 'function') {
+      return {
+        returnTypeFunc: returnTypeFuncOrOptions,
+        options: maybeOptions || {}
+      };
+    }
+
+    return {
+      options: returnTypeFuncOrOptions || {}
+    };
+  }
+
+  function Field(returnTypeFunction, maybeOptions) {
+    return function (target, propertyKey) {
+      if (typeof propertyKey === 'symbol') {
+        throw new SymbolKeysNotSupportedError();
+      }
+
+      var _a = getTypeDecoratorParams(returnTypeFunction, maybeOptions),
+          options = _a.options,
+          returnTypeFunc = _a.returnTypeFunc;
+
+      defineTypes(target, propertyKey, options, returnTypeFunc);
+    };
+  }
+
   var _extendStatics = function extendStatics(d, b) {
     _extendStatics = Object.setPrototypeOf || {
       __proto__: []
@@ -41,13 +212,11 @@ var _EVA_IIFE_spine = function (exports, pixi_js, eva_js, pluginRenderer) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
   }
 
-  function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) {
-      return value instanceof P ? value : new P(function (resolve) {
-        resolve(value);
-      });
-    }
+  function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+  }
 
+  function __awaiter(thisArg, _arguments, P, generator) {
     return new (P || (P = Promise))(function (resolve, reject) {
       function fulfilled(value) {
         try {
@@ -66,7 +235,9 @@ var _EVA_IIFE_spine = function (exports, pixi_js, eva_js, pluginRenderer) {
       }
 
       function step(result) {
-        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        result.done ? resolve(result.value) : new P(function (resolve) {
+          resolve(result.value);
+        }).then(fulfilled, rejected);
       }
 
       step((generator = generator.apply(thisArg, _arguments || [])).next());
@@ -185,11 +356,10 @@ var _EVA_IIFE_spine = function (exports, pixi_js, eva_js, pluginRenderer) {
   }
 
   function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator,
-        m = s && o[s],
+    var m = typeof Symbol === "function" && o[Symbol.iterator],
         i = 0;
     if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
+    return {
       next: function next() {
         if (o && i >= o.length) o = void 0;
         return {
@@ -198,28 +368,6 @@ var _EVA_IIFE_spine = function (exports, pixi_js, eva_js, pluginRenderer) {
         };
       }
     };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-  }
-
-  function getIDEPropsPropertyObj(target, propertyKey) {
-    if (!target.constructor.IDEProps) {
-      target.constructor.IDEProps = {};
-    }
-
-    if (!target.constructor.IDEProps[propertyKey]) {
-      target.constructor.IDEProps[propertyKey] = {};
-    }
-
-    var propertyObj = target.constructor.IDEProps[propertyKey];
-    return propertyObj;
-  }
-
-  function type(type) {
-    return function (target, propertyKey) {
-      var prop = getIDEPropsPropertyObj(target, propertyKey);
-      prop.key = propertyKey;
-      prop.type = type;
-    };
   }
 
   var Spine$2 = function (_super) {
@@ -387,16 +535,16 @@ var _EVA_IIFE_spine = function (exports, pixi_js, eva_js, pluginRenderer) {
 
     Spine.componentName = 'Spine';
 
-    __decorate([type('string')], Spine.prototype, "resource", void 0);
+    __decorate([Field(), __metadata("design:type", String)], Spine.prototype, "resource", void 0);
 
-    __decorate([type('string')], Spine.prototype, "animationName", void 0);
+    __decorate([Field(), __metadata("design:type", String)], Spine.prototype, "animationName", void 0);
 
-    __decorate([type('boolean')], Spine.prototype, "autoPlay", void 0);
+    __decorate([Field(), __metadata("design:type", Boolean)], Spine.prototype, "autoPlay", void 0);
 
     return Spine;
   }(eva_js.Component);
 
-  var SpineBase = Spine$2;
+  var Spine$1$1 = Spine$2;
   var texCache = {};
 
   function cacheImage(data) {
@@ -544,21 +692,21 @@ var _EVA_IIFE_spine = function (exports, pixi_js, eva_js, pluginRenderer) {
             var obj = objs[i];
 
             if (obj.id === id) {
-              var sp = obj.getComponent(SpineBase);
+              var sp = obj.getComponent(Spine$1$1);
 
               if (sp) {
                 _this.remove({
                   type: eva_js.OBSERVER_TYPE.REMOVE,
                   gameObject: obj,
                   component: sp,
-                  componentName: SpineBase.componentName
+                  componentName: Spine$1$1.componentName
                 });
 
                 toAdd.push({
                   type: eva_js.OBSERVER_TYPE.ADD,
                   gameObject: obj,
                   component: sp,
-                  componentName: SpineBase.componentName
+                  componentName: Spine$1$1.componentName
                 });
               }
 
@@ -761,7 +909,8 @@ var _EVA_IIFE_spine = function (exports, pixi_js, eva_js, pluginRenderer) {
     return SpineSystem;
   }(pluginRenderer.Renderer);
 
-  var SpineSystemBase = SpineSystem$2;
+  var SpineSystem$1$1 = SpineSystem$2;
+  eva_js.resource.registerResourceType('SPINE');
   var VERSION = '4.8.9';
   var loader = pixi_js.loaders.shared;
   var PIXI = {
@@ -9557,9 +9706,9 @@ var _EVA_IIFE_spine = function (exports, pixi_js, eva_js, pluginRenderer) {
         var cachedResource = loader.resources[name];
 
         if (cachedResource) {
-          var done = function done() {
+          function done() {
             callback(cachedResource.texture.baseTexture);
-          };
+          }
 
           if (cachedResource.texture) {
             done();
@@ -9610,7 +9759,7 @@ var _EVA_IIFE_spine = function (exports, pixi_js, eva_js, pluginRenderer) {
   var pixiSpine = pixi_spine;
 
   var SpineSystem = function (_super) {
-    __extends$1(SpineSystem, _super);
+    __extends$3(SpineSystem, _super);
 
     function SpineSystem() {
       return _super !== null && _super.apply(this, arguments) || this;
@@ -9623,19 +9772,19 @@ var _EVA_IIFE_spine = function (exports, pixi_js, eva_js, pluginRenderer) {
     };
 
     return SpineSystem;
-  }(SpineSystemBase);
+  }(SpineSystem$1$1);
 
   var SpineSystem$1 = SpineSystem;
 
   var Spine = function (_super) {
-    __extends$1(Spine, _super);
+    __extends$3(Spine, _super);
 
     function Spine() {
       return _super !== null && _super.apply(this, arguments) || this;
     }
 
     return Spine;
-  }(SpineBase);
+  }(Spine$1$1);
 
   var Spine$1 = Spine;
   exports.Spine = Spine$1;
@@ -9644,6 +9793,6 @@ var _EVA_IIFE_spine = function (exports, pixi_js, eva_js, pluginRenderer) {
     value: true
   });
   return exports;
-}({}, PIXI, EVA, EVA.plugin.renderer);
+}({}, EVA, EVA.plugin.renderer, PIXI);
 
 window.EVA.plugin.renderer.spine = window.EVA.plugin.renderer.spine || _EVA_IIFE_spine;