morphicons 1.1.0 → 1.1.1

package/README.md

@@ -208,7 +208,7 @@ Let `aᶜᵢ = aᵢ − c_A` and `b̃ᵢ = R(−θ*)·(bᵢ − c_B)/σ*` (B bro
 ```
 P(t) = c(t) + σ*ᵗ · R(t·θ*) · [(1−t)·aᶜᵢ + t·b̃ᵢ]
 
-  c(t)  = lerp(c_A, c_B, t)        linear translation
+  c(t)  = lerp(c_A, c_B, t)        linear translation (block transport under the global hybrid — below)
   t·θ*  = linear angle             (θ* is already in (−π, π], short path)
   σ*ᵗ   = exp(t·ln σ*)             log-linear scale (geodesic in ℝ⁺)
 ```
@@ -220,6 +220,14 @@ Exact at both endpoints (max error ~3.6e-15 in tests). Properties:
 - Mixed cases do both simultaneously and continuously.
 - With spring overshoot (t > 1) the formula **extrapolates** naturally: rotation and scale overshoot slightly and come back — free juice.
 
+**Block transport (global hybrid).** When the whole icon is congruent (§4), lerping each subpath centroid reintroduces the chord disease one level up: every part spins with the shared θ*, but an off-center part travels the chord — inside the arc — and drifts toward the center mid-flight. An arrow's head sagged ~1 px toward its shaft at t = 0.5 (`r·(1 − cos(θ/2))` with r = 3.5, θ = 90°) while both parts rotated perfectly. Under the hybrid, each centroid rides the shared similarity around the global centroid `g_A` instead:
+
+```
+c_k(t) = c_{A,k} + t·d_k + (σ*ᵗ·R(t·θ*) − I)·(c_{A,k} − g_A)
+```
+
+`d_k` is fixed once so that `c_k(1) = c_{B,k}` exactly (it absorbs the tiny global residual). Every point of every subpath then moves under ONE similarity per frame: congruent icons are rigid through the whole flight, not only at the endpoints. With θ* = 0, or centroids sitting on `g_A`, or no hybrid at all, the formula degrades continuously to the plain lerp — no thresholds, no special cases.
+
 ### 6. Serialization and canonical snap
 
 In flight, each subpath is emitted as `M x y L x y …` (+ `Z` if the pair is closed↔closed; closed→open flies open, the loop opening at the cut chosen by the circular correspondence) with 2 decimals — invisible at 24px, and the frame's only allocation. On settle, the driver **snaps to the canonical `d`** of the target icon: exact fidelity at rest (real curves, not polylines), subpath count reset after duplications, and the DOM ends up identical to a static icon's. The jump is < 0.02px — imperceptible.
@@ -255,9 +263,9 @@ CI budget (size-limit, gzip) as an anti-regression tripwire — gates carry ~10%
 
 | entry | measured | gate |
 |---|---|---|
-| `morphicons` (core) | 6.45 KB | 7 KB |
-| `morphicons/dom` (core + driver) | 6.92 KB | 7.5 KB |
-| `morphicons/react` (all, react external) | 7.65 KB | 8.5 KB |
+| `morphicons` (core) | 6.60 KB | 7 KB |
+| `morphicons/dom` (core + driver) | 7.04 KB | 7.5 KB |
+| `morphicons/react` (all, react external) | 7.77 KB | 8.5 KB |
 
 ## Playground
 

package/dist/dom.js

@@ -1,4 +1,4 @@
-import { a as buildPlan, c as cubicsToPathD, f as interpPolar, l as serialize, n as Spring, r as resampleIcon, s as iconToCubics, t as SPRING_PRESETS, u as allocOutputs } from "./spring-BR0BCAfU.js";
+import { a as buildPlan, c as cubicsToPathD, f as interpPolar, l as serialize, n as Spring, r as resampleIcon, s as iconToCubics, t as SPRING_PRESETS, u as allocOutputs } from "./spring-BTcHiHR5.js";
 //#region src/dom/index.ts
 const tickers = /* @__PURE__ */ new Set();
 let rafId = 0;

package/dist/index.d.ts

@@ -18,6 +18,13 @@ interface PlanItem {
   /** true if both endpoints are closed loops: the subpath flies with Z.
    *  Closed → open flies open: the loop opens at the chosen cut. */
   closed: boolean;
+  /** Block transport (set by the global hybrid, else null): mid-flight the
+   *  centroid rides the shared similarity around the global centroid instead
+   *  of lerping — off = c_A − g_A; drift closes c(1) = c_B exactly. */
+  block: {
+    off: readonly [number, number];
+    drift: readonly [number, number];
+  } | null;
 }
 interface MorphPlan {
   items: PlanItem[];

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as buildPlan, c as cubicsToPathD, d as interpLinear, f as interpPolar, i as resamplePath, l as serialize, n as Spring, o as fitIcon, r as resampleIcon, s as iconToCubics, t as SPRING_PRESETS, u as allocOutputs } from "./spring-BR0BCAfU.js";
+import { a as buildPlan, c as cubicsToPathD, d as interpLinear, f as interpPolar, i as resamplePath, l as serialize, n as Spring, o as fitIcon, r as resampleIcon, s as iconToCubics, t as SPRING_PRESETS, u as allocOutputs } from "./spring-BTcHiHR5.js";
 export { SPRING_PRESETS, Spring, allocOutputs, buildPlan, cubicsToPathD, fitIcon, iconToCubics, interpLinear, interpPolar, resampleIcon, resamplePath, serialize };

package/dist/react.js

@@ -1,4 +1,4 @@
-import { a as buildPlan, f as interpPolar, l as serialize, r as resampleIcon, u as allocOutputs } from "./spring-BR0BCAfU.js";
+import { a as buildPlan, f as interpPolar, l as serialize, r as resampleIcon, u as allocOutputs } from "./spring-BTcHiHR5.js";
 import { canonicalD, createMorph } from "./dom.js";
 import { forwardRef, useEffect, useImperativeHandle, useLayoutEffect, useRef, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";

package/dist/{spring-BR0BCAfU.js → spring-BTcHiHR5.js}

@@ -8,12 +8,21 @@ function interpPolar(plan, t, out) {
 		const it = plan.items[k];
 		const o = out[k];
 		const n = plan.n;
-		const cx = it.ca[0] + (it.cb[0] - it.ca[0]) * t;
-		const cy = it.ca[1] + (it.cb[1] - it.ca[1]) * t;
 		const s = Math.exp(it.lnSigma * t);
 		const ang = it.theta * t;
 		const cos = Math.cos(ang) * s;
 		const sin = Math.sin(ang) * s;
+		let cx;
+		let cy;
+		if (it.block) {
+			const [ox, oy] = it.block.off;
+			const [dx, dy] = it.block.drift;
+			cx = it.ca[0] + dx * t + (ox * cos - oy * sin - ox);
+			cy = it.ca[1] + dy * t + (ox * sin + oy * cos - oy);
+		} else {
+			cx = it.ca[0] + (it.cb[0] - it.ca[0]) * t;
+			cy = it.ca[1] + (it.cb[1] - it.ca[1]) * t;
+		}
 		for (let i = 0; i < n; i++) {
 			const px = it.aC[2 * i] + (it.bT[2 * i] - it.aC[2 * i]) * t;
 			const py = it.aC[2 * i + 1] + (it.bT[2 * i + 1] - it.aC[2 * i + 1]) * t;
@@ -806,7 +815,8 @@ function applyGlobal(items, n) {
 		ga.set(it.a, 2 * n * k);
 		gb.set(it.bO, 2 * n * k);
 	});
-	const g = procrustes(ga, gb, centroid(ga), centroid(gb));
+	const gca = centroid(ga);
+	const g = procrustes(ga, gb, gca, centroid(gb));
 	if (g.res >= GLOBAL_EPS) return;
 	const cos = Math.cos(-g.theta);
 	const sin = Math.sin(-g.theta);
@@ -828,6 +838,17 @@ function applyGlobal(items, n) {
 		it.theta = g.theta;
 		it.lnSigma = Math.log(g.sigma);
 		it.res = nb > 1e-12 ? Math.sqrt(e2 / nb) : 0;
+		const s1 = Math.exp(it.lnSigma);
+		const c1 = Math.cos(it.theta) * s1;
+		const n1 = Math.sin(it.theta) * s1;
+		const ox = it.ca[0] - gca[0];
+		const oy = it.ca[1] - gca[1];
+		const rx = ox * c1 - oy * n1 - ox;
+		const ry = ox * n1 + oy * c1 - oy;
+		it.block = {
+			off: [ox, oy],
+			drift: [it.cb[0] - it.ca[0] - rx, it.cb[1] - it.ca[1] - ry]
+		};
 	}
 }
 /** Builds the morph plan between two lists of sampled subpaths. The plan is
@@ -879,7 +900,8 @@ function buildPlan(srcSubs, dstSubs) {
 			theta: al.theta,
 			lnSigma: Math.log(al.sigma),
 			res: al.res,
-			closed: srcSubs[si].closed && dstSubs[di].closed
+			closed: srcSubs[si].closed && dstSubs[di].closed,
+			block: null
 		};
 	});
 	if (items.length > 1) applyGlobal(items, n);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "morphicons",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Universal morphing for stroke-based icons with spring physics — zero runtime dependencies",
   "license": "MIT",
   "author": "Guillermo (https://guillermolg.com)",