Files
hyperframes/packages/cli/scripts/build-copy.mjs
T
Michael Wang ed93a13125 fix(cli): media-use copies only bundled SFX named by the bundled index (#7895)
* wip: paused before review

* chore: keep only the meaningful hunks

* chore(cli): drop formatting-only changes from the media index fix
2026-11-16 01:34:36 +00:00

223 lines
8.6 KiB
JavaScript

// Cross-platform replacement for the previous `mkdir -p … && cp -r …` shell
// chain, which failed on Windows because `cp` doesn't accept `-r` there.
import {
chmodSync,
copyFileSync,
cpSync,
existsSync,
mkdirSync,
readFileSync,
readdirSync,
rmSync,
} from "node:fs";
import { createRequire } from "node:module";
import { dirname, join, resolve } from "node:path";
import { fileURLToPath } from "node:url";
import { setTimeout as sleep } from "node:timers/promises";
const HERE = dirname(fileURLToPath(import.meta.url));
const CLI_ROOT = resolve(HERE, "..");
const REPO_ROOT = resolve(CLI_ROOT, "..", "..");
const DIST = join(CLI_ROOT, "dist");
// Studio's vite build clears its dist before rewriting it; don't start the
// copy until both sentinels are present so we never observe a partial tree.
const STUDIO_WAIT_TIMEOUT_MS = 30_000;
const STUDIO_POLL_INTERVAL_MS = 250;
// fallow-ignore-next-line complexity
async function waitForStudioDist(dir) {
const deadline = Date.now() + STUDIO_WAIT_TIMEOUT_MS;
while (Date.now() < deadline) {
try {
const entries = new Set(readdirSync(dir));
// vite emits `assets/` before rewriting `index.html` at the end of the
// build — so once both are present, the tree is complete.
if (entries.has("index.html") && entries.has("assets")) return;
} catch {
// dir doesn't exist yet — vite will create it
}
await sleep(STUDIO_POLL_INTERVAL_MS);
}
throw new Error(`[build-copy] timed out waiting for studio dist at ${dir}`);
}
function copyDir(src, dest) {
cpSync(src, dest, { recursive: true, force: true });
}
// Source maps stay out: the CLI ships none of its own (tsup sourcemap: false).
function copyDirContents(src, dest) {
for (const entry of readdirSync(src)) {
cpSync(join(src, entry), join(dest, entry), {
recursive: true,
force: true,
filter: (path) => !path.endsWith(".map"),
});
}
}
function copyMdFiles(srcDir, destDir) {
if (!existsSync(srcDir)) return;
for (const name of readdirSync(srcDir)) {
if (name.endsWith(".md")) {
cpSync(join(srcDir, name), join(destDir, name));
}
}
}
// Studio preview loads these from the CLI's own server instead of jsDelivr
// (studioServer.ts serves dist/vendor/npm). They come from the workspace's
// installed gsap, which must match the version core asks for, or Studio would
// quietly fall back to the CDN for every preview.
const GSAP_VENDOR_FILES = ["gsap.min.js", "CustomEase.min.js", "MotionPathPlugin.min.js"];
function copyGsapVendorFiles() {
const coreRequire = createRequire(join(REPO_ROOT, "packages", "core", "package.json"));
const gsapRoot = dirname(coreRequire.resolve("gsap/package.json"));
const { version } = JSON.parse(readFileSync(join(gsapRoot, "package.json"), "utf-8"));
const coreSource = readFileSync(
join(REPO_ROOT, "packages", "core", "src", "gsapCdn.ts"),
"utf-8",
);
const expected = coreSource.match(/GSAP_CDN_VERSION = "([^"]+)"/)?.[1];
if (version !== expected) {
throw new Error(
`[build-copy] installed gsap ${version} does not match GSAP_CDN_VERSION ${expected}`,
);
}
const vendorDir = join(DIST, "vendor", "npm");
rmSync(vendorDir, { recursive: true, force: true });
const dest = join(vendorDir, `gsap@${version}`, "dist");
mkdirSync(dest, { recursive: true });
for (const file of GSAP_VENDOR_FILES) {
copyFileSync(join(gsapRoot, "dist", file), join(dest, file));
chmodSync(join(dest, file), 0o644);
}
}
// fallow-ignore-next-line complexity
async function main() {
for (const sub of ["studio", "docs", "templates", "skills", "docker"]) {
mkdirSync(join(DIST, sub), { recursive: true });
}
mkdirSync(join(DIST, "commands"), { recursive: true });
// The bundled sharing modules resolve their policy and Unicode tables beside
// the CLI chunks, rather than from the share package's source directory.
copyDir(
join(REPO_ROOT, "packages", "share", "src", "sources", "contract"),
join(DIST, "contract"),
);
const studioDist = resolve(CLI_ROOT, "..", "studio", "dist");
await waitForStudioDist(studioDist);
// Only the SPA studioServer.ts serves (index.html, /assets, /icons, /favicon.svg);
// the rest of studio/dist is the npm library build.
for (const entry of ["index.html", "assets", "icons", "favicon.svg"]) {
copyDir(join(studioDist, entry), join(DIST, "studio", entry));
}
for (const tmpl of ["blank", "from-file", "_shared"]) {
copyDir(join(CLI_ROOT, "src", "templates", tmpl), join(DIST, "templates", tmpl));
}
// Bundle warm-grain from the repo registry so the built CLI can scaffold it
// offline and CI smoke tests pick up PR-branch changes before merge to main.
const warmGrainSrc = join(REPO_ROOT, "registry", "examples", "warm-grain");
if (existsSync(warmGrainSrc)) {
copyDir(warmGrainSrc, join(DIST, "templates", "warm-grain"));
}
// Skills bundled into the published CLI. Branches don't all carry the same
// skills/ tree (it gets restructured), so each entry is existsSync-guarded:
// a missing skill dir warns + skips instead of crashing the build.
for (const skill of ["hyperframes", "hyperframes-cli", "media-use"]) {
const src = join(REPO_ROOT, "skills", skill);
if (!existsSync(src)) {
console.warn(`[build-copy] skill not found, skipping: skills/${skill}`);
continue;
}
const destination = join(DIST, "skills", skill);
rmSync(destination, { recursive: true, force: true });
copyDir(src, destination);
}
// The media-use engine lives with the CLI source, but keeps its published
// skill-relative layout so the moved .mjs tree can run without a rewrite.
const mediaEngine = join(CLI_ROOT, "src", "media-use");
const publishedMediaLib = join(DIST, "skills", "media-use", "scripts", "lib");
rmSync(publishedMediaLib, { recursive: true, force: true });
mkdirSync(publishedMediaLib, { recursive: true });
copyDirContents(join(mediaEngine, "lib"), publishedMediaLib);
cpSync(
join(mediaEngine, "resolve.mjs"),
join(DIST, "skills", "media-use", "scripts", "resolve.mjs"),
);
// The SFX media index ships with the release whose bundled SFX files it names.
mkdirSync(join(DIST, "catalog-artifact"), { recursive: true });
cpSync(
join(REPO_ROOT, "registry", "catalog-artifact", "media-vectors.json"),
join(DIST, "catalog-artifact", "media-vectors.json"),
);
const dockerfile = join(CLI_ROOT, "src", "docker", "Dockerfile.render");
if (existsSync(dockerfile)) {
cpSync(dockerfile, join(DIST, "docker", "Dockerfile.render"));
}
const layoutAuditScript = join(CLI_ROOT, "src", "commands", "layout-audit.browser.js");
if (existsSync(layoutAuditScript)) {
cpSync(layoutAuditScript, join(DIST, "commands", "layout-audit.browser.js"));
}
const contrastAuditScript = join(CLI_ROOT, "src", "commands", "contrast-audit.browser.js");
if (existsSync(contrastAuditScript)) {
cpSync(contrastAuditScript, join(DIST, "commands", "contrast-audit.browser.js"));
}
const motionSignatureScript = join(CLI_ROOT, "src", "commands", "motion-signature.browser.js");
if (existsSync(motionSignatureScript)) {
cpSync(motionSignatureScript, join(DIST, "commands", "motion-signature.browser.js"));
}
const motionSampleScript = join(CLI_ROOT, "src", "commands", "motion-sample.browser.js");
if (existsSync(motionSampleScript)) {
cpSync(motionSampleScript, join(DIST, "commands", "motion-sample.browser.js"));
}
// Player bundles for the standalone browser player used by `present` and
// `play`. resolvePlayerPath/resolveSlideshowPath look for these alongside the
// built CLI (dist/<name>.global.js), so they must ship in the package — the
// monorepo-dev fallback paths don't exist once installed from npm. Without
// this, `npx hyperframes present` fails with "@hyperframes/player not found".
const playerDist = join(REPO_ROOT, "packages", "player", "dist");
const playerGlobals = [
[join(playerDist, "hyperframes-player.global.js"), join(DIST, "hyperframes-player.global.js")],
[
join(playerDist, "slideshow", "hyperframes-slideshow.global.js"),
join(DIST, "hyperframes-slideshow.global.js"),
],
];
for (const [src, dest] of playerGlobals) {
if (existsSync(src)) {
cpSync(src, dest);
} else {
console.warn(`[build-copy] player bundle not found, skipping: ${src}`);
}
}
// The bundled inspector reads its page runtime from beside its own chunk.
const inspectorRuntime = join(REPO_ROOT, "packages", "inspector", "dist", "inspection.js");
cpSync(inspectorRuntime, join(DIST, "inspection.js"));
copyGsapVendorFiles();
copyMdFiles(join(CLI_ROOT, "src", "docs"), join(DIST, "docs"));
console.log("[build-copy] done");
}
await main();