@ssgoi/core 5.2.1 → 6.0.0

package/dist/types.d.ts

@@ -1,504 +1,2 @@
-import { Integrator } from './animator/integrator';
-export type TransitionKey = string | symbol;
-/**
- * Double spring follower configuration
- * Allows customizing the follower spring independently
- */
-export type DoubleSpringFollowerConfig = {
-    stiffness: number;
-    damping: number;
-};
-export type SpringConfig = {
-    stiffness: number;
-    damping: number;
-    /**
-     * Enable double spring for ease-in-out effect (Chained/Lagged Spring)
-     *
-     * - true: same stiffness for both springs
-     * - number (0-1): follower stiffness ratio (smaller = stronger ease-in)
-     *   - 1.0: same as true
-     *   - 0.5: follower has half stiffness → stronger ease-in
-     *   - 0.3: even stronger ease-in
-     * - { stiffness, damping }: custom follower spring config
-     *
-     * Creates a two-spring system:
-     * - Leader spring: tracks the target directly
-     * - Follower spring: tracks the leader's position (this is the output)
-     */
-    doubleSpring?: boolean | number | DoubleSpringFollowerConfig;
-    /**
-     * Position threshold for settling detection
-     * When distance to target is below this, position is considered settled
-     * @default 0.01
-     */
-    restDelta?: number;
-    /**
-     * Velocity threshold for settling detection
-     * When speed is below this, velocity is considered settled
-     * @default 0.01
-     */
-    restSpeed?: number;
-};
-/**
- * Resistance type for inertia physics
- * - linear: resistance proportional to velocity (F = -r * v)
- * - quadratic: resistance proportional to velocity squared (F = -r * v²)
- */
-export type ResistanceType = "linear" | "quadratic";
-/**
- * Inertia configuration for ease-in effect
- * Simulates acceleration with resistance
- */
-export type InertiaConfig = {
-    /** Acceleration force (higher = faster acceleration) */
-    acceleration: number;
-    /** Resistance coefficient (higher = more resistance) */
-    resistance: number;
-    /** Resistance type (default: 'quadratic') */
-    resistanceType?: ResistanceType;
-    /**
-     * Minimum boundary value
-     * When position goes below this, spring bounce is applied
-     */
-    min?: number;
-    /**
-     * Maximum boundary value
-     * When position goes above this, spring bounce is applied
-     */
-    max?: number;
-    /**
-     * Spring stiffness for boundary bounce effect
-     * Higher value = stiffer bounce
-     * @default 500
-     */
-    bounceStiffness?: number;
-    /**
-     * Spring damping for boundary bounce effect
-     * Higher value = faster settling
-     * @default 10
-     */
-    bounceDamping?: number;
-    /**
-     * Position threshold for settling detection
-     * When distance to target is below this, position is considered settled
-     * @default 0.01
-     */
-    restDelta?: number;
-};
-/**
- * Custom integrator factory function
- * Allows using custom physics implementations
- */
-export type IntegratorFactory = () => Integrator;
-/**
- * Physics options for animations
- * Use with & to add physics options to any config type
- *
- * @example
- * type FadeOptions = { from?: number; to?: number } & PhysicsOptions;
- */
-export type PhysicsOptions = {
-    /** Spring physics (ease-out) */
-    spring?: SpringConfig;
-    /** Inertia physics (ease-in) */
-    inertia?: InertiaConfig;
-    /** Custom integrator factory */
-    integrator?: IntegratorFactory;
-};
-/**
- * CSS style object type
- */
-export type StyleObject = Record<string, number | string>;
-/**
- * Schedule strategy for multi-spring animations (user-facing)
- * - parallel: All springs start immediately (offset = 0)
- * - sequential: Each spring waits for previous to complete (offset = 1)
- * - stagger: Springs start at custom progress offsets (0-1)
- */
-export type ScheduleType = "parallel" | "sequential" | "stagger";
-/**
- * Base configuration shared by both single and multi-spring transitions
- */
-export type BaseTransitionConfig = {
-    prepare?: () => void;
-    wait?: () => Promise<void>;
-    onReady?: () => void;
-    onStart?: () => void;
-    onEnd?: () => void;
-};
-/**
- * Single spring configuration
- * Used for simple transitions with a single animation value
- *
- * Supports two animation modes:
- * - tick: RAF-based animation with callback on each frame
- * - css: Web Animation API with CSS string generation
- */
-export type SingleSpringConfig = BaseTransitionConfig & {
-    /**
-     * Physics configuration for animation
-     * Choose one: spring (ease-out), inertia (ease-in), or custom integrator
-     */
-    physics?: PhysicsOptions;
-    tick?: (progress: number) => void;
-    /**
-     * Style generator for Web Animation API mode
-     *
-     * When provided, the animation uses Web Animation API instead of RAF.
-     * Spring physics are pre-computed and converted to keyframes.
-     *
-     * @param progress - Current progress value (0 to 1)
-     * @returns Style object for Web Animation API
-     *
-     * @example
-     * ```ts
-     * css: (progress) => ({
-     *   opacity: progress,
-     *   transform: `translateY(${(1 - progress) * 20}px)`,
-     * })
-     * ```
-     */
-    css?: (progress: number) => StyleObject;
-};
-/**
- * Common fields shared by every AnimationItem variant
- */
-type AnimationItemBase = {
-    onStart?: () => void;
-    onComplete?: () => void;
-    /**
-     * Progress offset (0-1) before this spring starts
-     * - 0: Start immediately (parallel behavior)
-     * - 1: Start after previous spring completes (sequential behavior)
-     * - 0.5: Start when previous spring is 50% complete
-     *
-     * Only applies to 'stagger' schedule mode.
-     * For 'parallel' mode, all springs start at 0.
-     * For 'sequential' mode, all springs use offset 1.
-     */
-    offset?: number;
-};
-/**
- * Spring-driven animation item — physics drives a tick or css generator
- */
-export type SpringAnimationItem = AnimationItemBase & {
-    /**
-     * Physics configuration for animation
-     * Choose one: spring (ease-out), inertia (ease-in), or custom integrator
-     */
-    physics?: PhysicsOptions;
-    /**
-     * Frame callback - called on each animation frame with progress value (RAF-based)
-     *
-     * **Performance Warning:** Use WRITE-ONLY operations for best performance.
-     * Avoid reading layout properties inside tick to prevent layout thrashing.
-     *
-     * @example
-     * tick: (progress) => {
-     *   element.style.opacity = String(progress)
-     * }
-     */
-    tick?: (progress: number) => void;
-    /**
-     * Style generator for Web Animation API mode
-     *
-     * When provided, the animation uses Web Animation API instead of RAF.
-     * Spring physics are pre-computed and converted to keyframes.
-     *
-     * Two forms supported:
-     * 1. Function only - uses parent element: `css: (progress) => ({ ... })`
-     * 2. Object with element - specifies target element: `css: { element, style: (progress) => ({ ... }) }`
-     *
-     * @param progress - Current progress value (0 to 1)
-     * @returns Style object for Web Animation API
-     */
-    css?: ((progress: number) => StyleObject) | {
-        element: HTMLElement;
-        style: (progress: number) => StyleObject;
-    };
-    /** keyframes mode is mutually exclusive with physics/tick/css */
-    keyframes?: never;
-};
-/**
- * Pre-baked keyframes animation item — bypasses physics simulation
- *
- * Plays a pre-built `Keyframe[]` directly via Web Animation API. Use this when
- * you've already composed the desired motion as keyframes (e.g. multiple springs
- * baked into a single timeline) and want the animation to run entirely on the
- * compositor with zero per-frame JS.
- */
-export type KeyframesAnimationItem = AnimationItemBase & {
-    keyframes: {
-        /** Element to animate */
-        element: HTMLElement;
-        /** WAAPI keyframe array (offsets 0..1) */
-        frames: Keyframe[];
-        /** Total animation duration in ms */
-        duration: number;
-        /** WAAPI easing string (default: "linear") */
-        easing?: string;
-    };
-    /** physics/tick/css are not used in keyframes mode */
-    physics?: never;
-    tick?: never;
-    css?: never;
-};
-/**
- * Individual animation item in a multi-animation config
- *
- * Three mutually-exclusive modes:
- * - tick: RAF-based animation with callback on each frame
- * - css: Web Animation API, generated from spring physics
- * - keyframes: Web Animation API, played from pre-baked Keyframe[]
- */
-export type AnimationItem = SpringAnimationItem | KeyframesAnimationItem;
-/**
- * Multi-animation configuration
- * Used for complex transitions with multiple coordinated animations
- */
-export type MultiAnimationConfig = BaseTransitionConfig & {
-    items: AnimationItem[];
-    schedule?: ScheduleType;
-    onProgress?: (completed: number, total: number) => void;
-};
-/**
- * Transition configuration - supports both single and multi animations
- * Uses Union Type for type safety and backward compatibility
- */
-export type TransitionConfig = SingleSpringConfig | MultiAnimationConfig;
-/**
- * Type guard to check if config is single animation
- */
-export declare function isSingleAnimation(config: TransitionConfig): config is SingleSpringConfig;
-/**
- * Type guard to check if config is multi-animation
- */
-export declare function isMultiAnimation(config: TransitionConfig): config is MultiAnimationConfig;
-/**
- * Type guard to check if config uses CSS mode (Web Animation API)
- */
-export declare function isCssAnimation(config: SingleSpringConfig): config is SingleSpringConfig & {
-    css: (progress: number) => string;
-};
-/**
- * Type guard to check if config uses tick mode (RAF-based)
- */
-export declare function isTickAnimation(config: SingleSpringConfig): config is SingleSpringConfig & {
-    tick: (progress: number) => void;
-};
-/**
- * Type guard to check if an AnimationItem uses pre-baked keyframes mode
- */
-export declare function isKeyframesAnimation(item: AnimationItem): item is KeyframesAnimationItem;
-/**
- * Normalize TransitionConfig to MultiAnimationConfig
- * Converts SingleSpringConfig to MultiAnimationConfig with single animation item
- * Accepts both sync config and Promise<TransitionConfig>
- * @internal
- */
-export declare function normalizeToMultiAnimation(config: TransitionConfig | Promise<TransitionConfig>): Promise<MultiAnimationConfig>;
-export type GetTransitionConfig<TContext = undefined> = TContext extends undefined ? (node: HTMLElement) => TransitionConfig | Promise<TransitionConfig> : (node: HTMLElement, context: TContext) => TransitionConfig | Promise<TransitionConfig>;
-export type Transition<TContext = undefined> = {
-    in?: GetTransitionConfig<TContext>;
-    out?: GetTransitionConfig<TContext>;
-    key?: TransitionKey;
-};
-/**
- * Scope behavior for transitions
- * - 'global': Always run animations (default)
- * - 'local': Skip animations when mounting/unmounting with parent TransitionScope
- */
-export type TransitionScope = "global" | "local";
-export type TransitionOptions<TContext = undefined> = Transition<TContext> & {
-    key: TransitionKey;
-    /**
-     * Controls animation behavior relative to TransitionScope
-     * - 'global' (default): Always run IN/OUT animations
-     * - 'local': Skip animations when mounting/unmounting simultaneously with scope
-     */
-    scope?: TransitionScope;
-};
-export type TransitionCallback = (element: HTMLElement | null) => void | (() => void);
-/**
- * Ref callback type for 'auto' mode
- * Handles null and manages unmount automatically via MutationObserver
- */
-export type RefCallback = (element: HTMLElement | null) => void;
-/**
- * Transition mode
- * - 'manual': Returns TransitionCallback with cleanup function (default)
- * - 'auto': Returns RefCallback with automatic unmount detection via MutationObserver
- */
-export type TransitionMode = "manual" | "auto";
-/**
- * Context object passed to view transitions
- * Provides essential information for smooth page transitions
- */
-export type SggoiTransitionContext = {
-    /**
-     * The scroll position difference between 'from' and 'to' pages
-     * Used in hero and pinterest transitions to maintain natural scroll position
-     * when transitioning between pages with different scroll states
-     */
-    scrollOffset: {
-        x: number;
-        y: number;
-    };
-    /**
-     * The current page's scroll position
-     * Provides the actual scroll coordinates for precise viewport calculations
-     * OUT transition receives 'from' page scroll, IN transition receives 'to' page scroll
-     */
-    scroll: {
-        x: number;
-        y: number;
-    };
-    /**
-     * The scrollable container element (document.documentElement or custom container)
-     * Provides viewport dimensions for calculating transition animations
-     * Lazy-evaluated to handle delayed initialization
-     */
-    scrollingElement: HTMLElement;
-    /**
-     * The positioned parent element (containing block for absolute positioning)
-     * Returns the nearest ancestor with position: relative/absolute/fixed/sticky
-     * Falls back to document.body if no positioned ancestor exists
-     * Lazy-evaluated to handle delayed initialization
-     */
-    positionedParent: HTMLElement;
-};
-export type SggoiTransition = Transition<SggoiTransitionContext>;
-export type SsgoiConfig = {
-    transitions?: {
-        from: string;
-        to: string;
-        transition: SggoiTransition;
-        symmetric?: boolean;
-    }[];
-    defaultTransition?: SggoiTransition;
-    middleware?: (from: string, to: string) => {
-        from: string;
-        to: string;
-    };
-    /**
-     * Automatically preserve and restore scroll position when navigating between pages.
-     *
-     * - `false`: scroll positions are tracked only for the OUT transition diff,
-     *   then evicted — SSGOI does not restore scroll on arrival.
-     * - `true`: save scroll on leave, restore on return. New (unvisited) paths scroll to 0.
-     * - `{ exclude: string[] }`: preserve everywhere except matching paths. Excluded paths
-     *   behave like `false` (evict, no restore). Supports wildcards: `/post/*`, `*`.
-     * - `(isMobile) => value`: function returning any of the above; evaluated on each
-     *   navigation so the answer can vary by environment (e.g. mobile vs. desktop).
-     *
-     * @default (isMobile) => isMobile  // mobile preserves, desktop does not
-     */
-    preserveScroll?: PreserveScrollOption;
-};
-export type PreserveScrollValue = boolean | {
-    exclude: string[];
-};
-export type PreserveScrollFn = (isMobile: boolean) => PreserveScrollValue;
-export type PreserveScrollOption = PreserveScrollValue | PreserveScrollFn;
-/**
- * Internal options for framework adapters
- * Not exposed to end users
- * @internal
- */
-export type SsgoiInternalOptions = {
-    /**
-     * Whether OUT transition must arrive before IN transition
-     *
-     * - true (default): OUT must arrive first, IN completes the pair.
-     *   Best for frameworks with native destroy callbacks (Svelte).
-     *
-     * - false: OUT and IN can arrive in any order, both wait indefinitely.
-     *   Best for frameworks using MutationObserver for unmount detection
-     *   (React, Vue, Solid).
-     *
-     * @default true
-     */
-    outFirst?: boolean;
-};
-export type SsgoiContext = (path: string) => Transition & {
-    key: TransitionKey;
-};
-/**
- * Normalized schedule entry for internal processing
- * All schedule types are normalized to progress-based offsets (0-1)
- *
- * Progress offset determines when each spring starts relative to previous spring:
- * - 0: Start immediately (parallel)
- * - 1: Start after previous completes (sequential)
- * - 0.5: Start when previous is 50% complete
- *
- * @internal
- */
-export type NormalizedScheduleEntry = {
-    id: string;
-    /**
-     * Progress offset (0-1) relative to previous spring
-     * - 0: Start immediately with previous spring
-     * - 1: Start after previous spring completes
-     * - 0-1: Start when previous spring reaches this progress
-     */
-    offset: number;
-};
-/**
- * Normalized animation item for internal use
- * - css is always in object form: { element, style } (spring mode)
- * - keyframes pass through as-is (already normalized — element required)
- * - normalizedOffset is always present
- * @internal
- */
-export type NormalizedAnimationItem = {
-    onStart?: () => void;
-    onComplete?: () => void;
-    normalizedOffset: number;
-    physics?: PhysicsOptions;
-    tick?: (progress: number) => void;
-    css?: {
-        element: HTMLElement;
-        style: (progress: number) => StyleObject;
-    };
-    keyframes?: {
-        element: HTMLElement;
-        frames: Keyframe[];
-        duration: number;
-        easing?: string;
-    };
-};
-/**
- * Normalized multi-animation config for internal use
- * Schedule is always normalized to progress-based offsets
- * @internal
- */
-export type NormalizedMultiAnimationConfig = Omit<MultiAnimationConfig, "items" | "schedule"> & {
-    items: NormalizedAnimationItem[];
-};
-/**
- * Normalize MultiAnimationConfig schedule to progress-based offsets
- *
- * Converts user-facing schedule types to unified offset values:
- * - parallel: All items get offset 0 (start together)
- * - sequential: All items get offset 1 (wait for previous)
- * - stagger: Use each item's custom offset (0-1)
- *
- * Also normalizes css to object form: { element, style }
- *
- * @internal
- */
-export declare function normalizeSchedule(config: MultiAnimationConfig, element?: HTMLElement): NormalizedMultiAnimationConfig;
-/**
- * Animation state
- * For MultiAnimator: returns first animator's state
- * @internal
- */
-export type AnimationState = {
-    position: number;
-    velocity: number;
-    from: number;
-    to: number;
-};
-export {};
-//# sourceMappingURL=types.d.ts.map
+export * from './types/index'
+export {}

package/dist/types.js

@@ -1,80 +1,6 @@
-function h(e) {
-  return ("tick" in e || "css" in e) && !("items" in e);
-}
-function d(e) {
-  return "items" in e;
-}
-function k(e) {
-  return "css" in e && typeof e.css == "function";
-}
-function w(e) {
-  return "tick" in e && typeof e.tick == "function";
-}
-function f(e) {
-  return "keyframes" in e && e.keyframes !== void 0 && e.keyframes !== null;
-}
-async function A(e) {
-  const t = await e;
-  return d(t) ? {
-    prepare: t.prepare,
-    wait: t.wait,
-    onReady: t.onReady,
-    onStart: t.onStart,
-    onEnd: t.onEnd,
-    items: t.items,
-    schedule: t.schedule
-  } : {
-    prepare: t.prepare,
-    wait: t.wait,
-    onReady: t.onReady,
-    onStart: t.onStart,
-    onEnd: t.onEnd,
-    items: [
-      {
-        physics: t.physics,
-        tick: t.tick,
-        css: t.css
-      }
-    ],
-    schedule: "parallel"
-  };
-}
-function S(e, t) {
-  const a = e.schedule ?? "parallel", r = e.items.map(
-    (i) => {
-      let n;
-      switch (a) {
-        case "parallel":
-          n = 0;
-          break;
-        case "sequential":
-          n = 1;
-          break;
-        case "stagger":
-          n = Math.max(0, Math.min(1, i.offset ?? 0));
-          break;
-        default:
-          n = 0;
-      }
-      if (f(i)) {
-        const { offset: y, ...u } = i;
-        return { ...u, normalizedOffset: n };
-      }
-      const { css: s, offset: p, ...c } = i, l = s ? typeof s == "function" ? t ? { element: t, style: s } : void 0 : { element: s.element, style: s.style } : void 0;
-      return { ...c, css: l, normalizedOffset: n };
-    }
-  ), { schedule: m, ...o } = e;
-  return {
-    ...o,
-    items: r
-  };
+function e(n) {
+  return n;
 }
 export {
-  k as isCssAnimation,
-  f as isKeyframesAnimation,
-  d as isMultiAnimation,
-  h as isSingleAnimation,
-  w as isTickAnimation,
-  S as normalizeSchedule,
-  A as normalizeToMultiAnimation
+  e as defineTransition
 };

package/dist/utils/get-scrolling-element.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-scrolling-element.d.ts","sourceRoot":"","sources":["../../src/lib/utils/get-scrolling-element.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,WAAW,KAAG,WAyB1D,CAAC"}
+{"version":3,"file":"get-scrolling-element.d.ts","sourceRoot":"","sources":["../../src/lib/utils/get-scrolling-element.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,WAAW,KAAG,WAkB1D,CAAC"}

package/dist/utils/get-viewport-rect.d.ts

@@ -0,0 +1,17 @@
+import { SsgoiTransitionContext } from '../types/index.ts';
+/**
+ * Viewport-aligned slice of the scrolling container, anchored at the
+ * chosen side's scroll position. Used by page transitions
+ * (sheet/jaemin/film) to size the visible page area.
+ *
+ * When scrolling === positioned, no offset is subtracted — that container
+ * IS the viewport and its body-relative top is not an inset. Otherwise
+ * the positioned parent's offset within scrolling is subtracted.
+ */
+export declare function getViewportRect(context: SsgoiTransitionContext, side: "from" | "to"): {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+};
+//# sourceMappingURL=get-viewport-rect.d.ts.map

package/dist/utils/get-viewport-rect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-viewport-rect.d.ts","sourceRoot":"","sources":["../../src/lib/utils/get-viewport-rect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,QAAQ,CAAC;AAGrD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,sBAAsB,EAC/B,IAAI,EAAE,MAAM,GAAG,IAAI;;;;;EAcpB"}

package/dist/utils/index.d.ts

@@ -3,7 +3,9 @@ export { getScrollingElement } from './get-scrolling-element';
 export { getPositionedParent } from './get-positioned-parent';
 export { sleep } from './sleep';
 export { getRect } from './get-rect';
+export { getViewportRect } from './get-viewport-rect';
 export { round, floor, ceil, toFixed } from './number';
 export { withResolvers } from './with-resolvers';
 export { waitPaint } from './wait-paint';
+export { promiseAll, type AwaitedObject } from './promise-all';
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC"}

package/dist/utils/prepare-outgoing.d.ts

@@ -1,7 +1,7 @@
-import { SggoiTransitionContext } from '../types';
+import { SsgoiTransitionContext } from '../types/index.ts';
 /**
  * Applies common styles for outgoing page elements
  * Makes the element absolute positioned to allow the incoming page to take its place
  */
-export declare const prepareOutgoing: (element: HTMLElement, context?: SggoiTransitionContext) => void;
+export declare const prepareOutgoing: (element: HTMLElement, context?: Pick<SsgoiTransitionContext, "scrollOffset">) => void;
 //# sourceMappingURL=prepare-outgoing.d.ts.map

package/dist/utils/prepare-outgoing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prepare-outgoing.d.ts","sourceRoot":"","sources":["../../src/lib/utils/prepare-outgoing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,WAAW,EACpB,UAAU,sBAAsB,KAC/B,IAKF,CAAC"}
+{"version":3,"file":"prepare-outgoing.d.ts","sourceRoot":"","sources":["../../src/lib/utils/prepare-outgoing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,QAAQ,CAAC;AAErD;;;GAGG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,WAAW,EACpB,UAAU,IAAI,CAAC,sBAAsB,EAAE,cAAc,CAAC,KACrD,IAKF,CAAC"}

package/dist/utils/promise-all.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Resolve every value in an object that may be a Promise. Returns a Promise
+ * of the same shape with each value awaited.
+ *
+ * @example
+ * promiseAll({ from: fromPromise, to: toPromise, count: 7 })
+ *   .then(({ from, to, count }) => …)
+ *
+ * Useful inside transition presets that need both `from` and `to` resolved
+ * before they can compute layout-derived state.
+ */
+type Awaited<T> = T extends Promise<infer U> ? U : T;
+export type AwaitedObject<T> = {
+    [K in keyof T]: Awaited<T[K]>;
+};
+export declare function promiseAll<T extends Record<string, unknown>>(obj: T): Promise<AwaitedObject<T>>;
+export {};
+//# sourceMappingURL=promise-all.d.ts.map

package/dist/utils/promise-all.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-all.d.ts","sourceRoot":"","sources":["../../src/lib/utils/promise-all.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACrD,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAEjE,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1D,GAAG,EAAE,CAAC,GACL,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAS3B"}