mirror of
https://github.com/heygen-com/hyperframes.git
synced 2026-11-16 14:27:26 +00:00
449 lines
15 KiB
TypeScript
449 lines
15 KiB
TypeScript
import { describe, it, expect, beforeEach } from "vitest";
|
|
import type { GsapAnimation } from "@hyperframes/core/gsap-parser";
|
|
import { usePlayerStore, type KeyframeCacheEntry } from "../player/store/playerStore";
|
|
import {
|
|
clearKeyframeCacheForElement,
|
|
pruneKeyframeCacheToFiles,
|
|
replaceKeyframeCacheForFile,
|
|
updateKeyframeCacheFromParsed,
|
|
} from "./gsapKeyframeCacheHelpers";
|
|
|
|
const entry = (): KeyframeCacheEntry => ({
|
|
format: "percentage",
|
|
keyframes: [{ percentage: 0, properties: { x: 0 } }],
|
|
});
|
|
|
|
const seed = (key: string) => usePlayerStore.getState().setKeyframeCache(key, entry());
|
|
const cache = () => usePlayerStore.getState().keyframeCache;
|
|
|
|
const animWithKeyframes = (id: string): GsapAnimation => ({
|
|
id,
|
|
targetSelector: `#${id}`,
|
|
method: "to",
|
|
position: 0,
|
|
properties: {},
|
|
duration: 1,
|
|
resolvedStart: 0,
|
|
propertyGroup: "position",
|
|
keyframes: { format: "percentage", keyframes: [{ percentage: 50, properties: { x: 100 } }] },
|
|
});
|
|
|
|
beforeEach(() => {
|
|
usePlayerStore.setState({ keyframeCache: new Map(), gsapAnimations: new Map(), elements: [] });
|
|
});
|
|
|
|
describe("clearKeyframeCacheForElement", () => {
|
|
it("drops the prefixed, index.html fallback, and bare key for a non-index source", () => {
|
|
seed("comp.html#box");
|
|
seed("index.html#box");
|
|
seed("box");
|
|
|
|
clearKeyframeCacheForElement("comp.html", "box");
|
|
|
|
expect(cache().has("comp.html#box")).toBe(false);
|
|
expect(cache().has("index.html#box")).toBe(false);
|
|
// The bare key is what PropertyPanel's keyframe nav reads (element.id), so
|
|
// it must be cleared too, not just the prefixed variants.
|
|
expect(cache().has("box")).toBe(false);
|
|
});
|
|
|
|
it("drops the prefixed and bare key for an index.html source", () => {
|
|
seed("index.html#hero");
|
|
seed("hero");
|
|
|
|
clearKeyframeCacheForElement("index.html", "hero");
|
|
|
|
expect(cache().has("index.html#hero")).toBe(false);
|
|
expect(cache().has("hero")).toBe(false);
|
|
});
|
|
|
|
it("leaves other elements' keys untouched", () => {
|
|
seed("index.html#box");
|
|
seed("box");
|
|
seed("index.html#other");
|
|
seed("other");
|
|
|
|
clearKeyframeCacheForElement("index.html", "box");
|
|
|
|
expect(cache().has("index.html#other")).toBe(true);
|
|
expect(cache().has("other")).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("pruneKeyframeCacheToFiles", () => {
|
|
// Switching composition leaves the previous comp's elements cached with no
|
|
// owner left to clear them: each file only ever clears its own entries.
|
|
it("drops every element of a file the next scan no longer covers", () => {
|
|
seed("index.html#stress-1");
|
|
seed("stress-1");
|
|
seed("index.html#stress-2");
|
|
seed("stress-2");
|
|
seed("kf200.html#kf200");
|
|
seed("index.html#kf200");
|
|
seed("kf200");
|
|
|
|
pruneKeyframeCacheToFiles(["kf200.html"]);
|
|
|
|
for (const key of ["index.html#stress-1", "stress-1", "index.html#stress-2", "stress-2"]) {
|
|
expect(cache().has(key)).toBe(false);
|
|
}
|
|
expect(cache().has("kf200.html#kf200")).toBe(true);
|
|
});
|
|
|
|
it("prunes gsapAnimations alongside keyframeCache", () => {
|
|
usePlayerStore.getState().setGsapAnimations("index.html#stress-1", [animWithKeyframes("t")]);
|
|
usePlayerStore.getState().setGsapAnimations("kf200.html#kf200", [animWithKeyframes("u")]);
|
|
|
|
pruneKeyframeCacheToFiles(["kf200.html"]);
|
|
|
|
const animations = usePlayerStore.getState().gsapAnimations;
|
|
expect(animations.has("index.html#stress-1")).toBe(false);
|
|
expect(animations.has("kf200.html#kf200")).toBe(true);
|
|
});
|
|
|
|
it("keeps everything when every cached file is still covered", () => {
|
|
seed("index.html#hero");
|
|
seed("comp.html#a");
|
|
|
|
pruneKeyframeCacheToFiles(["index.html", "comp.html"]);
|
|
|
|
expect(cache().has("index.html#hero")).toBe(true);
|
|
expect(cache().has("comp.html#a")).toBe(true);
|
|
});
|
|
|
|
// The prune runs immediately before the atomic repopulate on every
|
|
// composition switch. One notification per stale element put every subscriber
|
|
// through a cache that was progressively emptier, which is the flash the
|
|
// atomic repopulate exists to avoid.
|
|
it("drops every stale file in one notification", () => {
|
|
seed("old.html#a");
|
|
seed("old.html#b");
|
|
seed("older.html#c");
|
|
seed("kept.html#k");
|
|
let notifications = 0;
|
|
const unsubscribe = usePlayerStore.subscribe(() => {
|
|
notifications += 1;
|
|
});
|
|
|
|
pruneKeyframeCacheToFiles(["kept.html"]);
|
|
unsubscribe();
|
|
|
|
expect(notifications).toBe(1);
|
|
expect([...cache().keys()]).toEqual(["kept.html#k"]);
|
|
});
|
|
|
|
// A prune that finds nothing stale must not hand subscribers a fresh Map
|
|
// identity: every keyframe consumer re-renders on cache identity alone.
|
|
it("does not publish when nothing is stale", () => {
|
|
seed("kept.html#k");
|
|
const before = cache();
|
|
let notifications = 0;
|
|
const unsubscribe = usePlayerStore.subscribe(() => {
|
|
notifications += 1;
|
|
});
|
|
|
|
pruneKeyframeCacheToFiles(["kept.html"]);
|
|
unsubscribe();
|
|
|
|
expect(notifications).toBe(0);
|
|
expect(cache()).toBe(before);
|
|
});
|
|
});
|
|
|
|
describe("replaceKeyframeCacheForFile", () => {
|
|
it("publishes complete keyframe and animation maps in one notification", () => {
|
|
const staleEntry = entry();
|
|
const otherEntry = entry();
|
|
const staleAnimation = animWithKeyframes("stale");
|
|
const freshAnimation = animWithKeyframes("fresh");
|
|
usePlayerStore.setState({
|
|
keyframeCache: new Map([
|
|
["scene.html#stale", staleEntry],
|
|
["index.html#stale", staleEntry],
|
|
["stale", staleEntry],
|
|
["other.html#other", otherEntry],
|
|
["other", otherEntry],
|
|
]),
|
|
gsapAnimations: new Map([
|
|
["scene.html#stale", [staleAnimation]],
|
|
["index.html#stale", [staleAnimation]],
|
|
["stale", [staleAnimation]],
|
|
["other.html#other", [staleAnimation]],
|
|
["other", [staleAnimation]],
|
|
]),
|
|
});
|
|
const snapshots: Array<{ cacheKeys: string[]; animationKeys: string[] }> = [];
|
|
const unsubscribe = usePlayerStore.subscribe((state) => {
|
|
snapshots.push({
|
|
cacheKeys: [...state.keyframeCache.keys()].sort(),
|
|
animationKeys: [...state.gsapAnimations.keys()].sort(),
|
|
});
|
|
});
|
|
|
|
replaceKeyframeCacheForFile(
|
|
"scene.html",
|
|
new Map([["fresh", entry()]]),
|
|
new Map([["fresh", [freshAnimation]]]),
|
|
);
|
|
unsubscribe();
|
|
|
|
expect(snapshots).toEqual([
|
|
{
|
|
cacheKeys: ["fresh", "index.html#fresh", "other", "other.html#other", "scene.html#fresh"],
|
|
animationKeys: [
|
|
"fresh",
|
|
"index.html#fresh",
|
|
"other",
|
|
"other.html#other",
|
|
"scene.html#fresh",
|
|
],
|
|
},
|
|
]);
|
|
expect(usePlayerStore.getState().gsapAnimations.get("scene.html#fresh")).toEqual([
|
|
freshAnimation,
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe("updateKeyframeCacheFromParsed", () => {
|
|
it("records colliding animation targets with their own tween percentages", () => {
|
|
const animation = (
|
|
id: string,
|
|
propertyGroup: string,
|
|
properties: Record<string, number>,
|
|
percentage: number,
|
|
resolvedStart: number,
|
|
): GsapAnimation => ({
|
|
...animWithKeyframes(id),
|
|
targetSelector: "#hero",
|
|
propertyGroup,
|
|
resolvedStart,
|
|
keyframes: { format: "percentage", keyframes: [{ percentage, properties }] },
|
|
});
|
|
|
|
usePlayerStore.setState({
|
|
elements: [{ id: "hero", domId: "hero", tag: "div", start: 0, duration: 4, track: 0 }],
|
|
});
|
|
|
|
updateKeyframeCacheFromParsed(
|
|
[
|
|
animation("hero-position", "position", { x: 100 }, 50, 0.5),
|
|
animation("hero-visual", "visual", { opacity: 1 }, 80, 0.2),
|
|
animation("hero-position", "position", { y: 50 }, 25, 0.75),
|
|
animation("hero-scale", "scale", { scale: 2 }, 60, 0.4),
|
|
],
|
|
"scene.html",
|
|
"hero",
|
|
{},
|
|
);
|
|
|
|
expect(cache().get("scene.html#hero")?.keyframes[0]?.collidingAnimationTargets).toEqual([
|
|
{ animationId: "hero-position", tweenPercentage: 50 },
|
|
{ animationId: "hero-visual", tweenPercentage: 80 },
|
|
{ animationId: "hero-scale", tweenPercentage: 60 },
|
|
]);
|
|
});
|
|
|
|
it("serializes a multi-keyframe tween with a stable shape and animation identity", () => {
|
|
const animation: GsapAnimation = {
|
|
...animWithKeyframes("hero"),
|
|
duration: 2,
|
|
resolvedStart: 3,
|
|
keyframes: {
|
|
format: "percentage",
|
|
keyframes: [
|
|
{ percentage: 0, properties: { x: 0 } },
|
|
{ percentage: 50, properties: { x: 100 }, ease: "power1.inOut" },
|
|
{ percentage: 100, properties: { x: 200 } },
|
|
],
|
|
easeEach: "power1.inOut",
|
|
},
|
|
};
|
|
usePlayerStore.setState({
|
|
elements: [
|
|
{
|
|
id: "hero-clip",
|
|
domId: "hero",
|
|
tag: "div",
|
|
start: 2,
|
|
duration: 4,
|
|
track: 0,
|
|
},
|
|
],
|
|
});
|
|
|
|
updateKeyframeCacheFromParsed([animation], "scene.html", "hero", {});
|
|
|
|
expect(JSON.stringify(cache().get("scene.html#hero"))).toBe(
|
|
'{"format":"percentage","keyframes":[{"percentage":25,"properties":{"x":0},"tweenPercentage":0,"propertyGroup":"position","animationId":"hero"},{"percentage":50,"properties":{"x":100},"ease":"power1.inOut","tweenPercentage":50,"propertyGroup":"position","animationId":"hero"},{"percentage":75,"properties":{"x":200},"tweenPercentage":100,"propertyGroup":"position","animationId":"hero"}],"easeEach":"power1.inOut"}',
|
|
);
|
|
});
|
|
|
|
it("clears the bare key when the selected element no longer has keyframes", () => {
|
|
// Element previously had keyframes, so a bare entry exists (writes set both).
|
|
seed("index.html#box");
|
|
seed("box");
|
|
|
|
// A mutation leaves #box without any keyframes in the parsed animations.
|
|
updateKeyframeCacheFromParsed([], "index.html", "box", {});
|
|
|
|
expect(cache().has("index.html#box")).toBe(false);
|
|
// Without the bare-key clear this assertion fails: the stale entry survives
|
|
// and PropertyPanel keeps rendering the removed keyframes.
|
|
expect(cache().has("box")).toBe(false);
|
|
});
|
|
|
|
it("still writes the bare key for elements that have keyframes", () => {
|
|
updateKeyframeCacheFromParsed([animWithKeyframes("hero")], "index.html", "hero", {});
|
|
|
|
expect(cache().has("index.html#hero")).toBe(true);
|
|
expect(cache().has("hero")).toBe(true);
|
|
});
|
|
|
|
it("caches flat tweens as clip-relative start and end keyframes", () => {
|
|
const animation: GsapAnimation = {
|
|
id: "flat-box",
|
|
targetSelector: "#box",
|
|
method: "to",
|
|
position: 1,
|
|
properties: { x: 420 },
|
|
duration: 2,
|
|
resolvedStart: 1,
|
|
ease: "power2.out",
|
|
propertyGroup: "position",
|
|
};
|
|
usePlayerStore.setState({
|
|
elements: [{ id: "box-clip", domId: "box", tag: "div", start: 1, duration: 2, track: 0 }],
|
|
});
|
|
|
|
updateKeyframeCacheFromParsed([animation], "scene.html", "box", {});
|
|
|
|
expect(cache().get("scene.html#box")).toEqual({
|
|
format: "percentage",
|
|
keyframes: [
|
|
{
|
|
percentage: 0,
|
|
properties: { x: 0 },
|
|
tweenPercentage: 0,
|
|
propertyGroup: "position",
|
|
animationId: "flat-box",
|
|
},
|
|
{
|
|
percentage: 100,
|
|
properties: { x: 420 },
|
|
ease: "power2.out",
|
|
tweenPercentage: 100,
|
|
propertyGroup: "position",
|
|
animationId: "flat-box",
|
|
},
|
|
],
|
|
});
|
|
expect(usePlayerStore.getState().gsapAnimations.get("scene.html#box")).toEqual([animation]);
|
|
});
|
|
|
|
it("records an ungrouped tween in gsapAnimations too, so the two stores agree", () => {
|
|
// `{ x, opacity }` spans two property groups, so the parser leaves
|
|
// propertyGroup undefined. Skipping it here used to cache diamonds with no
|
|
// source animation behind them: the collapsed row drew keyframes the
|
|
// expanded lanes could not render.
|
|
const animation: GsapAnimation = {
|
|
id: "mixed-box",
|
|
targetSelector: "#box",
|
|
method: "to",
|
|
position: 0,
|
|
properties: { x: 100, opacity: 0 },
|
|
duration: 1,
|
|
resolvedStart: 0,
|
|
};
|
|
usePlayerStore.setState({
|
|
elements: [{ id: "box-clip", domId: "box", tag: "div", start: 0, duration: 1, track: 0 }],
|
|
});
|
|
|
|
updateKeyframeCacheFromParsed([animation], "scene.html", "box", {});
|
|
|
|
expect(cache().has("scene.html#box")).toBe(true);
|
|
expect(usePlayerStore.getState().gsapAnimations.get("scene.html#box")).toEqual([animation]);
|
|
});
|
|
|
|
// `#stat3 .block` animates the BLOCK inside #stat3, not #stat3. An unanchored
|
|
// `^#([\w-]+)/` prefix match filed it under "stat3", which both stole the
|
|
// child's diamonds and collided with #stat3's own tween at the shared
|
|
// percentage (dropping #stat3's ease as ambiguous).
|
|
it("attributes a descendant selector to the child, not to its ancestor", () => {
|
|
const parent: GsapAnimation = {
|
|
id: "stat3-fromTo",
|
|
targetSelector: "#stat3",
|
|
method: "fromTo",
|
|
position: 8.88,
|
|
resolvedStart: 8.88,
|
|
duration: 0.25,
|
|
fromProperties: { y: 20 },
|
|
properties: { y: 0 },
|
|
ease: "power2.out",
|
|
propertyGroup: "position",
|
|
};
|
|
const child: GsapAnimation = {
|
|
id: "block-from",
|
|
targetSelector: "#stat3 .block",
|
|
method: "from",
|
|
position: 9.13,
|
|
resolvedStart: 9.13,
|
|
duration: 0.3,
|
|
properties: { opacity: 0 },
|
|
ease: "power2.in",
|
|
propertyGroup: "visual",
|
|
};
|
|
usePlayerStore.setState({
|
|
elements: [
|
|
{ id: "stat3-clip", domId: "stat3", tag: "div", start: 8.88, duration: 1, track: 0 },
|
|
],
|
|
});
|
|
const doc = {
|
|
querySelectorAll: (selector: string) =>
|
|
(selector === "#stat3 .block"
|
|
? [{ id: "stat3-block" }]
|
|
: []) as unknown as NodeListOf<Element>,
|
|
} as unknown as Document;
|
|
|
|
updateKeyframeCacheFromParsed([parent, child], "scene.html", "stat3", {}, doc);
|
|
|
|
expect(usePlayerStore.getState().gsapAnimations.get("scene.html#stat3")).toEqual([parent]);
|
|
expect(usePlayerStore.getState().gsapAnimations.get("scene.html#stat3-block")).toEqual([child]);
|
|
// With the collision gone, #stat3's own curve survives instead of being
|
|
// deleted as an ambiguous same-percentage merge.
|
|
const parentKeyframes = cache().get("scene.html#stat3")?.keyframes ?? [];
|
|
expect(parentKeyframes.at(-1)?.ease).toBe("power2.out");
|
|
expect(parentKeyframes.some((keyframe) => "easeAmbiguous" in keyframe)).toBe(false);
|
|
});
|
|
|
|
it("attributes a descendant selector to nothing when there is no document", () => {
|
|
const child: GsapAnimation = {
|
|
...animWithKeyframes("block-from"),
|
|
targetSelector: "#stat3 .block",
|
|
};
|
|
|
|
updateKeyframeCacheFromParsed([child], "scene.html", "stat3", {});
|
|
|
|
expect(cache().has("scene.html#stat3")).toBe(false);
|
|
expect(usePlayerStore.getState().gsapAnimations.has("scene.html#stat3")).toBe(false);
|
|
});
|
|
|
|
it("does not cache a flat tween without animatable numeric properties", () => {
|
|
const animation: GsapAnimation = {
|
|
id: "flat-box",
|
|
targetSelector: "#box",
|
|
method: "to",
|
|
position: 0,
|
|
properties: { backgroundColor: "#fff" },
|
|
duration: 1,
|
|
propertyGroup: "visual",
|
|
};
|
|
|
|
updateKeyframeCacheFromParsed([animation], "scene.html", "box", {});
|
|
|
|
expect(cache().has("scene.html#box")).toBe(false);
|
|
expect(cache().has("box")).toBe(false);
|
|
expect(usePlayerStore.getState().gsapAnimations.has("scene.html#box")).toBe(false);
|
|
});
|
|
});
|