framefields 2.4.3 → 2.5.1

package/dist/{program-KwDdbC0-.mjs → program-BdPDtfVv.mjs}

@@ -1,6 +1,6 @@
-import { $t as parseCssGradient, Kt as mixColors, Ot as getActiveMediaMetadata, Qt as parseCssColor, gt as createVirtualMedia, l as Color, ut as assertNever, y as Effect } from "./dist-TrtLGPvc.mjs";
-import { t as ColorSchema } from "./dist-Bo2_zeCn.mjs";
-import { Mt as KineticMarqueeConfigSchema, Nn as signalRegistry, Yt as TextPathOptionsSchema, gt as AETextAnimatorSchema, nn as TypewriterAnimatorSchema, vt as AdvancedTextAnimatorSchema } from "./dist-hmWTJPik.mjs";
+import { $t as parseCssGradient, Kt as mixColors, Ot as getActiveMediaMetadata, Qt as parseCssColor, gt as createVirtualMedia, l as Color, ut as assertNever, y as Effect } from "./dist-DFeF-ygz.mjs";
+import { t as ColorSchema } from "./dist-CQZ5_60A.mjs";
+import { Fn as signalRegistry, Pt as KineticMarqueeConfigSchema, Zt as TextPathOptionsSchema, bt as AdvancedTextAnimatorSchema, in as TypewriterAnimatorSchema, vt as AETextAnimatorSchema } from "./dist-DBWkkSvJ.mjs";
 import { z } from "zod";
 import { loadYoga } from "yoga-layout/load";
 
@@ -62,8 +62,8 @@ function dirOf(node) {
 		case "shape":
 		case "camera":
 		case "light":
-		case "model3d": return null;
-		default: return assertNever(node);
+		case "model3d":
+		default: return null;
 	}
 }
 /** Container default width spec (block fills like HTML). */
@@ -518,18 +518,14 @@ var LayerAnimation = class LayerAnimation$1 {
 	tracks = [];
 	/** Hold each value for this many frames (see {@link LayerAnimation.stepped}). */
 	frameStep;
+	defaultRepeat;
+	defaultYoyo;
 	constructor(tracks = []) {
 		this.tracks = [...tracks];
 	}
 	static create() {
 		return new LayerAnimation$1();
 	}
-	/**
-	* Stepped timing for the whole layer: every animated value is held for
-	* `frames` frames ("on twos" = 2, "on threes" = 3), the choppy, hand-made
-	* look of stop motion and cel animation. Applies to all of the layer's
-	* tracks, including ones added by other `.animate()` calls.
-	*/
 	static stepped(frames = 2) {
 		return new LayerAnimation$1().stepped(frames);
 	}
@@ -542,8 +538,8 @@ var LayerAnimation = class LayerAnimation$1 {
 		return new LayerAnimation$1().fromTo(prop, fromValue, toValue, options);
 	}
 	/** A track from a list of `[frame, value, ease?]` keyframes; see {@link LayerAnimation.keys}. */
-	static keys(prop, keyframes) {
-		return new LayerAnimation$1().keys(prop, keyframes);
+	static keys(prop, keyframes, options) {
+		return new LayerAnimation$1().keys(prop, keyframes, options);
 	}
 	static signal(prop, signalOrHandleId, options = {}) {
 		return new LayerAnimation$1().signal(prop, signalOrHandleId, options);
@@ -584,11 +580,47 @@ var LayerAnimation = class LayerAnimation$1 {
 	static rotation(fromAngle, toAngle, options = {}) {
 		return new LayerAnimation$1().fromTo("rotation", fromAngle, toAngle, options);
 	}
+	static scale(fromScale, toScale, options = {}) {
+		return new LayerAnimation$1().fromTo("scale", fromScale, toScale, options);
+	}
+	static scaleX(fromScale, toScale, options = {}) {
+		return new LayerAnimation$1().fromTo("scaleX", fromScale, toScale, options);
+	}
+	static scaleY(fromScale, toScale, options = {}) {
+		return new LayerAnimation$1().fromTo("scaleY", fromScale, toScale, options);
+	}
 	addTrack(track) {
 		this.tracks.push(track);
 		return this;
 	}
 	/**
+	* Configures repeat count on all tracks, or on a specific prop's track:
+	* - `-1`: loops indefinitely.
+	* - `N`: repeats N times after the initial iteration (total N + 1 iterations).
+	*/
+	repeat(count = -1, prop) {
+		this.defaultRepeat = count;
+		for (const track of this.tracks) if (!prop || track.prop === prop) track.repeat = count;
+		return this;
+	}
+	/**
+	* Enables or disables yoyo (alternate playback direction on each repeat iteration).
+	*/
+	yoyo(enable = true, prop) {
+		this.defaultYoyo = enable;
+		for (const track of this.tracks) if (!prop || track.prop === prop) track.yoyo = enable;
+		return this;
+	}
+	/**
+	* Shorthand to loop keyframed animation continuously (infinite repeat).
+	* If `options.yoyo` is true, oscillates back and forth.
+	*/
+	loop(options = {}, prop) {
+		this.repeat(-1, prop);
+		if (options.yoyo) this.yoyo(true, prop);
+		return this;
+	}
+	/**
 	* Creates a keyframed track animating from fromValue to toValue.
 	*/
 	fromTo(prop, fromValue, toValue, options = {}) {
@@ -600,11 +632,16 @@ var LayerAnimation = class LayerAnimation$1 {
 			const newTrack = {
 				id: `${prop}_fromTo_${this.tracks.length}`,
 				prop,
-				keyframes: []
+				keyframes: [],
+				...this.defaultRepeat !== void 0 && { repeat: this.defaultRepeat },
+				...this.defaultYoyo !== void 0 && { yoyo: this.defaultYoyo }
 			};
 			this.tracks.push(newTrack);
 			track = newTrack;
 		}
+		if (options.repeat !== void 0) track.repeat = options.repeat;
+		if (options.yoyo !== void 0) track.yoyo = options.yoyo;
+		if (options.durationFrames !== void 0) track.durationFrames = options.durationFrames;
 		const id = track.id;
 		if (track.keyframes.length === 0 && start > 0) track.keyframes.push({
 			id: `${id}_k0`,
@@ -634,7 +671,9 @@ var LayerAnimation = class LayerAnimation$1 {
 			const newTrack = {
 				id: `${prop}_track_${this.tracks.length}`,
 				prop,
-				keyframes: []
+				keyframes: [],
+				...this.defaultRepeat !== void 0 && { repeat: this.defaultRepeat },
+				...this.defaultYoyo !== void 0 && { yoyo: this.defaultYoyo }
 			};
 			this.tracks.push(newTrack);
 			track = newTrack;
@@ -657,8 +696,16 @@ var LayerAnimation = class LayerAnimation$1 {
 	* `.keys("scale", [[0, 0], [12, 1.1, "back.out"], [20, 1]])`.
 	* Frames are rounded to whole frames, so beat math can be passed straight in.
 	*/
-	keys(prop, keyframes) {
+	keys(prop, keyframes, options) {
 		for (const [frame, value, ease] of keyframes) this.keyframe(prop, Math.round(frame), value, ease);
+		if (options) {
+			const track = this.tracks.find((t) => t.prop === prop && (!t.source || t.source.type === "keyframe"));
+			if (track) {
+				if (options.repeat !== void 0) track.repeat = options.repeat;
+				if (options.yoyo !== void 0) track.yoyo = options.yoyo;
+				if (options.durationFrames !== void 0) track.durationFrames = options.durationFrames;
+			}
+		}
 		return this;
 	}
 	/**
@@ -769,6 +816,24 @@ var LayerAnimation = class LayerAnimation$1 {
 		return this.fromTo("rotateZ", fromAngle, toAngle, options);
 	}
 	/**
+	* Animate scale along the X axis.
+	*/
+	scaleX(fromScale, toScale, options = {}) {
+		return this.fromTo("scaleX", fromScale, toScale, options);
+	}
+	/**
+	* Animate scale along the Y axis.
+	*/
+	scaleY(fromScale, toScale, options = {}) {
+		return this.fromTo("scaleY", fromScale, toScale, options);
+	}
+	/**
+	* Animate uniform scale.
+	*/
+	scale(fromScale, toScale, options = {}) {
+		return this.fromTo("scale", fromScale, toScale, options);
+	}
+	/**
 	* Animate perspective camera distance in pixels.
 	*/
 	perspective(fromDist, toDist, options = {}) {
@@ -1912,21 +1977,47 @@ const COLOR_PROPS$1 = new Set([
 	"textBackgroundColor",
 	"color"
 ]);
+function computeRepeatFrame(track, localFrame, startFrame, lastFrame) {
+	const repeat = track.repeat ?? 0;
+	const cycleSpan = lastFrame - startFrame;
+	const cycleDuration = track.durationFrames !== void 0 && track.durationFrames > 0 ? track.durationFrames : cycleSpan;
+	if (repeat === 0 || cycleDuration <= 0) {
+		if (localFrame >= lastFrame) {
+			const kfs = track.keyframes ?? [];
+			return { completedValue: kfs[kfs.length - 1].value };
+		}
+		return { frame: localFrame };
+	}
+	const delta = localFrame - startFrame;
+	const cycleIndex = Math.floor(delta / cycleDuration);
+	if (repeat > 0 && cycleIndex >= 1 + repeat) {
+		const isFinalReverse = Boolean(track.yoyo) && repeat % 2 === 1;
+		const kfs = track.keyframes ?? [];
+		return { completedValue: isFinalReverse ? kfs[0].value : kfs[kfs.length - 1].value };
+	}
+	const cycleOffset = delta - cycleIndex * cycleDuration;
+	if (Boolean(track.yoyo) && cycleIndex % 2 === 1) return { frame: cycleOffset >= cycleSpan ? startFrame : lastFrame - cycleOffset };
+	return { frame: cycleOffset >= cycleSpan ? lastFrame : startFrame + cycleOffset };
+}
 /**
-* Standard keyframe track evaluation.
+* Standard keyframe track evaluation with loop (repeat/yoyo) support.
 */
 function evaluateKeyframes(track, localFrame, ease) {
 	const keyframes = track.keyframes ?? [];
 	if (keyframes.length === 0) return 0;
 	if (keyframes.length === 1) return keyframes[0].value;
-	if (localFrame <= keyframes[0].frame) return keyframes[0].value;
-	if (localFrame >= keyframes[keyframes.length - 1].frame) return keyframes[keyframes.length - 1].value;
+	const startFrame = keyframes[0].frame;
+	if (localFrame <= startFrame) return keyframes[0].value;
+	const lastFrame = keyframes[keyframes.length - 1].frame;
+	const repeatResolution = computeRepeatFrame(track, localFrame, startFrame, lastFrame);
+	if ("completedValue" in repeatResolution) return repeatResolution.completedValue;
+	const evalFrame = repeatResolution.frame;
 	for (let i = 0; i < keyframes.length - 1; i++) {
 		const kf0 = keyframes[i];
 		const kf1 = keyframes[i + 1];
-		if (localFrame >= kf0.frame && localFrame <= kf1.frame) {
+		if (evalFrame >= kf0.frame && evalFrame <= kf1.frame) {
 			const delta = kf1.frame - kf0.frame;
-			const linear = delta > 0 ? (localFrame - kf0.frame) / delta : 0;
+			const linear = delta > 0 ? (evalFrame - kf0.frame) / delta : 0;
 			const t = ease ? ease(kf1.ease ?? kf0.ease, delta, linear) : linear;
 			if (typeof kf0.value === "boolean") return linear >= 1 ? kf1.value : kf0.value;
 			if (typeof kf0.value === "string" && typeof kf1.value === "string") {
@@ -2008,6 +2099,12 @@ const COLOR_PROPS = [
 	"emissive",
 	"color"
 ];
+/**
+* Keyframes on one layer past which an animation is probably keyed every
+* frame by mistake. There is no hard limit: evaluation and playback handle
+* any count, but programs this size are slow to send, read and edit.
+*/
+const LARGE_ANIMATION_KEYFRAMES = 2e3;
 /** Contrast below this makes text hard to read (WCAG large-text minimum). */
 const MIN_TEXT_CONTRAST = 3;
 function tracksOf(node) {
@@ -2094,11 +2191,15 @@ function lintComposition(config) {
 			"translateX",
 			"translateY",
 			"scale",
+			"scaleX",
+			"scaleY",
 			"rotation"
 		])) {
 			const { x, y, width, height } = node;
 			if (x + width <= 0 || y + height <= 0 || x >= W || y >= H) push("warning", "offscreen_layer", `'${id}' sits entirely outside the ${W}×${H} canvas (x ${x}, y ${y}) and never moves in.`, id);
 		}
+		const keyframeCount = tracksOf(node).reduce((n, t) => n + (t.keyframes?.length ?? 0), 0);
+		if (keyframeCount > LARGE_ANIMATION_KEYFRAMES) push("warning", "large_animation", `'${id}' has ${keyframeCount} keyframes across its tracks (over ${LARGE_ANIMATION_KEYFRAMES}). Keying every frame is rarely needed: key the turning points and let eases fill in, or drive the prop from a signal.`, id);
 		for (const t of tracksOf(node)) {
 			const kfs = t.keyframes ?? [];
 			if ((!t.source || t.source.type === "keyframe") && kfs.length >= 2 && kfs.every((k) => JSON.stringify(k.value) === JSON.stringify(kfs[0].value))) push("info", "static_track", `'${id}' animates \`${t.prop}\` but every keyframe holds ${JSON.stringify(kfs[0].value)}.`, id);
@@ -2431,11 +2532,9 @@ const TrackSourceSchema = z.preprocess((val) => {
 }, RawTrackSourceSchema);
 const animationInvariants = (anim, ctx) => {
 	if (!anim?.tracks) return;
-	let totalKeyframes = 0;
 	for (let tIdx = 0; tIdx < anim.tracks.length; tIdx++) {
 		const track = anim.tracks[tIdx];
 		const keyframes = track.keyframes ?? [];
-		totalKeyframes += keyframes.length;
 		if ((!track.source || track.source.type === "keyframe") && keyframes.length < 1) ctx.addIssue({
 			code: z.ZodIssueCode.custom,
 			message: `Track for property '${track.prop}' must have at least 1 keyframe.`,
@@ -2521,11 +2620,6 @@ const animationInvariants = (anim, ctx) => {
 			});
 		}
 	}
-	if (totalKeyframes > 128) ctx.addIssue({
-		code: z.ZodIssueCode.custom,
-		message: `Total keyframes across all tracks (${totalKeyframes}) exceeds the limit of 128.`,
-		path: ["tracks"]
-	});
 };
 const AnimationTrackSchema = z.object({
 	id: z.string().min(1),
@@ -2567,6 +2661,8 @@ const BaseNodeFields = {
 	effects: z.array(EffectSpecSchema).optional(),
 	rotation: z.number().default(0),
 	scale: z.number().min(0).default(1),
+	scaleX: z.number().default(1),
+	scaleY: z.number().default(1),
 	anchorX: z.number().min(0).max(1).default(.5),
 	anchorY: z.number().min(0).max(1).default(.5),
 	startFrame: z.number().int().min(0).default(0),
@@ -3141,7 +3237,14 @@ const Model3DNodeSchema = z.object({
 	text3dOptions: z.unknown().optional(),
 	primitive3d: z.unknown().optional()
 }).strict();
-const LayoutNodeSchema = z.lazy(() => z.union([
+/**
+* Dispatch on `kind`, not a plain union: a plain union tries every member,
+* and each member parses `children` before failing, so parse time grows
+* ~3x per nesting level (a depth-14 tree took minutes). The node schemas
+* are typed `ZodType<…>` for their recursive types, but each is a strict
+* object with a `kind` literal, which is all `discriminatedUnion` reads.
+*/
+const LayoutNodeSchema = z.lazy(() => z.discriminatedUnion("kind", [
 	FlexNodeSchema,
 	BlockNodeSchema,
 	BoxNodeSchema,
@@ -3574,4 +3677,4 @@ function collectNodeOps(nodes) {
 
 //#endregion
 export { applyStaggerToChildren as A, evaluateTrackAtFrame as B, ShapeNodeSchema as C, TextSpanMarkSchema as D, TextNodeSchema as E, computeLayout as F, initLayout as H, computeLayoutSync as I, computeStaggerDelay as L, collectNodeOps as M, compositorToProgram as N, TextSpanSchema as O, computeCarrierContinuity as P, evaluateAnimationAtFrame as R, Sequence as S, TextAnimatorSchema as T, lintComposition as U, hoistMattes as V, mergeAnimationTracks as W, MediaNodeSchema as _, CarrierHandoffConfigSchema as a, SceneDefinitionSchema as b, EnvironmentFogSchema as c, LayerAnimation as d, LayoutNodeSchema as f, MatteModeSchema as g, MaterialTypeSchema as h, CameraNodeSchema as i, calculateSequenceTimeline as j, ToneMappingSchema as k, EnvironmentPresetSchema as l, LightTypeSchema as m, BoxNodeSchema as n, ColorStopSchema as o, LightNodeSchema as p, CameraAnimation as r, CompositorProgramSchema as s, BloomConfigSchema as t, FlexNodeSchema as u, Model3DNodeSchema as v, TextAnimator as w, SceneTransitionTypeSchema as x, Scene as y, evaluateKeyframes as z };
-//# sourceMappingURL=program-KwDdbC0-.mjs.map
+//# sourceMappingURL=program-BdPDtfVv.mjs.map