mirror of
https://github.com/heygen-com/hyperframes.git
synced 2026-11-19 11:26:02 +00:00
* feat(cli): add 1440p resolution presets to --resolution Adds landscape-1440p (2560x1440), portrait-1440p (1440x2560) and square-1440p (1440x1440) next to the existing 4K, 720p and 480p tiers, with the aliases 1440p, 2k and qhd plus 1440p-portrait and 1440p-square. 1440p joins the aspect-agnostic aliases, like 720p and 480p. Every validator derives from CANVAS_DIMENSIONS, so no logic changes: a 4K composition renders down to 1440p through the existing smaller-preset path, and a 1280x720 composition supersamples to 1440p at an exact 2x. A 1920x1080 composition is still refused by the non-integer-scale check (4/3); fractional scale factors are not part of this change. Refs #6309 Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> * fix(cli): clarify 1440p aliases and repair skill validation --------- Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com> Co-authored-by: James <james.russo@heygen.com>
269 lines
12 KiB
TypeScript
269 lines
12 KiB
TypeScript
// @vitest-environment node
|
|
import { describe, it, expect } from "vitest";
|
|
import * as core from "./index.js";
|
|
|
|
describe("@hyperframes/core public API exports", () => {
|
|
describe("type-related constants and utilities", () => {
|
|
it("exports CANVAS_DIMENSIONS", () => {
|
|
expect(core.CANVAS_DIMENSIONS).toBeDefined();
|
|
expect(core.CANVAS_DIMENSIONS.landscape).toEqual({ width: 1920, height: 1080 });
|
|
expect(core.CANVAS_DIMENSIONS.portrait).toEqual({ width: 1080, height: 1920 });
|
|
expect(core.CANVAS_DIMENSIONS["landscape-4k"]).toEqual({ width: 3840, height: 2160 });
|
|
expect(core.CANVAS_DIMENSIONS["portrait-4k"]).toEqual({ width: 2160, height: 3840 });
|
|
expect(core.CANVAS_DIMENSIONS.square).toEqual({ width: 1080, height: 1080 });
|
|
expect(core.CANVAS_DIMENSIONS["square-4k"]).toEqual({ width: 2160, height: 2160 });
|
|
expect(core.CANVAS_DIMENSIONS["landscape-1440p"]).toEqual({ width: 2560, height: 1440 });
|
|
expect(core.CANVAS_DIMENSIONS["portrait-1440p"]).toEqual({ width: 1440, height: 2560 });
|
|
expect(core.CANVAS_DIMENSIONS["square-1440p"]).toEqual({ width: 1440, height: 1440 });
|
|
});
|
|
|
|
it("exports VALID_CANVAS_RESOLUTIONS derived from CANVAS_DIMENSIONS", () => {
|
|
expect(core.VALID_CANVAS_RESOLUTIONS).toEqual([
|
|
"landscape",
|
|
"portrait",
|
|
"landscape-4k",
|
|
"portrait-4k",
|
|
"square",
|
|
"square-4k",
|
|
"landscape-1440p",
|
|
"portrait-1440p",
|
|
"square-1440p",
|
|
"landscape-720p",
|
|
"portrait-720p",
|
|
"square-720p",
|
|
"landscape-480p",
|
|
"portrait-480p",
|
|
"square-480p",
|
|
]);
|
|
});
|
|
|
|
it("exports normalizeResolutionFlag with alias support", () => {
|
|
expect(core.normalizeResolutionFlag("4k")).toBe("landscape-4k");
|
|
expect(core.normalizeResolutionFlag("uhd")).toBe("landscape-4k");
|
|
expect(core.normalizeResolutionFlag("1080p")).toBe("landscape");
|
|
expect(core.normalizeResolutionFlag("landscape-4k")).toBe("landscape-4k");
|
|
expect(core.normalizeResolutionFlag("UHD")).toBe("landscape-4k");
|
|
expect(core.normalizeResolutionFlag("square")).toBe("square");
|
|
expect(core.normalizeResolutionFlag("square-4k")).toBe("square-4k");
|
|
expect(core.normalizeResolutionFlag("1080p-square")).toBe("square");
|
|
expect(core.normalizeResolutionFlag("4k-square")).toBe("square-4k");
|
|
expect(core.normalizeResolutionFlag("1440p")).toBe("landscape-1440p");
|
|
expect(core.normalizeResolutionFlag("2k")).toBeUndefined();
|
|
expect(core.normalizeResolutionFlag("QHD")).toBe("landscape-1440p");
|
|
expect(core.normalizeResolutionFlag("1440p-portrait")).toBe("portrait-1440p");
|
|
expect(core.normalizeResolutionFlag("1440p-square")).toBe("square-1440p");
|
|
expect(core.normalizeResolutionFlag("portrait-1440p")).toBe("portrait-1440p");
|
|
expect(core.normalizeResolutionFlag("8k")).toBeUndefined();
|
|
expect(core.normalizeResolutionFlag(undefined)).toBeUndefined();
|
|
});
|
|
|
|
it("exports isAspectAgnosticResolutionAlias for tier-only aliases", () => {
|
|
// Tier-only aliases → true (orientation follows the composition).
|
|
expect(core.isAspectAgnosticResolutionAlias("1080p")).toBe(true);
|
|
expect(core.isAspectAgnosticResolutionAlias("hd")).toBe(true);
|
|
expect(core.isAspectAgnosticResolutionAlias("4k")).toBe(true);
|
|
expect(core.isAspectAgnosticResolutionAlias("uhd")).toBe(true);
|
|
expect(core.isAspectAgnosticResolutionAlias("1440p")).toBe(true);
|
|
expect(core.isAspectAgnosticResolutionAlias("2k")).toBe(false);
|
|
expect(core.isAspectAgnosticResolutionAlias("qhd")).toBe(true);
|
|
// Case-insensitive.
|
|
expect(core.isAspectAgnosticResolutionAlias("1080P")).toBe(true);
|
|
expect(core.isAspectAgnosticResolutionAlias("UHD")).toBe(true);
|
|
// Orientation-suffixed aliases → false (user picked an orientation).
|
|
expect(core.isAspectAgnosticResolutionAlias("1080p-portrait")).toBe(false);
|
|
expect(core.isAspectAgnosticResolutionAlias("portrait-1080p")).toBe(false);
|
|
expect(core.isAspectAgnosticResolutionAlias("4k-square")).toBe(false);
|
|
expect(core.isAspectAgnosticResolutionAlias("1080p-square")).toBe(false);
|
|
expect(core.isAspectAgnosticResolutionAlias("1440p-portrait")).toBe(false);
|
|
// Canonical presets → false.
|
|
expect(core.isAspectAgnosticResolutionAlias("landscape")).toBe(false);
|
|
expect(core.isAspectAgnosticResolutionAlias("portrait")).toBe(false);
|
|
expect(core.isAspectAgnosticResolutionAlias("landscape-4k")).toBe(false);
|
|
// Unknown / empty / undefined → false.
|
|
expect(core.isAspectAgnosticResolutionAlias("8k")).toBe(false);
|
|
expect(core.isAspectAgnosticResolutionAlias("")).toBe(false);
|
|
expect(core.isAspectAgnosticResolutionAlias(undefined)).toBe(false);
|
|
});
|
|
|
|
it("exports resolveResolutionFlagPair — the pair every distributed entrypoint must forward", () => {
|
|
// The single source of truth every distributed adapter reads
|
|
// (`hyperframes cloudrun render`, `hyperframes lambda render`,
|
|
// `hyperframes lambda render-batch`). Divergent copies across those
|
|
// callers is what shipped the portrait-1080p failure this helper
|
|
// exists to prevent (PR #2529). Case-insensitive on the raw input.
|
|
expect(core.resolveResolutionFlagPair("1080p")).toEqual({
|
|
outputResolution: "landscape",
|
|
outputResolutionAspectAgnostic: true,
|
|
});
|
|
expect(core.resolveResolutionFlagPair("4K")).toEqual({
|
|
outputResolution: "landscape-4k",
|
|
outputResolutionAspectAgnostic: true,
|
|
});
|
|
// Canonical preset — aspect-agnostic stays false.
|
|
expect(core.resolveResolutionFlagPair("portrait")).toEqual({
|
|
outputResolution: "portrait",
|
|
outputResolutionAspectAgnostic: false,
|
|
});
|
|
// Orientation-suffixed alias — aspect-agnostic stays false.
|
|
expect(core.resolveResolutionFlagPair("1080p-portrait")).toEqual({
|
|
outputResolution: "portrait",
|
|
outputResolutionAspectAgnostic: false,
|
|
});
|
|
// Unknown / empty / undefined → both fields degrade cleanly so
|
|
// callers can produce their own "invalid" UX.
|
|
expect(core.resolveResolutionFlagPair("8k")).toEqual({
|
|
outputResolution: undefined,
|
|
outputResolutionAspectAgnostic: false,
|
|
});
|
|
expect(core.resolveResolutionFlagPair(undefined)).toEqual({
|
|
outputResolution: undefined,
|
|
outputResolutionAspectAgnostic: false,
|
|
});
|
|
});
|
|
|
|
it("exports TIMELINE_COLORS", () => {
|
|
expect(core.TIMELINE_COLORS).toBeDefined();
|
|
expect(core.TIMELINE_COLORS.video).toBeDefined();
|
|
expect(core.TIMELINE_COLORS.image).toBeDefined();
|
|
expect(core.TIMELINE_COLORS.text).toBeDefined();
|
|
expect(core.TIMELINE_COLORS.audio).toBeDefined();
|
|
expect(core.TIMELINE_COLORS.composition).toBeDefined();
|
|
});
|
|
|
|
it("exports DEFAULT_DURATIONS", () => {
|
|
expect(core.DEFAULT_DURATIONS).toBeDefined();
|
|
expect(core.DEFAULT_DURATIONS.video).toBe(5);
|
|
expect(core.DEFAULT_DURATIONS.text).toBe(2);
|
|
});
|
|
|
|
it("exports type guard functions", () => {
|
|
expect(typeof core.isTextElement).toBe("function");
|
|
expect(typeof core.isMediaElement).toBe("function");
|
|
expect(typeof core.isCompositionElement).toBe("function");
|
|
});
|
|
|
|
it("exports getDefaultStageZoom", () => {
|
|
expect(typeof core.getDefaultStageZoom).toBe("function");
|
|
const zoom = core.getDefaultStageZoom("landscape");
|
|
expect(zoom.scale).toBe(1);
|
|
expect(zoom.focusX).toBe(960);
|
|
expect(zoom.focusY).toBe(540);
|
|
});
|
|
});
|
|
|
|
describe("template exports", () => {
|
|
it("exports generateBaseHtml", () => {
|
|
expect(typeof core.generateBaseHtml).toBe("function");
|
|
});
|
|
|
|
it("exports getStageStyles", () => {
|
|
expect(typeof core.getStageStyles).toBe("function");
|
|
});
|
|
|
|
it("exports template constants", () => {
|
|
expect(core.GSAP_CDN).toBeDefined();
|
|
expect(core.BASE_STYLES).toBeDefined();
|
|
expect(core.ELEMENT_BASE_STYLES).toBeDefined();
|
|
expect(core.MEDIA_STYLES).toBeDefined();
|
|
expect(core.TEXT_STYLES).toBeDefined();
|
|
expect(core.ZOOM_CONTAINER_STYLES).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe("parser exports", () => {
|
|
it("does NOT re-export GSAP parser functions from barrel (available via gsap-parser subpath)", () => {
|
|
// GSAP AST parser functions are not re-exported from the barrel —
|
|
// use the acorn parser (gsapParserAcorn) or writer (gsapWriterAcorn) directly.
|
|
expect(typeof (core as Record<string, unknown>).parseGsapScript).toBe("undefined");
|
|
});
|
|
|
|
it("does NOT re-export GSAP constants from barrel (available via gsap-constants subpath)", () => {
|
|
expect((core as Record<string, unknown>).SUPPORTED_PROPS).toBeUndefined();
|
|
});
|
|
|
|
it("exports HTML parser functions", () => {
|
|
expect(typeof core.parseHtml).toBe("function");
|
|
expect(typeof core.updateElementInHtml).toBe("function");
|
|
expect(typeof core.addElementToHtml).toBe("function");
|
|
expect(typeof core.removeElementFromHtml).toBe("function");
|
|
expect(typeof core.validateCompositionHtml).toBe("function");
|
|
expect(typeof core.extractCompositionMetadata).toBe("function");
|
|
});
|
|
});
|
|
|
|
describe("generator exports", () => {
|
|
it("exports hyperframes generator functions", () => {
|
|
expect(typeof core.generateHyperframesHtml).toBe("function");
|
|
expect(typeof core.generateGsapTimelineScript).toBe("function");
|
|
expect(typeof core.generateHyperframesStyles).toBe("function");
|
|
});
|
|
});
|
|
|
|
describe("compiler exports", () => {
|
|
it("exports compiler functions", () => {
|
|
expect(typeof core.compileTimingAttrs).toBe("function");
|
|
expect(typeof core.injectDurations).toBe("function");
|
|
expect(typeof core.extractResolvedMedia).toBe("function");
|
|
expect(typeof core.clampDurations).toBe("function");
|
|
expect(typeof core.shouldClampMediaDuration).toBe("function");
|
|
expect(typeof core.shouldClampResolvedMediaDuration).toBe("function");
|
|
});
|
|
});
|
|
|
|
describe("lint exports", () => {
|
|
it("exposes lintHyperframeHtml via the @hyperframes/core/lint back-compat stub", async () => {
|
|
// Lint moved to @hyperframes/lint; core's main entry no longer re-exports
|
|
// it (that would cycle through the lint package). The subpath stub keeps
|
|
// existing @hyperframes/core/lint imports working.
|
|
const lint = await import("./lint/index.js");
|
|
expect(typeof lint.lintHyperframeHtml).toBe("function");
|
|
});
|
|
});
|
|
|
|
describe("media exports", () => {
|
|
it("exports parseAnimatedGifMetadata", () => {
|
|
expect(typeof core.parseAnimatedGifMetadata).toBe("function");
|
|
});
|
|
});
|
|
|
|
describe("inline-script exports", () => {
|
|
it("exports hyperframe runtime artifacts", () => {
|
|
expect(core.HYPERFRAME_RUNTIME_ARTIFACTS).toBeDefined();
|
|
expect(core.HYPERFRAME_RUNTIME_CONTRACT).toBeDefined();
|
|
expect(typeof core.loadHyperframeRuntimeSource).toBe("function");
|
|
});
|
|
|
|
it("exports runtime contract constants", () => {
|
|
expect(core.HYPERFRAME_RUNTIME_GLOBALS).toBeDefined();
|
|
expect(core.HYPERFRAME_BRIDGE_SOURCES).toBeDefined();
|
|
expect(core.HYPERFRAME_CONTROL_ACTIONS).toBeDefined();
|
|
});
|
|
|
|
it("exports buildHyperframesRuntimeScript", () => {
|
|
expect(typeof core.buildHyperframesRuntimeScript).toBe("function");
|
|
});
|
|
|
|
it("exports MEDIA_VISUAL_STYLE_PROPERTIES", () => {
|
|
expect(core.MEDIA_VISUAL_STYLE_PROPERTIES).toBeDefined();
|
|
expect(Array.isArray(core.MEDIA_VISUAL_STYLE_PROPERTIES)).toBe(true);
|
|
expect(core.MEDIA_VISUAL_STYLE_PROPERTIES).toContain("width");
|
|
expect(core.MEDIA_VISUAL_STYLE_PROPERTIES).toContain("opacity");
|
|
expect(core.MEDIA_VISUAL_STYLE_PROPERTIES).toContain("transform");
|
|
});
|
|
|
|
it("exports copyMediaVisualStyles", () => {
|
|
expect(typeof core.copyMediaVisualStyles).toBe("function");
|
|
});
|
|
|
|
it("exports quantizeTimeToFrame", () => {
|
|
expect(typeof core.quantizeTimeToFrame).toBe("function");
|
|
});
|
|
});
|
|
|
|
describe("adapter exports", () => {
|
|
it("exports createGSAPFrameAdapter", () => {
|
|
expect(typeof core.createGSAPFrameAdapter).toBe("function");
|
|
});
|
|
});
|
|
});
|