@glissade/lottie 0.45.0-pre.0 → 0.45.0-pre.2

package/dist/index.d.ts

@@ -170,6 +170,8 @@ interface LottieAsset {
   layers?: LottieLayer[];
 }
 interface LottieDocument {
+  /** bodymovin schema version (`v`) — strict lottie-web/dotLottie validators require it. */
+  v?: string;
   fr: number;
   ip: number;
   op: number;

package/dist/index.js

@@ -1254,7 +1254,15 @@ function emitKeys(keys, fr, toS) {
 /**
 * Sample `tr` at every integer frame across its keyed span (or the whole
 * document `[ip, op]` for an expr track with no keys) and emit linear Lottie
-* keys. `toS` maps a sampled value to the Lottie `s` payload.
+* keys, then DECIMATE redundant ones ({@link decimateLinearKeys}). `toS` maps a
+* sampled value to the Lottie `s` payload.
+*
+* Dense per-frame sampling is faithful but huge — a spring or named ease over a
+* long shot densifies to one key per frame on every channel (a real episode
+* measured ~148k keys / 139 MB). Since Lottie plays LINEAR between keys, most of
+* those samples lie on the straight run between two others and are redundant;
+* decimation drops them within a per-component tolerance, collapsing constant and
+* constant-velocity stretches to their endpoints while keeping the curvature.
 */
 function sampleToLottieKeys(tr, fr, ip, op, toS) {
 	const keys = tr.keys;
@@ -1283,6 +1291,75 @@ function sampleToLottieKeys(tr, fr, ip, op, toS) {
 		}
 		out.push(frame);
 	}
+	return decimateLinearKeys(out);
+}
+/**
+* Ramer–Douglas–Peucker over linear-interpolated keyframes: keep the endpoints
+* plus any interior key whose value is NOT reproduced (within `relEps` of each
+* component's range) by linear interpolation between the kept neighbors — those
+* are exactly the keys Lottie's linear playback can't recreate, so the rest are
+* safe to drop. Endpoints (first/last, hence the exact start/end value and time)
+* are always kept; existing linear handles on the survivors stay valid. Only
+* flat-numeric `s` payloads are decimated — path `sh` data (nested vertex arrays)
+* is left dense. `relEps` is a fraction of each channel's value range, so it is
+* scale-invariant across position (px), opacity (0–100), scale (×100), color (0–1).
+*/
+function decimateLinearKeys(keys, relEps = .002) {
+	const n = keys.length;
+	if (n <= 2) return keys;
+	const isFlat = (s) => Array.isArray(s) && s.every((x) => typeof x === "number");
+	if (!keys.every((k) => isFlat(k.s))) return keys;
+	const sAt = (i) => keys[i].s;
+	const dim = sAt(0).length;
+	const min = new Array(dim).fill(Infinity);
+	const max = new Array(dim).fill(-Infinity);
+	for (let i = 0; i < n; i++) {
+		const s = sAt(i);
+		for (let c = 0; c < dim; c++) {
+			const v = s[c];
+			if (v < min[c]) min[c] = v;
+			if (v > max[c]) max[c] = v;
+		}
+	}
+	const invRange = new Array(dim);
+	for (let c = 0; c < dim; c++) {
+		const r = max[c] - min[c];
+		invRange[c] = r > 1e-9 ? 1 / r : 0;
+	}
+	const keep = new Uint8Array(n);
+	keep[0] = 1;
+	keep[n - 1] = 1;
+	const stack = [[0, n - 1]];
+	while (stack.length > 0) {
+		const [lo, hi] = stack.pop();
+		if (hi - lo < 2) continue;
+		const a = sAt(lo);
+		const b = sAt(hi);
+		const ta = keys[lo].t;
+		const span = keys[hi].t - ta;
+		let worst = -1;
+		let worstDev = relEps;
+		for (let i = lo + 1; i < hi; i++) {
+			const s = sAt(i);
+			const f = span > 0 ? (keys[i].t - ta) / span : 0;
+			let dev = 0;
+			for (let c = 0; c < dim; c++) {
+				const chord = a[c] + (b[c] - a[c]) * f;
+				const d = Math.abs(s[c] - chord) * invRange[c];
+				if (d > dev) dev = d;
+			}
+			if (dev > worstDev) {
+				worstDev = dev;
+				worst = i;
+			}
+		}
+		if (worst >= 0) {
+			keep[worst] = 1;
+			stack.push([lo, worst], [worst, hi]);
+		}
+	}
+	const out = [];
+	for (let i = 0; i < n; i++) if (keep[i] === 1) out.push(keys[i]);
 	return out;
 }
 //#endregion
@@ -1346,6 +1423,7 @@ function exportLottie(mod, opts) {
 	};
 	walkChildren(ctx, scene.root.children, void 0, byNode);
 	return {
+		v: BODYMOVIN_VERSION,
 		fr,
 		ip: 0,
 		op,
@@ -1355,6 +1433,12 @@ function exportLottie(mod, opts) {
 		layers: ctx.layers
 	};
 }
+/**
+* bodymovin schema version stamped on every export. Strict lottie-web / dotLottie
+* validators reject a document without a top-level `v`; 5.7.x is a widely-supported
+* modern version and the shape this exporter emits is a subset of it.
+*/
+const BODYMOVIN_VERSION = "5.7.0";
 /** Resolve a track target to `[nodeId, propPath]` by the longest registered-id prefix. */
 function resolveTrackNode(nodes, target) {
 	for (let slash = target.lastIndexOf("/"); slash > 0; slash = target.lastIndexOf("/", slash - 1)) {
@@ -1504,7 +1588,7 @@ function sampleComponentVec(ctx, xt, yt, staticVal, map) {
 		}
 		out.push(frame);
 	}
-	return out;
+	return decimateLinearKeys(out);
 }
 /** Union frame span of a set of tracks (their first→last key), else [ip, op]. */
 function frameSpan(ctx, tracks) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glissade/lottie",
-  "version": "0.45.0-pre.0",
+  "version": "0.45.0-pre.2",
   "description": "glissade Lottie import (S1 MVP): pure .json (Lottie/bodymovin) → node specs + a v1 Timeline. Fail-fast feature audit; no DOM/Node dependencies.",
   "license": "Apache-2.0",
   "engines": {
@@ -18,11 +18,11 @@
     "dist"
   ],
   "dependencies": {
-    "@glissade/core": "0.45.0-pre.0",
-    "@glissade/scene": "0.45.0-pre.0"
+    "@glissade/core": "0.45.0-pre.2",
+    "@glissade/scene": "0.45.0-pre.2"
   },
   "devDependencies": {
-    "@glissade/backend-skia": "0.45.0-pre.0"
+    "@glissade/backend-skia": "0.45.0-pre.2"
   },
   "repository": {
     "type": "git",