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

package/dist/index.js

@@ -1,5 +1,5 @@
 import { Circle, Group, ImageNode, Path, Rect, Text, createScene } from "@glissade/scene";
-import { cubicBezier, formatColor, parseColor, sampleTrack, track } from "@glissade/core";
+import { compileTimeline, cubicBezier, formatColor, parseColor, sampleTrack, track } from "@glissade/core";
 import "@glissade/core/expr";
 //#region src/spec.ts
 var LottieImportError = class extends Error {
@@ -1402,7 +1402,56 @@ function sampleToLottieKeys(tr, fr, ip, op, toS) {
 		}
 		out.push(frame);
 	}
-	return decimateLinearKeys(out);
+	return anchorSampledSpan(decimateLinearKeys(out), f0, f1, ip, op, (frame) => toS(sampleTrack(tr, frame / fr)));
+}
+/**
+* Anchor the document boundaries of a densely-SAMPLED channel whose keyed span
+* [f0,f1] doesn't reach the document bounds [ip,op]. Lottie extrapolates a channel
+* by HOLDING its first key backward and its last key forward, so when the span
+* starts AFTER ip the first EMITTED sample holds backward across the whole leading
+* dormant run — and for a fade-in whose first key rounds to a frame PAST the fade
+* start (a fractional key time, `round(t·fr) > t·fr`), that first sample is already
+* non-zero (e.g. ~9%), so a "hidden" element GHOSTS at ~9% from t=0 instead of 0.
+* Make the true base explicit:
+*   • f0 > ip → PREPEND a HOLD key at ip carrying `sampleAt(ip)` — the value
+*     `sampleTrack` holds across the dormant run (0 for a dormant-at-0 fade). HELD,
+*     not linearly ramped, so a long dormant window stays at the base value the
+*     whole way instead of sloping up to the first sample.
+*   • f1 < op → APPEND a key at op carrying `sampleAt(op)`. Lottie already holds
+*     the last key forward, but a fractional last-key round-DOWN leaves the true
+*     tail value unsampled (e.g. a fade-out whose final 0 is skipped); this pins it.
+* `body` is the already-decimated sampled keyframes; the boundary keys sit OUTSIDE
+* it, so decimation (which assumes pure linear segments) never touches them. A span
+* that already covers [ip,op] (the common integer-keyed case) returns `body`
+* unchanged — byte-identical to before this fix.
+*/
+function anchorSampledSpan(body, f0, f1, ip, op, sampleAt) {
+	if (body.length === 0 || f0 <= ip && f1 >= op) return body;
+	const out = body.slice();
+	if (f1 < op) {
+		const last = out[out.length - 1];
+		out[out.length - 1] = {
+			...last,
+			o: {
+				x: 0,
+				y: 0
+			},
+			i: {
+				x: 1,
+				y: 1
+			}
+		};
+		out.push({
+			t: op,
+			s: sampleAt(op)
+		});
+	}
+	if (f0 > ip) out.unshift({
+		t: ip,
+		s: sampleAt(ip),
+		h: 1
+	});
+	return out;
 }
 /**
 * Ramer–Douglas–Peucker over linear-interpolated keyframes: keep the endpoints
@@ -1531,8 +1580,9 @@ function exportLottie(mod, opts) {
 	const scene = mod.createScene();
 	const fr = opts.fps ?? mod.timeline.fps ?? 60;
 	const warn = opts.onWarn ?? ((m) => console.warn(`gs export: ${m}`));
+	const compiled = compileTimeline(mod.timeline);
 	const byNode = /* @__PURE__ */ new Map();
-	for (const tr of mod.timeline.tracks) {
+	for (const tr of compiled.tracks.values()) {
 		const resolved = resolveTrackNode(scene.nodes, tr.target);
 		if (resolved === void 0) {
 			warn(`track '${tr.target}' targets no node in the scene — dropped`);
@@ -1676,14 +1726,17 @@ function combineOpacity(ctx, node, tracks, accum) {
 		k: leafStatic * accum.factor * 100
 	};
 	const [f0, f1] = frameSpan(ctx, leafTrack ? [leafTrack, ...accum.tracks] : [...accum.tracks]);
-	const out = [];
-	for (let f = f0; f <= f1; f++) {
-		const t = f / ctx.fr;
+	const sampleAt = (frame) => {
+		const t = frame / ctx.fr;
 		let product = (leafTrack ? sampleTrack(leafTrack, t) : leafStatic) * accum.factor;
 		for (const at of accum.tracks) product *= sampleTrack(at, t);
+		return [product * 100];
+	};
+	const out = [];
+	for (let f = f0; f <= f1; f++) {
 		const frame = {
 			t: f,
-			s: [product * 100]
+			s: sampleAt(f)
 		};
 		if (f < f1) {
 			frame.o = {
@@ -1699,7 +1752,7 @@ function combineOpacity(ctx, node, tracks, accum) {
 	}
 	return {
 		a: 1,
-		k: decimateLinearKeys(out)
+		k: anchorSampledSpan(decimateLinearKeys(out), f0, f1, ctx.ip, ctx.op, sampleAt)
 	};
 }
 function scalarProp(ctx, tracks, prop, staticVal, map) {
@@ -1773,14 +1826,15 @@ function positionProp(ctx, tracks, staticPos) {
 }
 function sampleComponentVec(ctx, xt, yt, staticVal, map) {
 	const [f0, f1] = frameSpan(ctx, [xt, yt]);
+	const sampleAt = (frame) => {
+		const t = frame / ctx.fr;
+		return map([xt ? sampleTrack(xt, t) : staticVal[0], yt ? sampleTrack(yt, t) : staticVal[1]]);
+	};
 	const out = [];
 	for (let f = f0; f <= f1; f++) {
-		const t = f / ctx.fr;
-		const x = xt ? sampleTrack(xt, t) : staticVal[0];
-		const y = yt ? sampleTrack(yt, t) : staticVal[1];
 		const frame = {
 			t: f,
-			s: map([x, y])
+			s: sampleAt(f)
 		};
 		if (f < f1) {
 			frame.o = {
@@ -1794,7 +1848,7 @@ function sampleComponentVec(ctx, xt, yt, staticVal, map) {
 		}
 		out.push(frame);
 	}
-	return decimateLinearKeys(out);
+	return anchorSampledSpan(decimateLinearKeys(out), f0, f1, ctx.ip, ctx.op, sampleAt);
 }
 /** 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.48.0-pre.0",
+  "version": "0.48.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.48.0-pre.0",
-    "@glissade/scene": "0.48.0-pre.0"
+    "@glissade/core": "0.48.0-pre.2",
+    "@glissade/scene": "0.48.0-pre.2"
   },
   "devDependencies": {
-    "@glissade/backend-skia": "0.48.0-pre.0"
+    "@glissade/backend-skia": "0.48.0-pre.2"
   },
   "repository": {
     "type": "git",