reacthub-pixitweenjs 0.2.109-alpha.7 → 0.3.0-alpha.4

package/dist/utils/entranceOverlap.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Entrance overlap at hard cuts (Option A crossfade).
+ *
+ * When element B starts exactly where element A ends AND A has an
+ * animationOut AND B has an animationIn, B's entrance begins
+ * ENTRANCE_OVERLAP_SEC *before* B.start. Without this the landing frame
+ * carries almost no image (A faded to alpha 0 + B still at scale ~0) — a
+ * black blink on every cut at 30fps encodes (invisible at 60fps playback,
+ * which is why only renders jitter).
+ *
+ * The overlap is stamped as `transformation.entranceOverlapSec` so it flows
+ * through canvasElementsStore verbatim into usePixiAnimation (entrance tween
+ * position) and PixiSequence (visibility window). Elements without a
+ * qualifying neighbour keep no field (treated as 0 everywhere).
+ *
+ * Must match the nodejs renderer frame-exactly (same constant, same
+ * neighbour rule, same clamps).
+ */
+type Overlappable = {
+    uniqueId?: string;
+    start?: number;
+    end?: number;
+    transformation?: {
+        animationIn?: {
+            name?: string;
+            duration?: number;
+        } | string | null;
+        animationOut?: {
+            name?: string;
+            duration?: number;
+        } | string | null;
+        [key: string]: unknown;
+    } | null;
+    [key: string]: unknown;
+};
+export declare function applyEntranceOverlaps<T extends Overlappable>(elements: T[]): T[];
+export {};

package/dist/utils/fonts/fontLoader.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Loads Google Fonts and tells the engine when they are usable.
+ *
+ * Why this exists: text is measured with whatever font is available at that moment, and the
+ * result is cached. If a webfont is still loading, a caption/text layout is cached against the
+ * fallback font's metrics and stays wrong after the real font arrives. Loading through here
+ * emits `Events.FONTS_LOADED`, which `useFontEpoch` turns into a cache flush + re-layout.
+ *
+ * Ported from the Clippy editor's `useWebFontLoader`, without the `webfontloader` dependency:
+ * a stylesheet `<link>` plus `document.fonts.load()` (with a timeout) does the same job.
+ */
+export interface FontsLoadedDetail {
+    families: string[];
+    /** True when loading timed out or failed (blocked network / ad-blocker). Still unblocks the UI. */
+    inactive?: boolean;
+}
+export declare const FONT_LOAD_TIMEOUT_MS = 5000;
+/** Specs already covered by an earlier load. */
+export declare const getLoadedFonts: () => readonly string[];
+/** Test hook: forget what has been loaded. */
+export declare const resetFontLoaderState: () => void;
+export interface LoadFontsOptions {
+    timeoutMs?: number;
+    /** Emit `Events.FONTS_LOADED`. Default true. */
+    emit?: boolean;
+}
+/**
+ * Load Google font specs (`"Montserrat:400,800"`, or a bare family name). Resolves when every
+ * face is ready or the timeout hits; it never rejects. Already-covered specs are skipped.
+ */
+export declare function loadGoogleFonts(specs: string[], opts?: LoadFontsOptions): Promise<FontsLoadedDetail>;
+/** Fonts the editor preloads on startup. */
+export { PRELOAD_FONTS } from './googleFonts';

package/dist/utils/fonts/fontSpec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pure helpers for Google Fonts family specs (`"Montserrat:400,800"`). Ported unchanged from
+ * the Clippy editor's `useWebFontLoader`; no DOM, no React.
+ */
+/** Base family name for dedupe (`Inter:400` and `Inter` -> `inter`). */
+export declare const fontFamilyKey: (spec: string) => string;
+/** Google Fonts API family string; adds weights when only a name is given. */
+export declare const formatGoogleFamily: (name: string) => string;
+/** Weights in a spec (`Montserrat:400,800` -> ['400','800']); a bare name means 400 and 700. */
+export declare const fontWeightsOf: (spec: string) => string[];
+/** True when an earlier load of the same family already covered every requested weight. */
+export declare const isFontSpecCovered: (spec: string, loadedSpecs: string[]) => boolean;
+/** CSS family name from a spec: `"Bebas Neue:400"` -> `Bebas Neue`. */
+export declare const cssFamilyOf: (spec: string) => string;
+/** Google Fonts CSS2 URL for one or more specs. */
+export declare const googleFontsHref: (specs: string[]) => string;

package/dist/utils/fonts/googleFonts.d.ts

@@ -0,0 +1,9 @@
+export declare const GOOGLE_FONTS: {
+    SANS_SERIF: string[];
+    SERIF: string[];
+    DISPLAY: string[];
+    MONOSPACE: string[];
+    HANDWRITING: string[];
+};
+export declare const ALL_GOOGLE_FONTS: string[];
+export declare const PRELOAD_FONTS: string[];

package/dist/utils/gifTiming.d.ts

@@ -0,0 +1,22 @@
+/** One GIF frame's window on the animation clock, in milliseconds (Pixi's `GifFrame`). */
+export interface GifFrameTiming {
+    start: number;
+    end: number;
+}
+export interface GifFrameAtOptions {
+    /** Wrap around when the clock passes the end. Default true. */
+    loop?: boolean;
+    /** Playback-rate multiplier. Default 1. */
+    speed?: number;
+}
+/**
+ * Which GIF frame is showing `timeSec` seconds into the animation.
+ *
+ * Uses each frame's REAL start time (binary search), so GIFs with variable frame delays play
+ * correctly. The old mapping, `floor(progress * totalFrames)`, assumed every frame lasts the
+ * same time and stretched the GIF across the whole clip.
+ *
+ *  - loop:  the clock wraps at the GIF's duration
+ *  - !loop: the last frame is held
+ */
+export declare function gifFrameAt(frames: ReadonlyArray<GifFrameTiming>, timeSec: number, { loop, speed }?: GifFrameAtOptions): number;