@eva/plugin-renderer-dragonbone 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/global.d.ts

@@ -0,0 +1,6 @@
+import "@eva/eva.js";
+declare module "@eva/eva.js" {
+  export enum RESOURCE_TYPE {
+    'DRAGONBONE' = 'DRAGONBONE'
+  }
+}

package/dist/plugin-renderer-dragonbone.cjs.js

@@ -21,20 +21,6 @@ MERCHANTABLITY OR NON-INFRINGEMENT.
 See the Apache Version 2.0 License for specific language governing permissions
 and limitations under the License.
 ***************************************************************************** */
-/* global Reflect, Promise */
-
-var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends$1(d, b) {
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
 
 function __decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -50,74 +36,44 @@ function __awaiter(thisArg, _arguments, P, generator) {
         function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
-}
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
 }
 
-var DragonBone$3 = (function (_super) {
-    __extends$1(DragonBone, _super);
-    function DragonBone() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.waitPlay = false;
-        _this.waitStop = false;
-        _this.waitPlayInfo = {
+class DragonBone$3 extends eva_js.Component {
+    constructor() {
+        super(...arguments);
+        this.waitPlay = false;
+        this.waitStop = false;
+        this.waitPlayInfo = {
             animationName: null,
         };
-        _this.resource = '';
-        _this.armatureName = '';
-        _this.animationName = '';
-        _this.autoPlay = true;
-        return _this;
+        this.resource = '';
+        this.armatureName = '';
+        this.animationName = '';
+        this.autoPlay = true;
     }
-    DragonBone.prototype.init = function (obj) {
+    init(obj) {
         if (!obj)
             return;
         if (!obj.armatureName) {
-            throw new Error("The dragonBone component on " + this.gameObject.name + ", armatureName is required!");
+            throw new Error(`The dragonBone component on ${this.gameObject.name}, armatureName is required!`);
         }
         Object.assign(this, obj);
         if (this.autoPlay) {
             this.play(this.animationName);
         }
-    };
-    DragonBone.prototype.play = function (name, times) {
+    }
+    play(name, times) {
         if (name)
             this.animationName = name;
         if (!this.armature) {
-            this.waitPlayInfo = { animationName: name, times: times };
+            this.waitPlayInfo = { animationName: name, times };
             this.waitPlay = true;
         }
         else {
             this.armature.play(this.animationName, times);
         }
-    };
-    DragonBone.prototype.stop = function (name) {
+    }
+    stop(name) {
         if (!this.armature) {
             this.waitPlayInfo = { animationName: name };
             this.waitStop = true;
@@ -126,43 +82,37 @@ var DragonBone$3 = (function (_super) {
             this.armature.stop(name);
         }
         this.animationName = null;
-    };
-    Object.defineProperty(DragonBone.prototype, "armature", {
-        get: function () {
-            return this._armature;
-        },
-        set: function (val) {
-            this._armature = val;
-            if (!val)
-                return;
-            var _a = this.waitPlayInfo, animationName = _a.animationName, times = _a.times;
-            this.waitPlay && this.play(animationName, times);
-            this.waitStop && this.stop(animationName);
-            this.waitPlay = false;
-            this.waitStop = false;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    DragonBone.prototype.onDestroy = function () {
+    }
+    set armature(val) {
+        this._armature = val;
+        if (!val)
+            return;
+        const { animationName, times } = this.waitPlayInfo;
+        this.waitPlay && this.play(animationName, times);
+        this.waitStop && this.stop(animationName);
+        this.waitPlay = false;
+        this.waitStop = false;
+    }
+    get armature() {
+        return this._armature;
+    }
+    onDestroy() {
         this.removeAllListeners();
-    };
-    DragonBone.componentName = 'DragonBone';
-    __decorate([
-        inspectorDecorator.type('string')
-    ], DragonBone.prototype, "resource", void 0);
-    __decorate([
-        inspectorDecorator.type('string')
-    ], DragonBone.prototype, "armatureName", void 0);
-    __decorate([
-        inspectorDecorator.type('string')
-    ], DragonBone.prototype, "animationName", void 0);
-    __decorate([
-        inspectorDecorator.type('boolean')
-    ], DragonBone.prototype, "autoPlay", void 0);
-    return DragonBone;
-}(eva_js.Component));
-var DragonBone$4 = DragonBone$3;
+    }
+}
+DragonBone$3.componentName = 'DragonBone';
+__decorate([
+    inspectorDecorator.type('string')
+], DragonBone$3.prototype, "resource", void 0);
+__decorate([
+    inspectorDecorator.type('string')
+], DragonBone$3.prototype, "armatureName", void 0);
+__decorate([
+    inspectorDecorator.type('string')
+], DragonBone$3.prototype, "animationName", void 0);
+__decorate([
+    inspectorDecorator.type('boolean')
+], DragonBone$3.prototype, "autoPlay", void 0);
 
 const PIXI = {
   Texture: pixi_js.Texture,
@@ -16955,23 +16905,20 @@ if (!Date.now) {
 
 var dragonBones$1 = dragonBones;
 
-var DragonBone$2 = (function () {
-    function DragonBone(_a) {
-        var armatureName = _a.armatureName;
+class DragonBone$2 {
+    constructor({ armatureName }) {
         this.factory = dragonBones$1.PixiFactory.factory;
         this.armature = this.factory.buildArmatureDisplay(armatureName);
     }
-    DragonBone.prototype.play = function (name, time) {
+    play(name, time) {
         return this.armature.animation.play(name, time);
-    };
-    DragonBone.prototype.stop = function (name) {
+    }
+    stop(name) {
         return this.armature.animation.stop(name);
-    };
-    return DragonBone;
-}());
-var DragonBoneEngine = DragonBone$2;
+    }
+}
 
-var events = {
+const events = {
     START: 'start',
     LOOP_COMPLETE: 'loopComplete',
     COMPLETE: 'complete',
@@ -16982,106 +16929,87 @@ var events = {
     FRAME_EVENT: 'frameEvent',
     SOUND_EVENT: 'soundEvent',
 };
-var factory = dragonBones$1.PixiFactory.factory;
+const factory = dragonBones$1.PixiFactory.factory;
 eva_js.resource.registerResourceType('DRAGONBONE');
-eva_js.resource.registerInstance(eva_js.RESOURCE_TYPE.DRAGONBONE, function (_a) {
-    var data = _a.data, name = _a.name;
+eva_js.resource.registerInstance(eva_js.RESOURCE_TYPE.DRAGONBONE, ({ data, name }) => {
     factory.parseDragonBonesData(data.ske, name);
     factory.parseTextureAtlasData(data.tex, pixi_js.Texture.from(data.image), name);
 });
-eva_js.resource.registerDestroy(eva_js.RESOURCE_TYPE.DRAGONBONE, function (_a) {
-    var name = _a.name;
+eva_js.resource.registerDestroy(eva_js.RESOURCE_TYPE.DRAGONBONE, ({ name }) => {
     factory.removeDragonBonesData(name);
     factory.removeTextureAtlasData(name);
 });
-var DragonBone = (function (_super) {
-    __extends$1(DragonBone, _super);
-    function DragonBone() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.name = 'DragonBone';
-        _this.armatures = {};
-        _this.autoPlay = {};
-        _this.isRemovedMap = new Map();
-        return _this;
+let DragonBone = class DragonBone extends pluginRenderer.Renderer {
+    constructor() {
+        super(...arguments);
+        this.name = 'DragonBone';
+        this.armatures = {};
+        this.autoPlay = {};
+        this.isRemovedMap = new Map();
     }
-    DragonBone.prototype.init = function () {
+    init() {
         this.renderSystem = this.game.getSystem(pluginRenderer.RendererSystem);
         this.renderSystem.rendererManager.register(this);
         this.renderSystem.application.ticker.add(dragonBones$1.PixiFactory._clockHandler, dragonBones$1.PixiFactory);
-    };
-    DragonBone.prototype.onDestroy = function () {
+    }
+    onDestroy() {
         this.renderSystem.application.ticker.remove(dragonBones$1.PixiFactory._clockHandler, dragonBones$1.PixiFactory);
-    };
-    DragonBone.prototype.componentChanged = function (changed) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                this.autoPlay[changed.gameObject.id] = changed.component.autoPlay;
-                if (changed.componentName === 'DragonBone') {
-                    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 'armature':
-                                this.change(changed);
-                                break;
-                        }
-                    }
-                    else if (changed.type === eva_js.OBSERVER_TYPE.REMOVE) {
-                        this.remove(changed);
+    }
+    componentChanged(changed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.autoPlay[changed.gameObject.id] = changed.component.autoPlay;
+            if (changed.componentName === 'DragonBone') {
+                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 'armature':
+                            this.change(changed);
+                            break;
                     }
                 }
-                return [2];
-            });
-        });
-    };
-    DragonBone.prototype.add = function (changed) {
-        return __awaiter(this, void 0, void 0, function () {
-            var component, asyncId, armature, _loop_1, key;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        component = changed.component;
-                        this.isRemovedMap.delete(component);
-                        asyncId = this.increaseAsyncId(changed.gameObject.id);
-                        return [4, eva_js.resource.getResource(component.resource)];
-                    case 1:
-                        _a.sent();
-                        if (!this.validateAsyncId(changed.gameObject.id, asyncId))
-                            return [2];
-                        if (this.isRemovedMap.get(component)) {
-                            this.isRemovedMap.delete(component);
-                            return [2];
-                        }
-                        armature = new DragonBoneEngine({
-                            armatureName: component.armatureName,
-                        });
-                        this.armatures[changed.gameObject.id] = armature;
-                        this.renderSystem.containerManager.getContainer(changed.gameObject.id).addChildAt(armature.armature, 0);
-                        component.armature = armature;
-                        _loop_1 = function (key) {
-                            armature.armature.on(events[key], function (e) {
-                                component.emit(events[key], e);
-                            });
-                        };
-                        for (key in events) {
-                            _loop_1(key);
-                        }
-                        return [2];
+                else if (changed.type === eva_js.OBSERVER_TYPE.REMOVE) {
+                    this.remove(changed);
                 }
+            }
+        });
+    }
+    add(changed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const component = changed.component;
+            this.isRemovedMap.delete(component);
+            const asyncId = this.increaseAsyncId(changed.gameObject.id);
+            yield eva_js.resource.getResource(component.resource);
+            if (!this.validateAsyncId(changed.gameObject.id, asyncId))
+                return;
+            if (this.isRemovedMap.get(component)) {
+                this.isRemovedMap.delete(component);
+                return;
+            }
+            const armature = new DragonBone$2({
+                armatureName: component.armatureName,
             });
+            this.armatures[changed.gameObject.id] = armature;
+            this.renderSystem.containerManager.getContainer(changed.gameObject.id).addChildAt(armature.armature, 0);
+            component.armature = armature;
+            for (const key in events) {
+                armature.armature.on(events[key], e => {
+                    component.emit(events[key], e);
+                });
+            }
         });
-    };
-    DragonBone.prototype.change = function (changed) {
+    }
+    change(changed) {
         this.remove(changed);
         this.add(changed);
         if (this.autoPlay[changed.gameObject.id]) {
-            var component = changed.component;
+            const component = changed.component;
             component.play(component.animationName);
         }
-    };
-    DragonBone.prototype.remove = function (changed) {
-        var armature = this.armatures[changed.gameObject.id];
+    }
+    remove(changed) {
+        const armature = this.armatures[changed.gameObject.id];
         if (!armature) {
             this.isRemovedMap.set(changed.component, true);
             return;
@@ -17090,23 +17018,22 @@ var DragonBone = (function (_super) {
         this.renderSystem.containerManager.getContainer(changed.gameObject.id).removeChild(armature.armature);
         armature.armature.removeAllListeners();
         armature.armature.destroy({ children: true });
-        var component = changed.component;
+        const component = changed.component;
         component.armature = null;
         delete this.armatures[changed.gameObject.id];
         if (changed.type === eva_js.OBSERVER_TYPE.CHANGE) {
             delete this.autoPlay[changed.gameObject.id];
             component.removeAllListeners();
         }
-    };
-    DragonBone.systemName = 'DragonBone';
-    DragonBone = __decorate([
-        eva_js.decorators.componentObserver({
-            DragonBone: ['armatureName'],
-        })
-    ], DragonBone);
-    return DragonBone;
-}(pluginRenderer.Renderer));
+    }
+};
+DragonBone.systemName = 'DragonBone';
+DragonBone = __decorate([
+    eva_js.decorators.componentObserver({
+        DragonBone: ['armatureName'],
+    })
+], DragonBone);
 var DragonBone$1 = DragonBone;
 
-exports.DragonBone = DragonBone$4;
+exports.DragonBone = DragonBone$3;
 exports.DragonBoneSystem = DragonBone$1;