@hyperframes/core 0.8.168 → 0.8.170

package/dist/compiler/compositionScoping.d.ts

@@ -4,7 +4,11 @@ export declare function scopeCssToComposition(css: string, compositionId: string
 }): string;
 /** Drops repeats of an identical `@font-face` across the given style texts, keeping the last copy:
  * the last matching rule is the one the browser uses, so a rule in between never gains precedence. */
-export declare function dedupeFontFaceRules(styleTexts: string[]): string[];
+export declare const dedupeFontFaceRules: (styleTexts: string[]) => string[];
+export declare function hoistFontFaceRules(styleTexts: string[]): {
+    styles: string[];
+    faces: string[];
+};
 export declare function scopedModulePrelude(timelineCompositionId: string, compositionSrc?: string | null): string;
 export declare function wrapScopedCompositionScript(source: string, compositionId: string, errorLabel?: string, scopeSelectorOverride?: string, timelineCompositionId?: string, authoredRootId?: string | null, compositionSrc?: string | null): string;
 export declare function wrapInlineScriptWithErrorBoundary(source: string, errorLabel: string): string;

package/dist/compiler/compositionScoping.js

@@ -162,7 +162,12 @@ function fontFaceKey(atRule) {
 }
 /** Drops repeats of an identical `@font-face` across the given style texts, keeping the last copy:
  * the last matching rule is the one the browser uses, so a rule in between never gains precedence. */
-export function dedupeFontFaceRules(styleTexts) {
+export const dedupeFontFaceRules = (styleTexts) => dropFontFaces(styleTexts);
+export function hoistFontFaceRules(styleTexts) {
+    const faces = [];
+    return { styles: dropFontFaces(styleTexts, faces), faces };
+}
+function dropFontFaces(styleTexts, hoisted) {
     const seen = new Set();
     return [...styleTexts]
         .reverse()
@@ -181,13 +186,14 @@ export function dedupeFontFaceRules(styleTexts) {
             if (!isFontFaceAtRule(node))
                 continue;
             const key = fontFaceKey(node);
-            if (seen.has(key)) {
-                node.remove();
-                changed = true;
-            }
-            else {
+            if (!seen.has(key)) {
                 seen.add(key);
+                if (!hoisted)
+                    continue;
+                hoisted.unshift(node.toString());
             }
+            node.remove();
+            changed = true;
         }
         return changed ? root.toResult({ map: false }).css : css;
     })

package/dist/compiler/htmlBundler.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { compositionStyle, cssStyleMergeKey, deferScriptsUntilFonts, UNCONDITIONAL_CSS_KEY, headStyleRuns, INLINED_FILE_ATTR, inlineScriptRuns, styleElementsFor, } from "./scriptRuns.js";
 import { countPageRoot, executableScripts, isJavaScriptType, planCompositionAssembly, } from "./compositionAssembly.js";
-import { SCENE_PART_ATTR } from "../sceneParts.js";
+import { SCENE_FONTS_ATTR, SCENE_PART_ATTR } from "../sceneParts.js";
 import { ensureExternalScriptTag, readExternalScriptAttributes, } from "./externalScripts.js";
 import { emitMountedModuleScripts, parseImportMap } from "./importMaps.js";
 import { markFlattenedInnerRoot } from "../runtime/flattenedRoot.js";
@@ -20,7 +20,7 @@ import { transform } from "esbuild";
 import { compileHtml } from "./htmlCompiler.js";
 import { RUNTIME_BOOTSTRAP_ATTR, escapeInlineScriptSource, insertRuntimeTag, parseHTMLContent, stripEmbeddedRuntimeScripts, } from "./htmlDocument.js";
 // rewriteSubCompPaths functions are used by inlineSubCompositions (shared module)
-import { buildVariablesByCompScript, dedupeFontFaceRules, scopeCssToComposition, wrapInlineScriptWithErrorBoundary, scopedModulePrelude, wrapScopedCompositionScript, } from "./compositionScoping.js";
+import { buildVariablesByCompScript, dedupeFontFaceRules, hoistFontFaceRules, scopeCssToComposition, wrapInlineScriptWithErrorBoundary, scopedModulePrelude, wrapScopedCompositionScript, } from "./compositionScoping.js";
 import { validateHyperframeHtmlContract } from "./staticGuard.js";
 import { getHyperframeRuntimeScript } from "../generated/runtime-inline.js";
 import { readDeclaredDefaults } from "../runtime/getVariables.js";
@@ -1171,13 +1171,20 @@ async function bundleProject(projectDir, options) {
         if (srcset)
             el.setAttribute("srcset", rewriteSrcsetWithInlinedAssets(srcset, projectDir, inlineAssets));
     }
-    // Before inlining, so postcss reads paths not font bytes; scene parts keep copies to swap alone.
-    if (!options?.sceneParts) {
-        const liveStyles = [...document.querySelectorAll("style")].filter(isAlwaysAppliedStyle);
-        const dedupedStyles = dedupeFontFaceRules(liveStyles.map((el) => el.textContent || ""));
-        liveStyles.forEach((el, i) => {
-            el.textContent = dedupedStyles[i] ?? "";
-        });
+    // Before inlining, so postcss reads paths not font bytes.
+    const liveStyles = [...document.querySelectorAll("style")].filter(isAlwaysAppliedStyle);
+    const liveCss = liveStyles.map((el) => el.textContent || "");
+    const { styles, faces } = options?.sceneParts
+        ? hoistFontFaceRules(liveCss)
+        : { styles: dedupeFontFaceRules(liveCss), faces: [] };
+    liveStyles.forEach((el, i) => {
+        el.textContent = styles[i] ?? "";
+    });
+    if (faces.length > 0) {
+        const holder = document.createElement("style");
+        holder.setAttribute(SCENE_FONTS_ATTR, "");
+        holder.textContent = faces.join("\n");
+        document.head.prepend(holder);
     }
     for (const styleEl of document.querySelectorAll("style")) {
         styleEl.textContent = rewriteCssUrlsWithInlinedAssets(styleEl.textContent || "", projectDir, inlineAssets);

package/dist/compiler/scenePartsManifest.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { SCENE_PART_ATTR, SCENE_PARTS_META } from "../sceneParts.js";
+import { SCENE_FONTS_ATTR, SCENE_PART_ATTR, SCENE_PARTS_META, } from "../sceneParts.js";
 import { injectTagsAtHeadStart, parseHTMLContent } from "./htmlDocument.js";
 const hash = (text) => createHash("sha1").update(text).digest("hex").slice(0, 16);
 /**
@@ -19,7 +19,9 @@ export function addScenePartsManifest(html, ignore = []) {
     // A marker keeps each part's place in `shared`, so moving or reordering a scene changes it.
     for (const el of parts)
         el.replaceWith(doc.createComment(`hf-scene:${el.getAttribute(SCENE_PART_ATTR)}`));
-    for (const el of ignore.flatMap((sel) => [...doc.querySelectorAll(sel)]))
+    for (const el of [...ignore, `style[${SCENE_FONTS_ATTR}]`].flatMap((sel) => [
+        ...doc.querySelectorAll(sel),
+    ]))
         el.remove();
     const manifest = {
         shared: hash(doc.toString()),

package/dist/core.types.d.ts

@@ -65,10 +65,6 @@ export declare function parseFps(input: string | number): FpsParseResult;
  * errors — those still surface via the discriminated result.
  */
 export declare function parseFpsWithDefault(input: string | number | undefined): FpsParseResult;
-/** Integer rates the distributed renderer (Lambda, Cloud Run) accepts; fractional fps renders in-process only. */
-export declare const DISTRIBUTED_FPS: readonly [24, 25, 30, 60];
-export type DistributedFps = (typeof DISTRIBUTED_FPS)[number];
-export declare function isDistributedFps(value: unknown): value is DistributedFps;
 /** Video orientation / aspect ratio. */
 export type Orientation = "16:9" | "9:16";
 export type { Asset, TimelineElementType, MediaElementType, TimelineElementBase, TimelineMediaElement, WaveformData, TimelineTextElement, TimelineCompositionElement, CompositionVariableType, CompositionVariableBase, StringVariable, NumberVariable, ColorVariable, BooleanVariable, EnumVariable, CompositionVariable, CompositionSpec, TimelineElement, MediaFile, CanvasResolution, CompositionAPI, PlayerAPI, AddElementData, ValidationResult, CompositionAsset, Keyframe, KeyframeProperties, ElementKeyframes, StageZoom, StageZoomKeyframe, } from "@hyperframes/parsers";

package/dist/core.types.js

@@ -101,9 +101,4 @@ export function parseFpsWithDefault(input) {
         return { ok: true, value: { num: 30, den: 1 } };
     return parseFps(input);
 }
-/** Integer rates the distributed renderer (Lambda, Cloud Run) accepts; fractional fps renders in-process only. */
-export const DISTRIBUTED_FPS = [24, 25, 30, 60];
-export function isDistributedFps(value) {
-    return DISTRIBUTED_FPS.includes(value);
-}
 export { CANVAS_DIMENSIONS, VALID_CANVAS_RESOLUTIONS, normalizeResolutionFlag, isAspectAgnosticResolutionAlias, resolveResolutionFlagPair, checkOutputResolutionCompatibility, suggestMatchingPreset, COMPOSITION_VARIABLE_TYPES, TIMELINE_COLORS, DEFAULT_DURATIONS, getDefaultStageZoom, isTextElement, isMediaElement, isCompositionElement, } from "@hyperframes/parsers";

package/dist/distributedFps.d.ts

@@ -0,0 +1,4 @@
+/** Integer rates the distributed renderer (Lambda, Cloud Run) accepts; fractional fps renders in-process only. */
+export declare const DISTRIBUTED_FPS: readonly [24, 25, 30, 60];
+export type DistributedFps = (typeof DISTRIBUTED_FPS)[number];
+export declare function isDistributedFps(value: unknown): value is DistributedFps;

package/dist/distributedFps.js

@@ -0,0 +1,5 @@
+/** Integer rates the distributed renderer (Lambda, Cloud Run) accepts; fractional fps renders in-process only. */
+export const DISTRIBUTED_FPS = [24, 25, 30, 60];
+export function isDistributedFps(value) {
+    return DISTRIBUTED_FPS.includes(value);
+}

package/dist/fonts/authoredGoogleFonts.js

@@ -20,6 +20,8 @@ function googleStylesheetFamilies(urlText) {
         .filter(Boolean);
 }
 function importUrls(css) {
+    if (!/@import/i.test(css))
+        return [];
     let root;
     try {
         root = postcss.parse(css);

package/dist/fonts/deterministicFonts.js

@@ -202,6 +202,8 @@ export function normalizeSystemFontPrimaryFamilies(html, deterministicPrimary =
     return changed ? document.toString() : html;
 }
 function collectCssCustomProperties(css, customProperties) {
+    if (!css.includes("--"))
+        return;
     const root = parseCssRoot(css);
     if (!root)
         return;
@@ -228,6 +230,8 @@ function* iterateCssRootFontFamilyDeclarations(root) {
     yield* declarations;
 }
 function* iterateCssFontFamilyDeclarations(css) {
+    if (!/font-family/i.test(css))
+        return;
     const root = parseCssRoot(css);
     if (!root)
         return;

package/dist/fonts/systemFontLocator.d.ts

@@ -24,5 +24,4 @@ export interface LocatedFontVariant extends LocatedFont {
     style: "normal" | "italic";
 }
 export declare function locateSystemFontVariants(family: string): LocatedFontVariant[];
-export declare function getSystemProfilerFamilies(): string[];
 export declare function clearSystemFontCache(): void;

package/dist/fonts/systemFontLocator.js

@@ -3,7 +3,6 @@ import { existsSync, lstatSync, readdirSync, realpathSync } from "node:fs";
 import { homedir, platform } from "node:os";
 import { join, resolve } from "node:path";
 export const SYSTEM_FONT_SIZE_LIMIT = 5 * 1024 * 1024;
-const PROFILER_TIMEOUT_MS = 5000;
 const FC_MATCH_TIMEOUT_MS = 3000;
 export const FONT_EXT_RE = /\.(otf|ttf|ttc|woff2?)$/i;
 const FORMAT_PRIORITY = {
@@ -193,64 +192,6 @@ function pickBestCandidate(candidates) {
     const best = candidates[0];
     return { path: best.path, format: best.format };
 }
-let profilerCache = null;
-// fallow-ignore-next-line complexity
-function getSystemProfilerIndex() {
-    if (profilerCache)
-        return profilerCache;
-    profilerCache = new Map();
-    if (platform() !== "darwin")
-        return profilerCache;
-    try {
-        const raw = execFileSync("system_profiler", ["SPFontsDataType", "-json"], {
-            encoding: "utf8",
-            maxBuffer: 12 * 1024 * 1024,
-            timeout: PROFILER_TIMEOUT_MS,
-        });
-        const parsed = JSON.parse(raw);
-        if (!parsed?.SPFontsDataType || !Array.isArray(parsed.SPFontsDataType))
-            return profilerCache;
-        for (const fontEntry of parsed.SPFontsDataType) {
-            if (!fontEntry?.typefaces || !Array.isArray(fontEntry.typefaces))
-                continue;
-            for (const typeface of fontEntry.typefaces) {
-                if (!typeface)
-                    continue;
-                const family = typeface.family ?? typeface.fullname ?? typeface._name;
-                if (typeof family !== "string")
-                    continue;
-                const filePath = typeface.path;
-                if (typeof filePath !== "string" || !FONT_EXT_RE.test(filePath))
-                    continue;
-                const normalized = normalizeName(family);
-                const ext = filePath.match(FONT_EXT_RE)?.[1] ?? "ttf";
-                const entry = {
-                    family: normalized,
-                    path: filePath,
-                    format: extensionToFormat(ext),
-                    isRegular: isRegularWeight(filePath),
-                };
-                const list = profilerCache.get(normalized) ?? [];
-                list.push(entry);
-                profilerCache.set(normalized, list);
-            }
-        }
-    }
-    catch {
-        // system_profiler unavailable
-    }
-    return profilerCache;
-}
-function locateViaSystemProfiler(targetFamily) {
-    const index = getSystemProfilerIndex();
-    const entries = index.get(targetFamily);
-    if (!entries || entries.length === 0)
-        return null;
-    const candidates = entries
-        .filter((e) => isRegularFile(e.path) && isPathBounded(e.path))
-        .map((e) => ({ path: e.path, format: e.format, isRegular: e.isRegular }));
-    return pickBestCandidate(candidates);
-}
 // fallow-ignore-next-line complexity
 function locateViaFcMatch(targetFamily) {
     if (platform() !== "linux")
@@ -280,11 +221,7 @@ export function locateSystemFont(family) {
     const cached = cache.get(normalized);
     if (cached !== undefined)
         return cached;
-    let result = null;
-    result = locateViaSystemProfiler(normalized);
-    if (!result) {
-        result = locateViaFcMatch(normalized);
-    }
+    let result = locateViaFcMatch(normalized);
     if (!result) {
         const allCandidates = [];
         for (const dir of fontDirectories()) {
@@ -330,18 +267,6 @@ export function locateSystemFontVariants(family) {
     if (!normalized)
         return [];
     const variants = [];
-    const profilerIndex = getSystemProfilerIndex();
-    const profilerEntries = profilerIndex.get(normalized);
-    if (profilerEntries && profilerEntries.length > 0) {
-        for (const e of profilerEntries) {
-            if (!isRegularFile(e.path) || !isPathBounded(e.path))
-                continue;
-            const { weight, style } = inferWeightAndStyle(e.path);
-            variants.push({ path: e.path, format: e.format, weight, style });
-        }
-        if (variants.length > 0)
-            return dedupeVariants(variants);
-    }
     const allCandidates = [];
     for (const dir of fontDirectories()) {
         allCandidates.push(...collectCandidatesFromDir(dir, normalized));
@@ -361,12 +286,7 @@ function dedupeVariants(variants) {
     }
     return Array.from(seen.values());
 }
-export function getSystemProfilerFamilies() {
-    const index = getSystemProfilerIndex();
-    return Array.from(index.keys());
-}
 export function clearSystemFontCache() {
     cache.clear();
-    profilerCache = null;
     allowedDirsCache = null;
 }