@eva/plugin-renderer 2.0.0-beta.0 → 2.0.0-beta.2

package/dist/plugin-renderer.esm.js

@@ -18,31 +18,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(d, b) {
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-var __assign = function() {
-    __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);
-};
 
 function __decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -58,293 +33,137 @@ 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 };
-    }
-}
-
-function __values(o) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
-    if (m) return m.call(o);
-    return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-}
-
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __spread() {
-    for (var ar = [], i = 0; i < arguments.length; i++)
-        ar = ar.concat(__read(arguments[i]));
-    return ar;
 }
 
-var RendererManager = (function () {
-    function RendererManager(_a) {
-        var game = _a.game, rendererSystem = _a.rendererSystem;
+class RendererManager {
+    constructor({ game, rendererSystem }) {
         this.renderers = [];
         this.game = game;
         this.rendererSystem = rendererSystem;
     }
-    RendererManager.prototype.register = function () {
-        var e_1, _a;
-        var renderers = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            renderers[_i] = arguments[_i];
-        }
-        try {
-            for (var renderers_1 = __values(renderers), renderers_1_1 = renderers_1.next(); !renderers_1_1.done; renderers_1_1 = renderers_1.next()) {
-                var renderer = renderers_1_1.value;
-                renderer.game = this.game;
-                renderer.rendererManager = this.rendererSystem.rendererManager;
-                renderer.containerManager = this.rendererSystem.containerManager;
-                this.renderers.push(renderer);
-            }
+    register(...renderers) {
+        for (const renderer of renderers) {
+            renderer.game = this.game;
+            renderer.rendererManager = this.rendererSystem.rendererManager;
+            renderer.containerManager = this.rendererSystem.containerManager;
+            this.renderers.push(renderer);
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (renderers_1_1 && !renderers_1_1.done && (_a = renderers_1.return)) _a.call(renderers_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    };
-    RendererManager.prototype.componentChanged = function (changes) {
-        var e_2, _a;
-        var _loop_1 = function (changed) {
-            var e_3, _a;
-            try {
-                for (var _b = (e_3 = void 0, __values(this_1.renderers)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var renderer = _c.value;
-                    var props = renderer.observerInfo[changed.componentName];
-                    if (props) {
-                        if ([OBSERVER_TYPE.ADD, OBSERVER_TYPE.REMOVE].indexOf(changed.type) > -1) {
-                            try {
-                                renderer.componentChanged && renderer.componentChanged(changed);
-                            }
-                            catch (e) {
-                                console.error("gameObject: " + changed.gameObject.name + ", " + changed.componentName + " is error.", changed, e);
-                            }
-                            continue;
+    }
+    componentChanged(changes) {
+        for (const changed of changes) {
+            for (const renderer of this.renderers) {
+                const props = renderer.observerInfo[changed.componentName];
+                if (props) {
+                    if ([OBSERVER_TYPE.ADD, OBSERVER_TYPE.REMOVE].indexOf(changed.type) > -1) {
+                        try {
+                            renderer.componentChanged && renderer.componentChanged(changed);
                         }
-                        var index = props.findIndex(function (prop) {
-                            return isEqual(prop, changed.prop);
-                        });
-                        if (index > -1) {
-                            try {
-                                renderer.componentChanged && renderer.componentChanged(changed);
-                            }
-                            catch (e) {
-                                console.error("gameObject: " + (changed.gameObject && changed.gameObject.name) + ", " + changed.componentName + " is componentChanged error.", changed, e);
-                            }
+                        catch (e) {
+                            console.error(`gameObject: ${changed.gameObject.name}, ${changed.componentName} is error.`, changed, e);
                         }
+                        continue;
                     }
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-        };
-        var this_1 = this;
-        try {
-            for (var changes_1 = __values(changes), changes_1_1 = changes_1.next(); !changes_1_1.done; changes_1_1 = changes_1.next()) {
-                var changed = changes_1_1.value;
-                _loop_1(changed);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (changes_1_1 && !changes_1_1.done && (_a = changes_1.return)) _a.call(changes_1);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-    };
-    RendererManager.prototype.update = function (gameObject) {
-        var e_4, _a, e_5, _b;
-        try {
-            for (var _c = __values(gameObject.components), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var component = _d.value;
-                try {
-                    for (var _e = (e_5 = void 0, __values(this.renderers)), _f = _e.next(); !_f.done; _f = _e.next()) {
-                        var renderer = _f.value;
-                        var cache = [];
-                        var props = renderer.observerInfo[component.name];
-                        if (props && cache.indexOf(gameObject) === -1) {
-                            cache.push(gameObject);
-                            try {
-                                renderer.rendererUpdate && renderer.rendererUpdate(gameObject);
-                            }
-                            catch (e) {
-                                console.info("gameObject: " + gameObject.name + ", " + component.name + " is update error", e);
-                            }
+                    const index = props.findIndex(prop => {
+                        return isEqual(prop, changed.prop);
+                    });
+                    if (index > -1) {
+                        try {
+                            renderer.componentChanged && renderer.componentChanged(changed);
+                        }
+                        catch (e) {
+                            console.error(`gameObject: ${changed.gameObject && changed.gameObject.name}, ${changed.componentName} is componentChanged error.`, changed, e);
                         }
                     }
                 }
-                catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                finally {
+            }
+        }
+    }
+    update(gameObject) {
+        for (const component of gameObject.components) {
+            for (const renderer of this.renderers) {
+                const cache = [];
+                const props = renderer.observerInfo[component.name];
+                if (props && cache.indexOf(gameObject) === -1) {
+                    cache.push(gameObject);
                     try {
-                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                        renderer.rendererUpdate && renderer.rendererUpdate(gameObject);
+                    }
+                    catch (e) {
+                        console.info(`gameObject: ${gameObject.name}, ${component.name} is update error`, e);
                     }
-                    finally { if (e_5) throw e_5.error; }
                 }
             }
         }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-            }
-            finally { if (e_4) throw e_4.error; }
-        }
-    };
-    return RendererManager;
-}());
+    }
+}
 var RendererManager$1 = RendererManager;
 
-var ContainerManager = (function () {
-    function ContainerManager() {
+class ContainerManager {
+    constructor() {
         this.containerMap = {};
     }
-    ContainerManager.prototype.addContainer = function (_a) {
-        var name = _a.name, container = _a.container;
+    addContainer({ name, container }) {
         this.containerMap[name] = container;
-    };
-    ContainerManager.prototype.getContainer = function (name) {
+    }
+    getContainer(name) {
         return this.containerMap[name];
-    };
-    ContainerManager.prototype.removeContainer = function (name) {
+    }
+    removeContainer(name) {
         var _a;
         (_a = this.containerMap[name]) === null || _a === void 0 ? void 0 : _a.destroy({ children: true });
         delete this.containerMap[name];
-    };
-    ContainerManager.prototype.updateTransform = function (_a) {
-        var name = _a.name, transform = _a.transform;
-        var container = this.containerMap[name];
+    }
+    updateTransform({ name, transform }) {
+        const container = this.containerMap[name];
         if (!container || !transform)
             return;
-        var anchor = transform.anchor, origin = transform.origin, position = transform.position, rotation = transform.rotation, scale = transform.scale, size = transform.size, skew = transform.skew;
+        const { anchor, origin, position, rotation, scale, size, skew } = transform;
         container.rotation = rotation;
         container.scale = scale;
         container.pivot.x = size.width * origin.x;
         container.pivot.y = size.height * origin.y;
         container.skew = skew;
-        var x = position.x;
-        var y = position.y;
+        let x = position.x;
+        let y = position.y;
         if (transform.parent) {
-            var parent_1 = transform.parent;
-            x = x + parent_1.size.width * anchor.x;
-            y = y + parent_1.size.height * anchor.y;
+            const parent = transform.parent;
+            x = x + parent.size.width * anchor.x;
+            y = y + parent.size.height * anchor.y;
         }
-        container.position = { x: x, y: y };
-    };
-    return ContainerManager;
-}());
-var ContainerManager$1 = ContainerManager;
+        container.position = { x, y };
+    }
+}
 
-var Transform = (function (_super) {
-    __extends(Transform, _super);
-    function Transform(_a) {
-        var system = _a.system, containerManager = _a.containerManager;
-        var _this = _super.call(this) || this;
-        _this.name = 'Transform';
-        _this.waitRemoveIds = [];
-        _this.waitChangeScenes = [];
-        _this.containerManager = containerManager;
-        _this.init(system);
-        return _this;
+let Transform = class Transform extends EventEmitter {
+    constructor({ system, containerManager }) {
+        super();
+        this.name = 'Transform';
+        this.waitRemoveIds = [];
+        this.waitChangeScenes = [];
+        this.containerManager = containerManager;
+        this.init(system);
     }
-    Transform.prototype.init = function (system) {
-        var _this = this;
+    init(system) {
         this.system = system;
-        this.on('changeScene', function (_a) {
-            var scene = _a.scene, mode = _a.mode, application = _a.application;
-            _this.waitChangeScenes.push({ scene: scene, mode: mode, application: application });
+        this.on('changeScene', ({ scene, mode, application }) => {
+            this.waitChangeScenes.push({ scene, mode, application });
         });
-    };
-    Transform.prototype.update = function () {
-        var e_1, _a, e_2, _b;
-        try {
-            for (var _c = __values(this.waitRemoveIds), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var id = _d.value;
-                this.containerManager.removeContainer(id);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-            }
-            finally { if (e_1) throw e_1.error; }
+    }
+    update() {
+        for (const id of this.waitRemoveIds) {
+            this.containerManager.removeContainer(id);
         }
         this.waitRemoveIds = [];
-        try {
-            for (var _e = __values(this.waitChangeScenes), _f = _e.next(); !_f.done; _f = _e.next()) {
-                var sceneInfo = _f.value;
-                var container = this.containerManager.getContainer(sceneInfo.scene.id);
-                if (container) {
-                    sceneInfo.application.stage.removeChildren();
-                    sceneInfo.application.stage.addChild(container);
-                }
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        for (const sceneInfo of this.waitChangeScenes) {
+            const container = this.containerManager.getContainer(sceneInfo.scene.id);
+            if (container) {
+                sceneInfo.application.stage.removeChildren();
+                sceneInfo.application.stage.addChild(container);
             }
-            finally { if (e_2) throw e_2.error; }
         }
         this.waitChangeScenes = [];
-    };
-    Transform.prototype.componentChanged = function (changed) {
+    }
+    componentChanged(changed) {
         if (changed.type === OBSERVER_TYPE.ADD) {
             this.addContainer(changed);
         }
@@ -354,48 +173,47 @@ var Transform = (function (_super) {
         else if (changed.type === OBSERVER_TYPE.REMOVE) {
             this.waitRemoveIds.push(changed.gameObject.id);
         }
-    };
-    Transform.prototype.addContainer = function (changed) {
-        var container = new Container();
+    }
+    addContainer(changed) {
+        const container = new Container();
         container.label = changed.gameObject.name;
         this.containerManager.addContainer({
             name: changed.gameObject.id,
-            container: container,
+            container,
         });
-        var transform = changed.component;
+        const transform = changed.component;
         transform.worldTransform = container.worldTransform;
-    };
-    Transform.prototype.change = function (changed) {
-        var transform = changed.component;
+    }
+    change(changed) {
+        const transform = changed.component;
         if (transform.parent) {
-            var parentContainer = this.containerManager.getContainer(transform.parent.gameObject.id);
+            const parentContainer = this.containerManager.getContainer(transform.parent.gameObject.id);
             parentContainer.addChild(this.containerManager.getContainer(changed.gameObject.id));
-            var render = changed.gameObject.transform.parent &&
+            const render = changed.gameObject.transform.parent &&
                 changed.gameObject.transform.parent.gameObject.getComponent('Render');
             if (render) {
                 render.sortDirty = true;
             }
         }
         else {
-            var container = this.containerManager.getContainer(changed.gameObject.id);
+            const container = this.containerManager.getContainer(changed.gameObject.id);
             delete transform.worldTransform;
             container.parent && container.parent.removeChild(container);
         }
-    };
-    Transform.prototype.destroy = function () {
+    }
+    destroy() {
         this.removeAllListeners();
         this.waitRemoveIds = null;
         this.waitChangeScenes = null;
         this.system = null;
         this.containerManager = null;
-    };
-    Transform = __decorate([
-        decorators.componentObserver({
-            Transform: ['_parent'],
-        })
-    ], Transform);
-    return Transform;
-}(EventEmitter));
+    }
+};
+Transform = __decorate([
+    decorators.componentObserver({
+        Transform: ['_parent'],
+    })
+], Transform);
 var Transform$1 = Transform;
 
 var RENDERER_TYPE;
@@ -404,158 +222,104 @@ var RENDERER_TYPE;
     RENDERER_TYPE[RENDERER_TYPE["WEBGL"] = 1] = "WEBGL";
     RENDERER_TYPE[RENDERER_TYPE["CANVAS"] = 2] = "CANVAS";
 })(RENDERER_TYPE || (RENDERER_TYPE = {}));
-var disableScroll = function (renderer) {
+const disableScroll = renderer => {
     renderer.events.autoPreventDefault = true;
     renderer.canvas.style.touchAction = 'none';
 };
-var enableScroll = function (renderer) {
+const enableScroll = renderer => {
     renderer.events.autoPreventDefault = false;
     renderer.canvas.style.touchAction = 'auto';
 };
-var Renderer$2 = (function (_super) {
-    __extends(Renderer, _super);
-    function Renderer() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.multiApps = [];
-        return _this;
+let Renderer$1 = class Renderer extends System {
+    constructor() {
+        super(...arguments);
+        this.multiApps = [];
     }
-    Renderer.prototype.init = function (params) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        this.params = params;
-                        _a = this;
-                        return [4, this.createApplication(params)];
-                    case 1:
-                        _a.application = _b.sent();
-                        this.containerManager = new ContainerManager$1();
-                        this.rendererManager = new RendererManager$1({
-                            game: this.game,
-                            rendererSystem: this,
-                        });
-                        this.game.canvas = this.application.canvas;
-                        this.transform = new Transform$1({
-                            system: this,
-                            containerManager: this.containerManager,
-                        });
-                        this.game.on('sceneChanged', function (_a) {
-                            var scene = _a.scene, mode = _a.mode, params = _a.params;
-                            var application;
-                            switch (mode) {
-                                case LOAD_SCENE_MODE.SINGLE:
-                                    application = _this.application;
-                                    break;
-                                case LOAD_SCENE_MODE.MULTI_CANVAS:
-                                    application = _this.createMultiApplication({ params: params });
-                                    break;
-                            }
-                            scene.canvas = application.canvas;
-                            _this.transform.emit('changeScene', {
-                                scene: scene,
-                                mode: mode,
-                                application: application,
-                            });
-                        });
-                        return [2];
+    init(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.params = params;
+            this.application = yield this.createApplication(params);
+            this.containerManager = new ContainerManager();
+            this.rendererManager = new RendererManager$1({
+                game: this.game,
+                rendererSystem: this,
+            });
+            this.game.canvas = this.application.canvas;
+            this.transform = new Transform$1({
+                system: this,
+                containerManager: this.containerManager,
+            });
+            this.game.on('sceneChanged', ({ scene, mode, params }) => {
+                let application;
+                switch (mode) {
+                    case LOAD_SCENE_MODE.SINGLE:
+                        application = this.application;
+                        break;
+                    case LOAD_SCENE_MODE.MULTI_CANVAS:
+                        application = this.createMultiApplication({ params });
+                        break;
                 }
+                scene.canvas = application.canvas;
+                this.transform.emit('changeScene', {
+                    scene,
+                    mode,
+                    application,
+                });
             });
         });
-    };
-    Renderer.prototype.registerObserver = function (observerInfo) {
-        var _a;
-        var thisObserverInfo = this.constructor.observerInfo;
-        for (var key in observerInfo) {
+    }
+    registerObserver(observerInfo) {
+        const thisObserverInfo = this.constructor.observerInfo;
+        for (const key in observerInfo) {
             if (!thisObserverInfo[key]) {
                 thisObserverInfo[key] = [];
             }
-            (_a = thisObserverInfo[key]).push.apply(_a, __spread(observerInfo[key]));
+            thisObserverInfo[key].push(...observerInfo[key]);
         }
-    };
-    Renderer.prototype.createMultiApplication = function (_a) {
-        var params = _a.params;
-        var app = this.createApplication(params);
-        this.multiApps.push(app);
-        return app;
-    };
-    Renderer.prototype.createApplication = function (params) {
-        return __awaiter(this, void 0, void 0, function () {
-            var app;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        app = new Application();
-                        if (params.debugMode) {
-                            globalThis.__PIXI_APP__ = app;
-                        }
-                        return [4, app.init(__assign(__assign({ sharedTicker: true }, params), { hello: true }))];
-                    case 1:
-                        _a.sent();
-                        Ticker.shared.stop();
-                        Ticker.shared.autoStart = false;
-                        if (params.enableScroll !== undefined) {
-                            params.enableScroll ? enableScroll(app.renderer) : disableScroll(app.renderer);
-                        }
-                        return [2, app];
-                }
-            });
+    }
+    createMultiApplication({ params }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const app = yield this.createApplication(params);
+            this.multiApps.push(app);
+            return app;
         });
-    };
-    Renderer.prototype.update = function () {
-        var e_1, _a, e_2, _b;
-        var changes = this.componentObserver.clear();
-        try {
-            for (var changes_1 = __values(changes), changes_1_1 = changes_1.next(); !changes_1_1.done; changes_1_1 = changes_1.next()) {
-                var changed = changes_1_1.value;
-                this.transform.componentChanged(changed);
+    }
+    createApplication(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const app = new Application();
+            if (params.debugMode) {
+                globalThis.__PIXI_APP__ = app;
             }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (changes_1_1 && !changes_1_1.done && (_a = changes_1.return)) _a.call(changes_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        try {
-            for (var _c = __values(this.game.gameObjects), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var gameObject = _d.value;
-                this.containerManager.updateTransform({
-                    name: gameObject.id,
-                    transform: gameObject.transform,
-                });
-                this.rendererManager.update(gameObject);
+            yield app.init(Object.assign(Object.assign({ sharedTicker: true }, params), { hello: true }));
+            Ticker.shared.stop();
+            Ticker.shared.autoStart = false;
+            if (params.enableScroll !== undefined) {
+                params.enableScroll ? enableScroll(app.renderer) : disableScroll(app.renderer);
             }
+            return app;
+        });
+    }
+    update() {
+        const changes = this.componentObserver.clear();
+        for (const changed of changes) {
+            this.transform.componentChanged(changed);
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
-            }
-            finally { if (e_2) throw e_2.error; }
+        for (const gameObject of this.game.gameObjects) {
+            this.containerManager.updateTransform({
+                name: gameObject.id,
+                transform: gameObject.transform,
+            });
+            this.rendererManager.update(gameObject);
         }
-    };
-    Renderer.prototype.lateUpdate = function (e) {
+    }
+    lateUpdate(e) {
         this.transform.update();
         this.application.ticker.update(e.time);
-    };
-    Renderer.prototype.onDestroy = function () {
-        var e_3, _a;
+    }
+    onDestroy() {
         this.application.destroy();
-        try {
-            for (var _b = __values(this.multiApps), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var app = _c.value;
-                app && app.destroy();
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_3) throw e_3.error; }
+        for (const app of this.multiApps) {
+            app && app.destroy();
         }
         this.transform.destroy();
         this.transform = null;
@@ -565,69 +329,27 @@ var Renderer$2 = (function (_super) {
         this.application = null;
         this.game = null;
         this.multiApps = null;
-    };
-    Renderer.prototype.resize = function (width, height) {
+    }
+    resize(width, height) {
         this.params.width = width;
         this.params.height = height;
         this.application.renderer.resize(width, height);
-    };
-    Renderer.systemName = 'Renderer';
-    Renderer = __decorate([
-        decorators.componentObserver({
-            Transform: ['_parent'],
-        })
-    ], Renderer);
-    return Renderer;
-}(System));
-var Renderer$3 = Renderer$2;
-
-var Renderer = (function (_super) {
-    __extends(Renderer, _super);
-    function Renderer(params) {
-        var _this = _super.call(this, params) || this;
-        _this.asyncIdMap = {};
-        _this.observerInfo = _this.constructor.observerInfo;
-        return _this;
     }
-    Renderer.prototype.componentChanged = function (_changed) { };
-    Renderer.prototype.rendererUpdate = function (_gameObject) { };
-    Renderer.prototype.update = function (e) {
-        var e_1, _a;
-        var changes = this.componentObserver.clear();
-        try {
-            for (var changes_1 = __values(changes), changes_1_1 = changes_1.next(); !changes_1_1.done; changes_1_1 = changes_1.next()) {
-                var changed = changes_1_1.value;
-                this.componentChanged(changed);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (changes_1_1 && !changes_1_1.done && (_a = changes_1.return)) _a.call(changes_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    };
-    Renderer.prototype.increaseAsyncId = function (id) {
-        this.asyncIdMap[id] = (this.asyncIdMap[id] || 0) + 1;
-        return this.asyncIdMap[id];
-    };
-    Renderer.prototype.validateAsyncId = function (id, asyncId) {
-        return this.asyncIdMap[id] === asyncId;
-    };
-    return Renderer;
-}(System));
-var Renderer$1 = Renderer;
-
-var mixinPIXI = function () {
-};
+};
+Renderer$1.systemName = 'Renderer';
+Renderer$1 = __decorate([
+    decorators.componentObserver({
+        Transform: ['_parent'],
+    })
+], Renderer$1);
+var Renderer$2 = Renderer$1;
 
-var result = undefined;
+let result = undefined;
 function getSuportCompressedTextureFormats() {
     if (result)
         return result;
-    var canvas = document.createElement('canvas');
-    var gl = canvas.getContext('webgl2') || canvas.getContext('webgl');
+    const canvas = document.createElement('canvas');
+    const gl = canvas.getContext('webgl2') || canvas.getContext('webgl');
     if (!gl) {
         console.warn('WebGL not available for compressed textures. Silently failing.');
         return {
@@ -650,7 +372,7 @@ function getSuportCompressedTextureFormats() {
     try {
         console.log('Eva.js Supported Compressed Texture Format List: ' +
             Object.keys(result)
-                .filter(function (type) { return result[type]; })
+                .filter(type => result[type])
                 .join(', '));
     }
     catch (e) { }
@@ -660,14 +382,14 @@ function getSuportCompressedTextureFormats() {
 function addPreProcessResourceHandler(resource) {
     resource.addPreProcessResourceHandler(function normalizeResource(resource) {
         var _a, _b, _c;
-        var textures = (_b = (_a = resource.src) === null || _a === void 0 ? void 0 : _a.image) === null || _b === void 0 ? void 0 : _b.texture;
+        let textures = (_b = (_a = resource.src) === null || _a === void 0 ? void 0 : _a.image) === null || _b === void 0 ? void 0 : _b.texture;
         if (!textures)
             return;
         if (!Array.isArray(textures)) {
             textures = [textures];
         }
-        var formats = (_c = getSuportCompressedTextureFormats()) !== null && _c !== void 0 ? _c : {};
-        var target = textures.find(function (texture) { return formats[texture.type]; });
+        const formats = (_c = getSuportCompressedTextureFormats()) !== null && _c !== void 0 ? _c : {};
+        let target = textures.find(texture => formats[texture.type]);
         if (target) {
             Object.assign(resource.src.image, target);
         }
@@ -682,6 +404,32 @@ function registerKtx2CompressedTexture(params) {
     addPreProcessResourceHandler(resource);
 }
 
+class Renderer extends System {
+    constructor(params) {
+        super(params);
+        this.asyncIdMap = {};
+        this.observerInfo = this.constructor.observerInfo;
+    }
+    componentChanged(_changed) { }
+    rendererUpdate(_gameObject) { }
+    update(e) {
+        const changes = this.componentObserver.clear();
+        for (const changed of changes) {
+            this.componentChanged(changed);
+        }
+    }
+    increaseAsyncId(id) {
+        this.asyncIdMap[id] = (this.asyncIdMap[id] || 0) + 1;
+        return this.asyncIdMap[id];
+    }
+    validateAsyncId(id, asyncId) {
+        return this.asyncIdMap[id] === asyncId;
+    }
+}
+
+const mixinPIXI = () => {
+};
+
 mixinPIXI();
 
-export { ContainerManager$1 as ContainerManager, RENDERER_TYPE, Renderer$1 as Renderer, RendererManager$1 as RendererManager, Renderer$3 as RendererSystem, registerKtx2CompressedTexture };
+export { ContainerManager, RENDERER_TYPE, Renderer, RendererManager$1 as RendererManager, Renderer$2 as RendererSystem, registerKtx2CompressedTexture };