cineview 0.0.1-beta

package/dist/components/Cineview/ScrollSceneSlot.d.ts

@@ -0,0 +1,42 @@
+import { default as React } from 'react';
+import { buildSceneTimelineState, SceneAuthoringCompatProps, SceneLayoutInfo, ScrollInputDirection } from './directScrollHelpers';
+import { ScrollModeConfig } from '../../types';
+import { GroupedCallbacks } from './regroupCallbacks';
+import { SceneScrollTimelineState } from '../Scene/sceneScrollRuntime';
+import { KeyedScrollExternalStore } from '../runtime/scrollExternalStore';
+import { ScrollSceneFrameStore } from '../runtime/scrollSceneFrameStore';
+export interface ScrollSceneRenderSnapshot {
+    sceneLayout: SceneLayoutInfo | null;
+    sceneZoneState: SceneScrollTimelineState | null;
+    sceneTimelineState: ReturnType<typeof buildSceneTimelineState> | null;
+    isCurrent: boolean;
+    isBackdropActive: boolean;
+    visualViewportOffset: number;
+    isScrolling: boolean;
+    scrollDirection: ScrollInputDirection | null;
+    activeSceneIndex: number;
+    viewportWidth: number;
+    viewportHeight: number;
+    firstSceneEnterGateKnown: boolean;
+    firstSceneEnterActive: boolean;
+    firstSceneEnterReady: boolean;
+    direction: 'x' | 'y';
+    sceneCount: number;
+    sceneSizing: ScrollModeConfig['sceneSizing'];
+    exposeTakeoverDebugData: boolean;
+    takeoverSceneSpan: number | null;
+}
+export declare const EMPTY_SCROLL_SCENE_SNAPSHOT: ScrollSceneRenderSnapshot;
+export type ScrollSceneSnapshotList = readonly (ScrollSceneRenderSnapshot | undefined)[];
+export type ScrollSceneSnapshotStore = KeyedScrollExternalStore<ScrollSceneSnapshotList, number, ScrollSceneRenderSnapshot>;
+interface ScrollSceneSlotProps {
+    child: React.ReactElement<SceneAuthoringCompatProps>;
+    store: ScrollSceneSnapshotStore;
+    frameStore?: ScrollSceneFrameStore;
+    sceneIndex: number;
+    setWrapperRef: (sceneIndex: number, node: HTMLDivElement | null) => void;
+    scrollCallbacks?: GroupedCallbacks['scroll'];
+}
+export declare function areScrollSceneRenderSnapshotsEqual(previous: ScrollSceneRenderSnapshot, next: ScrollSceneRenderSnapshot): boolean;
+export declare const ScrollSceneSlot: React.NamedExoticComponent<ScrollSceneSlotProps>;
+export {};

package/dist/components/Cineview/ScrollSceneStack.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { GroupedCallbacks } from './regroupCallbacks';
+import { ScrollSceneSnapshotStore } from './ScrollSceneSlot';
+import { ScrollSceneFrameStore } from '../runtime/scrollSceneFrameStore';
+interface ScrollSceneStackProps {
+    childrenArray: React.ReactNode[];
+    store: ScrollSceneSnapshotStore;
+    frameStore?: ScrollSceneFrameStore;
+    setWrapperRef: (sceneIndex: number, node: HTMLDivElement | null) => void;
+    scrollCallbacks?: GroupedCallbacks['scroll'];
+}
+export declare function ScrollSceneStack({ childrenArray, store, frameStore, setWrapperRef, scrollCallbacks, }: ScrollSceneStackProps): React.JSX.Element;
+export {};

package/dist/components/Cineview/ScrollbarOverlay.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+import { ScrollExternalStore } from '../runtime/scrollExternalStore';
+import { ScrollbarConfig, SlideDirection } from '../../types';
+export interface ScrollbarOverlayProps {
+    direction: SlideDirection;
+    /** Main-axis viewport span (width when direction==='x', height otherwise). */
+    viewportSpan: number;
+    /** Total scrollable content span. */
+    scrollContentSpan: number;
+    /** Current native scroll offset (unclamped, component clamps to scrollable range). */
+    scrollOffset: number;
+    /** Optional live offset store; keeps the root scroll component out of the frame loop. */
+    scrollOffsetStore?: ScrollExternalStore<number>;
+    /** Whether currently scrolling (drives autoHide fade in/out). */
+    isScrolling: boolean;
+    /** Resolved scrollbar config object (width/inset/colors/autoHide). */
+    config: ScrollbarConfig;
+    /** On drag/track click, sends target native offset back to parent to write real scroll state. */
+    onScrollToOffset: (targetOffset: number) => void;
+}
+export declare function ScrollbarOverlay({ direction, viewportSpan, scrollContentSpan, scrollOffset: initialScrollOffset, scrollOffsetStore, isScrolling, config, onScrollToOffset, }: ScrollbarOverlayProps): React.JSX.Element | null;
+export declare namespace ScrollbarOverlay {
+    var displayName: string;
+}

package/dist/components/Cineview/directScrollHelpers.d.ts

@@ -0,0 +1,77 @@
+import { default as React } from 'react';
+import { AnimationType, CineviewBaseProps, ScrollTimelineState, SceneProps } from '../../types';
+export type SceneAuthoringCompatProps = SceneProps & {
+    sceneId?: string;
+    sceneHeight?: number | string;
+    sceneWidth?: number | string;
+    sceneZIndex?: number;
+    sceneTransitionDuration?: number;
+    enterAnimation?: AnimationType;
+    exitAnimation?: AnimationType;
+    exitDuration?: number;
+    scrollEnterLength?: number;
+    scrollExitLength?: number;
+};
+export interface SceneLayoutInfo {
+    sceneStart: number;
+    sceneEnd: number;
+    visualSpan: number;
+    flowSpan: number;
+    timelineDistancePx: number;
+    centerLockOffset: number;
+    segmentStart: number;
+    segmentEnd: number;
+    enterLength: number;
+    exitLength: number;
+    stackMode: 'replace' | 'cover';
+}
+export interface CenterLockSegment {
+    segmentStart: number;
+    segmentEnd: number;
+}
+export type ScrollInputDirection = 'forward' | 'backward';
+export declare const TAKEOVER_PROGRESS_SNAP_EPSILON_PX = 0.01;
+export declare const CENTER_LOCK_BOUNDARY_EPSILON_PX = 0.5;
+export declare function isScrollDebugEnabled(explicit?: boolean): boolean;
+export declare function clamp(value: number, min: number, max: number): number;
+/** Keep authored Scene identity independent of its current position in the list. */
+export declare function getSceneIdentity(scene: React.ReactElement, index: number): string;
+export declare function normalizeWheelDeltaPx(delta: number, deltaMode: number, viewportSpan: number): number;
+export declare function normalizeTouchDeltaPx(delta: number): number;
+export declare function shouldDeferToNestedScrollable(target: EventTarget | null, root: HTMLElement, direction: 'x' | 'y', deltaPx: number): boolean;
+export declare function normalizeKeyboardDeltaPx(key: string, shiftKey: boolean, viewportSpan: number): number;
+export declare function resolveScrollIntentOffset({ currentOffset, deltaPx, maxNativeOffset, segments, }: {
+    currentOffset: number;
+    deltaPx: number;
+    maxNativeOffset: number;
+    segments?: CenterLockSegment[];
+}): number;
+/**
+ * Scroll keyboard input must never hijack editable or interactive targets:
+ * all keys are released to input/textarea/select/contentEditable (typing),
+ * and Space is released to button/summary/link-like targets (activation).
+ * Shared by the window-level global handler (which additionally requires
+ * activeElement === body) and the container's onKeyDownCapture handler
+ * (where focus legitimately lives inside the container).
+ */
+export declare function isEditableOrInteractiveScrollKeyTarget(target: EventTarget | null, key: string): boolean;
+export declare function shouldIgnoreGlobalScrollKey(event: KeyboardEvent): boolean;
+export declare function isSceneElement(node: React.ReactNode): node is React.ReactElement<SceneAuthoringCompatProps>;
+export declare function isLegacyDisplayNameSceneElement(node: React.ReactNode): boolean;
+export declare function resolveDesignDimensions(designWidth: CineviewBaseProps['designWidth'] | undefined): {
+    designSize: number;
+};
+export declare function getSceneTransitionConfig(sceneProps: SceneAuthoringCompatProps): {
+    enterAnimation?: SceneAuthoringCompatProps['enterAnimation'];
+    exitAnimation?: SceneAuthoringCompatProps['exitAnimation'];
+    transitionDurationMs: number;
+    scrollEnterLength?: number;
+    scrollExitLength?: number;
+};
+export declare function resolveRootSceneStackMode(sceneProps: SceneAuthoringCompatProps): 'replace' | 'cover';
+export declare function resolveScrollSceneDeclaredSpan(sceneProps: SceneAuthoringCompatProps, direction: 'x' | 'y', viewportWidth: number, viewportHeight: number): number | null;
+export declare function resolveTakeoverSceneSpan(rawSize: number | string | undefined, viewportWidth: number, viewportHeight: number): number | null;
+export declare function getRelativeOffset(element: HTMLElement, root: HTMLElement, direction: 'x' | 'y'): number;
+export declare function buildSceneTimelineState(layout: SceneLayoutInfo | null, scrollOffset: number, viewportSpan: number): ScrollTimelineState | null;
+export declare function areSceneLayoutsEqual(currentLayouts: SceneLayoutInfo[], nextLayouts: SceneLayoutInfo[]): boolean;
+export declare function createScrollbarCss(): string;

package/dist/components/Cineview/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Cineview component exports
+ */
+export { Cineview } from './CineviewDispatch';
+export type { CineviewPreloadTarget, CineviewProps, CineviewRef } from '../../types';

package/dist/components/Cineview/preloadTargets.d.ts

@@ -0,0 +1,18 @@
+import { CineviewPreloadTarget } from '../../types';
+interface ScenePreloadTargetProps {
+    sceneId?: string;
+    scroll?: {
+        zoneId?: string;
+    };
+    assets?: {
+        preloadImages?: string[];
+    };
+}
+interface ScenePreloadSceneLike {
+    props: ScenePreloadTargetProps;
+}
+export declare function getScenePreloadImages(sceneProps: ScenePreloadTargetProps): string[];
+export declare function resolveScenePreloadTargetImages(scenes: ScenePreloadSceneLike[], targets?: CineviewPreloadTarget[], options?: {
+    includeZoneIds?: boolean;
+}): string[];
+export {};

package/dist/components/Cineview/regroupCallbacks.d.ts

@@ -0,0 +1,10 @@
+import { CineviewCommonCallbacks, CineviewDragCallbacks, CineviewScrollCallbacks } from '../../types';
+/** Superset of every flat callback key a consumer might pass (any mode). */
+export type FlatCallbacks = CineviewCommonCallbacks & CineviewDragCallbacks & CineviewScrollCallbacks;
+/** Internal grouped shape the runtime reads from. */
+export interface GroupedCallbacks {
+    common?: CineviewCommonCallbacks;
+    drag?: CineviewDragCallbacks;
+    scroll?: CineviewScrollCallbacks;
+}
+export declare function regroupCallbacks(flat: FlatCallbacks | undefined): GroupedCallbacks;

package/dist/components/Cineview/useCineviewImperativeApi.d.ts

@@ -0,0 +1,21 @@
+import { ForwardedRef, MutableRefObject } from 'react';
+import { CineviewRef } from '../../types';
+import { GroupedCallbacks } from './regroupCallbacks';
+interface SceneActionsPort {
+    goToScene: (index: number, animated?: boolean) => void;
+}
+interface PreloadActionsPort {
+    addUrls: (urls: string[], priority?: boolean) => void;
+    startPreload: () => Promise<void>;
+}
+interface UseCineViewImperativeApiParams {
+    ref: ForwardedRef<CineviewRef>;
+    currentSceneRef: MutableRefObject<number>;
+    scenesRef: MutableRefObject<React.ReactElement[]>;
+    sceneActionsRef: MutableRefObject<SceneActionsPort>;
+    preloadActionsRef: MutableRefObject<PreloadActionsPort>;
+    measureViewportRef: MutableRefObject<(() => void) | null>;
+    resolvedCallbacksRef: MutableRefObject<GroupedCallbacks>;
+}
+export declare function useCineviewImperativeApi({ ref, currentSceneRef, scenesRef, sceneActionsRef, preloadActionsRef, measureViewportRef, resolvedCallbacksRef, }: UseCineViewImperativeApiParams): CineviewRef;
+export {};

package/dist/components/Cineview/useNativeScrollController.d.ts

@@ -0,0 +1,38 @@
+import { MutableRefObject, RefObject } from 'react';
+import { SlideDirection } from '../../types';
+import { SceneLayoutInfo, ScrollInputDirection } from './directScrollHelpers';
+import { GroupedCallbacks } from './regroupCallbacks';
+import { ScrollExternalStore } from '../runtime/scrollExternalStore';
+import { ScrollTimelineStore, ScrollZoneRegistryRef, ScrollZoneStatesRef } from './useScrollZoneRegistry';
+interface UseNativeScrollControllerParams {
+    rootRef: RefObject<HTMLDivElement | null>;
+    direction: SlideDirection;
+    getViewportSpan: () => number;
+    updateViewportMetrics: () => void;
+    measureSceneLayouts: () => SceneLayoutInfo[];
+    sceneLayoutsRef: MutableRefObject<SceneLayoutInfo[]>;
+    zoneRegistryRef: ScrollZoneRegistryRef;
+    zoneStatesRef: ScrollZoneStatesRef;
+    timelineStoreRef: MutableRefObject<ScrollTimelineStore>;
+    scrollOffsetRef: MutableRefObject<number>;
+    scrollOffsetStore: ScrollExternalStore<number>;
+    activeSceneIndexRef: MutableRefObject<number>;
+    scrollDirectionRef: MutableRefObject<ScrollInputDirection | null>;
+    isScrollingStateRef: MutableRefObject<boolean>;
+    updateSceneRenderSnapshotsRef: MutableRefObject<(nativeOffset: number) => void>;
+    callbacks: GroupedCallbacks;
+    zoneRuntimeVersion: number;
+}
+export interface NativeScrollControllerPort {
+    isScrolling: boolean;
+    scrollContentSpan: number;
+    syncNativeScrollState: (fromGesture?: boolean) => void;
+    applyNativeScrollDelta: (deltaPx: number) => boolean;
+    applyNativeScrollbarOffset: (targetOffset: number) => void;
+    goToScrollZone: (zoneId: string, options?: {
+        animated?: boolean;
+    }) => void;
+    beginProgrammaticScroll: (targetOffset: number) => void;
+}
+export declare function useNativeScrollController({ rootRef, direction, getViewportSpan, updateViewportMetrics, measureSceneLayouts, sceneLayoutsRef, zoneRegistryRef, zoneStatesRef, timelineStoreRef, scrollOffsetRef, scrollOffsetStore, activeSceneIndexRef, scrollDirectionRef, isScrollingStateRef, updateSceneRenderSnapshotsRef, callbacks, zoneRuntimeVersion, }: UseNativeScrollControllerParams): NativeScrollControllerPort;
+export {};

package/dist/components/Cineview/useScrollInputBindings.d.ts

@@ -0,0 +1,9 @@
+import { RefObject } from 'react';
+interface UseScrollInputBindingsParams {
+    rootRef: RefObject<HTMLDivElement | null>;
+    direction: 'x' | 'y';
+    getViewportSpan: () => number;
+    applyNativeScrollDelta: (deltaPx: number) => boolean;
+}
+export declare function useScrollInputBindings({ rootRef, direction, getViewportSpan, applyNativeScrollDelta, }: UseScrollInputBindingsParams): void;
+export {};

package/dist/components/Cineview/useScrollSceneLayout.d.ts

@@ -0,0 +1,24 @@
+import { MutableRefObject, RefObject } from 'react';
+import { ScrollModeConfig, SlideDirection } from '../../types';
+import { SceneAuthoringCompatProps, SceneLayoutInfo } from './directScrollHelpers';
+import { ScrollZoneRegistryRef } from './useScrollZoneRegistry';
+interface UseScrollSceneLayoutParams {
+    rootRef: RefObject<HTMLDivElement | null>;
+    direction: SlideDirection;
+    scenes: React.ReactElement<SceneAuthoringCompatProps>[];
+    sceneSizing: ScrollModeConfig['sceneSizing'];
+    getViewportSpan: () => number;
+    getZoneIdForScene: (sceneIndex: number) => string | null;
+    getZoneDistance: (sceneIndex: number) => number;
+    zoneRegistryRef: ScrollZoneRegistryRef;
+    scrollOffsetRef: MutableRefObject<number>;
+    updateSceneRenderSnapshotsRef: MutableRefObject<(nativeOffset: number) => void>;
+}
+export interface ScrollSceneLayoutPort {
+    sceneLayoutsRef: MutableRefObject<SceneLayoutInfo[]>;
+    sceneWrapperRefs: MutableRefObject<Array<HTMLDivElement | null>>;
+    measureSceneLayouts: () => SceneLayoutInfo[];
+    setSceneWrapperRef: (sceneIndex: number, node: HTMLDivElement | null) => void;
+}
+export declare function useScrollSceneLayout({ rootRef, direction, scenes, sceneSizing, getViewportSpan, getZoneIdForScene, getZoneDistance, zoneRegistryRef, scrollOffsetRef, updateSceneRenderSnapshotsRef, }: UseScrollSceneLayoutParams): ScrollSceneLayoutPort;
+export {};

package/dist/components/Cineview/useScrollSceneSnapshots.d.ts

@@ -0,0 +1,32 @@
+import { MutableRefObject } from 'react';
+import { ScrollModeConfig, SlideDirection } from '../../types';
+import { SceneAuthoringCompatProps, SceneLayoutInfo, ScrollInputDirection } from './directScrollHelpers';
+import { ScrollSceneSnapshotStore } from './ScrollSceneSlot';
+import { ScrollSceneFrameStore } from '../runtime/scrollSceneFrameStore';
+import { ScrollTimelineStore } from './useScrollZoneRegistry';
+interface UseScrollSceneSnapshotsParams {
+    scenes: React.ReactElement<SceneAuthoringCompatProps>[];
+    sceneLayoutsRef: MutableRefObject<SceneLayoutInfo[]>;
+    timelineStoreRef: MutableRefObject<ScrollTimelineStore>;
+    viewportSizeRef: MutableRefObject<{
+        width: number;
+        height: number;
+    }>;
+    activeSceneIndexRef: MutableRefObject<number>;
+    scrollDirectionRef: MutableRefObject<ScrollInputDirection | null>;
+    isScrollingStateRef: MutableRefObject<boolean>;
+    direction: SlideDirection;
+    sceneSizing: ScrollModeConfig['sceneSizing'];
+    firstSceneEnterActive: boolean;
+    firstSceneEnterReady: boolean;
+    exposeTakeoverDebugData: boolean;
+    scrollOffsetRef: MutableRefObject<number>;
+    updateSceneRenderSnapshotsRef: MutableRefObject<(nativeOffset: number) => void>;
+}
+export interface ScrollSceneSnapshotsPort {
+    store: ScrollSceneSnapshotStore;
+    frameStore: ScrollSceneFrameStore;
+    updateSceneRenderSnapshots: (nativeOffset: number) => void;
+}
+export declare function useScrollSceneSnapshots({ scenes, sceneLayoutsRef, timelineStoreRef, viewportSizeRef, activeSceneIndexRef, scrollDirectionRef, isScrollingStateRef, direction, sceneSizing, firstSceneEnterActive, firstSceneEnterReady, exposeTakeoverDebugData, scrollOffsetRef, updateSceneRenderSnapshotsRef, }: UseScrollSceneSnapshotsParams): ScrollSceneSnapshotsPort;
+export {};

package/dist/components/Cineview/useScrollViewport.d.ts

@@ -0,0 +1,20 @@
+import { RefObject } from 'react';
+import { SlideDirection } from '../../types';
+interface UseScrollViewportParams {
+    rootRef: RefObject<HTMLDivElement | null>;
+    direction: SlideDirection;
+}
+export interface ScrollViewportPort {
+    viewportSize: {
+        width: number;
+        height: number;
+    };
+    viewportSizeRef: React.MutableRefObject<{
+        width: number;
+        height: number;
+    }>;
+    getViewportSpan: () => number;
+    updateViewportMetrics: () => void;
+}
+export declare function useScrollViewport({ rootRef, direction, }: UseScrollViewportParams): ScrollViewportPort;
+export {};

package/dist/components/Cineview/useScrollZoneRegistry.d.ts

@@ -0,0 +1,35 @@
+import { MutableRefObject } from 'react';
+import { SceneScrollRuntimeContextValue, SceneScrollTimelineState, SceneScrollTimelineStore } from '../Scene/sceneScrollRuntime';
+import { SceneScrollAnimationRegistration } from '../Scene/sceneScrollBudget';
+import { CineviewErrorDetail } from '../../types';
+export interface ScrollZoneRegistration {
+    sceneIndex: number;
+    element: HTMLElement | null;
+}
+export type ScrollZoneRegistryRef = MutableRefObject<Map<string, ScrollZoneRegistration>>;
+export type ScrollZoneAnimationsRef = MutableRefObject<Map<string, Map<string, SceneScrollAnimationRegistration>>>;
+export type ScrollZoneStatesRef = MutableRefObject<Record<string, SceneScrollTimelineState>>;
+export type ScrollTimelineStore = SceneScrollTimelineStore;
+interface UseScrollZoneRegistryParams {
+    scrollOffsetRef: MutableRefObject<number>;
+    measureSceneLayoutsRef: MutableRefObject<(() => void) | null>;
+    updateSceneRenderSnapshotsRef: MutableRefObject<(nativeOffset: number) => void>;
+    onError?: (detail: CineviewErrorDetail) => void;
+}
+export interface ScrollZoneRegistryPort {
+    zoneRegistryRef: ScrollZoneRegistryRef;
+    zoneAnimationsRef: ScrollZoneAnimationsRef;
+    zoneStatesRef: ScrollZoneStatesRef;
+    timelineStoreRef: MutableRefObject<ScrollTimelineStore>;
+    zoneRuntimeVersion: number;
+    getZoneIdForScene: (sceneIndex: number) => string | null;
+    getZoneDistance: (sceneIndex: number) => number;
+    syncZoneState: (zoneId: string, updater: (current: SceneScrollTimelineState | undefined) => SceneScrollTimelineState | null) => void;
+    recomputeZoneSequence: (zoneId: string) => void;
+    zoneRuntimeValue: SceneScrollRuntimeContextValue;
+    zoneTimelineValue: {
+        store: ScrollTimelineStore;
+    };
+}
+export declare function useScrollZoneRegistry({ scrollOffsetRef, measureSceneLayoutsRef, updateSceneRenderSnapshotsRef, onError, }: UseScrollZoneRegistryParams): ScrollZoneRegistryPort;
+export {};

package/dist/components/Container/Container.d.ts

@@ -0,0 +1,2 @@
+import { ContainerProps } from '../../types';
+export declare const Container: import('react').ForwardRefExoticComponent<ContainerProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/components/Container/index.d.ts

@@ -0,0 +1 @@
+export { Container } from './Container';

package/dist/components/Image/Image.d.ts

@@ -0,0 +1,12 @@
+import { CSSProperties, ImgHTMLAttributes } from 'react';
+type NativeImageProps = Omit<ImgHTMLAttributes<HTMLImageElement>, 'src' | 'alt' | 'width' | 'height' | 'style'>;
+export interface ImageProps extends NativeImageProps {
+    src: string;
+    alt: string;
+    width?: number | string;
+    height?: number | string;
+    style?: CSSProperties;
+    preload?: boolean;
+}
+export declare const Image: import('react').ForwardRefExoticComponent<ImageProps & import('react').RefAttributes<HTMLImageElement>>;
+export {};

package/dist/components/Image/index.d.ts

@@ -0,0 +1,2 @@
+export { Image } from './Image';
+export type { ImageProps } from './Image';

package/dist/components/Position/Position.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { PositionProps } from '../../types';
+interface PositionLegacyCompatProps {
+    x?: number;
+    y?: number;
+    offsetX?: number;
+    offsetY?: number;
+    fixed?: boolean;
+}
+export type PositionInternalProps = PositionProps & PositionLegacyCompatProps;
+export declare const SceneFixedLayerContext: React.Context<HTMLElement | null>;
+export declare const Position: React.ForwardRefExoticComponent<PositionProps & PositionLegacyCompatProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/Position/index.d.ts

@@ -0,0 +1 @@
+export { Position } from './Position';

package/dist/components/Scene/Scene.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { SceneInternalProps } from './types';
+export declare const SceneIdentityContext: React.Context<number | null>;
+export declare const Scene: React.ForwardRefExoticComponent<SceneInternalProps & React.RefAttributes<HTMLDivElement>> & {
+    cineViewScene: true;
+};
+export declare const SceneInternal: React.ForwardRefExoticComponent<SceneInternalProps & React.RefAttributes<HTMLDivElement>> & {
+    cineViewScene: true;
+};
+export default Scene;

package/dist/components/Scene/SceneFixedLayer.d.ts

@@ -0,0 +1,14 @@
+import { RefCallback } from 'react';
+import { FixedLayerMetrics } from './helpers';
+import { ScrollSceneFrameStore } from '../runtime/scrollSceneFrameStore';
+interface SceneFixedLayerProps {
+    sceneIndex: number;
+    metrics: FixedLayerMetrics;
+    setHostRef: RefCallback<HTMLDivElement>;
+    frameStore?: ScrollSceneFrameStore;
+    direction?: 'x' | 'y';
+    viewportWidth?: number;
+    viewportHeight?: number;
+}
+export declare function SceneFixedLayer({ sceneIndex, metrics, setHostRef, frameStore, direction, viewportWidth, viewportHeight, }: SceneFixedLayerProps): React.JSX.Element;
+export {};

package/dist/components/Scene/__fixtures__/scene-grouped-public-path.fixture.d.ts

@@ -0,0 +1 @@
+export declare function GroupedPublicPathFixture(): React.JSX.Element;

package/dist/components/Scene/dragPreparedState.d.ts

@@ -0,0 +1,49 @@
+import { ParsedAnimationVariant } from '../../types';
+import { FrozenAnimationRegistrySnapshot } from '../../animations/registry';
+import { ResolvedDragTimelineConfig } from '../../utils/dragTimelineMapping';
+export interface PreparedSceneSnapshot {
+    readonly sceneIndex: number;
+    readonly instanceId: symbol;
+    readonly revision: number;
+    readonly enabled: boolean;
+    readonly mapping: Readonly<ResolvedDragTimelineConfig>;
+    readonly registrySnapshot: FrozenAnimationRegistrySnapshot;
+    readonly enterVariantsByAnimateId: ReadonlyMap<string, ParsedAnimationVariant>;
+}
+export type DragSceneTransactionPhase = 'driving' | 'settling' | 'bouncing' | 'programmatic';
+export interface DragSceneTransaction {
+    readonly transactionId: symbol;
+    readonly targetSceneIndex: number;
+    readonly targetInstanceId: symbol;
+    readonly targetRevision: number;
+    readonly phase: DragSceneTransactionPhase;
+    readonly mapping: Readonly<ResolvedDragTimelineConfig>;
+    readonly registrySnapshot: FrozenAnimationRegistrySnapshot;
+    readonly enterVariantsByAnimateId: ReadonlyMap<string, ParsedAnimationVariant>;
+    readonly releaseSeed: Readonly<{
+        progressRatio: number;
+        elapsedMs: number;
+    }>;
+}
+export interface PreparedSceneInvalidation {
+    readonly sceneIndex: number;
+    readonly instanceId: symbol;
+    readonly revision: number;
+}
+export declare function createPreparedSceneSnapshot(snapshot: PreparedSceneSnapshot): PreparedSceneSnapshot;
+export declare function createDragSceneTransaction(snapshot: PreparedSceneSnapshot, phase: DragSceneTransactionPhase, progressRatio: number): DragSceneTransaction;
+/** CineView-owned prepared-scene and cross-commit transaction store. */
+export declare class DragPreparedSceneStore {
+    private readonly preparedScenes;
+    private readonly activeTransactions;
+    private readonly transactionIdsByTarget;
+    constructor();
+    publishPrepared(snapshot: PreparedSceneSnapshot): void;
+    invalidatePrepared(invalidation: PreparedSceneInvalidation): void;
+    getPrepared(sceneIndex: number): PreparedSceneSnapshot | null;
+    beginTransaction(targetSceneIndex: number, phase: DragSceneTransactionPhase, progressRatio: number): DragSceneTransaction | null;
+    getTransaction(transactionId: symbol): DragSceneTransaction | null;
+    getTransactionForTarget(targetSceneIndex: number): DragSceneTransaction | null;
+    releaseTransaction(transactionId: symbol): void;
+    clear(): void;
+}

package/dist/components/Scene/helpers.d.ts

@@ -0,0 +1,101 @@
+import { default as React } from 'react';
+import { SceneAnchor, SceneVisibilityDetail, ScrollMode } from '../../types';
+import { SceneInternalProps } from './types';
+export declare function resolveSceneAnchor(anchor: SceneAnchor): React.CSSProperties;
+export declare function resolveScrollSceneAnchor(anchor: SceneAnchor): React.CSSProperties;
+export declare function resolveDragTouchAction(mode: ScrollMode, direction: 'x' | 'y'): React.CSSProperties['touchAction'];
+export interface NormalizedSceneProps {
+    effectiveMode: ScrollMode;
+    effectiveDirection: 'x' | 'y';
+    isActive: boolean;
+    sceneIndex: number;
+    totalScenes: number;
+    currentSceneIndex: number;
+    globalDirection: 'forward' | 'backward' | null;
+    globalIsSceneAnimating: boolean;
+    globalSharedTimelineDurationMs: number;
+    globalActivationToken: number;
+    globalActivationKind: NonNullable<SceneInternalProps['sceneRuntime']>['activationKind'] | null;
+    globalFirstSceneEnterGateKnown: boolean;
+    globalFirstSceneEnterActive: boolean;
+    globalFirstSceneEnterReady: boolean;
+    globalViewportWidth: number;
+    globalViewportHeight: number;
+    globalDragProgress: number;
+    globalRenderProgress: number;
+    globalDragTimelineProgress: number;
+    globalIsDragging: boolean;
+    globalDragRelease: Exclude<NonNullable<SceneInternalProps['dragRuntime']>['release'], undefined> | null;
+    globalScrollProgress: number;
+    globalIsScrolling: boolean;
+    globalScrollDirection: 'forward' | 'backward' | null;
+    globalScrollTransitionSnapshot: Exclude<NonNullable<SceneInternalProps['scrollRuntime']>['transitionSnapshot'], undefined> | null;
+    globalScrollBackdropActive: boolean;
+    globalScrollTimelineState: Exclude<NonNullable<SceneInternalProps['scrollRuntime']>['timelineState'], undefined> | null;
+    globalScrollActiveSceneIndex: number;
+    globalScrollViewportOffset: number;
+    resolvedSceneWidth: NonNullable<SceneInternalProps['layout']>['width'] | number | string;
+    resolvedSceneHeight: NonNullable<SceneInternalProps['layout']>['height'] | number | string;
+    resolvedSceneAnchor: SceneAnchor;
+    resolvedSceneOverflow: NonNullable<SceneInternalProps['layout']>['overflow'] | 'hidden' | 'visible';
+    resolvedSceneZIndex: number | undefined;
+    effectiveSceneStackMode: 'replace' | 'cover';
+    resolvedSceneTransitionDuration: number;
+    resolvedEnterAnimation: SceneInternalProps['enterAnimation'];
+    resolvedExitAnimation: SceneInternalProps['exitAnimation'];
+    sceneVisibilityCallback?: NonNullable<NonNullable<SceneInternalProps['callbacks']>['onVisibilityChange']>;
+    onVisibilityChange: SceneInternalProps['onVisibilityChange'];
+    onSceneChange: SceneInternalProps['onSceneChange'];
+    scrollCommitThreshold: number;
+    scrollReleaseDuration: number;
+    scrollLockToSingleScene: boolean;
+    scrollRuntime: SceneInternalProps['scrollRuntime'];
+    dragRuntime: SceneInternalProps['dragRuntime'];
+    onActivationComplete: SceneInternalProps['onActivationComplete'];
+    onDragProgressChange: SceneInternalProps['onDragProgressChange'];
+    onRenderProgressChange: SceneInternalProps['onRenderProgressChange'];
+    onDragTimelineProgressChange: SceneInternalProps['onDragTimelineProgressChange'];
+    onSharedElapsedMsChange: SceneInternalProps['onSharedElapsedMsChange'];
+    onDraggingChange: SceneInternalProps['onDraggingChange'];
+    onSharedTimelineDurationChange: SceneInternalProps['onSharedTimelineDurationChange'];
+    onDragRelease: SceneInternalProps['onDragRelease'];
+    onDragGestureEnd: SceneInternalProps['onDragGestureEnd'];
+    onDragReset: SceneInternalProps['onDragReset'];
+    onScrollProgressChange: SceneInternalProps['onScrollProgressChange'];
+    onScrollDirectionChange: SceneInternalProps['onScrollDirectionChange'];
+    onScrollingChange: SceneInternalProps['onScrollingChange'];
+    onScrollCommit: SceneInternalProps['onScrollCommit'];
+    onScrollReset: SceneInternalProps['onScrollReset'];
+    slideDuration: number;
+    compatFields: unknown[];
+}
+export declare function normalizeSceneProps(props: SceneInternalProps): NormalizedSceneProps;
+export declare function getSceneVisibilityProgress({ effectiveMode, isActive, globalScrollTimelineState, hasExitAnimation, }: {
+    effectiveMode: ScrollMode;
+    isActive: boolean;
+    globalScrollTimelineState: NormalizedSceneProps['globalScrollTimelineState'];
+    hasExitAnimation: boolean;
+}): number;
+export declare function emitSceneVisibility({ onVisibilityChange, sceneVisibilityCallback, sceneIndex, visible, progress, }: {
+    onVisibilityChange?: (visible: boolean, progress: number) => void;
+    sceneVisibilityCallback?: (detail: SceneVisibilityDetail) => void;
+    sceneIndex: number;
+    visible: boolean;
+    progress: number;
+}): void;
+export interface FixedLayerMetrics {
+    visible: boolean;
+    isHorizontal: boolean;
+    hostOffset: number;
+    hostSpan: number;
+    clipWidth: number;
+    clipHeight: number;
+}
+export declare function getFixedLayerMetrics({ effectiveMode, effectiveDirection, globalScrollTimelineState, globalScrollViewportOffset, globalViewportWidth, globalViewportHeight, }: {
+    effectiveMode: ScrollMode;
+    effectiveDirection: 'x' | 'y';
+    globalScrollTimelineState: NormalizedSceneProps['globalScrollTimelineState'];
+    globalScrollViewportOffset: number;
+    globalViewportWidth: number;
+    globalViewportHeight: number;
+}): FixedLayerMetrics;

package/dist/components/Scene/index.d.ts

@@ -0,0 +1 @@
+export { Scene } from './Scene';