@energy8platform/golem 0.5.0 → 0.7.0

package/dist/lib/harness.js

@@ -49524,7 +49524,9 @@ ${parts.join("\n")}
     /** curve lengths for constant-speed positioning */
     lengths: external_exports.array(external_exports.number()).default([]),
     closed: external_exports.boolean().default(false),
-    constantSpeed: external_exports.boolean().default(true)
+    constantSpeed: external_exports.boolean().default(true),
+    /** Spine-style active clipping span in the posed draw order; end slot is inclusive. */
+    clipping: external_exports.object({ end: Id.optional() }).optional()
   });
   var Attachment = external_exports.discriminatedUnion("type", [RegionAttachment, MeshAttachment, PathAttachment]);
   var IkConstraint = external_exports.object({
@@ -49588,7 +49590,9 @@ ${parts.join("\n")}
     t: external_exports.number().nonnegative(),
     v: KeyValue,
     /** easing INTO the next key */
-    ease: Ease.default("ease_in_out")
+    ease: Ease.default("ease_in_out"),
+    /** Optional independent easing for numeric-array components (for example Spine RGBA curves). */
+    componentEase: external_exports.array(Ease).min(1).optional()
   });
   var Interpolation = { interpolation: external_exports.enum(["segment", "pchip"]).optional() };
   var Track = external_exports.discriminatedUnion("target", [
@@ -49775,6 +49779,10 @@ ${parts.join("\n")}
         else if (a2.slot !== s2.id) errs.push(`slot "${s2.id}": attachment "${s2.attachment}" belongs to slot "${a2.slot}"`);
       }
     }
+    for (const a2 of doc.attachments) if (a2.type === "path" && a2.clipping) {
+      if (!a2.closed) errs.push(`attachment "${a2.id}": clipping path must be closed`);
+      if (a2.clipping.end && !slots.has(a2.clipping.end)) errs.push(`attachment "${a2.id}": unknown clipping end slot "${a2.clipping.end}"`);
+    }
     const vertexCount = (a2) => {
       if (a2.type === "region") return 4;
       if (a2.type === "mesh") return a2.uvs.length / 2;
@@ -49858,6 +49866,7 @@ ${parts.join("\n")}
         const att = t2.target === "deform" ? attachments.get(t2.id) : void 0;
         let prev = -1;
         for (const k2 of t2.keys) {
+          if (k2.componentEase && (!Array.isArray(k2.v) || !k2.v.every((v2) => typeof v2 === "number") || k2.componentEase.length !== k2.v.length)) errs.push(`animation "${a2.id}" ${tid}: componentEase must match the numeric-array value length`);
           if (k2.t <= prev && prev >= 0) errs.push(`animation "${a2.id}" ${tid}: keys not strictly increasing`);
           if (k2.t > a2.duration) errs.push(`animation "${a2.id}" ${tid}: key at ${k2.t}s exceeds duration`);
           if (t2.target === "control") {
@@ -50022,8 +50031,8 @@ ${parts.join("\n")}
     }
     if (Array.isArray(a2.v) && Array.isArray(b2.v) && typeof a2.v[0] === "number") {
       if (track.interpolation === "pchip") return a2.v.map((_, j2) => smoothValue(track, i2, t2, j2, loop));
-      const u2 = ease(a2.ease)((t2 - a2.t) / (b2.t - a2.t)), av = a2.v, bv = b2.v;
-      return av.map((v2, k2) => v2 + ((bv[k2] ?? v2) - v2) * u2);
+      const phase = (t2 - a2.t) / (b2.t - a2.t), av = a2.v, bv = b2.v;
+      return av.map((v2, k2) => v2 + ((bv[k2] ?? v2) - v2) * ease(a2.componentEase?.[k2] ?? a2.ease)(phase));
     }
     return a2.v;
   }
@@ -50111,6 +50120,13 @@ ${parts.join("\n")}
     if (!parent) return local;
     if (bone.inherit === "normal") return mul(parent, local);
     const [tx, ty] = apply(parent, s2.x, s2.y);
+    if (bone.inherit === "noScale" || bone.inherit === "noScaleOrReflection") {
+      const r2 = s2.rotation * DEG2, x2 = parent.a * Math.cos(r2) + parent.c * Math.sin(r2), y2 = parent.b * Math.cos(r2) + parent.d * Math.sin(r2);
+      const length2 = Math.hypot(x2, y2), a2 = length2 > 1e-5 ? x2 / length2 : x2, b2 = length2 > 1e-5 ? y2 / length2 : y2;
+      const sign = bone.inherit === "noScale" && parent.a * parent.d - parent.b * parent.c < 0 ? -1 : 1;
+      const basis2 = { a: a2, b: b2, c: -b2 * sign, d: a2 * sign, tx: 0, ty: 0 };
+      return { ...mul(basis2, affineOf(0, 0, 0, s2.scaleX, s2.scaleY, s2.shearX, s2.shearY)), tx, ty };
+    }
     return { ...mul(inheritedParentLinear(bone, parent), { ...local, tx: 0, ty: 0 }), tx, ty };
   }
   var orderCache = /* @__PURE__ */ new WeakMap();
@@ -50143,11 +50159,11 @@ ${parts.join("\n")}
       shearY: num(pose, pk("bone", id, "shearY"), r2.shearY)
     };
   };
-  function updateSubtree(skel, root) {
+  function updateSubtree(skel, root, includeRoot = true) {
     const doc = skel.doc;
     const kids = /* @__PURE__ */ new Map();
     for (const b2 of doc.bones) if (b2.parent) (kids.get(b2.parent) ?? kids.set(b2.parent, []).get(b2.parent)).push(b2);
-    const stack = [root];
+    const stack = includeRoot ? [root] : (kids.get(root) ?? []).map((b2) => b2.id);
     while (stack.length) {
       const id = stack.pop(), b2 = boneOf(doc, id), st = skel.bones.get(id);
       st.world = boneWorldOf(b2, st, b2.parent ? skel.bones.get(b2.parent).world : void 0);
@@ -50181,6 +50197,23 @@ ${parts.join("\n")}
     }
     return skel;
   }
+  function slotClips(skel) {
+    const keyed = skel.pose.get(pk("drawOrder", "order", "order"));
+    const order = Array.isArray(keyed) ? keyed : [...skel.doc.slots].sort((a2, b2) => a2.z - b2.z).map((s2) => s2.id);
+    const masks = /* @__PURE__ */ new Map();
+    let active;
+    for (const id of order) {
+      const att = skel.attachment.get(id);
+      if (!active && att?.type === "path" && att.clipping) {
+        active = att;
+        continue;
+      }
+      if (active) masks.set(id, active.id);
+      if (active?.clipping?.end === id) active = void 0;
+    }
+    for (const s2 of skel.doc.slots) if (s2.clip) masks.set(s2.id, s2.clip);
+    return masks;
+  }
   var cnum = (skel, kind, id, prop, rest) => num(skel.pose, pk(kind, id, prop), typeof rest === "boolean" ? rest ? 1 : 0 : rest);
   var IDENTITY = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
   var wrapRad = (r2) => r2 > Math.PI ? r2 - 2 * Math.PI : r2 < -Math.PI ? r2 + 2 * Math.PI : r2;
@@ -50390,7 +50423,8 @@ ${parts.join("\n")}
     if (!mixRotate && !mixX && !mixY && !mixScaleX && !mixScaleY && !mixShearY) return;
     c2 = { ...c2, ...Object.fromEntries(["x", "y", "rotation", "scaleX", "scaleY", "shearY"].map((p2) => [p2, cnum(skel, "transform", c2.id, p2, c2[p2])])) };
     const target = skel.bones.get(c2.target), tw = target.world;
-    const offsetRotation = c2.rotation * DEG2, offsetShearY = c2.shearY * DEG2;
+    const handedness = tw.a * tw.d - tw.b * tw.c < 0 ? -1 : 1;
+    const offsetRotation = c2.rotation * DEG2 * (c2.local ? 1 : handedness), offsetShearY = c2.shearY * DEG2 * (c2.local ? 1 : handedness);
     for (const id of c2.bones) {
       const b2 = boneOf(skel.doc, id), st = skel.bones.get(id);
       if (c2.local) {
@@ -50552,6 +50586,7 @@ ${parts.join("\n")}
     const position = cnum(skel, "path", c2.id, "position", c2.position), spacing = cnum(skel, "path", c2.id, "spacing", c2.spacing);
     const tangents = c2.rotateMode === "tangent", scale = c2.rotateMode === "chainScale";
     const bones = c2.bones.map((id) => ({ b: boneOf(skel.doc, id), st: skel.bones.get(id) }));
+    const inputWorlds = bones.map(({ st }) => ({ ...st.world }));
     const spacesCount = tangents ? bones.length : bones.length + 1;
     const spaces = new Array(spacesCount).fill(0), worldLengths = [];
     let sum = 0;
@@ -50586,9 +50621,10 @@ ${parts.join("\n")}
       if (tw.a * tw.d - tw.b * tw.c < 0) offsetRotation = -offsetRotation;
     }
     let boneX = samples[0].x, boneY = samples[0].y;
+    const solvedWorlds = /* @__PURE__ */ new Map();
     for (let i2 = 0; i2 < bones.length; i2++) {
       const { b: b2, st } = bones[i2];
-      let w2 = { ...st.world };
+      let w2 = { ...inputWorlds[i2] };
       w2.tx += (boneX - w2.tx) * mixX;
       w2.ty += (boneY - w2.ty) * mixY;
       const next = samples[i2 + 1] ?? { x: 0, y: 0, angle: 0 };
@@ -50618,7 +50654,11 @@ ${parts.join("\n")}
         const cos = Math.cos(r2), sin = Math.sin(r2);
         w2 = { a: cos * a2 - sin * bb, b: sin * a2 + cos * bb, c: cos * cc - sin * d2, d: sin * cc + cos * d2, tx: w2.tx, ty: w2.ty };
       }
-      setEffectiveWorld(skel, b2, st, w2);
+      solvedWorlds.set(b2.id, w2);
+    }
+    for (const b2 of boneOrder(skel.doc)) {
+      const world = solvedWorlds.get(b2.id);
+      if (world) setEffectiveWorld(skel, b2, skel.bones.get(b2.id), world);
     }
   }
   function measuredPathLength(points, closed, lengths, constantSpeed) {
@@ -50647,9 +50687,14 @@ ${parts.join("\n")}
       case "onlyTranslation":
         return { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
       case "noRotationOrReflection": {
-        const lenX = Math.hypot(parent.a, parent.b) || 1;
+        const lenX = Math.hypot(parent.a, parent.b);
         const det = parent.a * parent.d - parent.b * parent.c;
-        return { a: lenX, b: 0, c: 0, d: Math.abs(det) / lenX, tx: 0, ty: 0 };
+        if (lenX * lenX <= 1e-4) {
+          const lenY = Math.hypot(parent.c, parent.d), ux3 = lenY ? parent.c / lenY : 0, uy3 = lenY ? parent.d / lenY : 0;
+          return { a: lenY * ux3 * ux3, b: lenY * ux3 * uy3, c: lenY * ux3 * uy3, d: lenY * uy3 * uy3, tx: 0, ty: 0 };
+        }
+        const ux2 = parent.a / lenX, uy2 = parent.b / lenX, sy = Math.abs(det) / lenX;
+        return { a: lenX * ux2 * ux2 + sy * uy2 * uy2, b: (lenX - sy) * ux2 * uy2, c: (lenX - sy) * ux2 * uy2, d: lenX * uy2 * uy2 + sy * ux2 * ux2, tx: 0, ty: 0 };
       }
       case "noScale":
       case "noScaleOrReflection": {
@@ -50675,7 +50720,16 @@ ${parts.join("\n")}
     st.scaleY = Math.hypot(lin.c, lin.d);
     st.shearX = 0;
     st.shearY = shortest(Math.atan2(lin.d, lin.c) / DEG2 - st.rotation - 90);
-    updateSubtree(skel, bone.id);
+    if (parent && (bone.inherit === "noScale" || bone.inherit === "noScaleOrReflection")) {
+      const direction = mul(invert({ ...parent, tx: 0, ty: 0 }), { ...world, tx: 0, ty: 0 });
+      st.rotation = Math.atan2(direction.b, direction.a) / DEG2;
+      st.scaleX = Math.hypot(world.a, world.b);
+      st.scaleY = Math.hypot(world.c, world.d);
+      const sign = bone.inherit === "noScale" && parent.a * parent.d - parent.b * parent.c < 0 ? -1 : 1;
+      st.shearY = shortest((Math.atan2(world.d, world.c) - Math.atan2(world.b, world.a)) / DEG2 * sign - 90);
+    }
+    st.world = world;
+    updateSubtree(skel, bone.id, false);
   }
   function attachmentWorldVertices(skel, slotId, att) {
     const deform = skel.pose.get(pk("deform", att.id, "vertices"));
@@ -51074,7 +51128,7 @@ ${parts.join("\n")}
       this.clipPoints.clear();
       const skel = this.skel = evaluate(this.doc, pose, this.beforePose);
       pose = skel.pose;
-      const clips = new Set(this.doc.slots.flatMap((s2) => s2.clip ? [s2.clip] : []));
+      const masks = slotClips(skel), clips = new Set(masks.values());
       for (const [id, g2] of this.clipGraphics) if (!clips.has(id)) {
         g2.destroy();
         this.clipGraphics.delete(id);
@@ -51101,7 +51155,8 @@ ${parts.join("\n")}
       if (Array.isArray(orderV)) orderV.forEach((id, i2) => order.set(id, i2));
       for (const it of this.items) {
         const s2 = it.slot, shown = skel.attachment.get(s2.id);
-        it.node.mask = s2.clip ? this.clipGraphics.get(s2.clip) ?? null : null;
+        const mask = masks.get(s2.id);
+        it.node.mask = mask ? this.clipGraphics.get(mask) ?? null : null;
         if (shown !== it.att || this.hidden.has(s2.id)) {
           it.node.visible = false;
           continue;