@frame-by-frame/core 1.0.0-rc.1

package/dist/types-BYfMRnsj.d.ts

@@ -0,0 +1,451 @@
+//#region src/types.d.ts
+/** The coordinate system used by every segment in one timeline. */
+type ScrollUnit = "px" | "progress";
+/** CSS-compatible easing keywords supported by the timeline engine. */
+type EasingName = "linear" | "ease-in" | "ease-out" | "ease-in-out";
+/** A custom easing function receives and returns normalized progress. */
+type EasingFunction = (progress: number) => number;
+/** A named or custom easing definition. */
+type Easing = EasingName | EasingFunction;
+/** A mapping between one scroll interval and one media-time interval. */
+interface TimelineSegment {
+  /** Scroll interval expressed in `scrollUnit`. */
+  readonly scroll: readonly [start: number, end: number];
+  /** Media-time interval in seconds; forward and reverse ranges are valid. */
+  readonly media: readonly [start: number, end: number];
+  /** Coordinate unit, defaulting to pixels. */
+  readonly scrollUnit?: ScrollUnit;
+  /** Opaque media clip ID carried through resolution. */
+  readonly clip?: string;
+  /** Override for the timeline-level easing default. */
+  readonly easing?: Easing;
+}
+/** Frame snapping is disabled unless `snap` is explicitly enabled. */
+type FrameConfig = {
+  /** Explicitly keeps frame snapping disabled. */
+  readonly snap?: false;
+  readonly fps?: never;
+} | {
+  /** Enables nearest-frame snapping. */
+  readonly snap: true;
+  /** Finite, positive frame rate used for snapping. */
+  readonly fps: number;
+};
+/** Configuration captured by `createTimeline`. */
+interface TimelineOptions {
+  /** Non-empty collection of mappings normalized at creation time. */
+  readonly segments: readonly TimelineSegment[];
+  /** Default easing inherited by segments without an override. */
+  readonly easing?: Easing;
+  /** Optional nearest-frame snapping configuration. */
+  readonly frame?: FrameConfig;
+}
+/** The timeline region containing a resolved position. */
+type TimelinePhase = "before" | "active" | "gap" | "after";
+/** The deterministic result of resolving one timeline position. */
+interface TimelineResolution {
+  /** Region of the timeline containing the position. */
+  readonly phase: TimelinePhase;
+  /** Original input index when `phase` is `active`. */
+  readonly segmentIndex: number | null;
+  /** Clip selected by the active or held segment. */
+  readonly clipId: string | null;
+  /** Linear progress inside an active segment. */
+  readonly rawProgress: number | null;
+  /** Progress after easing inside an active segment. */
+  readonly easedProgress: number | null;
+  /** Continuous media time before frame snapping. */
+  readonly requestedTime: number;
+  /** Effective media time after optional frame snapping. */
+  readonly targetTime: number;
+}
+/** An immutable, normalized timeline that can resolve positions repeatedly. */
+interface Timeline {
+  /** Effective unit shared by every normalized segment. */
+  readonly unit: ScrollUnit;
+  /** Resolves one finite position without mutating timeline state. */
+  resolve(position: number): TimelineResolution;
+}
+/** An independently observed scroll axis. */
+type AxisName = "x" | "y";
+/** A DOM scroll source resolved only when a controller mounts. */
+type ScrollSource = Document | HTMLElement;
+/** A direct, selected, or lazily resolved scroll source. */
+type ScrollSourceReference = ScrollSource | string | (() => ScrollSource | null);
+/** A direct, selected, or lazily resolved DOM element. */
+type ElementReference<T extends Element = HTMLElement> = T | string | (() => T | null);
+/** Renderer implementations available across the package entry points. */
+type RendererType = "video" | "canvas";
+/** Native hints plus explicit package-managed full-file preload. */
+type VideoPreload = "none" | "metadata" | "auto" | "full";
+/** Events that may activate an on-demand media binding. */
+type VideoLoadingTrigger = "manual" | "target-near-viewport" | "first-use";
+/** Loading policy shared by the clips in one binding. */
+type VideoLoadingConfig = {
+  /** Immediate loading is the default policy. */
+  readonly mode?: "immediate";
+  readonly trigger?: never;
+  readonly rootMargin?: never;
+  /** Fetch credentials used only by clips configured with preload full. */
+  readonly credentials?: RequestCredentials;
+  /** Fetch cache mode used only by clips configured with preload full. */
+  readonly cache?: RequestCache;
+} | {
+  readonly mode: "on-demand";
+  readonly trigger: "target-near-viewport";
+  /** IntersectionObserver root margin; defaults to 0px. */
+  readonly rootMargin?: string;
+  readonly credentials?: RequestCredentials;
+  readonly cache?: RequestCache;
+} | {
+  readonly mode: "on-demand";
+  readonly trigger: "manual" | "first-use";
+  readonly rootMargin?: never;
+  readonly credentials?: RequestCredentials;
+  readonly cache?: RequestCache;
+};
+/** Valid values for the media element crossorigin attribute. */
+type MediaCrossOrigin = "" | "anonymous" | "use-credentials";
+/** One ordered candidate for a video clip. */
+interface VideoSourceConfig {
+  /** URL assigned to the video element when this candidate is selected. */
+  readonly src: string;
+  /** Optional MIME type, including codecs when known. */
+  readonly type?: string;
+}
+/** One logical media asset that timeline segments may select by ID. */
+interface VideoClipConfig {
+  /** Unique clip ID within one binding. */
+  readonly id: string;
+  /** Ordered source candidates for the same content. */
+  readonly sources: readonly VideoSourceConfig[];
+  /** Optional poster applied while this clip is active. */
+  readonly poster?: string;
+  /** Optional CORS mode applied before the selected source. */
+  readonly crossOrigin?: MediaCrossOrigin;
+  /** Native preload hint; defaults to metadata. */
+  readonly preload?: VideoPreload;
+}
+/** Property overrides for a supplied or package-created video target. */
+interface VideoRendererConfig {
+  readonly muted?: boolean;
+  readonly playsInline?: boolean;
+  readonly controls?: boolean;
+  readonly loop?: boolean;
+}
+/** Bounded native seek scheduling options. */
+interface VideoSeekConfig {
+  /** Smallest meaningful target-time change in seconds; defaults to 0.001. */
+  readonly timeEpsilon?: number;
+}
+/** Timeline and video-decoder configuration shared by every media binding. */
+interface FrameByFrameBindingBaseConfig extends TimelineOptions {
+  /** Unique binding ID within one controller. */
+  readonly id: string;
+  /** Non-empty logical clips referenced by timeline segments. */
+  readonly clips: readonly VideoClipConfig[];
+  /** Binding-level eager or on-demand loading policy. */
+  readonly loading?: VideoLoadingConfig;
+  /** Optional video property overrides. */
+  readonly video?: VideoRendererConfig;
+  /** Optional native seek scheduler settings. */
+  readonly seek?: VideoSeekConfig;
+}
+/** One named native-video timeline controlled by a scroll axis. */
+type FrameByFrameBindingConfig = FrameByFrameBindingBaseConfig & ({
+  /** Native video is the default renderer for the root package entry. */
+  readonly renderer?: "video";
+  /** Existing video target resolved during mount. */
+  readonly target: ElementReference<HTMLVideoElement>;
+  readonly mountTo?: never;
+  readonly canvas?: never;
+} | {
+  /** Native video is the default renderer for the root package entry. */
+  readonly renderer?: "video";
+  readonly target?: never;
+  /** Container where the package creates and owns a video target. */
+  readonly mountTo: ElementReference;
+  readonly canvas?: never;
+});
+/** How a decoded video frame is fitted into the visible canvas. */
+type CanvasFit = "contain" | "cover" | "fill" | "none";
+/** Canvas presentation and optional decoder ownership. */
+interface CanvasRendererConfig {
+  /** Frame fitting mode; defaults to contain. */
+  readonly fit?: CanvasFit;
+  /** Bitmap-to-CSS scale; defaults to the current device pixel ratio. */
+  readonly pixelRatio?: number | "device";
+  /** Canvas 2D interpolation setting; defaults to true. */
+  readonly imageSmoothingEnabled?: boolean;
+  /** Existing video used as the decoder instead of an internal detached element. */
+  readonly decoderTarget?: ElementReference<HTMLVideoElement>;
+}
+/** Canvas fields that responsive breakpoints may change without replacing ownership. */
+interface CanvasRendererOverride {
+  readonly fit?: CanvasFit;
+  readonly pixelRatio?: number | "device";
+  readonly imageSmoothingEnabled?: boolean;
+}
+/** One named canvas timeline backed by a native video decoder. */
+type CanvasBindingConfig = FrameByFrameBindingBaseConfig & ({
+  readonly renderer: "canvas";
+  /** Existing visible canvas resolved during mount. */
+  readonly target: ElementReference<HTMLCanvasElement>;
+  readonly mountTo?: never;
+  readonly canvas?: CanvasRendererConfig;
+} | {
+  readonly renderer: "canvas";
+  readonly target?: never;
+  /** Container where the package creates and owns a visible canvas. */
+  readonly mountTo: ElementReference;
+  readonly canvas?: CanvasRendererConfig;
+});
+/** A video or canvas binding accepted by the opt-in canvas entry point. */
+type CanvasFrameByFrameBindingConfig = FrameByFrameBindingConfig | CanvasBindingConfig;
+/** Configuration for one independent scroll axis. */
+interface FrameByFrameAxisConfig {
+  /** Whether this axis participates in updates; defaults to true. */
+  readonly enabled?: boolean;
+  /** Non-empty timeline bindings driven by this axis. */
+  readonly bindings: readonly FrameByFrameBindingConfig[];
+}
+/** Horizontal and vertical controller configuration. */
+interface FrameByFrameAxesConfig {
+  readonly x?: false | FrameByFrameAxisConfig;
+  readonly y?: false | FrameByFrameAxisConfig;
+}
+/** One axis accepted by the opt-in canvas entry point. */
+interface CanvasFrameByFrameAxisConfig {
+  readonly enabled?: boolean;
+  readonly bindings: readonly CanvasFrameByFrameBindingConfig[];
+}
+/** Axes accepted by the opt-in canvas entry point. */
+interface CanvasFrameByFrameAxesConfig {
+  readonly x?: false | CanvasFrameByFrameAxisConfig;
+  readonly y?: false | CanvasFrameByFrameAxisConfig;
+}
+/** Timeline and media fields that a responsive breakpoint may replace or merge. */
+interface FrameByFrameBindingOverride {
+  /** Existing binding ID selected for this override. */
+  readonly id: string;
+  /** Replaces the binding's complete segment collection. */
+  readonly segments?: readonly TimelineSegment[];
+  /** Replaces the binding's complete clip collection. */
+  readonly clips?: readonly VideoClipConfig[];
+  /** Overrides the timeline-level easing default. */
+  readonly easing?: Easing;
+  /** Shallowly overrides frame snapping options. */
+  readonly frame?: FrameConfig;
+  /** Shallowly overrides loading options. */
+  readonly loading?: VideoLoadingConfig;
+  /** Shallowly overrides native video properties. */
+  readonly video?: VideoRendererConfig;
+  /** Shallowly overrides native seek options. */
+  readonly seek?: VideoSeekConfig;
+}
+/** Binding override accepted by the canvas-enabled responsive cascade. */
+interface CanvasFrameByFrameBindingOverride extends FrameByFrameBindingOverride {
+  /** Shallowly overrides canvas presentation without changing the decoder target. */
+  readonly canvas?: CanvasRendererOverride;
+}
+/** Responsive changes for one existing controller axis. */
+interface FrameByFrameAxisOverride {
+  /** Disables or re-enables the axis without removing its bindings. */
+  readonly enabled?: boolean;
+  /** Overrides merged into existing bindings by stable ID. */
+  readonly bindings?: readonly FrameByFrameBindingOverride[];
+}
+/** Responsive changes scoped to existing axes and bindings. */
+interface FrameByFrameBreakpointOverride {
+  readonly axes: {
+    readonly x?: false | FrameByFrameAxisOverride;
+    readonly y?: false | FrameByFrameAxisOverride;
+  };
+}
+/** One ordered media-query override in the responsive cascade. */
+interface FrameByFrameBreakpointConfig {
+  /** Unique stable ID exposed by controller state and events. */
+  readonly id: string;
+  /** Media query evaluated only after mount. */
+  readonly query: string;
+  /** Partial configuration applied while the query matches. */
+  readonly override: FrameByFrameBreakpointOverride;
+}
+/** Responsive axis changes accepted by the canvas-enabled entry point. */
+interface CanvasFrameByFrameAxisOverride {
+  readonly enabled?: boolean;
+  readonly bindings?: readonly CanvasFrameByFrameBindingOverride[];
+}
+/** Responsive changes accepted by the canvas-enabled entry point. */
+interface CanvasFrameByFrameBreakpointOverride {
+  readonly axes: {
+    readonly x?: false | CanvasFrameByFrameAxisOverride;
+    readonly y?: false | CanvasFrameByFrameAxisOverride;
+  };
+}
+/** One ordered media-query override for a canvas-enabled controller. */
+interface CanvasFrameByFrameBreakpointConfig {
+  readonly id: string;
+  readonly query: string;
+  readonly override: CanvasFrameByFrameBreakpointOverride;
+}
+/** How an active reduced-motion preference affects media bindings. */
+type ReducedMotionBehavior = "first-frame" | "last-frame" | "disable" | "ignore";
+/** Configuration captured by `createFrameByFrame`. */
+interface FrameByFrameOptions {
+  /** Scroll source resolved during mount; omission selects the document. */
+  readonly source?: ScrollSourceReference;
+  /** At least one configured axis with one binding is required. */
+  readonly axes: FrameByFrameAxesConfig;
+  /** Ordered responsive overrides; later matching entries win. */
+  readonly breakpoints?: readonly FrameByFrameBreakpointConfig[];
+  /** Reduced-motion behavior; defaults to first-frame. */
+  readonly reducedMotion?: ReducedMotionBehavior;
+}
+/** Configuration captured by the opt-in canvas-enabled factory. */
+interface CanvasFrameByFrameOptions {
+  readonly source?: ScrollSourceReference;
+  readonly axes: CanvasFrameByFrameAxesConfig;
+  readonly breakpoints?: readonly CanvasFrameByFrameBreakpointConfig[];
+  readonly reducedMotion?: ReducedMotionBehavior;
+}
+/** Controller lifecycle states. */
+type FrameByFrameStatus = "idle" | "mounting" | "ready" | "disabled" | "error" | "destroyed";
+/** Read-only public shape of package errors stored in state and events. */
+interface FrameByFrameErrorInfo extends Error {
+  readonly name: "FrameByFrameError";
+  readonly code: FrameByFrameErrorCode;
+  readonly cause: unknown;
+  readonly details: FrameByFrameErrorDetails | undefined;
+}
+/** Last observed metrics for one axis. */
+interface FrameByFrameAxisState {
+  readonly enabled: boolean;
+  readonly offset: number;
+  readonly max: number;
+  readonly progress: number;
+}
+/** Last timeline resolution for one binding. */
+interface FrameByFrameBindingState {
+  readonly id: string;
+  readonly axis: AxisName;
+  readonly resolution: TimelineResolution | null;
+  readonly renderer: RendererType;
+  readonly loadState: VideoLoadState;
+  /** Full-preload progress keyed by clip ID. */
+  readonly loadProgress: Readonly<Record<string, VideoLoadProgress>>;
+  readonly activeClipId: string | null;
+  readonly selectedSource: string | null;
+  readonly duration: number | null;
+  readonly appliedTime: number | null;
+  readonly presentedTime: number | null;
+  readonly seeking: boolean;
+  readonly error: FrameByFrameErrorInfo | null;
+}
+/** Native media readiness for a controller binding. */
+type VideoLoadState = "idle" | "loading" | "metadata" | "ready" | "error" | "unloaded";
+/** Byte progress for one explicit full-file preload. */
+interface VideoLoadProgress {
+  readonly loadedBytes: number;
+  readonly totalBytes: number | null;
+  readonly ratio: number | null;
+}
+/** Detached controller state for debugging and framework integration. */
+interface FrameByFrameState {
+  readonly status: FrameByFrameStatus;
+  readonly enabled: boolean;
+  readonly source: ScrollSource | null;
+  readonly activeBreakpoints: readonly string[];
+  readonly prefersReducedMotion: boolean;
+  readonly axes: Readonly<Partial<Record<AxisName, FrameByFrameAxisState>>>;
+  readonly bindings: Readonly<Record<string, FrameByFrameBindingState>>;
+  readonly lastError: FrameByFrameErrorInfo | null;
+}
+/** Why the controller published an update snapshot. */
+type FrameByFrameUpdateReason = "mount" | "scroll" | "refresh" | "enable" | "disable" | "breakpoint" | "preference" | "resize" | "visibility";
+/** Payload emitted after one coalesced controller update. */
+interface FrameByFrameUpdateEvent {
+  readonly reason: FrameByFrameUpdateReason;
+  readonly state: FrameByFrameState;
+}
+/** Payload emitted after the active responsive cascade changes successfully. */
+interface FrameByFrameBreakpointChangeEvent {
+  readonly previous: readonly string[];
+  readonly current: readonly string[];
+  readonly state: FrameByFrameState;
+}
+/** Shared identity and state included by media lifecycle events. */
+interface FrameByFrameBindingEvent {
+  readonly bindingId: string;
+  readonly clipId: string;
+  readonly state: FrameByFrameState;
+}
+/** Metadata became available for the selected clip. */
+interface FrameByFrameLoadedMetadataEvent extends FrameByFrameBindingEvent {
+  readonly duration: number | null;
+}
+/** Full-file preload progress for one binding clip. */
+interface FrameByFrameLoadProgressEvent extends FrameByFrameBindingEvent {
+  readonly loadedBytes: number;
+  readonly totalBytes: number | null;
+  readonly ratio: number | null;
+}
+/** A meaningful seek was submitted to the native video target. */
+interface FrameByFrameSeekRequestEvent extends FrameByFrameBindingEvent {
+  readonly requestedTime: number;
+  readonly targetTime: number;
+}
+/** A frame was observed at or near browser composition. */
+interface FrameByFrameFrameEvent extends FrameByFrameBindingEvent {
+  readonly presentedTime: number;
+  readonly expectedDisplayTime: number | null;
+  readonly width: number | null;
+  readonly height: number | null;
+}
+/** Public event payloads available in the controller foundation. */
+interface FrameByFrameEventMap {
+  readonly mount: FrameByFrameState;
+  readonly update: FrameByFrameUpdateEvent;
+  readonly breakpointchange: FrameByFrameBreakpointChangeEvent;
+  readonly loadstart: FrameByFrameBindingEvent;
+  readonly loadprogress: FrameByFrameLoadProgressEvent;
+  readonly loadedmetadata: FrameByFrameLoadedMetadataEvent;
+  readonly loadready: FrameByFrameBindingEvent;
+  readonly seekrequest: FrameByFrameSeekRequestEvent;
+  readonly frame: FrameByFrameFrameEvent;
+  readonly error: FrameByFrameErrorInfo;
+  readonly destroy: FrameByFrameState;
+}
+/** Framework-independent controller lifecycle and state API. */
+interface FrameByFrameController {
+  mount(): Promise<void>;
+  refresh(): void;
+  enable(): void;
+  disable(): void;
+  load(bindingId?: string): Promise<void>;
+  /** Waits for the latest automatically scheduled media readiness cycle. */
+  whenReady(): Promise<FrameByFrameState>;
+  unload(bindingId?: string): void;
+  getTarget(bindingId: string): HTMLVideoElement | null;
+  getState(): FrameByFrameState;
+  on<EventName extends keyof FrameByFrameEventMap>(event: EventName, listener: (payload: FrameByFrameEventMap[EventName]) => void): () => void;
+  destroy(): void;
+}
+/** Controller returned by the opt-in canvas entry point. */
+interface CanvasFrameByFrameController extends Omit<FrameByFrameController, "getTarget"> {
+  getTarget(bindingId: string): HTMLVideoElement | HTMLCanvasElement | null;
+}
+/** Stable error codes currently emitted by the public package APIs. */
+type FrameByFrameErrorCode = "INVALID_TIMELINE" | "INVALID_SEGMENT" | "OVERLAPPING_SEGMENTS" | "INVALID_FRAME_RATE" | "INVALID_EASING_RESULT" | "INVALID_CONTROLLER" | "INVALID_BREAKPOINT_CONFIG" | "DUPLICATE_BINDING_ID" | "ENVIRONMENT_UNAVAILABLE" | "SOURCE_NOT_FOUND" | "INVALID_LIFECYCLE_OPERATION" | "CONTROLLER_DESTROYED" | "INVALID_MEDIA_CONFIG" | "TARGET_NOT_FOUND" | "INVALID_TARGET_TYPE" | "TARGET_CONFLICT" | "MEDIA_SOURCE_UNSUPPORTED" | "MEDIA_LOAD_FAILED" | "FULL_PRELOAD_FAILED" | "MEDIA_DECODE_FAILED" | "MEDIA_SEEK_FAILED" | "CANVAS_CONTEXT_UNAVAILABLE" | "CANVAS_DRAW_FAILED" | "CANVAS_SECURITY_ERROR";
+/** Structured context attached to a `FrameByFrameError`. */
+type FrameByFrameErrorDetails = Readonly<Record<string, unknown>>;
+/** Optional metadata accepted by `FrameByFrameError`. */
+interface FrameByFrameErrorOptions {
+  /** Original failure that caused this package error. */
+  readonly cause?: unknown;
+  /** Package-owned read-only copy of structured diagnostic values. */
+  readonly details?: FrameByFrameErrorDetails;
+}
+//#endregion
+export { Timeline as $, FrameByFrameBreakpointOverride as A, FrameByFrameOptions as B, FrameByFrameBindingBaseConfig as C, FrameByFrameBindingState as D, FrameByFrameBindingOverride as E, FrameByFrameErrorOptions as F, FrameByFrameUpdateReason as G, FrameByFrameState as H, FrameByFrameEventMap as I, ReducedMotionBehavior as J, FrameConfig as K, FrameByFrameFrameEvent as L, FrameByFrameErrorCode as M, FrameByFrameErrorDetails as N, FrameByFrameBreakpointChangeEvent as O, FrameByFrameErrorInfo as P, ScrollUnit as Q, FrameByFrameLoadProgressEvent as R, FrameByFrameAxisState as S, FrameByFrameBindingEvent as T, FrameByFrameStatus as U, FrameByFrameSeekRequestEvent as V, FrameByFrameUpdateEvent as W, ScrollSource as X, RendererType as Y, ScrollSourceReference as Z, EasingName as _, CanvasFrameByFrameAxisConfig as a, VideoLoadProgress as at, FrameByFrameAxisConfig as b, CanvasFrameByFrameBindingOverride as c, VideoLoadingTrigger as ct, CanvasFrameByFrameController as d, VideoSeekConfig as dt, TimelineOptions as et, CanvasFrameByFrameOptions as f, VideoSourceConfig as ft, EasingFunction as g, Easing as h, CanvasFrameByFrameAxesConfig as i, VideoClipConfig as it, FrameByFrameController as j, FrameByFrameBreakpointConfig as k, CanvasFrameByFrameBreakpointConfig as l, VideoPreload as lt, CanvasRendererOverride as m, CanvasBindingConfig as n, TimelineResolution as nt, CanvasFrameByFrameAxisOverride as o, VideoLoadState as ot, CanvasRendererConfig as p, MediaCrossOrigin as q, CanvasFit as r, TimelineSegment as rt, CanvasFrameByFrameBindingConfig as s, VideoLoadingConfig as st, AxisName as t, TimelinePhase as tt, CanvasFrameByFrameBreakpointOverride as u, VideoRendererConfig as ut, ElementReference as v, FrameByFrameBindingConfig as w, FrameByFrameAxisOverride as x, FrameByFrameAxesConfig as y, FrameByFrameLoadedMetadataEvent as z };
+//# sourceMappingURL=types-BYfMRnsj.d.ts.map

package/dist/types-BYfMRnsj.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BYfMRnsj.d.ts","names":[],"sources":["../src/types.ts"],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+import { $ as Timeline, A as FrameByFrameBreakpointOverride, B as FrameByFrameOptions, C as FrameByFrameBindingBaseConfig, D as FrameByFrameBindingState, E as FrameByFrameBindingOverride, F as FrameByFrameErrorOptions, G as FrameByFrameUpdateReason, H as FrameByFrameState, I as FrameByFrameEventMap, J as ReducedMotionBehavior, K as FrameConfig, L as FrameByFrameFrameEvent, M as FrameByFrameErrorCode, N as FrameByFrameErrorDetails, O as FrameByFrameBreakpointChangeEvent, P as FrameByFrameErrorInfo, Q as ScrollUnit, R as FrameByFrameLoadProgressEvent, S as FrameByFrameAxisState, T as FrameByFrameBindingEvent, U as FrameByFrameStatus, V as FrameByFrameSeekRequestEvent, W as FrameByFrameUpdateEvent, X as ScrollSource, Y as RendererType, Z as ScrollSourceReference, _ as EasingName, a as CanvasFrameByFrameAxisConfig, at as VideoLoadProgress, b as FrameByFrameAxisConfig, c as CanvasFrameByFrameBindingOverride, ct as VideoLoadingTrigger, d as CanvasFrameByFrameController, dt as VideoSeekConfig, et as TimelineOptions, f as CanvasFrameByFrameOptions, ft as VideoSourceConfig, g as EasingFunction, h as Easing, i as CanvasFrameByFrameAxesConfig, it as VideoClipConfig, j as FrameByFrameController, k as FrameByFrameBreakpointConfig, l as CanvasFrameByFrameBreakpointConfig, lt as VideoPreload, m as CanvasRendererOverride, n as CanvasBindingConfig, nt as TimelineResolution, o as CanvasFrameByFrameAxisOverride, ot as VideoLoadState, p as CanvasRendererConfig, q as MediaCrossOrigin, r as CanvasFit, rt as TimelineSegment, s as CanvasFrameByFrameBindingConfig, st as VideoLoadingConfig, t as AxisName, tt as TimelinePhase, u as CanvasFrameByFrameBreakpointOverride, ut as VideoRendererConfig, v as ElementReference, w as FrameByFrameBindingConfig, x as FrameByFrameAxisOverride, y as FrameByFrameAxesConfig, z as FrameByFrameLoadedMetadataEvent } from "./types-BYfMRnsj.js";
+export { AxisName, CanvasBindingConfig, CanvasFit, CanvasFrameByFrameAxesConfig, CanvasFrameByFrameAxisConfig, CanvasFrameByFrameAxisOverride, CanvasFrameByFrameBindingConfig, CanvasFrameByFrameBindingOverride, CanvasFrameByFrameBreakpointConfig, CanvasFrameByFrameBreakpointOverride, CanvasFrameByFrameController, CanvasFrameByFrameOptions, CanvasRendererConfig, CanvasRendererOverride, Easing, EasingFunction, EasingName, ElementReference, FrameByFrameAxesConfig, FrameByFrameAxisConfig, FrameByFrameAxisOverride, FrameByFrameAxisState, FrameByFrameBindingBaseConfig, FrameByFrameBindingConfig, FrameByFrameBindingEvent, FrameByFrameBindingOverride, FrameByFrameBindingState, FrameByFrameBreakpointChangeEvent, FrameByFrameBreakpointConfig, FrameByFrameBreakpointOverride, FrameByFrameController, FrameByFrameErrorCode, FrameByFrameErrorDetails, FrameByFrameErrorInfo, FrameByFrameErrorOptions, FrameByFrameEventMap, FrameByFrameFrameEvent, FrameByFrameLoadProgressEvent, FrameByFrameLoadedMetadataEvent, FrameByFrameOptions, FrameByFrameSeekRequestEvent, FrameByFrameState, FrameByFrameStatus, FrameByFrameUpdateEvent, FrameByFrameUpdateReason, FrameConfig, MediaCrossOrigin, ReducedMotionBehavior, RendererType, ScrollSource, ScrollSourceReference, ScrollUnit, Timeline, TimelineOptions, TimelinePhase, TimelineResolution, TimelineSegment, VideoClipConfig, VideoLoadProgress, VideoLoadState, VideoLoadingConfig, VideoLoadingTrigger, VideoPreload, VideoRendererConfig, VideoSeekConfig, VideoSourceConfig };

package/dist/video.d.ts

@@ -0,0 +1,4 @@
+import { $ as Timeline, A as FrameByFrameBreakpointOverride, B as FrameByFrameOptions, D as FrameByFrameBindingState, E as FrameByFrameBindingOverride, F as FrameByFrameErrorOptions, G as FrameByFrameUpdateReason, H as FrameByFrameState, I as FrameByFrameEventMap, J as ReducedMotionBehavior, K as FrameConfig, L as FrameByFrameFrameEvent, M as FrameByFrameErrorCode, N as FrameByFrameErrorDetails, O as FrameByFrameBreakpointChangeEvent, P as FrameByFrameErrorInfo, Q as ScrollUnit, R as FrameByFrameLoadProgressEvent, S as FrameByFrameAxisState, T as FrameByFrameBindingEvent, U as FrameByFrameStatus, V as FrameByFrameSeekRequestEvent, W as FrameByFrameUpdateEvent, X as ScrollSource, Y as RendererType, Z as ScrollSourceReference, _ as EasingName, at as VideoLoadProgress, b as FrameByFrameAxisConfig, ct as VideoLoadingTrigger, dt as VideoSeekConfig, et as TimelineOptions, ft as VideoSourceConfig, g as EasingFunction, h as Easing, it as VideoClipConfig, j as FrameByFrameController, k as FrameByFrameBreakpointConfig, lt as VideoPreload, nt as TimelineResolution, ot as VideoLoadState, q as MediaCrossOrigin, rt as TimelineSegment, st as VideoLoadingConfig, t as AxisName, tt as TimelinePhase, ut as VideoRendererConfig, v as ElementReference, w as FrameByFrameBindingConfig, x as FrameByFrameAxisOverride, y as FrameByFrameAxesConfig, z as FrameByFrameLoadedMetadataEvent } from "./types-BYfMRnsj.js";
+import { n as FrameByFrameError, t as createTimeline } from "./timeline-DDuRBPRJ.js";
+import { t as createFrameByFrame } from "./index-DhdyeigP.js";
+export { type AxisName, type Easing, type EasingFunction, type EasingName, type ElementReference, type FrameByFrameAxesConfig, type FrameByFrameAxisConfig, type FrameByFrameAxisOverride, type FrameByFrameAxisState, type FrameByFrameBindingConfig, type FrameByFrameBindingEvent, type FrameByFrameBindingOverride, type FrameByFrameBindingState, type FrameByFrameBreakpointChangeEvent, type FrameByFrameBreakpointConfig, type FrameByFrameBreakpointOverride, type FrameByFrameController, FrameByFrameError, type FrameByFrameErrorCode, type FrameByFrameErrorDetails, type FrameByFrameErrorInfo, type FrameByFrameErrorOptions, type FrameByFrameEventMap, type FrameByFrameFrameEvent, type FrameByFrameLoadProgressEvent, type FrameByFrameLoadedMetadataEvent, type FrameByFrameOptions, type FrameByFrameSeekRequestEvent, type FrameByFrameState, type FrameByFrameStatus, type FrameByFrameUpdateEvent, type FrameByFrameUpdateReason, type FrameConfig, type MediaCrossOrigin, type ReducedMotionBehavior, type RendererType, type ScrollSource, type ScrollSourceReference, type ScrollUnit, type Timeline, type TimelineOptions, type TimelinePhase, type TimelineResolution, type TimelineSegment, type VideoClipConfig, type VideoLoadProgress, type VideoLoadState, type VideoLoadingConfig, type VideoLoadingTrigger, type VideoPreload, type VideoRendererConfig, type VideoSeekConfig, type VideoSourceConfig, createFrameByFrame, createTimeline };

package/dist/video.js

@@ -0,0 +1,4 @@
+import { m as FrameByFrameError, p as createTimeline, t as createFrameByFrame } from "./public-controller-jGcw6iqQ.js";
+import "./index.js";
+
+export { FrameByFrameError, createFrameByFrame, createTimeline };

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@frame-by-frame/core",
+  "version": "1.0.0-rc.1",
+  "description": "Framework-agnostic TypeScript library for mapping scroll position to video time.",
+  "keywords": [
+    "animation",
+    "canvas",
+    "scroll",
+    "scroll-animation",
+    "typescript",
+    "video",
+    "video-scrubbing"
+  ],
+  "homepage": "https://github.com/mariozenmedina/frame-by-frame#readme",
+  "bugs": {
+    "url": "https://github.com/mariozenmedina/frame-by-frame/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mariozenmedina/frame-by-frame.git"
+  },
+  "license": "MIT",
+  "author": "Mário Veronesi Medina",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./video": {
+      "types": "./dist/video.d.ts",
+      "import": "./dist/video.js",
+      "default": "./dist/video.js"
+    },
+    "./canvas": {
+      "types": "./dist/canvas.d.ts",
+      "import": "./dist/canvas.js",
+      "default": "./dist/canvas.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js",
+      "default": "./dist/types.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": "^22.18.0 || ^24.11.0"
+  },
+  "packageManager": "pnpm@11.5.3",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "browserslist": [
+    "baseline widely available"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "build:watch": "tsdown --watch",
+    "check": "pnpm format:check && pnpm check:docs && pnpm check:release && pnpm lint && pnpm typecheck && pnpm test:coverage && pnpm build && pnpm check:bundle && pnpm test:package",
+    "check:bundle": "node scripts/check-bundle-budget.mjs",
+    "check:docs": "node scripts/check-doc-links.mjs",
+    "check:release": "node scripts/check-release.mjs",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "generate:browser-media": "node scripts/generate-browser-media.mjs",
+    "lint": "eslint . --max-warnings 0",
+    "test": "vitest",
+    "test:browser": "pnpm build && playwright test --config playwright.config.ts",
+    "test:coverage": "vitest run --coverage",
+    "test:package": "node tests/package-imports.mjs && node tests/packed-consumer.mjs",
+    "test:run": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/core": "0.18.5",
+    "@eslint/js": "10.0.1",
+    "@playwright/test": "1.61.1",
+    "@types/node": "24.13.3",
+    "@vitest/coverage-v8": "4.1.10",
+    "eslint": "10.7.0",
+    "prettier": "3.9.5",
+    "publint": "0.3.21",
+    "tsdown": "0.22.7",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.64.0",
+    "vitest": "4.1.10"
+  }
+}