minimojs 1.0.0-alpha.17 → 1.0.0-alpha.18

package/dist/internal/AnimationSystem.js

@@ -1,12 +1,19 @@
 /** @internal */
 export class AnimationSystem {
     constructor() {
+        /** @internal */
         this._animations = [];
+        /** @internal */
         this._deformAnimations = [];
+        /** @internal */
         this._motionAnimations = [];
+        /** @internal */
         this._shakeAnimations = [];
+        /** @internal */
         this._blinkAnimations = [];
+        /** @internal */
         this._flickerAnimations = [];
+        /** @internal */
         this._renderDataSprites = new Set();
     }
     update(dtMs) {
@@ -211,31 +218,37 @@ export class AnimationSystem {
         this._flickerAnimations = [];
         this._renderDataSprites.clear();
     }
+    /** @internal */
     sanitizeScale(value) {
         if (!Number.isFinite(value))
             return 1;
         return Math.max(0, value);
     }
+    /** @internal */
     sanitizeDuration(value) {
         if (!Number.isFinite(value))
             return 1;
         return Math.max(1, value);
     }
+    /** @internal */
     sanitizeNonNegative(value) {
         if (!Number.isFinite(value))
             return 0;
         return Math.max(0, value);
     }
+    /** @internal */
     sanitizePivot(value) {
         if (!Number.isFinite(value))
             return 0.5;
         return Math.max(0, Math.min(1, value));
     }
+    /** @internal */
     replaceMotionAnimation(entry) {
         const animations = this._motionAnimations.filter((a) => a.sprite !== entry.sprite);
         animations.push(entry);
         this._motionAnimations = animations;
     }
+    /** @internal */
     rebuildRenderData(dtMs) {
         const next = new Map();
         const nextSprites = new Set();

package/dist/internal/AssetSystem.js

@@ -1,8 +1,11 @@
 /** @internal */
 export class AssetSystem {
     constructor() {
+        /** @internal */
         this._queuedImages = new Map();
+        /** @internal */
         this._loadedImages = new Map();
+        /** @internal */
         this._imageSources = new Map();
     }
     queueImage(key, src) {
@@ -51,6 +54,7 @@ export class AssetSystem {
         }));
         this._queuedImages.clear();
     }
+    /** @internal */
     loadImage(src) {
         return new Promise((resolve, reject) => {
             const image = new Image();

package/dist/internal/BackgroundSystem.js

@@ -1,6 +1,7 @@
 /** @internal */
 export class BackgroundSystem {
     constructor() {
+        /** @internal */
         this._layers = [];
     }
     add(layer) {

package/dist/internal/CanvasSystem.js

@@ -1,8 +1,10 @@
 /** @internal */
 export class CanvasSystem {
-    constructor(canvas) {
+    constructor(/** @internal */ canvas) {
         this.canvas = canvas;
+        /** @internal */
         this.onResize = () => this.applyResponsiveCanvasLayout();
+        /** @internal */
         this.onViewportChange = () => this.applyResponsiveCanvasLayout();
     }
     initialize() {
@@ -22,6 +24,7 @@ export class CanvasSystem {
         window.visualViewport?.addEventListener("resize", this.onViewportChange);
         window.visualViewport?.addEventListener("scroll", this.onViewportChange);
     }
+    /** @internal */
     applyResponsiveCanvasLayout() {
         if (!document.body)
             return;

package/dist/internal/ExplosionSystem.js

@@ -45,7 +45,9 @@ const DEFAULT_WIPE_OPTIONS = {
 /** @internal */
 export class ExplosionSystem {
     constructor() {
+        /** @internal */
         this._pieceEffects = [];
+        /** @internal */
         this._wipes = [];
     }
     animateExplode(sprite, glyphCanvas, options, onComplete) {
@@ -190,6 +192,7 @@ export class ExplosionSystem {
         this._pieceEffects = [];
         this._wipes = [];
     }
+    /** @internal */
     spawnRadialEffect(mode, sprite, glyphCanvas, context, options, forceHideSprite, restoreVisibility, finalVisible, onComplete) {
         this.clearSpriteEffects(sprite);
         if (forceHideSprite || restoreVisibility) {
@@ -241,6 +244,7 @@ export class ExplosionSystem {
             onComplete,
         });
     }
+    /** @internal */
     spawnDirectionalEffect(mode, sprite, glyphCanvas, context, options, forceHideSprite, restoreVisibility, finalVisible, onComplete) {
         this.clearSpriteEffects(sprite);
         if (forceHideSprite || restoreVisibility) {
@@ -298,6 +302,7 @@ export class ExplosionSystem {
             onComplete,
         });
     }
+    /** @internal */
     buildPieceGrid(glyphCanvas, context, rows, cols, builder, mode) {
         const pieces = [];
         const rotationRad = (context.rotation * Math.PI) / 180;
@@ -362,6 +367,7 @@ export class ExplosionSystem {
         }
         return pieces;
     }
+    /** @internal */
     buildPieceSpriteContext(sprite, glyphCanvas) {
         const renderData = sprite._renderData;
         const deformScaleX = this.getSafeScale(renderData?.scaleX);
@@ -392,6 +398,7 @@ export class ExplosionSystem {
             absScaleY: Math.abs(signedScaleY),
         };
     }
+    /** @internal */
     clearSpriteEffects(sprite) {
         const remainingPieces = [];
         for (const effect of this._pieceEffects) {
@@ -418,6 +425,7 @@ export class ExplosionSystem {
         }
         this._wipes = remainingWipes;
     }
+    /** @internal */
     getDirectionalProgress(row, col, rows, cols, direction) {
         const rowProgress = rows <= 1 ? 0 : row / (rows - 1);
         const colProgress = cols <= 1 ? 0 : col / (cols - 1);
@@ -432,6 +440,7 @@ export class ExplosionSystem {
                 return 1 - rowProgress;
         }
     }
+    /** @internal */
     getDirectionVector(direction) {
         switch (direction) {
             case "left-to-right":
@@ -444,6 +453,7 @@ export class ExplosionSystem {
                 return { x: 0, y: -1 };
         }
     }
+    /** @internal */
     getRadialVelocity(x, y) {
         const magnitude = Math.hypot(x, y);
         let dirX = 0;
@@ -460,6 +470,7 @@ export class ExplosionSystem {
         const jitterAngle = (Math.random() - 0.5) * (Math.PI / 2);
         return this.rotate(dirX, dirY, jitterAngle);
     }
+    /** @internal */
     easePieceProgress(mode, t) {
         const clamped = Math.max(0, Math.min(1, t));
         switch (mode) {
@@ -471,6 +482,7 @@ export class ExplosionSystem {
                 return clamped * clamped * (3 - 2 * clamped);
         }
     }
+    /** @internal */
     rotate(x, y, radians) {
         const cos = Math.cos(radians);
         const sin = Math.sin(radians);
@@ -479,39 +491,47 @@ export class ExplosionSystem {
             y: x * sin + y * cos,
         };
     }
+    /** @internal */
     lerp(from, to, t) {
         return from + (to - from) * t;
     }
+    /** @internal */
     getSafeScale(value) {
         if (!Number.isFinite(value))
             return 1;
         return Math.max(0, value);
     }
+    /** @internal */
     getSafePivot(value) {
         if (!Number.isFinite(value))
             return 0.5;
         return Math.max(0, Math.min(1, value));
     }
+    /** @internal */
     getSafeNumber(value, fallback) {
         if (!Number.isFinite(value))
             return fallback;
         return value;
     }
+    /** @internal */
     sanitizeCount(value, fallback) {
         if (!Number.isFinite(value))
             return fallback;
         return Math.max(1, Math.round(value));
     }
+    /** @internal */
     sanitizeDuration(value, fallback) {
         if (!Number.isFinite(value))
             return fallback;
         return Math.max(1, value);
     }
+    /** @internal */
     sanitizeNonNegative(value, fallback) {
         if (!Number.isFinite(value))
             return fallback;
         return Math.max(0, value);
     }
+    /** @internal */
     sanitizeNumber(value, fallback) {
         if (!Number.isFinite(value))
             return fallback;

package/dist/internal/InputSystem.js

@@ -1,19 +1,33 @@
 /** @internal */
 export class InputSystem {
-    constructor(game, canvas) {
+    constructor(
+    /** @internal */ game, 
+    /** @internal */ canvas) {
         this.game = game;
         this.canvas = canvas;
+        /** @internal */
         this._keysDown = new Set();
+        /** @internal */
         this._keysPressed = new Set();
+        /** @internal */
         this._pointerDown = false;
+        /** @internal */
         this._pointerPressed = false;
+        /** @internal */
         this._pointerX = 0;
+        /** @internal */
         this._pointerY = 0;
+        /** @internal */
         this._mouseDown = false;
+        /** @internal */
         this._mousePressed = false;
+        /** @internal */
         this._mouseX = 0;
+        /** @internal */
         this._mouseY = 0;
+        /** @internal */
         this._touchPointers = new Map();
+        /** @internal */
         this._primaryTouchId = null;
     }
     get pointerX() {
@@ -176,6 +190,7 @@ export class InputSystem {
     resetPressedState() {
         this.clearFramePressedState();
     }
+    /** @internal */
     getCanvasPoint(clientX, clientY) {
         const rect = this.canvas.getBoundingClientRect();
         const scaleX = this.canvas.width / rect.width;
@@ -185,6 +200,7 @@ export class InputSystem {
             y: (clientY - rect.top) * scaleY,
         };
     }
+    /** @internal */
     isScreenPointOverSprite(x, y, sprite) {
         const halfWidth = sprite.displayWidth / 2;
         const halfHeight = sprite.displayHeight / 2;
@@ -192,6 +208,7 @@ export class InputSystem {
         const drawY = sprite.ignoreScroll ? sprite.renderY : sprite.renderY - this.game.scrollY;
         return Math.abs(x - drawX) <= halfWidth && Math.abs(y - drawY) <= halfHeight;
     }
+    /** @internal */
     collectPointers() {
         const pointers = [];
         if (this._mouseDown) {
@@ -214,6 +231,7 @@ export class InputSystem {
         }
         return pointers;
     }
+    /** @internal */
     syncPrimaryPointer() {
         if (this._primaryTouchId !== null) {
             const primaryTouch = this._touchPointers.get(this._primaryTouchId);

package/dist/internal/LoopSystem.js

@@ -1,12 +1,18 @@
 /** @internal */
 export class LoopSystem {
-    constructor(onFrame) {
+    constructor(/** @internal */ onFrame) {
         this.onFrame = onFrame;
+        /** @internal */
         this._rafId = null;
+        /** @internal */
         this._lastTimestamp = null;
+        /** @internal */
         this._running = false;
+        /** @internal */
         this._hasCreated = false;
+        /** @internal */
         this._onCreate = null;
+        /** @internal */
         this.loop = (timestamp) => {
             if (!this._running)
                 return;

package/dist/internal/PhysicsSystem.js

@@ -1,8 +1,11 @@
 /** @internal */
 export class PhysicsSystem {
     constructor() {
+        /** @internal */
         this._gravityX = 0;
+        /** @internal */
         this._gravityY = 0;
+        /** @internal */
         this._enabled = false;
     }
     get gravityX() {
@@ -94,11 +97,13 @@ export class PhysicsSystem {
         }
         return null;
     }
+    /** @internal */
     assertEnabled() {
         if (!this._enabled) {
             throw new Error("MinimoJS: collide() and collideAny() require game.physics = true.");
         }
     }
+    /** @internal */
     getCollisionResolution(a, b) {
         const halfWidthA = a.bodyDisplayWidth / 2;
         const halfHeightA = a.bodyDisplayHeight / 2;

package/dist/internal/RenderSystem.js

@@ -1,10 +1,15 @@
 /** @internal */
 export class RenderSystem {
     constructor() {
+        /** @internal */
         this._surfaceCache = new Map();
+        /** @internal */
         this._lastAppliedPageBackground = undefined;
+        /** @internal */
         this._transitionScratchCanvas = null;
+        /** @internal */
         this._transitionScratchContext = null;
+        /** @internal */
         this._dynamicSurfacePassId = 0;
     }
     clearSpriteCache() {
@@ -95,6 +100,7 @@ export class RenderSystem {
                 return;
         }
     }
+    /** @internal */
     renderScene(options) {
         const ctx = options.context;
         const W = options.canvas.width;
@@ -207,6 +213,7 @@ export class RenderSystem {
             this.drawInputDebugOverlay(ctx, sorted, options.scrollX, options.scrollY);
         }
     }
+    /** @internal */
     drawBodyDebugOverlay(ctx, sprites, scrollX, scrollY) {
         ctx.save();
         ctx.setLineDash([6, 4]);
@@ -233,6 +240,7 @@ export class RenderSystem {
         }
         ctx.restore();
     }
+    /** @internal */
     drawInputDebugOverlay(ctx, sprites, scrollX, scrollY) {
         ctx.save();
         ctx.setLineDash([3, 5]);
@@ -284,6 +292,7 @@ export class RenderSystem {
         ctx.strokeRect(barX, barY, barWidth, barHeight);
         ctx.restore();
     }
+    /** @internal */
     drawFadeTransition(ctx, transition, width, height, progress) {
         const firstHalf = progress < 0.5;
         const localT = firstHalf ? progress / 0.5 : (progress - 0.5) / 0.5;
@@ -294,6 +303,7 @@ export class RenderSystem {
         ctx.fillRect(0, 0, width, height);
         ctx.restore();
     }
+    /** @internal */
     drawWipeTransition(ctx, transition, width, height, progress) {
         ctx.drawImage(transition.fromCanvas, 0, 0, width, height);
         const clip = this.getScreenWipeClipRect(width, height, transition.direction, progress);
@@ -306,11 +316,13 @@ export class RenderSystem {
         ctx.drawImage(transition.toCanvas, 0, 0, width, height);
         ctx.restore();
     }
+    /** @internal */
     drawSlideTransition(ctx, transition, width, height, progress) {
         const offset = this.getSlideOffset(transition.direction, width, height, progress);
         ctx.drawImage(transition.fromCanvas, offset.fromX, offset.fromY, width, height);
         ctx.drawImage(transition.toCanvas, offset.toX, offset.toY, width, height);
     }
+    /** @internal */
     drawIrisTransition(ctx, transition, width, height, progress) {
         ctx.drawImage(transition.fromCanvas, 0, 0, width, height);
         const maxRadius = Math.max(Math.hypot(transition.centerX, transition.centerY), Math.hypot(width - transition.centerX, transition.centerY), Math.hypot(transition.centerX, height - transition.centerY), Math.hypot(width - transition.centerX, height - transition.centerY));
@@ -321,6 +333,7 @@ export class RenderSystem {
         ctx.drawImage(transition.toCanvas, 0, 0, width, height);
         ctx.restore();
     }
+    /** @internal */
     drawPixelateTransition(ctx, transition, width, height, progress) {
         const firstHalf = progress < 0.5;
         const localT = firstHalf ? progress / 0.5 : (progress - 0.5) / 0.5;
@@ -330,6 +343,7 @@ export class RenderSystem {
             : this.lerp(transition.pixelSize, 1, localT);
         this.drawPixelatedCanvas(ctx, source, width, height, pixelSize);
     }
+    /** @internal */
     drawFlashTransition(ctx, transition, width, height, progress) {
         const swapPoint = 0.28;
         const overlayPeak = 0.52;
@@ -351,22 +365,38 @@ export class RenderSystem {
         ctx.fillRect(0, 0, width, height);
         ctx.restore();
     }
+    /** @internal */
     getRenderSurface(sprite) {
         if (this.isDrawSprite(sprite)) {
             return this.getDrawSurface(sprite);
         }
         const cacheKey = sprite.getRenderCacheKey();
         const cached = this._surfaceCache.get(cacheKey);
-        if (cached)
+        if (cached) {
+            this._surfaceCache.delete(cacheKey);
+            this._surfaceCache.set(cacheKey, cached);
             return cached;
+        }
         const surface = this.isTextSprite(sprite)
             ? this.createTextSurface(sprite)
             : this.isImageSprite(sprite)
                 ? this.createImageSurface(sprite)
                 : this.createEmojiSurface(this.asEmojiSprite(sprite));
         this._surfaceCache.set(cacheKey, surface);
+        this.trimSurfaceCache();
         return surface;
     }
+    /** @internal */
+    trimSurfaceCache() {
+        while (this._surfaceCache.size > RenderSystem.MAX_SURFACE_CACHE_ENTRIES) {
+            const oldestKey = this._surfaceCache.keys().next().value;
+            if (oldestKey === undefined) {
+                break;
+            }
+            this._surfaceCache.delete(oldestKey);
+        }
+    }
+    /** @internal */
     createEmojiSurface(sprite) {
         const size = Math.max(1, Math.round(sprite.size));
         const color = sprite.color;
@@ -390,6 +420,7 @@ export class RenderSystem {
         glyphCtx.fillText(sprite.sprite, boxSize / 2, boxSize / 2);
         return glyphCanvas;
     }
+    /** @internal */
     createTextSurface(sprite) {
         const canvas = document.createElement("canvas");
         const ctx = canvas.getContext("2d");
@@ -458,6 +489,7 @@ export class RenderSystem {
         }
         return canvas;
     }
+    /** @internal */
     createImageSurface(sprite) {
         const image = sprite.game?.getImage(sprite.imageKey);
         if (!image) {
@@ -474,6 +506,7 @@ export class RenderSystem {
         ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
         return canvas;
     }
+    /** @internal */
     getDrawSurface(sprite) {
         const width = Math.max(1, Math.round(sprite.width));
         const height = Math.max(1, Math.round(sprite.height));
@@ -509,15 +542,19 @@ export class RenderSystem {
         sprite._lastRedrawPassId = this._dynamicSurfacePassId;
         return surface;
     }
+    /** @internal */
     isTextSprite(sprite) {
         return "text" in sprite && "fontFamily" in sprite && "fontSize" in sprite;
     }
+    /** @internal */
     isDrawSprite(sprite) {
         return "redraw" in sprite && "_surface" in sprite && "_surfaceCtx" in sprite;
     }
+    /** @internal */
     isImageSprite(sprite) {
         return "imageKey" in sprite && "setTexture" in sprite;
     }
+    /** @internal */
     getWipeClipRect(drawWidth, drawHeight, direction, progress) {
         const halfWidth = drawWidth / 2;
         const halfHeight = drawHeight / 2;
@@ -556,6 +593,7 @@ export class RenderSystem {
             }
         }
     }
+    /** @internal */
     getScreenWipeClipRect(width, height, direction, progress) {
         switch (direction) {
             case "left-to-right":
@@ -592,12 +630,14 @@ export class RenderSystem {
             }
         }
     }
+    /** @internal */
     asEmojiSprite(sprite) {
         if ("sprite" in sprite && "size" in sprite) {
             return sprite;
         }
         throw new Error("MinimoJS: Unsupported sprite type for emoji rendering.");
     }
+    /** @internal */
     layoutTextLines(ctx, sprite) {
         this.applyTextStyle(ctx, sprite);
         const rawLines = sprite.text.split("\n");
@@ -627,6 +667,7 @@ export class RenderSystem {
         }
         return wrappedLines.length > 0 ? wrappedLines : [""];
     }
+    /** @internal */
     getAvailableTextWidth(sprite) {
         const borderPad = Math.max(0, sprite.borderWidth) * 2;
         const strokePad = Math.max(0, sprite.strokeWidth) * 2;
@@ -642,6 +683,7 @@ export class RenderSystem {
         }
         return Math.max(1, Math.floor(Math.min(...limits)));
     }
+    /** @internal */
     applyTextStyle(ctx, sprite) {
         ctx.font = `${sprite.fontWeight} ${sprite.fontSize}px ${sprite.fontFamily}`;
         ctx.shadowColor = "transparent";
@@ -649,14 +691,17 @@ export class RenderSystem {
         ctx.shadowOffsetX = 0;
         ctx.shadowOffsetY = 0;
     }
+    /** @internal */
     fillRoundedRect(ctx, x, y, width, height, radius) {
         this.buildRoundedRectPath(ctx, x, y, width, height, radius);
         ctx.fill();
     }
+    /** @internal */
     strokeRoundedRect(ctx, x, y, width, height, radius) {
         this.buildRoundedRectPath(ctx, x, y, width, height, radius);
         ctx.stroke();
     }
+    /** @internal */
     buildRoundedRectPath(ctx, x, y, width, height, radius) {
         const safeRadius = Math.max(0, Math.min(radius, width / 2, height / 2));
         ctx.beginPath();
@@ -675,23 +720,27 @@ export class RenderSystem {
         ctx.quadraticCurveTo(x, y, x + safeRadius, y);
         ctx.closePath();
     }
+    /** @internal */
     getSafeRenderScale(value) {
         if (!Number.isFinite(value))
             return 1;
         const safeValue = value;
         return Math.max(0, safeValue);
     }
+    /** @internal */
     getSafePivot(value) {
         if (!Number.isFinite(value))
             return 0.5;
         const safeValue = value;
         return Math.max(0, Math.min(1, safeValue));
     }
+    /** @internal */
     getSafeNumber(value, fallback) {
         if (!Number.isFinite(value))
             return fallback;
         return value;
     }
+    /** @internal */
     paintCanvasBackground(ctx, width, height, background, backgroundGradient) {
         ctx.clearRect(0, 0, width, height);
         if (backgroundGradient !== null) {
@@ -706,6 +755,7 @@ export class RenderSystem {
             ctx.fillRect(0, 0, width, height);
         }
     }
+    /** @internal */
     drawBackgroundLayer(ctx, canvas, layer, image) {
         const destX = Math.round(layer.x);
         const destY = Math.round(layer.y);
@@ -739,11 +789,13 @@ export class RenderSystem {
         ctx.drawImage(image, drawX, drawY, drawW, drawH);
         ctx.restore();
     }
+    /** @internal */
     getPositiveLength(value, fallback) {
         if (!Number.isFinite(value) || value <= 0)
             return fallback;
         return Math.round(value);
     }
+    /** @internal */
     getBackgroundScale(fit, destW, destH, imageW, imageH) {
         const scaleX = destW / imageW;
         const scaleY = destH / imageH;
@@ -752,10 +804,12 @@ export class RenderSystem {
         }
         return Math.max(scaleX, scaleY);
     }
+    /** @internal */
     easeTransitionProgress(t) {
         const clamped = Math.max(0, Math.min(1, t));
         return clamped * clamped * (3 - 2 * clamped);
     }
+    /** @internal */
     getSlideOffset(direction, width, height, progress) {
         switch (direction) {
             case "left-to-right":
@@ -788,6 +842,7 @@ export class RenderSystem {
                 };
         }
     }
+    /** @internal */
     drawPixelatedCanvas(ctx, source, width, height, pixelSize) {
         const roundedPixelSize = Math.max(1, Math.round(pixelSize));
         if (roundedPixelSize <= 1) {
@@ -812,6 +867,7 @@ export class RenderSystem {
         ctx.drawImage(scratch, 0, 0, scaledWidth, scaledHeight, 0, 0, width, height);
         ctx.restore();
     }
+    /** @internal */
     getTransitionScratchSurface(width, height) {
         if (!this._transitionScratchCanvas) {
             this._transitionScratchCanvas = document.createElement("canvas");
@@ -831,9 +887,11 @@ export class RenderSystem {
         }
         return this._transitionScratchCanvas;
     }
+    /** @internal */
     lerp(from, to, t) {
         return from + (to - from) * t;
     }
+    /** @internal */
     applyPageBackground(pageBackground) {
         if (!document.body)
             return;
@@ -848,3 +906,5 @@ export class RenderSystem {
         this._lastAppliedPageBackground = pageBackground;
     }
 }
+/** @internal */
+RenderSystem.MAX_SURFACE_CACHE_ENTRIES = 256;

package/dist/internal/SoundSystem.js

@@ -1,6 +1,7 @@
 /** @internal */
 export class SoundSystem {
     constructor() {
+        /** @internal */
         this._audioCtx = null;
     }
     sound(freq, durationMs) {
@@ -40,6 +41,7 @@ export class SoundSystem {
             startTime += durationSec;
         }
     }
+    /** @internal */
     getAudioContext() {
         if (!this._audioCtx) {
             this._audioCtx = new AudioContext();