archetype-ecs-lib 0.5.0 → 0.6.1

package/lib/ecs/stats/StatsOverlay.js

@@ -0,0 +1,548 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (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;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsOverlay = void 0;
+var StatsOverlay = /** @class */ (function () {
+    function StatsOverlay(options) {
+        if (options === void 0) { options = {}; }
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        this.root = null;
+        this.header = null;
+        this.toggleButton = null;
+        this.debugToggleButton = null;
+        this.content = null;
+        this.text = null;
+        this.canvas = null;
+        this.ctx = null;
+        this.resizeObserver = null;
+        this.isExpanded = true;
+        this.debugLoggingEnabled = false;
+        this.isInitialized = false;
+        this.debugingEnabled = false;
+        // ---- Profiling / stats (last completed frame) ----
+        this._profilingEnabled = true;
+        this._frameCounter = 0;
+        this._lastDt = 0;
+        this._lastFrameMs = 0;
+        this._phaseMs = new Map();
+        this._systemMs = new Map();
+        // ---- Profiling history (rolling window) ----
+        this._historyCapacity = 120;
+        this._histDt = [];
+        this._histFrameMs = [];
+        this._histPhaseMs = new Map();
+        this._histSystemMs = new Map();
+        // Drag state
+        this.isDragging = false;
+        this.dragOffsetX = 0;
+        this.dragOffsetY = 0;
+        this.opts = {
+            parent: (_a = options.parent) !== null && _a !== void 0 ? _a : null,
+            left: (_b = options.left) !== null && _b !== void 0 ? _b : 8,
+            top: (_c = options.top) !== null && _c !== void 0 ? _c : 8,
+            width: (_d = options.width) !== null && _d !== void 0 ? _d : 320,
+            height: (_e = options.height) !== null && _e !== void 0 ? _e : 80,
+            targetFrameMs: (_f = options.targetFrameMs) !== null && _f !== void 0 ? _f : 16.67,
+            slowFrameMs: (_g = options.slowFrameMs) !== null && _g !== void 0 ? _g : 20,
+            maxSamples: (_h = options.maxSamples) !== null && _h !== void 0 ? _h : 240
+        };
+    }
+    StatsOverlay.prototype.initializeDom = function () {
+        var _this = this;
+        if (this.isInitialized || !this.opts.parent)
+            return;
+        this.isInitialized = true;
+        this.root = document.createElement("div");
+        this.root.style.position = "fixed";
+        this.root.style.left = "".concat(this.opts.left, "px");
+        this.root.style.top = "".concat(this.opts.top, "px");
+        this.root.style.zIndex = "9999";
+        this.root.style.fontFamily = "ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace";
+        this.root.style.fontSize = "12px";
+        this.root.style.color = "#d7e3ff";
+        this.root.style.background = "rgba(10, 14, 24, 0.75)";
+        this.root.style.border = "1px solid rgba(140, 170, 255, 0.25)";
+        this.root.style.borderRadius = "8px";
+        this.root.style.backdropFilter = "blur(2px)";
+        this.root.style.maxWidth = "calc(100vw - 16px)";
+        this.header = document.createElement("div");
+        this.header.style.display = "flex";
+        this.header.style.alignItems = "center";
+        this.header.style.padding = "8px";
+        this.header.style.cursor = "pointer";
+        this.header.style.pointerEvents = "auto";
+        this.header.style.userSelect = "none";
+        var title = document.createElement("span");
+        title.textContent = "ECS Stats";
+        title.style.fontWeight = "600";
+        title.style.userSelect = "none";
+        title.style.marginRight = "10px";
+        this.toggleButton = document.createElement("button");
+        this.toggleButton.textContent = "−";
+        this.toggleButton.style.background = "rgba(140, 170, 255, 0.15)";
+        this.toggleButton.style.border = "1px solid rgba(140, 170, 255, 0.3)";
+        this.toggleButton.style.borderRadius = "4px";
+        this.toggleButton.style.color = "#d7e3ff";
+        this.toggleButton.style.width = "24px";
+        this.toggleButton.style.height = "24px";
+        this.toggleButton.style.cursor = "pointer";
+        this.toggleButton.style.fontSize = "16px";
+        this.toggleButton.style.lineHeight = "1";
+        this.toggleButton.style.padding = "0";
+        this.toggleButton.style.display = "flex";
+        this.toggleButton.style.alignItems = "center";
+        this.toggleButton.style.justifyContent = "center";
+        this.toggleButton.style.userSelect = "none";
+        this.toggleButton.addEventListener("mouseenter", function () {
+            _this.toggleButton.style.background = "rgba(140, 170, 255, 0.25)";
+        });
+        this.toggleButton.addEventListener("mouseleave", function () {
+            _this.toggleButton.style.background = "rgba(140, 170, 255, 0.15)";
+        });
+        this.toggleButton.addEventListener("click", function (e) {
+            e.stopPropagation();
+            _this.toggle();
+        });
+        this.debugToggleButton = this.createDebugToggleButton("🔇", "Toggle console debug logging");
+        this.debugToggleButton.style.marginRight = "5px";
+        this.debugToggleButton.addEventListener("click", function (e) {
+            e.stopPropagation();
+            _this.toggleDebugLogging();
+        });
+        this.header.appendChild(title);
+        this.header.appendChild(this.debugToggleButton);
+        this.header.appendChild(this.toggleButton);
+        this.content = document.createElement("div");
+        this.content.style.padding = "0 8px 8px 8px";
+        this.content.style.pointerEvents = "none";
+        this.text = document.createElement("pre");
+        this.text.style.margin = "0 0 6px 0";
+        this.text.style.whiteSpace = "pre";
+        this.text.style.lineHeight = "1.2";
+        this.canvas = document.createElement("canvas");
+        this.canvas.style.display = "block";
+        this.canvas.style.borderRadius = "6px";
+        this.canvas.style.background = "rgba(255,255,255,0.04)";
+        this.canvas.style.width = "100%";
+        this.canvas.style.height = "auto";
+        var ctx = this.canvas.getContext("2d");
+        if (!ctx)
+            throw new Error("StatsOverlay: canvas 2D context not available");
+        this.ctx = ctx;
+        this.content.appendChild(this.text);
+        this.content.appendChild(this.canvas);
+        this.root.appendChild(this.header);
+        this.root.appendChild(this.content);
+        this.opts.parent.appendChild(this.root);
+        this.resizeCanvas();
+        this.resizeObserver = new ResizeObserver(function () { return _this.resizeCanvas(); });
+        this.resizeObserver.observe(this.root);
+        this.setupDrag();
+    };
+    StatsOverlay.prototype.setDebugging = function (enabled) {
+        var _a;
+        if (enabled) {
+            // Only initialize DOM if we're in a browser environment
+            if (typeof document !== "undefined") {
+                this.opts.parent = (_a = this.opts.parent) !== null && _a !== void 0 ? _a : document.body;
+                this.initializeDom();
+            }
+        }
+        else {
+            this.destroyOverlay();
+        }
+        this.debugingEnabled = enabled;
+    };
+    StatsOverlay.prototype.setProfilingEnabled = function (enabled) {
+        this._profilingEnabled = enabled;
+    };
+    StatsOverlay.prototype.setProfilingHistorySize = function (frames) {
+        this._historyCapacity = Math.max(0, Math.floor(frames));
+        this._trimHistoryToCapacity();
+    };
+    StatsOverlay.prototype._trimHistoryToCapacity = function () {
+        var e_1, _a, e_2, _b;
+        var cap = this._historyCapacity;
+        var trimArray = function (arr) {
+            if (cap === 0) {
+                arr.length = 0;
+                return;
+            }
+            while (arr.length > cap)
+                arr.shift();
+        };
+        trimArray(this._histDt);
+        trimArray(this._histFrameMs);
+        try {
+            for (var _c = __values(this._histPhaseMs.values()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var arr = _d.value;
+                trimArray(arr);
+            }
+        }
+        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; }
+        }
+        try {
+            for (var _e = __values(this._histSystemMs.values()), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var arr = _f.value;
+                trimArray(arr);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    StatsOverlay.prototype._pushSeriesFrame = function (series, current) {
+        var e_3, _a, e_4, _b;
+        var _c;
+        var sizeBefore = this._histFrameMs.length; // same as dt length before push
+        try {
+            // Ensure existing keys get a value (0 if missing this frame)
+            for (var series_1 = __values(series), series_1_1 = series_1.next(); !series_1_1.done; series_1_1 = series_1.next()) {
+                var _d = __read(series_1_1.value, 2), k = _d[0], arr = _d[1];
+                var v = (_c = current.get(k)) !== null && _c !== void 0 ? _c : 0;
+                arr.push(v);
+                if (this._historyCapacity === 0)
+                    arr.length = 0;
+                else
+                    while (arr.length > this._historyCapacity)
+                        arr.shift();
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (series_1_1 && !series_1_1.done && (_a = series_1.return)) _a.call(series_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        try {
+            // New keys discovered this frame: backfill zeros so lengths align
+            for (var current_1 = __values(current), current_1_1 = current_1.next(); !current_1_1.done; current_1_1 = current_1.next()) {
+                var _e = __read(current_1_1.value, 2), k = _e[0], v = _e[1];
+                if (series.has(k))
+                    continue;
+                var arr = new Array(sizeBefore).fill(0);
+                arr.push(v);
+                series.set(k, arr);
+                if (this._historyCapacity === 0)
+                    arr.length = 0;
+                else
+                    while (arr.length > this._historyCapacity)
+                        arr.shift();
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (current_1_1 && !current_1_1.done && (_b = current_1.return)) _b.call(current_1);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    };
+    /** @internal Called by Schedule/World.update to start a new profiling frame */
+    StatsOverlay.prototype._profBeginFrame = function (dt) {
+        this._frameCounter++;
+        this._lastDt = dt;
+        this._phaseMs.clear();
+        this._systemMs.clear();
+        if (!this._profilingEnabled) {
+            this._lastFrameMs = 0;
+            return 0;
+        }
+        return performance.now();
+    };
+    /** @internal Called by Schedule/World.update to end a new profiling frame */
+    StatsOverlay.prototype._profEndFrame = function (frameStartMs) {
+        if (!this._profilingEnabled)
+            return;
+        this._lastFrameMs = performance.now() - frameStartMs;
+        // Update history (aligned series)
+        this._histDt.push(this._lastDt);
+        this._histFrameMs.push(this._lastFrameMs);
+        this._trimHistoryToCapacity();
+        this._pushSeriesFrame(this._histPhaseMs, this._phaseMs);
+        this._pushSeriesFrame(this._histSystemMs, this._systemMs);
+    };
+    /** @internal */
+    StatsOverlay.prototype._profAddPhase = function (phase, ms) {
+        var _a;
+        if (!this._profilingEnabled)
+            return;
+        this._phaseMs.set(phase, ((_a = this._phaseMs.get(phase)) !== null && _a !== void 0 ? _a : 0) + ms);
+    };
+    /** @internal */
+    StatsOverlay.prototype._profAddSystem = function (name, ms) {
+        var _a;
+        if (!this._profilingEnabled)
+            return;
+        this._systemMs.set(name, ((_a = this._systemMs.get(name)) !== null && _a !== void 0 ? _a : 0) + ms);
+    };
+    StatsOverlay.prototype.createDebugToggleButton = function (text, title) {
+        var btn = document.createElement("button");
+        btn.textContent = text;
+        btn.title = title;
+        btn.style.background = "rgba(140, 170, 255, 0.15)";
+        btn.style.border = "1px solid rgba(140, 170, 255, 0.3)";
+        btn.style.borderRadius = "4px";
+        btn.style.color = "#d7e3ff";
+        btn.style.width = "24px";
+        btn.style.height = "24px";
+        btn.style.cursor = "pointer";
+        btn.style.fontSize = "12px";
+        btn.style.lineHeight = "1";
+        btn.style.padding = "0";
+        btn.style.display = "flex";
+        btn.style.alignItems = "center";
+        btn.style.justifyContent = "center";
+        btn.style.userSelect = "none";
+        btn.addEventListener("mouseenter", function () {
+            btn.style.background = "rgba(140, 170, 255, 0.25)";
+        });
+        btn.addEventListener("mouseleave", function () {
+            btn.style.background = "rgba(140, 170, 255, 0.15)";
+        });
+        return btn;
+    };
+    StatsOverlay.prototype.toggleDebugLogging = function () {
+        this.debugLoggingEnabled = !this.debugLoggingEnabled;
+        this.debugToggleButton.textContent = this.debugLoggingEnabled ? "🔊" : "🔇";
+        this.debugToggleButton.title = this.debugLoggingEnabled
+            ? "Console debug logging ON (click to disable)"
+            : "Console debug logging OFF (click to enable)";
+    };
+    StatsOverlay.prototype.setupDrag = function () {
+        var _this = this;
+        var onMouseDown = function (e) {
+            // Ignore if clicking the toggle button
+            if (e.target === _this.toggleButton || e.target === _this.debugToggleButton)
+                return;
+            _this.isDragging = true;
+            var rect = _this.root.getBoundingClientRect();
+            _this.dragOffsetX = e.clientX - rect.left;
+            _this.dragOffsetY = e.clientY - rect.top;
+            _this.header.style.cursor = "grabbing";
+            document.body.style.userSelect = "none";
+        };
+        var onMouseMove = function (e) {
+            if (!_this.isDragging)
+                return;
+            var newLeft = e.clientX - _this.dragOffsetX;
+            var newTop = e.clientY - _this.dragOffsetY;
+            // Clamp to viewport bounds
+            var rect = _this.root.getBoundingClientRect();
+            var maxLeft = window.innerWidth - rect.width;
+            var maxTop = window.innerHeight - rect.height;
+            _this.root.style.left = "".concat(Math.max(0, Math.min(newLeft, maxLeft)), "px");
+            _this.root.style.top = "".concat(Math.max(0, Math.min(newTop, maxTop)), "px");
+        };
+        var onMouseUp = function () {
+            if (!_this.isDragging)
+                return;
+            _this.isDragging = false;
+            _this.header.style.cursor = "grab";
+            document.body.style.userSelect = "";
+        };
+        this.header.addEventListener("mousedown", onMouseDown);
+        document.addEventListener("mousemove", onMouseMove);
+        document.addEventListener("mouseup", onMouseUp);
+        // Store references for cleanup
+        this._dragCleanup = function () {
+            _this.header.removeEventListener("mousedown", onMouseDown);
+            document.removeEventListener("mousemove", onMouseMove);
+            document.removeEventListener("mouseup", onMouseUp);
+        };
+    };
+    StatsOverlay.prototype.resizeCanvas = function () {
+        if (!this.canvas || !this.ctx)
+            return;
+        var dpr = window.devicePixelRatio || 1;
+        var rect = this.canvas.getBoundingClientRect();
+        var width = Math.min(this.opts.width, rect.width || this.opts.width);
+        var height = this.opts.height;
+        this.canvas.width = width * dpr;
+        this.canvas.height = height * dpr;
+        this.canvas.style.width = "".concat(width, "px");
+        this.canvas.style.height = "".concat(height, "px");
+        // Reset transform so repeated resizes don't accumulate scale.
+        var ctxAny = this.ctx;
+        if (typeof ctxAny.setTransform === "function") {
+            ctxAny.setTransform(1, 0, 0, 1, 0, 0);
+        }
+        else if (typeof ctxAny.resetTransform === "function") {
+            ctxAny.resetTransform();
+        }
+        this.ctx.scale(dpr, dpr);
+    };
+    StatsOverlay.prototype.toggle = function () {
+        if (!this.content || !this.toggleButton)
+            return;
+        this.isExpanded = !this.isExpanded;
+        this.content.style.display = this.isExpanded ? "block" : "none";
+        this.toggleButton.textContent = this.isExpanded ? "−" : "+";
+    };
+    StatsOverlay.prototype.destroyOverlay = function () {
+        var _a, _b, _c, _d;
+        (_b = (_a = this)._dragCleanup) === null || _b === void 0 ? void 0 : _b.call(_a);
+        (_c = this.resizeObserver) === null || _c === void 0 ? void 0 : _c.disconnect();
+        (_d = this.root) === null || _d === void 0 ? void 0 : _d.remove();
+        this.isInitialized = false;
+    };
+    /** Convenience: call each frame */
+    StatsOverlay.prototype.updateOverlay = function (stats, statsHistory) {
+        if (!this.debugingEnabled || !this.isInitialized)
+            return;
+        this.render(stats, statsHistory);
+    };
+    StatsOverlay.prototype.render = function (s, h) {
+        if (!this.debugingEnabled || !this.text || !this.ctx)
+            return;
+        var topPhases = Object.entries(s.phaseMs)
+            .sort(function (a, b) { return b[1] - a[1]; })
+            .slice(0, 6)
+            .map(function (_a) {
+            var _b = __read(_a, 2), k = _b[0], v = _b[1];
+            return "".concat(k, "=").concat(v.toFixed(2), "ms");
+        })
+            .join(" ");
+        this.text.textContent =
+            "Frame ".concat(s.frame, "\n") +
+                "Archetypes: ".concat(s.archetypes, "\n") +
+                "Rows: ".concat(s.rows, "\n") +
+                "Alive entities: ".concat(s.aliveEntities, "\n") +
+                "Systems: ".concat(s.systems, "\n") +
+                "Resources: ".concat(s.resources, "\n") +
+                "Event channels: ".concat(s.eventChannels, "\n") +
+                "Pending commands: ".concat(String(s.pendingCommands), "\n") +
+                "dt=".concat((s.dt * 1000).toFixed(2), "ms frame=").concat(s.frameMs.toFixed(2), "ms\n") +
+                "Phases: ".concat(topPhases);
+        if (this.debugLoggingEnabled) {
+            // tslint:disable-next-line:no-console
+            console.debug("Phases: ".concat(topPhases));
+        }
+        this.drawFrameGraph(h);
+    };
+    StatsOverlay.prototype.drawFrameGraph = function (h) {
+        var ctx = this.ctx;
+        var dpr = window.devicePixelRatio || 1;
+        var w = this.canvas.width / dpr;
+        var hh = this.canvas.height / dpr;
+        ctx.clearRect(0, 0, w, hh);
+        var n = Math.min(h.size, this.opts.maxSamples);
+        var series = h.frameMs.slice(h.size - n);
+        var maxMs = Math.max.apply(Math, __spreadArray([33.33, this.opts.targetFrameMs], __read(series), false));
+        var toY = function (ms) { return hh - (ms / maxMs) * (hh - 10) - 5; };
+        // colors (match bars)
+        var targetLineColor = "rgba(255,255,255,0.18)";
+        var okBarColor = "rgba(110,200,255,0.85)";
+        var slowBarColor = "rgba(255,110,110,0.85)";
+        var legendTextColor = "rgba(215,227,255,0.90)";
+        var legendBg = "rgba(10, 14, 24, 0.55)";
+        // target line
+        ctx.strokeStyle = targetLineColor;
+        ctx.beginPath();
+        ctx.moveTo(0, toY(this.opts.targetFrameMs));
+        ctx.lineTo(w, toY(this.opts.targetFrameMs));
+        ctx.stroke();
+        // bars (use actual series length; ensure width >= 1px)
+        var barW = Math.max(1, Math.floor(w / Math.max(1, series.length)));
+        var drawW = Math.max(1, barW);
+        for (var i = 0; i < series.length; i++) {
+            var ms = series[i];
+            var _x = i * barW;
+            var _y = toY(ms);
+            var bh = hh - _y;
+            var slow = ms > this.opts.slowFrameMs;
+            ctx.fillStyle = slow ? slowBarColor : okBarColor;
+            ctx.fillRect(_x, _y, drawW, bh);
+        }
+        // ---- Legend (top-left inside graph) ----
+        ctx.save();
+        ctx.font = "11px ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace";
+        ctx.textBaseline = "middle";
+        ctx.fillStyle = legendTextColor;
+        var pad = 6;
+        var lineH = 14;
+        var lineLabel = "Target ".concat(this.opts.targetFrameMs.toFixed(2), "ms");
+        var okLabel = "OK \u2264 ".concat(this.opts.slowFrameMs.toFixed(0), "ms");
+        var slowLabel = "Slow > ".concat(this.opts.slowFrameMs.toFixed(0), "ms");
+        // compute background box width roughly
+        var w1 = ctx.measureText(lineLabel).width;
+        var w2 = ctx.measureText(okLabel).width;
+        var w3 = ctx.measureText(slowLabel).width;
+        var boxW = Math.ceil(Math.max(w1, w2, w3) + 40);
+        var boxH = pad * 2 + lineH * 3;
+        // background
+        ctx.fillStyle = legendBg;
+        ctx.fillRect(6, 6, boxW, boxH);
+        // row 1: target line sample
+        var x = 6 + pad;
+        var y = 6 + pad + lineH * 0.5;
+        ctx.strokeStyle = targetLineColor;
+        ctx.lineWidth = 2;
+        ctx.beginPath();
+        ctx.moveTo(x, y);
+        ctx.lineTo(x + 18, y);
+        ctx.stroke();
+        ctx.fillStyle = legendTextColor;
+        ctx.fillText(lineLabel, x + 24, y);
+        // row 2: ok bar sample
+        y += lineH;
+        ctx.fillStyle = okBarColor;
+        ctx.fillRect(x, y - 5, 18, 10);
+        ctx.fillStyle = legendTextColor;
+        ctx.fillText(okLabel, x + 24, y);
+        // row 3: slow bar sample
+        y += lineH;
+        ctx.fillStyle = slowBarColor;
+        ctx.fillRect(x, y - 5, 18, 10);
+        ctx.fillStyle = legendTextColor;
+        ctx.fillText(slowLabel, x + 24, y);
+        ctx.restore();
+    };
+    return StatsOverlay;
+}());
+exports.StatsOverlay = StatsOverlay;

package/lib/index.d.ts

@@ -4,3 +4,4 @@ export * from "./ecs/Commands";
 export * from "./ecs/World";
 export * from "./ecs/Schedule";
 export * from "./ecs/Events";
+export * from "./ecs/stats/StatsOverlay";

package/lib/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./ecs/Commands"), exports);
 __exportStar(require("./ecs/World"), exports);
 __exportStar(require("./ecs/Schedule"), exports);
 __exportStar(require("./ecs/Events"), exports);
+__exportStar(require("./ecs/stats/StatsOverlay"), exports);

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "archetype-ecs-lib",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "An Archetype Entity Component System (AECS)",
   "main": "./lib/index.js",
   "scripts": {
     "test": "jest --coverage",
     "build": "tsc",
-    "lint": "tslint -c tslint.json src/**/*.ts",
+    "lint": "eslint src/ test/",
+    "lint:fix": "eslint src/ test/ --fix",
     "reload-packages": "rm -Rf node_modules && npm cache clean --force && npm ci"
   },
   "repository": {
@@ -31,7 +32,6 @@
   },
   "license": "MIT",
   "dependencies": {
-    "tslint": "^6.1.3",
     "typescript": "^5.9.3"
   },
   "files": [
@@ -40,8 +40,12 @@
   ],
   "typings": "./lib/index.d.ts",
   "devDependencies": {
+    "@eslint/js": "^9.0.0",
     "@types/jest": "^30.0.0",
+    "eslint": "^9.0.0",
     "jest": "^30.2.0",
-    "ts-jest": "^29.4.6"
+    "jest-environment-jsdom": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "typescript-eslint": "^8.0.0"
   }
 }