mirror of
https://github.com/heygen-com/hyperframes.git
synced 2026-11-16 06:19:21 +00:00
The narrowing this branch adds missed the motion-path overlay, and every caller that could not narrow fell back to the exact bare class the narrowing exists to replace. - motionPathSelection.selectorFor now goes through writeTargetSelector. It feeds both the geometry read and the "set destination" write, so a class sibling measured its home off the FIRST sibling and then authored add-motion-path onto all of them. The toolbar toggle hides when no one-element form exists rather than arming a press that is dropped. - The five new-tween writers that fell back to the selection's own selector now drop the commit instead. A gesture that does not persist reverts on the next reload; a tween silently aimed at five elements does not. - tweenTargetsElement only follows the DOM to a target that matches exactly one element. A target the element merely shares with its siblings is a group tween, and these callers mutate what they find, so an individual nudge was rewriting the group's own tween and moving all five.
290 lines
12 KiB
TypeScript
290 lines
12 KiB
TypeScript
// @vitest-environment jsdom
|
|
import { afterEach, describe, expect, it, vi } from "vitest";
|
|
import { parseGsapScript } from "@hyperframes/core/gsap-parser";
|
|
import { addAnimationWithKeyframesToScript } from "@hyperframes/parsers/gsap-writer-acorn";
|
|
import type { DomEditSelection } from "../components/editor/domEditingTypes";
|
|
import { buildStableSelector, getSelectorIndex } from "../components/editor/domEditingDom";
|
|
import { resolveSelectorElementIds, tweenTargetsElement, writeTargetSelector } from "./gsapShared";
|
|
import { commitKeyframeAtTimeImpl } from "./gsapKeyframeCommit";
|
|
import { promoteSetToKeyframes } from "./useEnableKeyframes";
|
|
|
|
afterEach(() => {
|
|
document.body.innerHTML = "";
|
|
});
|
|
|
|
/**
|
|
* A selection built the way production builds it (getDomLayerPatchTarget), so
|
|
* the class-only case under test is the real one: buildStableSelector hands back
|
|
* a BARE class for an element with no id / hf-id / composition id.
|
|
*/
|
|
function selectionFor(el: HTMLElement): DomEditSelection {
|
|
const selector = buildStableSelector(el);
|
|
return {
|
|
element: el,
|
|
id: el.id || undefined,
|
|
hfId: el.getAttribute("data-hf-id") || undefined,
|
|
selector,
|
|
selectorIndex: getSelectorIndex(document, el, selector, "index.html", null),
|
|
sourceFile: "index.html",
|
|
dataAttributes: { start: "0", duration: "2" },
|
|
} as unknown as DomEditSelection;
|
|
}
|
|
|
|
/** Five class-only siblings — the shape that made one add collapse the timeline. */
|
|
function mountGroupSiblings(): HTMLElement[] {
|
|
document.body.innerHTML = `
|
|
<div id="scene" class="clip" data-start="0" data-duration="2">
|
|
<div class="group"></div>
|
|
<div class="group"></div>
|
|
<div class="group"></div>
|
|
<div class="group"></div>
|
|
<div class="group"></div>
|
|
</div>
|
|
`;
|
|
return Array.from(document.querySelectorAll<HTMLElement>(".group"));
|
|
}
|
|
|
|
const BASE_SCRIPT = `
|
|
const tl = gsap.timeline({ paused: true });
|
|
tl.to("#scene", { opacity: 1, duration: 0.5 }, 0);
|
|
`.trim();
|
|
|
|
const KEYFRAMES = [
|
|
{ percentage: 0, properties: { x: 0 } },
|
|
{ percentage: 100, properties: { x: 40 } },
|
|
];
|
|
|
|
/** Author the selector into a real script and read the tween's targets back. */
|
|
function roundTripTargets(selector: string): { script: string; targets: string[] } {
|
|
const { script } = addAnimationWithKeyframesToScript(BASE_SCRIPT, selector, 0, 1, KEYFRAMES);
|
|
const added = parseGsapScript(script).animations.find((a) => a.targetSelector === selector);
|
|
if (!added) throw new Error(`written selector did not re-parse: ${selector}`);
|
|
return { script, targets: resolveSelectorElementIds(added.targetSelector, document) };
|
|
}
|
|
|
|
describe("writeTargetSelector", () => {
|
|
it("addresses exactly one element when the only identity is a shared class", () => {
|
|
const groups = mountGroupSiblings();
|
|
const selection = selectionFor(groups[2]);
|
|
|
|
// Precondition: this is the defect's input — a bare class hitting all five.
|
|
expect(selection.selector).toBe(".group");
|
|
expect(document.querySelectorAll(".group")).toHaveLength(5);
|
|
|
|
const written = writeTargetSelector(selection);
|
|
|
|
expect(written).toBeTruthy();
|
|
expect(document.querySelectorAll(written!)).toHaveLength(1);
|
|
expect(document.querySelector(written!)).toBe(groups[2]);
|
|
});
|
|
|
|
it("keeps a unique #id target", () => {
|
|
document.body.innerHTML = `<div id="box" class="card"></div>`;
|
|
const el = document.querySelector<HTMLElement>("#box")!;
|
|
|
|
expect(writeTargetSelector(selectionFor(el))).toBe("#box");
|
|
});
|
|
|
|
it("prefers data-hf-id over a generated structural selector", () => {
|
|
document.body.innerHTML = `
|
|
<div id="scene"><div class="group"></div><div class="group" data-hf-id="hf-42"></div></div>
|
|
`;
|
|
const el = document.querySelectorAll<HTMLElement>(".group")[1]!;
|
|
|
|
const written = writeTargetSelector(selectionFor(el));
|
|
|
|
expect(written).toBe('[data-hf-id="hf-42"]');
|
|
expect(document.querySelector(written!)).toBe(el);
|
|
});
|
|
|
|
it("keeps an already-unique class selector as authored", () => {
|
|
document.body.innerHTML = `<div id="scene"><div class="header"></div></div>`;
|
|
const el = document.querySelector<HTMLElement>(".header")!;
|
|
|
|
expect(writeTargetSelector(selectionFor(el))).toBe(".header");
|
|
});
|
|
|
|
it("hands identity back to a data-hf-id ancestor part way up a deep chain", () => {
|
|
// Mixed identity: the walk must step past the id-less <section>, stop at the
|
|
// data-hf-id row, and NOT keep climbing to #outer.
|
|
document.body.innerHTML = `
|
|
<div id="outer">
|
|
<header></header>
|
|
<section>
|
|
<div data-hf-id="mid">
|
|
<div class="cell"></div>
|
|
<div class="cell"></div>
|
|
<div class="cell"></div>
|
|
</div>
|
|
</section>
|
|
</div>
|
|
`;
|
|
const el = document.querySelectorAll<HTMLElement>(".cell")[2]!;
|
|
|
|
const written = writeTargetSelector(selectionFor(el));
|
|
|
|
expect(written).toBe('[data-hf-id="mid"] > div:nth-child(3)');
|
|
expect(document.querySelectorAll(written!)).toHaveLength(1);
|
|
expect(document.querySelector(written!)).toBe(el);
|
|
});
|
|
|
|
it("falls through to the structural walk when the selection's selector is not valid CSS", () => {
|
|
document.body.innerHTML = `<div id="scene"><div></div><div></div></div>`;
|
|
const el = document.querySelectorAll<HTMLElement>("#scene > div")[1]!;
|
|
// querySelectorAll throws on this, so the "does it match exactly one?" rung
|
|
// must read as a miss rather than crashing the add.
|
|
const selection = { ...selectionFor(el), selector: "div[unclosed" } as DomEditSelection;
|
|
|
|
expect(writeTargetSelector(selection)).toBe("#scene > div:nth-child(2)");
|
|
});
|
|
|
|
it("returns null when a live DOM is present and no rung addresses one element", () => {
|
|
document.body.innerHTML = `<div id="scene"><div class="group"></div><div class="group"></div></div>`;
|
|
const el = document.querySelectorAll<HTMLElement>(".group")[1]!;
|
|
const selection = selectionFor(el);
|
|
expect(selection.selector).toBe(".group");
|
|
// Detached between selecting and committing: ownerDocument still resolves,
|
|
// but there is no parent to count a :nth-child position in. Returning
|
|
// ".group" here would re-author the very selector this function replaces.
|
|
el.remove();
|
|
|
|
expect(writeTargetSelector(selection)).toBeNull();
|
|
});
|
|
|
|
it("still returns the selection's own selector when there is no DOM to check against", () => {
|
|
const selection = {
|
|
selector: ".group",
|
|
sourceFile: "index.html",
|
|
} as unknown as DomEditSelection;
|
|
|
|
expect(writeTargetSelector(selection)).toBe(".group");
|
|
});
|
|
});
|
|
|
|
describe("writeTargetSelector — write/read round trip", () => {
|
|
it("re-parses and attributes the new tween to the one element it targeted", () => {
|
|
const groups = mountGroupSiblings();
|
|
// Ids let resolveSelectorElementIds name the attributed elements; the
|
|
// SELECTION still has none, so the write path still faces the bare class.
|
|
groups.forEach((el, i) => el.setAttribute("id", `group-${i}`));
|
|
const selection = { ...selectionFor(groups[2]), id: undefined } as DomEditSelection;
|
|
|
|
const written = writeTargetSelector(selection);
|
|
const { targets } = roundTripTargets(written!);
|
|
|
|
expect(targets).toEqual(["group-2"]);
|
|
});
|
|
|
|
it("does not widen the add to the element's four class siblings", () => {
|
|
const groups = mountGroupSiblings();
|
|
groups.forEach((el, i) => el.setAttribute("id", `group-${i}`));
|
|
const selection = { ...selectionFor(groups[0]), id: undefined } as DomEditSelection;
|
|
|
|
// The old bare-class write attributed the one add to every sibling — the
|
|
// attribution blow-up behind "one add collapsed the timeline to a single row".
|
|
expect(roundTripTargets(".group").targets).toHaveLength(5);
|
|
|
|
expect(roundTripTargets(writeTargetSelector(selection)!).targets).toHaveLength(1);
|
|
});
|
|
});
|
|
|
|
describe("existingTweenTargetSelector", () => {
|
|
it("keeps the narrowed target when a replace re-authors the tween", async () => {
|
|
const groups = mountGroupSiblings();
|
|
const selection = selectionFor(groups[2]);
|
|
const commitMutation = vi.fn(async () => undefined);
|
|
// A tween a previous add already narrowed to one sibling. Re-deriving the
|
|
// target from the selection would widen it back to all five.
|
|
const setAnim = {
|
|
id: "a1",
|
|
targetSelector: "#scene > div:nth-child(3)",
|
|
method: "set",
|
|
position: 0,
|
|
properties: { x: 10 },
|
|
};
|
|
|
|
await promoteSetToKeyframes({ commitMutation } as never, selection, setAnim as never, 0, null);
|
|
|
|
const mutation = commitMutation.mock.calls[0]?.[0] as { targetSelector: string };
|
|
expect(mutation.targetSelector).toBe("#scene > div:nth-child(3)");
|
|
expect(document.querySelectorAll(mutation.targetSelector)).toHaveLength(1);
|
|
});
|
|
|
|
it("falls back to the selection when the tween's own target did not resolve", async () => {
|
|
const groups = mountGroupSiblings();
|
|
const selection = selectionFor(groups[2]);
|
|
const commitMutation = vi.fn(async () => undefined);
|
|
const setAnim = {
|
|
id: "a1",
|
|
targetSelector: "targets[i]",
|
|
hasUnresolvedSelector: true,
|
|
method: "set",
|
|
position: 0,
|
|
properties: { x: 10 },
|
|
};
|
|
|
|
await promoteSetToKeyframes({ commitMutation } as never, selection, setAnim as never, 0, null);
|
|
|
|
const mutation = commitMutation.mock.calls[0]?.[0] as { targetSelector: string };
|
|
expect(mutation.targetSelector).toBe(".group");
|
|
});
|
|
});
|
|
|
|
describe("commitKeyframeAtTimeImpl — new-tween target", () => {
|
|
it("authors a one-element selector when no tween exists at the playhead", async () => {
|
|
const groups = mountGroupSiblings();
|
|
const selection = selectionFor(groups[3]);
|
|
const commitMutation = vi.fn(async () => undefined);
|
|
|
|
await commitKeyframeAtTimeImpl(selection, 1, [], { x: 12 }, commitMutation);
|
|
|
|
const mutation = commitMutation.mock.calls[0]?.[1] as { targetSelector: string };
|
|
expect(mutation.targetSelector).not.toBe(".group");
|
|
expect(document.querySelectorAll(mutation.targetSelector)).toHaveLength(1);
|
|
expect(document.querySelector(mutation.targetSelector)).toBe(groups[3]);
|
|
});
|
|
});
|
|
|
|
describe("tweenTargetsElement", () => {
|
|
it("matches a tween narrowed to this element by a selector the selection does not use", () => {
|
|
const groups = mountGroupSiblings();
|
|
groups[2]!.id = "narrowed";
|
|
|
|
// The write half authored "#narrowed"; the read half still has ".group".
|
|
expect(tweenTargetsElement("#narrowed", ".group", groups[2])).toBe(true);
|
|
});
|
|
|
|
it("does not hand an individual element the group tween it merely inherits", () => {
|
|
const groups = mountGroupSiblings();
|
|
|
|
// Selecting one sibling by its own address must not let an edit mutate the
|
|
// ".group" tween: that write moves all five, not the one being nudged.
|
|
expect(tweenTargetsElement(".group", "#scene > div:nth-child(3)", groups[2])).toBe(false);
|
|
});
|
|
|
|
it("still edits a group tween when the group itself is the selection", () => {
|
|
const groups = mountGroupSiblings();
|
|
|
|
expect(tweenTargetsElement(".group", ".group", groups[0])).toBe(true);
|
|
});
|
|
|
|
it("does not match a target that is not a selector matches() understands", () => {
|
|
const groups = mountGroupSiblings();
|
|
|
|
expect(tweenTargetsElement("div[unclosed", ".group", groups[0])).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("commitKeyframeAtTimeImpl — no one-element target", () => {
|
|
it("drops the keyframe rather than authoring the bare class", async () => {
|
|
const groups = mountGroupSiblings();
|
|
const selection = selectionFor(groups[3]!);
|
|
groups[3]!.remove();
|
|
const commitMutation = vi.fn(async () => undefined);
|
|
|
|
await commitKeyframeAtTimeImpl(selection, 1, [], { x: 12 }, commitMutation);
|
|
|
|
expect(commitMutation).not.toHaveBeenCalled();
|
|
});
|
|
});
|