@react-motion-router/stack 2.0.0-beta.eb7bb7e → 2.0.0-beta.sha-c42ac88

package/build/Anchor.d.ts

@@ -0,0 +1,19 @@
+import { PlainObject } from "@react-motion-router/core";
+import { Navigation } from "./Navigation";
+import { NavigateOptions, XOR } from "./common/types";
+interface BaseAnchorProps extends React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement> {
+    onClick?: React.MouseEventHandler<HTMLAnchorElement>;
+    navigation?: Navigation;
+}
+interface ForwardAnchorProps extends BaseAnchorProps {
+    params?: PlainObject<string | boolean | number>;
+    href: string;
+    type?: NavigateOptions["type"];
+    preload?: boolean;
+}
+interface BackAnchorProps extends BaseAnchorProps {
+    goBack: boolean;
+}
+type AnchorProps = XOR<ForwardAnchorProps, BackAnchorProps>;
+export declare function Anchor(props: AnchorProps): JSX.Element;
+export {};

package/build/GestureRegion.d.ts

@@ -0,0 +1,5 @@
+interface GestureRegionProps extends React.HTMLAttributes<HTMLDivElement> {
+    disabled?: boolean;
+}
+export declare function GestureRegion({ disabled, children, ...props }: GestureRegionProps): JSX.Element;
+export {};

package/build/HistoryEntry.d.ts

@@ -0,0 +1,19 @@
+export declare class HistoryEntry implements Omit<NavigationHistoryEntry, 'url'> {
+    #private;
+    readonly routerId: string;
+    readonly index: number;
+    constructor(nativeEntry: NavigationHistoryEntry, routerId: string, index: number);
+    set ondispose(handler: ((this: NavigationHistoryEntry, ev: Event) => any) | null);
+    get ondispose(): ((this: NavigationHistoryEntry, ev: Event) => any) | null;
+    get id(): string;
+    get globalIndex(): number;
+    get url(): URL | null;
+    get key(): string;
+    get sameDocument(): boolean;
+    addEventListener<K extends keyof NavigationHistoryEntryEventMap>(type: K, listener: (this: NavigationHistoryEntry, ev: NavigationHistoryEntryEventMap[K]) => any, options?: boolean | AddEventListenerOptions): () => void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): () => void;
+    removeEventListener<K extends keyof NavigationHistoryEntryEventMap>(type: K, listener: (this: NavigationHistoryEntry, ev: NavigationHistoryEntryEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    dispatchEvent(event: Event): boolean;
+    getState<T>(): T;
+}

package/build/Navigation.d.ts

@@ -0,0 +1,31 @@
+import { NavigationBase } from '@react-motion-router/core';
+import { GoBackOptions, GoForwardOptions, NavigateOptions, NavigationBaseOptions, NavigationProps, StackRouterEventMap } from './common/types';
+import { HistoryEntry } from './HistoryEntry';
+import { Router } from './Router';
+export declare class Navigation extends NavigationBase<StackRouterEventMap> {
+    protected readonly router: Router;
+    constructor(router: Router);
+    traverseTo(key: string): NavigationResult;
+    replace(route: string, props?: NavigationProps, options?: NavigationBaseOptions): NavigationResult;
+    push(route: string, props?: NavigationProps, options?: NavigationBaseOptions): NavigationResult;
+    reload(props?: NavigationProps): NavigationResult;
+    navigate(route: string, props?: NavigationProps, options?: NavigateOptions): NavigationResult;
+    goBack(options?: GoBackOptions): NavigationResult | undefined;
+    goForward(options?: GoForwardOptions): NavigationResult | undefined;
+    private createBackEvent;
+    private createForwardEvent;
+    private createNavigateEvent;
+    get transition(): NavigationTransition | {
+        from: NavigationHistoryEntry | null;
+        finished: Promise<void>;
+        navigationType: "load";
+    } | null;
+    get globalEntries(): NavigationHistoryEntry[];
+    get entries(): HistoryEntry[];
+    get index(): number;
+    get previous(): HistoryEntry | null;
+    get next(): HistoryEntry | null;
+    get current(): HistoryEntry;
+    get canGoBack(): boolean;
+    get canGoForward(): boolean;
+}

package/build/Router.d.ts

@@ -0,0 +1,58 @@
+import { RouterBase } from '@react-motion-router/core';
+import type { LoadEvent, NestedRouterContext, RouterBaseProps, RouterBaseState, ScreenChild } from '@react-motion-router/core';
+import { Navigation } from './Navigation';
+import { ScreenProps, Screen } from './Screen';
+import { SwipeDirection } from './common/types';
+export interface RouterProps extends RouterBaseProps<Screen> {
+    config: RouterBaseProps["config"] & {
+        screenConfig?: ScreenProps["config"];
+        disableBrowserRouting?: boolean;
+        initialPath?: string;
+        shouldIntercept?(navigateEvent: NavigateEvent): boolean;
+        onIntercept?(navigateEvent: NavigateEvent): boolean;
+    };
+}
+export interface RouterState extends RouterBaseState {
+    backNavigating: boolean;
+    transition: NavigationTransition | LoadEvent["transition"] | null;
+    screenStack: ScreenChild<Screen>[];
+    gestureDirection: SwipeDirection;
+    gestureAreaWidth: number;
+    gestureMinFlingVelocity: number;
+    gestureHysteresis: number;
+    disableGesture: boolean;
+    fromKey: React.Key | null;
+    destinationKey: React.Key | null;
+    documentTitle?: string;
+}
+export declare class Router extends RouterBase<RouterProps, RouterState> {
+    readonly navigation: Navigation;
+    constructor(props: RouterProps, context: React.ContextType<typeof NestedRouterContext>);
+    static readonly defaultProps: Partial<RouterProps>;
+    static getDerivedStateFromProps(_: RouterProps, state: RouterState): {
+        gestureDirection: SwipeDirection;
+        gestureAreaWidth: number;
+        gestureMinFlingVelocity: number;
+        gestureHysteresis: number;
+        disableGesture: boolean;
+        documentTitle: string | undefined;
+    };
+    componentDidMount(): void;
+    shouldComponentUpdate(nextProps: Readonly<RouterProps>, nextState: Readonly<RouterState>): boolean;
+    componentWillUnmount(): void;
+    private canGestureNavigate;
+    private onSwipeStart;
+    private onSwipeEnd;
+    protected get screens(): import("react").CElement<ScreenProps, Screen>[];
+    private screenChildFromPathname;
+    private getScreenChildByPathname;
+    private getScreenRefByKey;
+    protected canIntercept(e: NavigateEvent): boolean;
+    protected shouldIntercept(e: NavigateEvent): boolean;
+    protected intercept(e: NavigateEvent | LoadEvent): void;
+    private handleLoad;
+    private handleReplace;
+    private handleDefault;
+    private dispatchLifecycleHandlers;
+    private screenTransition;
+}

package/build/Screen.d.ts

@@ -0,0 +1,94 @@
+import { ScreenBase } from '@react-motion-router/core';
+import type { PlainObject, RouterContext, ScreenBaseProps, ScreenBaseState, ScreenBaseComponentProps } from '@react-motion-router/core';
+import { Navigation } from './Navigation';
+import { RouteProp, SwipeDirection } from './common/types';
+import { Router } from './Router';
+export interface ScreenComponentProps<T extends PlainObject = {}> extends ScreenBaseComponentProps<RouteProp<T>, Navigation> {
+}
+export interface ScreenProps extends ScreenBaseProps {
+    config?: ScreenBaseProps["config"] & {
+        title?: string;
+        presentation?: "default" | "dialog" | "modal";
+        keepAlive?: boolean;
+        gestureDirection?: SwipeDirection;
+        gestureAreaWidth?: number;
+        gestureMinFlingVelocity?: number;
+        gestureHysteresis?: number;
+        disableGesture?: boolean;
+    };
+}
+export interface ScreenState extends ScreenBaseState {
+}
+export declare class Screen extends ScreenBase<ScreenProps, ScreenState> {
+    readonly routeProp: {
+        setParams: (params: PlainObject) => void;
+        setConfig: (config: ScreenProps["config"]) => void;
+        readonly path: string;
+        readonly resolvedPathname: string | undefined;
+        readonly focused: boolean;
+        readonly config: {
+            header?: {
+                fallback?: React.ReactNode;
+                component: React.JSXElementConstructor<any> | import("@react-motion-router/core").LazyExoticComponent<any>;
+            };
+            footer?: {
+                fallback?: React.ReactNode;
+                component: React.JSXElementConstructor<any> | import("@react-motion-router/core").LazyExoticComponent<any>;
+            };
+            animation?: import("@react-motion-router/core").AnimationEffectFactory;
+            onEnter?: ((props: import("@react-motion-router/core").LifecycleProps<import("@react-motion-router/core").RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+            onExit?: ((props: import("@react-motion-router/core").LifecycleProps<import("@react-motion-router/core").RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+            onEntered?: ((props: import("@react-motion-router/core").LifecycleProps<import("@react-motion-router/core").RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+            onExited?: ((props: import("@react-motion-router/core").LifecycleProps<import("@react-motion-router/core").RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+            onLoad?: ((props: import("@react-motion-router/core").LifecycleProps<import("@react-motion-router/core").RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+            title?: string;
+            presentation?: "default" | "dialog" | "modal";
+            keepAlive?: boolean;
+            gestureDirection?: SwipeDirection;
+            gestureAreaWidth?: number;
+            gestureMinFlingVelocity?: number;
+            gestureHysteresis?: number;
+            disableGesture?: boolean;
+        };
+        readonly params: {
+            [x: string]: any;
+        };
+    };
+    constructor(props: ScreenProps, context: React.ContextType<typeof RouterContext>);
+    static getDerivedStateFromProps(props: ScreenProps): {
+        elementType: string;
+    };
+    get config(): {
+        header?: {
+            fallback?: React.ReactNode;
+            component: React.JSXElementConstructor<any> | import("@react-motion-router/core").LazyExoticComponent<any>;
+        };
+        footer?: {
+            fallback?: React.ReactNode;
+            component: React.JSXElementConstructor<any> | import("@react-motion-router/core").LazyExoticComponent<any>;
+        };
+        animation?: import("@react-motion-router/core").AnimationEffectFactory;
+        onEnter?: ((props: import("@react-motion-router/core").LifecycleProps<import("@react-motion-router/core").RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+        onExit?: ((props: import("@react-motion-router/core").LifecycleProps<import("@react-motion-router/core").RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+        onEntered?: ((props: import("@react-motion-router/core").LifecycleProps<import("@react-motion-router/core").RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+        onExited?: ((props: import("@react-motion-router/core").LifecycleProps<import("@react-motion-router/core").RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+        onLoad?: ((props: import("@react-motion-router/core").LifecycleProps<import("@react-motion-router/core").RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+        title?: string;
+        presentation?: "default" | "dialog" | "modal";
+        keepAlive?: boolean;
+        gestureDirection?: SwipeDirection;
+        gestureAreaWidth?: number;
+        gestureMinFlingVelocity?: number;
+        gestureHysteresis?: number;
+        disableGesture?: boolean;
+    };
+    get params(): {
+        [x: string]: any;
+    };
+    protected setParams(params: PlainObject): void;
+    protected setConfig(config: ScreenProps["config"]): void;
+    protected get router(): Router;
+    private onClickOutside;
+    onEnter(signal: AbortSignal): Promise<void>;
+    onExited(signal: AbortSignal): Promise<void>;
+}

package/build/animation-configs/animation-presets.d.ts

@@ -0,0 +1,9 @@
+import { AnimationEffectFactoryProps } from "@react-motion-router/core";
+export declare function iOSSlideInFromRight({ ref, direction, playbackRate, index }: AnimationEffectFactoryProps): KeyframeEffect;
+export declare function iOSSlideInFromLeft({ ref, direction, playbackRate, index }: AnimationEffectFactoryProps): KeyframeEffect;
+export declare function iOSSlideInFromBottom({ ref, direction, playbackRate }: AnimationEffectFactoryProps): KeyframeEffect;
+export declare function androidFadeInFromBottom({ ref, direction, playbackRate }: AnimationEffectFactoryProps): KeyframeEffect;
+export declare function androidFadeInFromBottomSheet({ ref, direction, index, playbackRate }: AnimationEffectFactoryProps): KeyframeEffect;
+export declare function androidRevealFromBottom({ ref, direction, index, playbackRate }: AnimationEffectFactoryProps): KeyframeEffect;
+export declare function androidFadeInFromRight({ ref, direction, index, playbackRate }: AnimationEffectFactoryProps): KeyframeEffect;
+export declare function androidScaleFromCentre({ ref, direction, index, playbackRate }: AnimationEffectFactoryProps): KeyframeEffect;

package/build/animation-configs/keyframe-options-presets.d.ts

@@ -0,0 +1,7 @@
+export declare const iOSKeyframeOptions: KeyframeEffectOptions;
+export declare const androidFadeInFromBottomOptions: KeyframeAnimationOptions;
+export declare const androidFadeOutToBottomOptions: KeyframeAnimationOptions;
+export declare const androidRevealFromBottomOptions: KeyframeAnimationOptions;
+export declare const androidScaleFromCentreOptions: KeyframeAnimationOptions;
+export declare const androidBottomSheetSlideInOptions: KeyframeAnimationOptions;
+export declare const androidBottomSheetSlideOutOptions: KeyframeAnimationOptions;

package/build/animation-configs/keyframe-presets.d.ts

@@ -0,0 +1,25 @@
+export declare const SlideInFromRightKeyframes: Keyframe[];
+export declare const iOSSlideInFromRightKeyframes: Keyframe[];
+export declare const SlideOutToLeftKeyframes: Keyframe[];
+export declare const iOSSlideOutToLeftKeyframes: Keyframe[];
+export declare const SlideInFromLeftKeyframes: Keyframe[];
+export declare const iOSSlideInFromLeftKeyframes: Keyframe[];
+export declare const SlideOutToRightKeyframes: Keyframe[];
+export declare const iOSSlideOutToRightKeyframes: Keyframe[];
+export declare const SlideInFromBottomKeyframes: Keyframe[];
+export declare const iOSSlideInFromBottomKeyframes: Keyframe[];
+export declare const SlideOutToTopKeyframes: Keyframe[];
+export declare const SlideInFromTopKeyframes: Keyframe[];
+export declare const SlideOutToBottomKeyframes: Keyframe[];
+export declare const ZoomInKeyframes: Keyframe[];
+export declare const ZoomOutKeyframes: Keyframe[];
+export declare const FadeInKeyframes: Keyframe[];
+export declare const FadeOutKeyframes: Keyframe[];
+export declare const androidFadeInFromBottomKeyframes: Keyframe[];
+export declare const androidFadeInFromRightKeyframes: Keyframe[];
+export declare const androidFadeOutToLeftKeyframes: Keyframe[];
+export declare const androidRevealFromBottomKeyframes: Keyframe[];
+export declare const androidConcealToBottomKeyframes: Keyframe[];
+export declare const androidScaleFromCentreKeyframes: Keyframe[];
+export declare const androidScaleToCentreKeyframes: Keyframe[];
+export declare const androidFadeInFromBottomSheetKeyframes: Keyframe[];

package/build/common/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_GESTURE_CONFIG: {
+    readonly gestureHysteresis: 0.5;
+    readonly gestureMinFlingVelocity: 400;
+    readonly gestureAreaWidth: 100;
+    readonly gestureDirection: "right";
+    readonly disableGesture: false;
+};

package/build/common/events.d.ts

@@ -0,0 +1,37 @@
+import { GestureEvent } from "web-gesture-events";
+import { NavigateOptions, NavigationProps } from "./types";
+export declare class NavigateEvent extends Event {
+    readonly routerId: string;
+    readonly route: string;
+    readonly props: NavigationProps;
+    readonly navigationType: NonNullable<NavigateOptions["type"]>;
+    readonly signal: AbortSignal;
+    readonly result: NavigationResult;
+    readonly transition: NavigationTransition;
+    constructor(routerId: string, route: string, props: NavigationProps, type: NavigateOptions["type"], signal: AbortSignal, result: NavigationResult, transition: NavigationTransition);
+}
+export declare class BackEvent extends Event {
+    readonly routerId: string;
+    readonly signal: AbortSignal;
+    readonly result: NavigationResult;
+    readonly transition: NavigationTransition;
+    constructor(routerId: string, signal: AbortSignal, result: NavigationResult, transition: NavigationTransition);
+}
+export declare class ForwardEvent extends Event {
+    readonly routerId: string;
+    readonly signal: AbortSignal;
+    readonly result: NavigationResult;
+    readonly transition: NavigationTransition;
+    constructor(routerId: string, signal: AbortSignal, result: NavigationResult, transition: NavigationTransition);
+}
+export declare class GestureStartEvent extends Event {
+    readonly source: GestureEvent;
+    constructor(source: GestureEvent);
+}
+export declare class GestureEndEvent extends Event {
+    readonly source: GestureEvent;
+    constructor(source: GestureEvent);
+}
+export declare class GestureCancelEvent extends Event {
+    constructor();
+}

package/build/common/hooks.d.ts

@@ -0,0 +1,6 @@
+import { Navigation } from "../Navigation";
+import { Router } from "../Router";
+import { RouteProp } from "./types";
+export declare function useNavigation(): Navigation;
+export declare function useRouter(): Router;
+export declare function useRoute(): RouteProp<{}>;

package/build/common/types.d.ts

@@ -0,0 +1,40 @@
+import { PlainObject, RoutePropBase, RouterBaseEventMap } from "@react-motion-router/core";
+import { ScreenProps } from "../Screen";
+import { RefObject } from "react";
+import { BackEvent, ForwardEvent, GestureCancelEvent, GestureEndEvent, GestureStartEvent, NavigateEvent } from "./events";
+export interface NavigationBaseOptions {
+    signal?: AbortSignal;
+}
+export interface NavigateOptions extends NavigationBaseOptions {
+    type?: "push" | "replace";
+}
+export interface GoBackOptions extends NavigationBaseOptions {
+}
+export interface GoForwardOptions extends NavigationBaseOptions {
+}
+export interface NavigationProps {
+    params?: Record<any, any>;
+    config?: ScreenProps["config"];
+}
+export type Without<T, U> = {
+    [P in Exclude<keyof T, keyof U>]?: never;
+};
+export type XOR<T, U> = (T | U) extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;
+export interface HistoryEntryState {
+    config?: ScreenProps["config"];
+    params?: PlainObject;
+}
+export declare function isRefObject<T>(value?: React.LegacyRef<T>): value is RefObject<T>;
+export interface StackRouterEventMap extends RouterBaseEventMap {
+    "navigate": NavigateEvent;
+    "back": BackEvent;
+    "forward": ForwardEvent;
+    "gesture-start": GestureStartEvent;
+    "gesture-end": GestureEndEvent;
+    "gesture-cancel": GestureCancelEvent;
+}
+export interface RouteProp<T extends PlainObject = {}> extends RoutePropBase<ScreenProps["config"], T> {
+}
+export type SwipeDirection = 'up' | 'down' | 'left' | 'right' | 'horizontal' | 'vertical';
+export declare function isVerticalDirection(direction: SwipeDirection): direction is 'up' | 'down' | 'vertical';
+export declare function isHorizontalDirection(direction: SwipeDirection): direction is 'left' | 'right' | 'horizontal';

package/build/common/utils.d.ts

@@ -0,0 +1,7 @@
+import { PlainObject } from "@react-motion-router/core";
+export declare function searchParamsToObject(searchPart: string): PlainObject<string> | undefined;
+export declare function searchParamsFromObject(params: {
+    [key: string]: any;
+}): string;
+export declare function isRollback(info?: unknown): boolean;
+export declare function deepEquals<T>(obj1: T, obj2: T): boolean;

package/build/index.d.ts

@@ -0,0 +1,10 @@
+import 'web-gesture-events';
+export * from './Navigation';
+export * from './Screen';
+export * from './Router';
+export * from './Anchor';
+export * from './animation-configs/keyframe-presets';
+export * from './animation-configs/keyframe-options-presets';
+export * from './animation-configs/animation-presets';
+export * from './common/hooks';
+export * from './GestureRegion';