@codexo/exojs 0.15.0 → 0.15.2

package/dist/exo.iife.js

@@ -419,8 +419,10 @@ var Exo = (function (exports) {
                 this._onStart?.();
             }
             this._elapsed += deltaSeconds;
-            // Clamp to duration for this cycle.
-            if (this._elapsed >= this._duration) {
+            // Clamp to duration for this cycle, remembering the overshoot so it can
+            // carry into the next repeat cycle below.
+            const overflow = this._elapsed - this._duration;
+            if (overflow >= 0) {
                 this._elapsed = this._duration;
             }
             // Apply interpolation.
@@ -438,8 +440,8 @@ var Exo = (function (exports) {
                     if (this._yoyo) {
                         this._direction = this._direction === 1 ? -1 : 1;
                     }
-                    // Reset elapsed for next cycle; carry overflow.
-                    const overflow = this._elapsed - this._duration;
+                    // Reset elapsed for next cycle; carry the overshoot (at most one
+                    // extra cycle per update call).
                     this._elapsed = overflow > 0 ? Math.min(overflow, this._duration) : 0;
                     // Apply progress for any overflow.
                     if (overflow > 0) {
@@ -1769,12 +1771,13 @@ var Exo = (function (exports) {
      */
     class AbstractVector {
         /**
-         * Angle of this vector in radians, measured from the positive Y-axis
-         * (clockwise). Setting this rotates the vector to the new angle while
-         * preserving its {@link length}. Mutates in place.
+         * Angle of this vector in radians, measured from the positive X-axis
+         * (the same convention as `PolarVector.phi`). Setting this rotates the
+         * vector to the new angle while preserving its {@link length}. Mutates in
+         * place.
          */
         get angle() {
-            return Math.atan2(this.x, this.y);
+            return Math.atan2(this.y, this.x);
         }
         set angle(angle) {
             const length = this.length;
@@ -2089,7 +2092,10 @@ var Exo = (function (exports) {
         const normY = (y1 - y2) / ry;
         return normX * normX + normY * normY <= 1;
     };
-    const intersectionPointPoly$1 = (point, { points }) => polygonContainsPoint(point, points);
+    const intersectionPointPoly$1 = (point, { x: offsetX, y: offsetY, points }) => 
+    // Shift the point into the polygon's local space so its x/y position
+    // offset is honoured (the local `points` never carry the offset).
+    polygonContainsPoint({ x: point.x - offsetX, y: point.y - offsetY }, points);
     const intersectionLineLineSegments = (a1, a2, b1, b2) => {
         const denominator = (a2.x - a1.x) * (b2.y - b1.y) - (b2.x - b1.x) * (a2.y - a1.y);
         if (Math.abs(denominator) <= epsilon$1) {
@@ -2317,8 +2323,13 @@ var Exo = (function (exports) {
         if (getVoronoiRegion(edgeX, edgeY, pointX, pointY) !== VoronoiRegion.right) {
             return false;
         }
-        const region = getVoronoiRegion(nextEdge.x, nextEdge.y, circleX - nextPoint.x, circleY - nextPoint.y);
-        return region === VoronoiRegion.left && getVectorLength(pointX, pointY) > radius;
+        // In the right region the closest polygon feature is the *next* vertex, so
+        // both the region refinement and the distance test use `circle - nextPoint`
+        // (mirrors the right-region branch of getCollisionPolygonCircle).
+        const positionBx = circleX - nextPoint.x;
+        const positionBy = circleY - nextPoint.y;
+        const region = getVoronoiRegion(nextEdge.x, nextEdge.y, positionBx, positionBy);
+        return region === VoronoiRegion.left && getVectorLength(positionBx, positionBy) > radius;
     };
     const shouldExcludeMiddleVoronoi = (pointX, pointY, radius, edgeX, edgeY) => {
         const normalX = edgeY;
@@ -2331,15 +2342,10 @@ var Exo = (function (exports) {
         return distance > 0 && Math.abs(distance) > radius;
     };
     const intersectionCirclePoly = ({ x: cx, y: cy, radius }, { x: px, y: py, points, edges }) => {
-        // Frame transform: express the circle's position relative to the polygon's
-        // local space, but with the sign inverted (poly.position - circle.position
-        // rather than the natural circle.position - poly.position). The poly's
-        // `points` are then in their local coordinates and the Voronoi-region tests
-        // below combine them with the negated-offset circle position to reach the
-        // same value as a positively-offset frame would. Don't flip without
-        // re-deriving the Voronoi math.
-        const circleX = px - cx;
-        const circleY = py - cy;
+        // Frame transform: the circle centre expressed in the polygon's local space
+        // (circle.position - poly.position), matching getCollisionPolygonCircle.
+        const circleX = cx - px;
+        const circleY = cy - py;
         const len = points.length;
         for (let i = 0; i < len; i++) {
             // i, prev, next are all valid indices into the parallel length-`len`
@@ -2428,8 +2434,8 @@ var Exo = (function (exports) {
             difference.destroy();
             return null;
         }
-        const projectionN = difference.clone().normalize();
-        const projectionV = difference.multiply(overlap);
+        const projectionN = difference.normalize();
+        const projectionV = projectionN.clone().multiply(overlap);
         return {
             shapeA: circleA,
             shapeB: circleB,
@@ -2942,10 +2948,19 @@ var Exo = (function (exports) {
                 this._owner?._onObservableChange(this._channel);
             }
         }
+        // The getters must be redeclared alongside the setter overrides: a
+        // setter-only accessor on the subclass prototype would shadow the whole
+        // inherited accessor pair, leaving `get` undefined.
+        get angle() {
+            return Math.atan2(this._y, this._x);
+        }
         set angle(angle) {
             const length = this.length;
             this.set(Math.cos(angle) * length, Math.sin(angle) * length);
         }
+        get length() {
+            return Math.sqrt(this._x * this._x + this._y * this._y);
+        }
         set length(magnitude) {
             const angle = this.angle;
             this.set(Math.cos(angle) * magnitude, Math.sin(angle) * magnitude);
@@ -4808,9 +4823,19 @@ var Exo = (function (exports) {
             this._registered.set('master', this.master);
             this._registered.set('music', this.music);
             this._registered.set('sound', this.sound);
-            onAudioContextReady.add(() => {
-                this.onUnlock.dispatch();
-            });
+            if (isAudioContextReady()) {
+                // The shared context is already running — this manager was constructed
+                // after the one-shot ready signal fired (e.g. a second Application in
+                // the same process; the buses above would otherwise consume the signal
+                // before this handler registers). Dispatch the unlock on a microtask so
+                // subscribers registered right after construction still observe it.
+                queueMicrotask(() => this.onUnlock.dispatch());
+            }
+            else {
+                onAudioContextReady.add(() => {
+                    this.onUnlock.dispatch();
+                });
+            }
         }
         /**
          * When `true`, the master bus is muted while `document.hidden` is true.
@@ -6607,6 +6632,9 @@ var Exo = (function (exports) {
             const length = Math.sqrt(axis.x * axis.x + axis.y * axis.y) || 1;
             const nx = axis.x / length;
             const ny = axis.y / length;
+            // World-space projection: the polygon's x/y offset shifts every vertex by
+            // the same amount, so it contributes a constant term along the axis.
+            const offset = nx * this._position.x + ny * this._position.y;
             const points = this._points;
             let min = Infinity;
             let max = -Infinity;
@@ -6619,7 +6647,7 @@ var Exo = (function (exports) {
                 if (projection > max)
                     max = projection;
             }
-            return result.set(min, max);
+            return result.set(min + offset, max + offset);
         }
         contains(x, y) {
             return intersectionPointPoly(Vector.temp.set(x, y), this);
@@ -7289,9 +7317,18 @@ var Exo = (function (exports) {
             this._invalidateSubtreeTransform();
             this._invalidateBoundsCascade();
         }
+        /**
+         * Re-derive `origin` from the fractional anchor and the CURRENT local
+         * bounds. Uses local (untransformed) bounds on purpose: the transform
+         * multiplies the origin by scale itself, so deriving from world bounds
+         * would double-apply scale whenever the anchor is set after scaling.
+         * Subclasses whose local bounds change after construction (e.g. a sprite
+         * switching to a texture sub-frame) must call this to keep an anchored
+         * node anchored.
+         */
         _updateOrigin() {
             const { x, y } = this._anchor;
-            const { width, height } = this.getBounds();
+            const { width, height } = this.getLocalBounds();
             this.setOrigin(width * x, height * y);
         }
     }
@@ -13108,9 +13145,18 @@ var Exo = (function (exports) {
                     existing._refreshBrowserGamepad(browserGamepad);
                 }
             }
-            for (const [browserIndex, pad] of [...this.gamepadsByBrowserIndex.entries()]) {
-                if (!seenBrowserIndices.has(browserIndex)) {
-                    this.gamepadsByBrowserIndex.delete(browserIndex);
+            // Two pads can vanish in the same poll, and the compact strategy's shift
+            // re-points map entries while this loop runs — so resolve each browser
+            // index against the LIVE map at dispatch time instead of a pre-loop
+            // entries snapshot (a stale pad reference would disconnect the wrong,
+            // already-repurposed slot and leave a ghost `connected` pad behind).
+            for (const browserIndex of [...this.gamepadsByBrowserIndex.keys()]) {
+                if (seenBrowserIndices.has(browserIndex)) {
+                    continue;
+                }
+                const pad = this.gamepadsByBrowserIndex.get(browserIndex);
+                this.gamepadsByBrowserIndex.delete(browserIndex);
+                if (pad !== undefined) {
                     this.handleGamepadDisconnect(pad);
                 }
             }
@@ -16342,6 +16388,14 @@ var Exo = (function (exports) {
                 this.width = width;
                 this.height = height;
             }
+            // The local bounds changed size — re-derive the origin from the
+            // fractional anchor, or an anchored sprite keeps the OLD bounds' pixel
+            // origin and renders offset by the size difference (an anchored sprite
+            // switching from the full atlas to its first animation frame used to
+            // land hundreds of pixels off-canvas).
+            if (this.anchor.x !== 0 || this.anchor.y !== 0) {
+                this._updateOrigin();
+            }
             this.invalidateCache();
             return this;
         }
@@ -16618,13 +16672,12 @@ var Exo = (function (exports) {
                 const extraPerGap = (maxLineWidth - line.width) / gaps;
                 let wordIdx = -1;
                 let prevWasSpace = true;
-                const spaceAdv = provider.getGlyph(' ', fontSize).advance;
                 for (const entry of line.placements) {
-                    if (prevWasSpace && entry.info.advance !== spaceAdv) {
+                    if (prevWasSpace && entry.char !== ' ') {
                         wordIdx++;
                         prevWasSpace = false;
                     }
-                    else if (!prevWasSpace && entry.info.advance === spaceAdv) {
+                    else if (!prevWasSpace && entry.char === ' ') {
                         prevWasSpace = true;
                     }
                     result.push({
@@ -33408,14 +33461,22 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
      * parent's source. `new URL(ref, source)` only works when `source` is an
      * absolute URL; loaders are frequently called with relative paths (e.g.
      * `assets/demo/fonts/x.fnt`), so fall back to a synthetic base and strip it.
+     * A root-absolute source (`/assets/demo/fonts/x.fnt`) must yield a
+     * root-absolute result again — dropping the leading slash would make the
+     * browser re-resolve the page image against the document base URL.
+     * @internal exported for tests
      */
     function resolveSubAssetPath(ref, source) {
+        if (/^(?:[a-z][a-z\d+.-]*:|\/\/|\/)/i.test(ref)) {
+            return ref;
+        }
         try {
             return new URL(ref, source).href;
         }
         catch {
             const base = 'https://exojs.invalid/';
-            return new URL(ref, base + source.replace(/^\/+/, '')).href.slice(base.length);
+            const resolved = new URL(ref, base + source.replace(/^\/+/, '')).href.slice(base.length);
+            return source.startsWith('/') ? `/${resolved}` : resolved;
         }
     }
     // ---------------------------------------------------------------------------
@@ -34334,6 +34395,13 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
          * instead if you need to await completion.
          */
         backgroundLoad() {
+            // Start a fresh progress batch only when idle; a re-entrant call while the
+            // queue is draining extends the running batch instead (mirrors the
+            // accounting in _loadSingleBackground).
+            if (this._backgroundQueue.length === 0 && this._backgroundActive === 0) {
+                this._backgroundLoaded = 0;
+                this._backgroundTotal = 0;
+            }
             for (const [type, entries] of this._manifest) {
                 for (const [alias, entry] of entries) {
                     if (this._hasResource(type, alias))
@@ -34341,16 +34409,17 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
                     const key = this._key(type, alias);
                     if (this._inFlight.has(key))
                         continue;
+                    if (this._isQueuedInBackground(type, alias))
+                        continue;
                     this._backgroundQueue.push({
                         type,
                         alias,
                         path: entry.path,
                         options: entry.options,
                     });
+                    this._backgroundTotal++;
                 }
             }
-            this._backgroundTotal = this._backgroundQueue.length;
-            this._backgroundLoaded = 0;
             this._drainBackground();
         }
         /**
@@ -35109,7 +35178,16 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             if (leftPrototype !== rightPrototype) {
                 return false;
             }
-            if (leftPrototype !== Object.prototype && leftPrototype !== null) {
+            // Same-prototype instances compare structurally by their own enumerable
+            // keys — the registerManifest contract allows deeply-equal options of any
+            // shared class, not just plain objects. Built-ins whose state is NOT
+            // carried in enumerable own keys need explicit handling: Dates compare by
+            // timestamp; other exotic containers stay reference-only (Object.is above)
+            // so two distinct-but-similar instances never count as equivalent.
+            if (left instanceof Date) {
+                return left.getTime() === right.getTime();
+            }
+            if (left instanceof Map || left instanceof Set || left instanceof RegExp || left instanceof ArrayBuffer || ArrayBuffer.isView(left)) {
                 return false;
             }
             const leftObject = left;
@@ -36661,12 +36739,26 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             this.addChild(this._createStrokeMesh(data));
             return this;
         }
+        /**
+         * Stroke a shape's perimeter. Shape builders return their outline OPEN
+         * (first point not repeated), but `buildPath` only closes a path whose
+         * first and last points coincide — so the closing segment (e.g. a
+         * rectangle's left edge) went missing. Repeat the first point here.
+         */
+        _strokeClosedOutline(points) {
+            if (points.length >= 4) {
+                this.drawPath([...points, points[0], points[1]]);
+            }
+            else {
+                this.drawPath(points);
+            }
+        }
         /** Fill a closed polygon defined by `[x0,y0, x1,y1, ...]` and optionally stroke its outline. */
         drawPolygon(path) {
             const data = buildPolygon(path);
             this._appendFill(data);
             if (this._lineWidth > 0) {
-                this.drawPath(data.points);
+                this._strokeClosedOutline(data.points);
             }
             return this;
         }
@@ -36675,7 +36767,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             const data = buildCircle(centerX, centerY, radius);
             this._appendFill(data);
             if (this._lineWidth > 0) {
-                this.drawPath(data.points);
+                this._strokeClosedOutline(data.points);
             }
             return this;
         }
@@ -36684,7 +36776,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             const data = buildEllipse(centerX, centerY, radiusX, radiusY);
             this._appendFill(data);
             if (this._lineWidth > 0) {
-                this.drawPath(data.points);
+                this._strokeClosedOutline(data.points);
             }
             return this;
         }
@@ -36693,7 +36785,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             const data = buildRectangle(x, y, width, height);
             this._appendFill(data);
             if (this._lineWidth > 0) {
-                this.drawPath(data.points);
+                this._strokeClosedOutline(data.points);
             }
             return this;
         }
@@ -36706,7 +36798,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             const data = buildRoundedRectangle(x, y, width, height, radius);
             this._appendFill(data);
             if (this._lineWidth > 0) {
-                this.drawPath(data.points);
+                this._strokeClosedOutline(data.points);
             }
             return this;
         }
@@ -36718,7 +36810,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             const data = buildStar(centerX, centerY, points, radius, innerRadius, rotation);
             this._appendFill(data);
             if (this._lineWidth > 0) {
-                this.drawPath(data.points);
+                this._strokeClosedOutline(data.points);
             }
             return this;
         }
@@ -36885,6 +36977,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         _clips = new Map();
         _currentClipName = null;
         _currentFrameIndex = 0;
+        _hasAppliedFrame = false;
         _playing = false;
         _repeatOverride = null;
         _elapsedFrameTimeMs = 0;
@@ -37165,7 +37258,23 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
          */
         _applyFrame(clip, frameIndex) {
             // In-bounds by every call site's own guard.
-            this.setTextureFrame(clip.frames[frameIndex], false);
+            if (this._hasAppliedFrame) {
+                // Frame-to-frame advance: keep the current pixel size so differently
+                // sized frames don't visibly pop.
+                this.setTextureFrame(clip.frames[frameIndex], false);
+            }
+            else {
+                // First application: the sprite still shows the full source texture
+                // (usually the whole atlas), so "keep the pixel size" would inflate the
+                // scale by atlasSize/frameSize and the sprite would render blown up far
+                // beyond the canvas. Snap the logical size to the frame instead — while
+                // preserving the user's scale, which `resetSize` would reset to 1.
+                const scaleX = this.scale.x;
+                const scaleY = this.scale.y;
+                this.setTextureFrame(clip.frames[frameIndex], true);
+                this.scale.set(scaleX, scaleY);
+                this._hasAppliedFrame = true;
+            }
             const offset = clip.frameOffsets?.[frameIndex];
             if (offset) {
                 this.getLocalBounds().setPosition(offset.x, offset.y);
@@ -39574,6 +39683,8 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
                     gamepadSlotStrategy: inputOptions.gamepadSlotStrategy ?? defaultInputSettings.gamepadSlotStrategy,
                     pointerDistanceThreshold: inputOptions.pointerDistanceThreshold ?? defaultInputSettings.pointerDistanceThreshold,
                 },
+                ...(appSettings.seed !== undefined && { seed: appSettings.seed }),
+                ...(appSettings.fixedTimeStep !== undefined && { fixedTimeStep: appSettings.fixedTimeStep }),
             };
             // Capture extension snapshot before constructing extension-sensitive subsystems.
             this._snapshot = appSettings.extensions === undefined ? getGlobalSnapshotInternal() : buildSnapshot([...(appSettings.extensions ?? [])]);
@@ -40139,8 +40250,8 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     const buildInfo = Object.freeze({
-        version: "0.15.0",
-        revision: "18cadeb",
+        version: "0.15.2",
+        revision: "e3df957",
         development: false,
     });