@codexo/exojs 0.15.0 → 0.15.1

package/dist/exo.iife.js

@@ -1769,12 +1769,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 +2090,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 +2321,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 +2340,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 +2432,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 +2946,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);
@@ -6607,6 +6620,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 +6635,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 +7305,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);
         }
     }
@@ -16342,6 +16367,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 +16651,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 +33440,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;
         }
     }
     // ---------------------------------------------------------------------------
@@ -36661,12 +36701,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 +36729,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 +36738,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 +36747,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 +36760,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 +36772,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 +36939,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 +37220,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);
@@ -40139,8 +40210,8 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     const buildInfo = Object.freeze({
-        version: "0.15.0",
-        revision: "18cadeb",
+        version: "0.15.1",
+        revision: "6f825a8",
         development: false,
     });