@yorozu/animations 0.3.0

package/package.json

@@ -0,0 +1,21 @@
+{
+    "name": "@yorozu/animations",
+    "type": "module",
+    "version": "0.3.0",
+    "description": "framework-agnostic compositor motion primitives",
+    "license": "MIT",
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./index.d.ts",
+                "default": "./index.js"
+            }
+        }
+    },
+    "sideEffects": false,
+    "author": "inshinrei",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/inshinrei/yorozu.git"
+    }
+}

package/playground/src/catalog.d.ts

@@ -0,0 +1,8 @@
+export type CatalogEntry = {
+    id: string;
+    title: string;
+    description: string;
+    tags: string[];
+    mount: (root: HTMLElement) => () => void;
+};
+export declare let catalog: CatalogEntry[];

package/playground/src/level-switch.d.ts

@@ -0,0 +1 @@
+export declare function mountLevelSwitch(host: HTMLElement): () => void;

package/playground/src/level.d.ts

@@ -0,0 +1,7 @@
+import { AnimationLevel } from '../../src/index.ts';
+export declare let LEVEL_KEY: string;
+type Listener = (level: AnimationLevel) => void;
+export declare function getAnimationLevel(): AnimationLevel;
+export declare function setAnimationLevel(next: AnimationLevel): void;
+export declare function subscribeAnimationLevel(listener: Listener): () => void;
+export {};

package/playground/src/overlay.d.ts

@@ -0,0 +1,2 @@
+export declare function closeOverlay(): void;
+export declare function openOverlay(title: string, mount: (root: HTMLElement) => () => void): void;

package/playground/src/testers/digit-flip.d.ts

@@ -0,0 +1 @@
+export declare function mountDigitFlip(root: HTMLElement): () => void;

package/playground/src/testers/dock.d.ts

@@ -0,0 +1 @@
+export declare function mountDock(root: HTMLElement): () => void;

package/playground/src/testers/fade.d.ts

@@ -0,0 +1 @@
+export declare function mountFade(root: HTMLElement): () => void;

package/playground/src/testers/list-layer.d.ts

@@ -0,0 +1 @@
+export declare function mountListLayer(root: HTMLElement): () => void;

package/playground/src/testers/list-reorder.d.ts

@@ -0,0 +1 @@
+export declare function mountListReorder(root: HTMLElement): () => void;

package/playground/src/testers/pinch-zoom.d.ts

@@ -0,0 +1 @@
+export declare function mountPinchZoom(root: HTMLElement): () => void;

package/playground/src/testers/popover.d.ts

@@ -0,0 +1 @@
+export declare function mountPopover(root: HTMLElement): () => void;

package/playground/src/testers/presence-pop.d.ts

@@ -0,0 +1 @@
+export declare function mountPresencePop(root: HTMLElement): () => void;

package/playground/src/testers/ripple.d.ts

@@ -0,0 +1 @@
+export declare function mountRipple(root: HTMLElement): () => void;

package/playground/src/testers/scroll-tween.d.ts

@@ -0,0 +1 @@
+export declare function mountScrollTween(root: HTMLElement): () => void;

package/playground/src/testers/send-flight.d.ts

@@ -0,0 +1 @@
+export declare function mountSendFlight(root: HTMLElement): () => void;

package/playground/src/testers/shared-element.d.ts

@@ -0,0 +1 @@
+export declare function mountSharedElement(root: HTMLElement): () => void;

package/playground/src/testers/sliding-indicator.d.ts

@@ -0,0 +1 @@
+export declare function mountSlidingIndicator(root: HTMLElement): () => void;

package/playground/src/testers/spoiler.d.ts

@@ -0,0 +1 @@
+export declare function mountSpoiler(root: HTMLElement): () => void;

package/playground/src/testers/swipe-reveal.d.ts

@@ -0,0 +1 @@
+export declare function mountSwipeReveal(root: HTMLElement): () => void;

package/playground/src/testers/tabs.d.ts

@@ -0,0 +1 @@
+export declare function mountTabs(root: HTMLElement): () => void;

package/playground/src/testers/view-slide-modes.d.ts

@@ -0,0 +1,3 @@
+type ExtraMode = "peek" | "lift" | "zoom" | "reveal";
+export declare function mountViewSlideModes(root: HTMLElement, initial?: ExtraMode): () => void;
+export {};

package/playground/src/testers/view-slide.d.ts

@@ -0,0 +1 @@
+export declare function mountViewSlide(root: HTMLElement): () => void;

package/playground/src/testers/waveform.d.ts

@@ -0,0 +1 @@
+export declare function mountWaveform(root: HTMLElement): () => void;

package/src/core/level.d.ts

@@ -0,0 +1,10 @@
+export type AnimationLevel = "low" | "med" | "high";
+export declare const ANIMATION_LEVELS: readonly AnimationLevel[];
+export declare const DEFAULT_ANIMATION_LEVEL: AnimationLevel;
+export declare function isAnimationLevel(value: unknown): value is AnimationLevel;
+export declare function parseAnimationLevel(raw: unknown): AnimationLevel | null;
+export declare function defaultAnimationLevel(prefersReduced: boolean): AnimationLevel;
+export declare function cycleAnimationLevel(level: AnimationLevel): AnimationLevel;
+export declare function canAnimate(level: AnimationLevel): boolean;
+export declare function pickAnimationLevelFromRatio(t: number): AnimationLevel;
+export declare function stepAnimationLevel(level: AnimationLevel, delta: number): AnimationLevel;

package/src/core/playback.d.ts

@@ -0,0 +1,7 @@
+import { Playback } from './types';
+export declare function createPlayback(): {
+    playback: Playback;
+    resolve: (ran: boolean) => void;
+    isCancelled: () => boolean;
+};
+export declare function animateElement(el: Element, keyframes: Keyframe[], options: KeyframeAnimationOptions): Animation | null;

package/src/core/raf.d.ts

@@ -0,0 +1 @@
+export declare function dualRaf(): Promise<void>;

package/src/core/reduced-motion.d.ts

@@ -0,0 +1 @@
+export declare function prefersReducedMotion(): boolean;

package/src/core/styles.d.ts

@@ -0,0 +1,2 @@
+export declare function applyStyles(el: HTMLElement, styles: Record<string, string>): void;
+export declare function clearStyles(el: HTMLElement, keys: readonly string[]): void;

package/src/core/tween.d.ts

@@ -0,0 +1,11 @@
+import { Playback } from './types';
+export declare function easeOutCubic(t: number): number;
+export declare function lerp(from: number, to: number, t: number): number;
+export type TweenOptions = {
+    from: number;
+    to: number;
+    durationMs: number;
+    easing?: (t: number) => number;
+    onUpdate: (value: number) => void;
+};
+export declare function tween(options: TweenOptions): Playback;

package/src/core/types.d.ts

@@ -0,0 +1,9 @@
+export type Key = string | number;
+export type Playback = {
+    readonly done: Promise<boolean>;
+    cancel: () => void;
+};
+export type AttachHandle = {
+    update: (next: Key) => void;
+    destroy: () => void;
+};

package/src/digit-flip/play.d.ts

@@ -0,0 +1,12 @@
+import { Playback } from '../core/types';
+export declare const DIGIT_FLIP_EASING: string;
+export declare const PRESENCE_POP_MS: number;
+export declare const PRESENCE_POP_EASING: string;
+export declare function playDigitFlip(el: HTMLElement, options?: {
+    durationMs?: number;
+    easing?: string;
+}): Playback;
+export declare function playPresencePop(el: HTMLElement, options?: {
+    durationMs?: number;
+    easing?: string;
+}): Playback;

package/src/digit-flip/slots.d.ts

@@ -0,0 +1,14 @@
+export declare const DIGIT_FLIP_MS: number;
+export declare const MAX_SIMULTANEOUS_DIGIT_FLIPS: number;
+export type DigitSlot = {
+    kind: "static";
+    char: string;
+} | {
+    kind: "flip";
+    char: string;
+    prevChar: string;
+};
+export declare function buildDigitSlots(text: string, prevText: string | undefined, shouldAnimate: boolean): DigitSlot[];
+export declare function formatCounterText(value: number): string;
+export declare function shouldPresencePop(prev: number | undefined, next: number): boolean;
+export declare function scheduleDigitFlip(condition: boolean): boolean;

package/src/dock/dock.d.ts

@@ -0,0 +1,23 @@
+import { Playback } from '../core/types';
+import { DockEdge, DockMode } from './transforms';
+export type { DockEdge, DockMode, DockPanelState, DockTransforms } from './transforms';
+export { DOCK_EASING, DOCK_FADE_OFFSET, DOCK_MS, dockTransforms } from './transforms';
+export type DockConfig = {
+    getMode: () => DockMode;
+    edge?: DockEdge;
+    durationMs?: number;
+    easing?: string;
+};
+export type DockHandle = {
+    destroy: () => void;
+};
+export type Dock = {
+    readonly mounted: boolean;
+    readonly leaving: boolean;
+    readonly animating: boolean;
+    setOpen: (open: boolean) => Playback;
+    attach: (panel: HTMLElement) => DockHandle;
+    attachBackdrop: (el: HTMLElement) => DockHandle;
+    destroy: () => void;
+};
+export declare function createDock(config: DockConfig): Dock;

package/src/dock/transforms.d.ts

@@ -0,0 +1,14 @@
+export type DockMode = "none" | "fade" | "slide";
+export type DockEdge = "right" | "left" | "top" | "bottom";
+export type DockPanelState = {
+    transform: string;
+    opacity: string;
+};
+export type DockTransforms = {
+    closed: DockPanelState;
+    open: DockPanelState;
+};
+export declare const DOCK_FADE_OFFSET: string;
+export declare const DOCK_MS: number;
+export declare const DOCK_EASING: string;
+export declare function dockTransforms(mode: Exclude<DockMode, "none">, edge: DockEdge): DockTransforms;

package/src/fade/fade.d.ts

@@ -0,0 +1,11 @@
+import { Playback } from '../core/types';
+export declare const FADE_MS: number;
+export declare const FADE_EASING: string;
+export type FadeOptions = {
+    durationMs?: number;
+    easing?: string;
+};
+export type Fade = {
+    setVisible: (visible: boolean) => Playback;
+};
+export declare function createFade(el: HTMLElement, options?: FadeOptions): Fade;

package/src/index.d.ts

@@ -0,0 +1,45 @@
+export type { AttachHandle, Key, Playback } from './core/types';
+export { prefersReducedMotion } from './core/reduced-motion';
+export { dualRaf } from './core/raf';
+export type { AnimationLevel } from './core/level';
+export { ANIMATION_LEVELS, DEFAULT_ANIMATION_LEVEL, isAnimationLevel, parseAnimationLevel, defaultAnimationLevel, cycleAnimationLevel, canAnimate, pickAnimationLevelFromRatio, stepAnimationLevel, } from './core/level';
+export type { TweenOptions } from './core/tween';
+export { easeOutCubic, lerp, tween } from './core/tween';
+export type { Rect, Size, Insets, ObjectFit } from './rect/types';
+export { fitContain, centerFitInViewport } from './rect/fit';
+export type { Flight, OpenFlightOpts, CloseFlightOpts } from './shared-element/math';
+export { uncoverByAspect, computeFlight, resolveNaturalSize, computeOpenFlight, computeCloseFlight, isRectFullyVisibleIn, isRectInViewport, offViewportLandingRect, } from './shared-element/math';
+export type { SharedElementSeed, SharedElementPlayOptions, SharedElementController } from './shared-element/player';
+export { SHARED_ELEMENT_MS, SHARED_ELEMENT_EASING, SHARED_ELEMENT_END_MS, createSharedElement, playSharedElement, } from './shared-element/player';
+export type { SlideDirection, ViewSlideMode, ViewSlideKind, ViewSlideMountPolicy, PanelRole, SlidePanelState, SlideTransforms, } from './view-slide/transforms';
+export { VIEW_SLIDE_FADE_OFFSET, VIEW_SLIDE_MS, VIEW_SLIDE_EASING, VIEW_SLIDE_COVER_MS, VIEW_SLIDE_COVER_EASING, VIEW_SLIDE_ZOOM_MS, VIEW_SLIDE_ZOOM_EASING, VIEW_SLIDE_REVEAL_MS, VIEW_SLIDE_REVEAL_EASING, slideDirectionByIndex, resolveViewSlideMode, viewSlideDurationMs, viewSlideEasing, viewSlideTransforms, } from './view-slide/transforms';
+export type { ViewSlideConfig, ViewSlide } from './view-slide/session';
+export { VIEW_SLIDE_SETTLE_SLACK_MS, createViewSlide } from './view-slide/session';
+export type { SlidingIndicator, SlidingIndicatorOptions } from './sliding-indicator/indicator';
+export { INDICATOR_MS, INDICATOR_EASING, createSlidingIndicator, } from './sliding-indicator/indicator';
+export type { ReorderAnimKind, OrderDiffByKey } from './list-reorder/classify';
+export { buildOrderDiff, classifyReorderAnim } from './list-reorder/classify';
+export type { ListReorder } from './list-reorder/reorder';
+export { LIST_REORDER_MS, LIST_REORDER_EASING, LIST_REORDER_EPSILON_PX, createListReorder, } from './list-reorder/reorder';
+export type { Fade, FadeOptions } from './fade/fade';
+export { FADE_MS, FADE_EASING, createFade } from './fade/fade';
+export type { Dock, DockConfig, DockEdge, DockHandle, DockMode, DockPanelState, DockTransforms, } from './dock/dock';
+export { DOCK_EASING, DOCK_FADE_OFFSET, DOCK_MS, createDock, dockTransforms } from './dock/dock';
+export type { Popover, PopoverPlayOptions } from './popover/popover';
+export { POPOVER_EASING, POPOVER_MS, POPOVER_ORIGIN, createPopover } from './popover/popover';
+export type { DigitSlot } from './digit-flip/slots';
+export { DIGIT_FLIP_MS, MAX_SIMULTANEOUS_DIGIT_FLIPS, buildDigitSlots, formatCounterText, scheduleDigitFlip, shouldPresencePop, } from './digit-flip/slots';
+export { DIGIT_FLIP_EASING, PRESENCE_POP_EASING, PRESENCE_POP_MS, playDigitFlip, playPresencePop, } from './digit-flip/play';
+export type { SendFlightOptions } from './send-flight/flight';
+export { SEND_FLIGHT_EASING, SEND_FLIGHT_MS, playSendFlight } from './send-flight/flight';
+export type { SwipeReveal, SwipeRevealOptions } from './swipe-reveal/swipe';
+export { SWIPE_MAX, SWIPE_THRESHOLD, SWIPE_TWEEN_MS, createSwipeReveal, rubberSwipeOffset, shouldCommitSwipe, } from './swipe-reveal/swipe';
+export type { ScrollTweenOptions } from './scroll-tween/scroll';
+export { SCROLL_TWEEN_MS, playScrollTween } from './scroll-tween/scroll';
+export type { RippleOptions } from './ripple/ripple';
+export { RIPPLE_COLOR, RIPPLE_EASING, RIPPLE_MS, RIPPLE_SIZE_PX, playRipple } from './ripple/ripple';
+export type { Point, Translate, ZoomState, PinchZoom, PinchZoomConfig } from './pinch-zoom/pinch';
+export { PINCH_MAX_SCALE, PINCH_MIN_SCALE, PINCH_WHEEL_FACTOR, boundTranslate, clampScale, createPinchZoom, maxTranslate, nextScaleFromWheel, resetZoom, zoomAtOrigin, zoomTransform, } from './pinch-zoom/pinch';
+export { decodeWaveform, fitWaveform } from './waveform/decode';
+export type { Spoiler, SpoilerOptions } from './spoiler/spoiler';
+export { SPOILER_EASING, SPOILER_MS, createSpoiler } from './spoiler/spoiler';

package/src/list-reorder/classify.d.ts

@@ -0,0 +1,10 @@
+import { Key } from '../core/types';
+export type ReorderAnimKind = "move" | "opacity" | "none";
+export type OrderDiffByKey = Map<Key, number>;
+/** orderDiff = newIndex − oldIndex for keys in curr; new keys → −Infinity. */
+export declare function buildOrderDiff(prev: Map<Key, number>, curr: Map<Key, number>): OrderDiffByKey;
+/**
+ * Majority vertical direction → move; minority / non-finite → opacity; zero → none.
+ * Adjacent swap (1 up, 1 down): up is opacity, down is move.
+ */
+export declare function classifyReorderAnim(orderDiffByKey: OrderDiffByKey, key: Key): ReorderAnimKind;

package/src/list-reorder/reorder.d.ts

@@ -0,0 +1,19 @@
+import { AttachHandle, Key } from '../core/types';
+export declare const LIST_REORDER_MS: number;
+export declare const LIST_REORDER_EASING: string;
+export declare const LIST_REORDER_EPSILON_PX: number;
+export type ListReorder<T> = {
+    register: (el: HTMLElement, key: Key) => AttachHandle;
+    sync: (items: readonly T[]) => void;
+    cancel: () => void;
+    destroy: () => void;
+};
+export declare function createListReorder<T>(options: {
+    getItemHeight: () => number;
+    getKey: (item: T, index: number) => Key;
+    isEnabled?: () => boolean;
+    isReduced?: () => boolean;
+    isSuppressed?: () => boolean;
+    durationMs?: number;
+    easing?: string;
+}): ListReorder<T>;

package/src/pinch-zoom/math.d.ts

@@ -0,0 +1,21 @@
+export declare const PINCH_MIN_SCALE: number;
+export declare const PINCH_MAX_SCALE: number;
+export declare const PINCH_WHEEL_FACTOR: number;
+export type Point = {
+    offsetX: number;
+    offsetY: number;
+};
+export type Translate = {
+    translateX: number;
+    translateY: number;
+};
+export type ZoomState = Translate & {
+    scale: number;
+};
+export declare function clampScale(scale: number, min: number, max: number): number;
+export declare function maxTranslate(scale: number, layoutW: number, layoutH: number, viewportW: number, viewportH: number): Translate;
+export declare function boundTranslate(translateX: number, translateY: number, scale: number, layoutW: number, layoutH: number, viewportW: number, viewportH: number): Translate;
+export declare function zoomAtOrigin(state: ZoomState, nextScale: number, origin: Point | null | undefined, layoutW: number, layoutH: number, viewportW: number, viewportH: number, minScale?: number, maxScale?: number): ZoomState;
+export declare function resetZoom(): ZoomState;
+export declare function zoomTransform(state: ZoomState): string;
+export declare function nextScaleFromWheel(scale: number, deltaY: number, minScale?: number, maxScale?: number): number;

package/src/pinch-zoom/pinch.d.ts

@@ -0,0 +1,15 @@
+import { Size } from '../rect/types';
+import { ZoomState } from './math';
+export type { Point, Translate, ZoomState } from './math';
+export { PINCH_MAX_SCALE, PINCH_MIN_SCALE, PINCH_WHEEL_FACTOR, boundTranslate, clampScale, maxTranslate, nextScaleFromWheel, resetZoom, zoomAtOrigin, zoomTransform, } from './math';
+export type PinchZoomConfig = {
+    getEl: () => HTMLElement | null;
+    getLayout: () => Size;
+    getViewport: () => Size;
+};
+export type PinchZoom = {
+    setState: (next: ZoomState) => ZoomState;
+    reset: () => ZoomState;
+    destroy: () => void;
+};
+export declare function createPinchZoom(config: PinchZoomConfig): PinchZoom;

package/src/popover/popover.d.ts

@@ -0,0 +1,14 @@
+import { Playback } from '../core/types';
+export declare const POPOVER_MS: number;
+export declare const POPOVER_EASING: string;
+export declare const POPOVER_ORIGIN: string;
+export type PopoverPlayOptions = {
+    origin?: string;
+    durationMs?: number;
+    easing?: string;
+};
+export type Popover = {
+    playOpen: (el: HTMLElement, options?: PopoverPlayOptions) => Playback;
+    playClose: (el: HTMLElement, options?: PopoverPlayOptions) => Playback;
+};
+export declare function createPopover(): Popover;

package/src/rect/fit.d.ts

@@ -0,0 +1,5 @@
+import { Insets, Rect, Size } from './types';
+/** Fit natural size into box without upscaling past natural (CSS contain-like). */
+export declare function fitContain(natural: Size, box: Size): Size | null;
+/** Center a fitted size inside a padded viewport. */
+export declare function centerFitInViewport(fit: Size, viewport: Size, insets: Insets): Rect;

package/src/rect/types.d.ts

@@ -0,0 +1,17 @@
+export type Rect = {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+};
+export type Size = {
+    width: number;
+    height: number;
+};
+export type Insets = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+export type ObjectFit = "cover" | "contain";

package/src/ripple/ripple.d.ts

@@ -0,0 +1,13 @@
+import { Playback } from '../core/types';
+export declare const RIPPLE_MS: number;
+export declare const RIPPLE_EASING: string;
+export declare const RIPPLE_COLOR: string;
+export declare const RIPPLE_SIZE_PX: number;
+export type RippleOptions = {
+    x: number;
+    y: number;
+    color?: string;
+    durationMs?: number;
+    easing?: string;
+};
+export declare function playRipple(host: HTMLElement, options: RippleOptions): Playback;

package/src/scroll-tween/scroll.d.ts

@@ -0,0 +1,8 @@
+import { Playback } from '../core/types';
+export declare const SCROLL_TWEEN_MS: number;
+export type ScrollTweenOptions = {
+    left?: number;
+    top?: number;
+    durationMs?: number;
+};
+export declare function playScrollTween(el: HTMLElement, options: ScrollTweenOptions): Playback;

package/src/send-flight/flight.d.ts

@@ -0,0 +1,14 @@
+import { Playback } from '../core/types';
+import { Rect } from '../rect/types';
+export declare const SEND_FLIGHT_MS: number;
+export declare const SEND_FLIGHT_EASING: string;
+export type SendFlightOptions = {
+    host: HTMLElement;
+    from: Rect;
+    to: Rect;
+    node?: HTMLElement;
+    imageUrl?: string | null;
+    durationMs?: number;
+    easing?: string;
+};
+export declare function playSendFlight(options: SendFlightOptions): Playback | null;

package/src/shared-element/math.d.ts

@@ -0,0 +1,45 @@
+import { Insets, ObjectFit, Rect, Size } from '../rect/types';
+export type Flight = {
+    to: Rect;
+    fromTranslateX: number;
+    fromTranslateY: number;
+    fromScaleX: number;
+    fromScaleY: number;
+};
+/** Expand a cover-cropped thumb so its aspect matches destination aspect. */
+export declare function uncoverByAspect(aspectWidth: number, aspectHeight: number, thumb: Rect): Rect;
+/** Center-based translate/scale so an element at `to` visually matches `from`. */
+export declare function computeFlight(from: Rect, to: Rect): Flight | null;
+/** Prefer natural size; fall back to thumb so fit is never empty. */
+export declare function resolveNaturalSize(naturalWidth: number | undefined, naturalHeight: number | undefined, thumb: Rect): Size;
+export type OpenFlightOpts = {
+    thumb: Rect;
+    naturalWidth?: number;
+    naturalHeight?: number;
+    objectFit: ObjectFit;
+    viewport: Size;
+    insets?: Insets;
+    /** Prefer live destination rect when already laid out. */
+    to?: Rect | null;
+};
+/**
+ * Open flight: (possibly uncovered) thumb → stage fit box (or explicit live `to`).
+ * Cover thumbs uncover against destination aspect so scale is uniform.
+ */
+export declare function computeOpenFlight(opts: OpenFlightOpts): Flight | null;
+export type CloseFlightOpts = {
+    fromStage: Rect;
+    thumb: Rect;
+    objectFit: ObjectFit;
+};
+/**
+ * Close flight: stage box → thumb.
+ * Cover uses Math.min(sx, sy) so the land crop matches.
+ */
+export declare function computeCloseFlight(opts: CloseFlightOpts): Flight | null;
+/** Whether rect is fully inside clip (within epsilon). */
+export declare function isRectFullyVisibleIn(rect: Rect, clip: Rect, epsilon?: number): boolean;
+/** Whether rect intersects the viewport enough to land on. */
+export declare function isRectInViewport(rect: Rect, viewport: Size, minVisiblePx?: number): boolean;
+/** Off-viewport landing: fly above or below toward the thumb's side. */
+export declare function offViewportLandingRect(from: Rect, thumb: Rect, viewportHeight: number): Rect;

package/src/shared-element/player.d.ts

@@ -0,0 +1,52 @@
+import { Playback } from '../core/types';
+import { Insets, ObjectFit, Rect, Size } from '../rect/types';
+export declare const SHARED_ELEMENT_MS: number;
+export declare const SHARED_ELEMENT_EASING: string;
+export declare const SHARED_ELEMENT_END_MS: number;
+export type SharedElementSeed = {
+    rect: Rect;
+    imageUrl?: string | null;
+    objectFit?: ObjectFit;
+    naturalWidth?: number;
+    naturalHeight?: number;
+};
+export type SharedElementPlayOptions = {
+    host: HTMLElement;
+    from: Rect;
+    to: Rect;
+    imageUrl?: string | null;
+    objectFit?: ObjectFit;
+    durationMs?: number;
+    easing?: string;
+    fadeOut?: boolean;
+    roundedStart?: boolean;
+    roundedEnd?: boolean;
+    hideTarget?: HTMLElement | null;
+    onLand?: () => void | Promise<void>;
+};
+export type SharedElementController = {
+    play: (opts: SharedElementPlayOptions) => Playback | null;
+    playOpen: (opts: {
+        host: HTMLElement;
+        seed: SharedElementSeed;
+        viewport?: Size;
+        insets?: Insets;
+        to?: Rect | null;
+        durationMs?: number;
+        hideTarget?: HTMLElement | null;
+        onLand?: () => void | Promise<void>;
+    }) => Playback | null;
+    playClose: (opts: {
+        host: HTMLElement;
+        fromStage: Rect;
+        target: SharedElementSeed | null;
+        imageUrl?: string | null;
+        fadeOut?: boolean;
+        durationMs?: number;
+        viewport?: Size;
+        hideTarget?: HTMLElement | null;
+    }) => Playback | null;
+    cancel: () => void;
+};
+export declare function createSharedElement(): SharedElementController;
+export declare function playSharedElement(opts: SharedElementPlayOptions): Playback | null;

package/src/sliding-indicator/indicator.d.ts

@@ -0,0 +1,15 @@
+export declare const INDICATOR_MS: number;
+export declare const INDICATOR_EASING: string;
+export type SlidingIndicator = {
+    measure: () => void;
+    destroy: () => void;
+};
+export type SlidingIndicatorOptions = {
+    getTrack: () => HTMLElement | null;
+    getIndicator: () => HTMLElement | null;
+    getActive: () => HTMLElement | null;
+    enabled?: () => boolean;
+    durationMs?: number;
+    easing?: string;
+};
+export declare function createSlidingIndicator(options: SlidingIndicatorOptions): SlidingIndicator;

package/src/spoiler/spoiler.d.ts

@@ -0,0 +1,14 @@
+import { Playback } from '../core/types';
+export declare const SPOILER_MS: number;
+export declare const SPOILER_EASING: string;
+export type SpoilerOptions = {
+    revealed: () => boolean;
+    durationMs?: number;
+    easing?: string;
+};
+export type Spoiler = {
+    reveal: () => Playback;
+    reset: () => Playback;
+    destroy: () => void;
+};
+export declare function createSpoiler(el: HTMLElement, options: SpoilerOptions): Spoiler;

package/src/swipe-reveal/swipe.d.ts

@@ -0,0 +1,16 @@
+export declare const SWIPE_THRESHOLD: number;
+export declare const SWIPE_MAX: number;
+export declare const SWIPE_TWEEN_MS: number;
+export declare function shouldCommitSwipe(offset: number, threshold: number): boolean;
+export declare function rubberSwipeOffset(delta: number, max: number): number;
+export type SwipeRevealOptions = {
+    axis?: "x";
+    threshold?: number;
+    max?: number;
+    durationMs?: number;
+    onCommit: () => void;
+};
+export type SwipeReveal = {
+    destroy: () => void;
+};
+export declare function createSwipeReveal(el: HTMLElement, options: SwipeRevealOptions): SwipeReveal;

package/src/view-slide/session.d.ts

@@ -0,0 +1,27 @@
+import { AttachHandle, Key } from '../core/types';
+import { PanelRole, SlideDirection, SlidePanelState, SlideTransforms, ViewSlideMode, ViewSlideMountPolicy } from './transforms';
+export { VIEW_SLIDE_COVER_EASING, VIEW_SLIDE_COVER_MS, VIEW_SLIDE_EASING, VIEW_SLIDE_MS } from './transforms';
+export declare const VIEW_SLIDE_SETTLE_SLACK_MS: number;
+export type { PanelRole, SlideDirection, SlidePanelState, SlideTransforms, ViewSlideMode, ViewSlideMountPolicy };
+export type ViewSlideConfig = {
+    getMode: () => ViewSlideMode;
+    getDirection: (from: Key, to: Key) => SlideDirection | null;
+    transforms?: (dir: SlideDirection, mode: Exclude<ViewSlideMode, "none">) => SlideTransforms;
+    durationMs?: (mode: Exclude<ViewSlideMode, "none">) => number;
+    easing?: (mode: Exclude<ViewSlideMode, "none">) => string;
+    mountPolicy?: ViewSlideMountPolicy;
+    settleSlackMs?: number;
+};
+export type ViewSlide = {
+    readonly mountedKeys: readonly Key[];
+    readonly animating: boolean;
+    readonly leavingKey: Key | undefined;
+    setActive: (key: Key | undefined) => void;
+    attach: (el: HTMLElement, key: Key) => AttachHandle;
+    isMounted: (key: Key) => boolean;
+    isVisible: (key: Key) => boolean;
+    role: (key: Key) => PanelRole;
+    cancel: () => void;
+    destroy: () => void;
+};
+export declare function createViewSlide(config: ViewSlideConfig): ViewSlide;