@react-motion-router/core 2.0.0-beta.sha-112968d → 2.0.0-beta.sha-c19f37e

package/build/Anchor.d.ts

@@ -1,21 +1,13 @@
-import { default as React } from 'react';
-interface AnchorProps extends React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement> {
-    href?: string;
-    rel?: string;
-    historyEntryKey?: string;
-    navigateInfo?: unknown;
-    navigateState?: unknown;
-    reload?: boolean;
-    replace?: boolean;
-    traverse?: boolean;
-    children?: React.ReactNode;
-}
+import { default as React, RefObject } from 'react';
 type AnchorState = {
     href?: string | null;
 };
-export declare class Anchor extends React.Component<AnchorProps, AnchorState> {
-    constructor(props: AnchorProps);
-    private readonly anchorRef;
+interface AnchorBaseProps extends Omit<AnchorProps, 'ref'> {
+    ref?: RefObject<AnchorBase | null>;
+}
+export declare class AnchorBase extends React.Component<AnchorBaseProps, AnchorState> {
+    constructor(props: AnchorBaseProps);
+    readonly anchorRef: React.RefObject<HTMLAnchorElement | null>;
     private static directionFromRel;
     private static findClosestEntryByHref;
     private static findClosestEntry;
@@ -23,7 +15,21 @@ export declare class Anchor extends React.Component<AnchorProps, AnchorState> {
     componentWillUnmount(): void;
     private readonly onNavigate;
     private get href();
+    private get search();
     private readonly handleClick;
     render(): import("react/jsx-runtime").JSX.Element;
 }
+export interface AnchorProps extends React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement> {
+    href?: string;
+    rel?: 'next' | 'prev' | (string & {});
+    historyEntryKey?: string;
+    navigateInfo?: unknown;
+    navigateState?: unknown;
+    reload?: boolean;
+    replace?: boolean;
+    traverse?: boolean;
+    children?: React.ReactNode;
+    search?: string;
+}
+export declare function Anchor({ ref: forwardedRef, ...props }: AnchorProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/build/NavigationBase.d.ts

@@ -1,10 +1,10 @@
-import { RouterHTMLElement, RouterBaseEventMap } from './common/types';
+import { RouterBaseHTMLElement } from './common/types';
 import { MetaData } from './MetaData';
-export interface NavigationBaseConfig<E extends RouterBaseEventMap = RouterBaseEventMap> {
-    addEventListener<K extends keyof E>(type: K, listener: (this: RouterHTMLElement<E>, ev: E[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
+export interface NavigationBaseConfig {
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: RouterBaseHTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): () => void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): () => void;
-    removeEventListener<K extends keyof E>(type: K, listener: (this: RouterHTMLElement<E>, ev: E[K]) => void, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: RouterBaseHTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | EventListenerOptions | undefined): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     dispatchEvent(event: Event): Promise<boolean>;
@@ -14,25 +14,26 @@ export interface NavigationBaseConfig<E extends RouterBaseEventMap = RouterBaseE
     baseURLPattern: URLPattern;
     getNavigatorById(routerId: string): NavigationBase | null;
 }
-export declare abstract class NavigationBase<E extends RouterBaseEventMap = RouterBaseEventMap> {
+export declare abstract class NavigationBase {
     private static rootNavigatorRef;
     readonly metaData: MetaData;
     readonly addEventListener: {
-        <K extends keyof E>(type: K, listener: (this: RouterHTMLElement<E>, ev: E[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
+        <K extends keyof HTMLElementEventMap>(type: K, listener: (this: RouterBaseHTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
         (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): () => void;
         (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): () => void;
     };
     readonly removeEventListener: {
-        <K extends keyof E>(type: K, listener: (this: RouterHTMLElement<E>, ev: E[K]) => void, options?: boolean | EventListenerOptions | undefined): void;
+        <K extends keyof HTMLElementEventMap>(type: K, listener: (this: RouterBaseHTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | EventListenerOptions | undefined): void;
         (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
         (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     };
     readonly dispatchEvent: (event: Event) => Promise<boolean>;
-    readonly parent: NavigationBase<RouterBaseEventMap> | null;
+    readonly parent: NavigationBase | null;
     readonly routerId: string;
     readonly baseURL: URL;
     readonly baseURLPattern: URLPattern;
     readonly getNavigatorById: (routerId: string) => NavigationBase | null;
-    constructor(config: NavigationBaseConfig<E>);
+    constructor(config: NavigationBaseConfig);
+    protected preload(route: string, state?: unknown): NavigationResult;
     private get isInDocument();
 }

package/build/RouterBase.d.ts

@@ -1,6 +1,6 @@
 import { NavigationBase } from './NavigationBase';
 import { ScreenTransitionLayer } from './ScreenTransitionLayer';
-import { ScreenChild, RouterBaseEventMap, RouterHTMLElement } from './common/types';
+import { ScreenChild, RouterBaseHTMLElement, EventHandler } from './common/types';
 import { NestedRouterContext } from './RouterContext';
 import { Component } from 'react';
 import { ScreenBase, ScreenBaseConfig } from './ScreenBase';
@@ -15,9 +15,9 @@ export interface RouterBaseProps<S extends ScreenBase = ScreenBase> {
     children: ScreenChild<S> | ScreenChild<S>[];
 }
 export type RouterBaseState = object;
-export declare abstract class RouterBase<P extends RouterBaseProps = RouterBaseProps, S extends RouterBaseState = RouterBaseState, E extends RouterBaseEventMap = RouterBaseEventMap> extends Component<P, S> {
+export declare abstract class RouterBase<P extends RouterBaseProps = RouterBaseProps, S extends RouterBaseState = RouterBaseState> extends Component<P, S> implements EventHandler {
     #private;
-    protected readonly ref: import('react').RefObject<RouterHTMLElement<E> | null>;
+    protected readonly ref: import('react').RefObject<RouterBaseHTMLElement | null>;
     protected screenTransitionLayer: import('react').RefObject<ScreenTransitionLayer | null>;
     abstract readonly navigation: NavigationBase;
     readonly parent: RouterBase | null;
@@ -31,15 +31,17 @@ export declare abstract class RouterBase<P extends RouterBaseProps = RouterBaseP
     } | null>;
     context: React.ContextType<typeof NestedRouterContext>;
     constructor(props: P, context: React.ContextType<typeof NestedRouterContext>);
+    private static get events();
     componentDidMount(): void;
     componentWillUnmount(): void;
-    private handleNavigationDispatch;
+    onnavigate(e: NavigateEvent): void;
     getRouterById(routerId: string, target?: RouterBase): RouterBase | null;
     dispatchEvent(event: Event): Promise<boolean>;
-    addEventListener<K extends keyof E>(type: K, listener: (this: RouterHTMLElement<E>, ev: E[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: RouterBaseHTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): () => void;
-    removeEventListener<K extends keyof E>(type: K, listener: (this: RouterHTMLElement<E>, ev: E[K]) => void, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: RouterBaseHTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | EventListenerOptions | undefined): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    handleEvent(e: Event): void;
     protected screenChildFromPathname(pathname: string): {
         child: ScreenChild<ScreenType<P["children"]>>;
         matchInfo: import('./common/types').MatchedRoute;

package/build/RouterContext.d.ts

@@ -4,4 +4,4 @@ export declare const NestedRouterContext: import('react').Context<{
     parentRouter: RouterBase;
     parentScreen: ScreenBase;
 } | null>;
-export declare const RouterContext: import('react').Context<RouterBase<import('./RouterBase').RouterBaseProps<ScreenBase<import('./ScreenBase').ScreenBaseProps, import('./ScreenBase').ScreenBaseState<import('./ScreenBase').ScreenBaseConfig<import('.').RoutePropBase<{}, import('.').PlainObject<any>>, import('./NavigationBase').NavigationBase<import('.').RouterBaseEventMap>> | undefined, import('.').PlainObject>, import('.').RoutePropBase<import('./ScreenBase').ScreenBaseConfig<import('.').RoutePropBase<{}, import('.').PlainObject<any>>, import('./NavigationBase').NavigationBase<import('.').RouterBaseEventMap>> | undefined, import('.').PlainObject<any>>>>, object, import('.').RouterBaseEventMap>>;
+export declare const RouterContext: import('react').Context<RouterBase<import('./RouterBase').RouterBaseProps<ScreenBase<import('./ScreenBase').ScreenBaseProps, import('./ScreenBase').ScreenBaseState<import('./ScreenBase').ScreenBaseConfig<import('.').RoutePropBase<{}, import('.').PlainObject<any>>, import('./NavigationBase').NavigationBase> | undefined, import('.').PlainObject>, import('.').RoutePropBase<import('./ScreenBase').ScreenBaseConfig<import('.').RoutePropBase<{}, import('.').PlainObject<any>>, import('./NavigationBase').NavigationBase> | undefined, import('.').PlainObject<any>>>>, object>>;

package/build/ScreenBase.d.ts

@@ -54,9 +54,9 @@ export declare abstract class ScreenBase<P extends ScreenBaseProps = ScreenBaseP
     protected readonly ref: import('react').RefObject<HTMLDivElement | null>;
     protected readonly nestedRouterData: {
         parentScreen: ScreenBase;
-        parentRouter: import('./RouterBase').RouterBase<import('./RouterBase').RouterBaseProps<ScreenBase<ScreenBaseProps, ScreenBaseState<ScreenBaseConfig<RoutePropBase<{}, PlainObject<any>>, NavigationBase<import('./common/types').RouterBaseEventMap>> | undefined, PlainObject>, RoutePropBase<ScreenBaseConfig<RoutePropBase<{}, PlainObject<any>>, NavigationBase<import('./common/types').RouterBaseEventMap>> | undefined, PlainObject<any>>>>, object, import('./common/types').RouterBaseEventMap>;
+        parentRouter: import('./RouterBase').RouterBase<import('./RouterBase').RouterBaseProps<ScreenBase<ScreenBaseProps, ScreenBaseState<ScreenBaseConfig<RoutePropBase<{}, PlainObject<any>>, NavigationBase> | undefined, PlainObject>, RoutePropBase<ScreenBaseConfig<RoutePropBase<{}, PlainObject<any>>, NavigationBase> | undefined, PlainObject<any>>>>, object>;
     };
-    static readonly contextType: import('react').Context<import('./RouterBase').RouterBase<import('./RouterBase').RouterBaseProps<ScreenBase<ScreenBaseProps, ScreenBaseState<ScreenBaseConfig<RoutePropBase<{}, PlainObject<any>>, NavigationBase<import('./common/types').RouterBaseEventMap>> | undefined, PlainObject>, RoutePropBase<ScreenBaseConfig<RoutePropBase<{}, PlainObject<any>>, NavigationBase<import('./common/types').RouterBaseEventMap>> | undefined, PlainObject<any>>>>, object, import('./common/types').RouterBaseEventMap>>;
+    static readonly contextType: import('react').Context<import('./RouterBase').RouterBase<import('./RouterBase').RouterBaseProps<ScreenBase<ScreenBaseProps, ScreenBaseState<ScreenBaseConfig<RoutePropBase<{}, PlainObject<any>>, NavigationBase> | undefined, PlainObject>, RoutePropBase<ScreenBaseConfig<RoutePropBase<{}, PlainObject<any>>, NavigationBase> | undefined, PlainObject<any>>>>, object>>;
     context: React.ContextType<typeof RouterContext>;
     state: S;
     constructor(props: P, context: React.ContextType<typeof RouterContext>);

package/build/ScreenTransitionProvider.d.ts

@@ -20,8 +20,8 @@ export declare class ScreenTransitionProvider extends Component<ScreenTransition
     index: number;
     exiting: boolean;
     state: ScreenTransitionProviderState;
-    private onAnimationEnd;
-    private onAnimationStart;
+    private onroutertransitionend;
+    private onroutertransitionstart;
     componentDidMount(): void;
     componentWillUnmount(): void;
     get animationEffect(): AnimationEffect | null;

package/build/__tests__/common/utils.d.ts

@@ -13,16 +13,16 @@ export declare class TestRouter extends RouterBase {
     constructor(props: RouterBaseProps, context: React.ContextType<typeof NestedRouterContext>);
     protected canIntercept(): boolean;
     protected shouldIntercept(): boolean;
-    protected get screens(): React.CElement<import('../../ScreenBase').ScreenBaseProps, ScreenBase<import('../../ScreenBase').ScreenBaseProps, import('../../ScreenBase').ScreenBaseState<import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase<import('../..').RouterBaseEventMap>> | undefined, import('../..').PlainObject>, import('../..').RoutePropBase<import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase<import('../..').RouterBaseEventMap>> | undefined, import('../..').PlainObject<any>>>> | React.CElement<import('../../ScreenBase').ScreenBaseProps, ScreenBase<import('../../ScreenBase').ScreenBaseProps, import('../../ScreenBase').ScreenBaseState<import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase<import('../..').RouterBaseEventMap>> | undefined, import('../..').PlainObject>, import('../..').RoutePropBase<import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase<import('../..').RouterBaseEventMap>> | undefined, import('../..').PlainObject<any>>>>[];
+    protected get screens(): React.CElement<import('../../ScreenBase').ScreenBaseProps, ScreenBase<import('../../ScreenBase').ScreenBaseProps, import('../../ScreenBase').ScreenBaseState<import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase> | undefined, import('../..').PlainObject>, import('../..').RoutePropBase<import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase> | undefined, import('../..').PlainObject<any>>>> | React.CElement<import('../../ScreenBase').ScreenBaseProps, ScreenBase<import('../../ScreenBase').ScreenBaseProps, import('../../ScreenBase').ScreenBaseState<import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase> | undefined, import('../..').PlainObject>, import('../..').RoutePropBase<import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase> | undefined, import('../..').PlainObject<any>>>>[];
     protected intercept(e: NavigateEvent): void;
 }
 export declare class TestScreen extends ScreenBase {
     get id(): string;
     get params(): import('../..').PlainObject;
-    get config(): import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase<import('../..').RouterBaseEventMap>>;
+    get config(): import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase>;
     get resolvedPathname(): string;
     protected get routeProp(): {
-        config: import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase<import('../..').RouterBaseEventMap>>;
+        config: import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase>;
         params: import('../..').PlainObject;
         focused: boolean;
         path: string;

package/build/common/events.d.ts

@@ -1,27 +1,14 @@
 import { LoadNavigationTransition } from './types';
-export declare class TransitionStartEvent extends Event {
-    constructor();
-}
-export declare class TransitionCancelEvent extends Event {
-    constructor();
-}
-export declare class TransitionEndEvent extends Event {
-    constructor();
-}
-export declare class MotionProgressStartEvent extends Event {
-    constructor();
-}
-export declare class MotionProgressEndEvent extends Event {
-    constructor();
-}
 export declare class LoadEvent extends Event implements Omit<NavigateEvent, 'navigationType' | 'commit'> {
     #private;
     readonly hasUAVisualTransition = false;
-    constructor();
+    constructor(navigationType: 'load' | 'preload', loadEventInitDict?: {
+        destination?: NavigationDestination | null;
+    });
     intercept(options?: NavigationInterceptOptions | undefined): void;
     scroll(): void;
-    get transition(): LoadNavigationTransition | null;
-    get navigationType(): "load";
+    get transition(): LoadNavigationTransition;
+    get navigationType(): "load" | "preload";
     get userInitiated(): boolean;
     get canIntercept(): boolean;
     get hashChange(): boolean;

package/build/common/promise-wrapper.d.ts

@@ -0,0 +1,8 @@
+export declare class PromiseWrapper<T> {
+    #private;
+    promise: Promise<T>;
+    state: 'pending' | 'resolved' | 'rejected';
+    constructor();
+    resolve(value: T): void;
+    reject(reason: unknown): void;
+}

package/build/common/types.d.ts

@@ -1,5 +1,4 @@
 import { ScreenBase, ScreenBaseProps } from '../ScreenBase';
-import { MotionProgressEndEvent, MotionProgressStartEvent, TransitionCancelEvent, TransitionEndEvent, TransitionStartEvent } from './events';
 import { SharedElement } from '../SharedElement';
 import { StandardPropertiesHyphen } from 'csstype';
 export type ScreenChild<E extends ScreenBase = ScreenBase> = E extends ScreenBase<infer P> ? React.CElement<P, E> : never;
@@ -38,17 +37,22 @@ export declare function isValidScreenChild<S extends ScreenBase>(value: any): va
 export type PlainObject<T = any> = {
     [key: string]: T;
 };
-export interface RouterBaseEventMap extends HTMLElementEventMap {
-    'transition-start': TransitionStartEvent;
-    'transition-cancel': TransitionCancelEvent;
-    'transition-end': TransitionEndEvent;
-    'motion-progress-start': MotionProgressStartEvent;
-    'motion-progress-end': MotionProgressEndEvent;
+declare global {
+    interface HTMLElementEventMap {
+        'routertransitionstart': TransitionEvent;
+        'routertransitioncancel': TransitionEvent;
+        'routertransitionend': TransitionEvent;
+    }
 }
-export type RouterHTMLElement<E extends RouterBaseEventMap, T extends HTMLElement = HTMLDivElement> = T & {
-    addEventListener<K extends keyof E>(type: K, listener: (this: T, ev: E[K]) => any, options?: boolean | AddEventListenerOptions): void;
+export type EventHandler = {
+    [K in keyof HTMLElementEventMap as `on${K}`]?: (e: HTMLElementEventMap[K]) => void;
+} & {
+    handleEvent: (e: Event) => void;
+};
+export type RouterBaseHTMLElement<T extends HTMLElement = HTMLDivElement> = T & {
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: T, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-    removeEventListener<K extends keyof E>(type: K, listener: (this: T, ev: E[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: T, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 };
 export type CustomElementType = `${string}-${string}`;
@@ -81,7 +85,7 @@ export type StylableElement = Element & {
 };
 export declare function isStylableElement(element: any): element is StylableElement;
 export interface LoadNavigationTransition extends Omit<NavigationTransition, 'navigationType'> {
-    navigationType: 'load';
+    navigationType: 'load' | 'preload';
 }
 declare global {
     interface NavigateEvent extends Event {

package/build/common/utils.d.ts

@@ -13,3 +13,4 @@ export declare function PromiseAllSequential<T>(values: Iterable<T | PromiseLike
 export declare function toCamelCase(value: string): string;
 export declare function cloneAndInject<C extends React.CElement<any, any>, IP extends Partial<ElementPropType<C>>>(element: C, injectProps: IP): ClonedElementType<C, IP>;
 export declare function omit<T extends object, K extends readonly (keyof T)[]>(obj: T, keys: K): Omit<T, K[number]>;
+export declare function historyEntryFromDestination(destination: NavigationDestination): NavigationHistoryEntry;

package/build/index.d.ts

@@ -8,5 +8,8 @@ export * from './common/types';
 export * from './common/events';
 export * from './common/utils';
 export * from './common/test-utils';
+export * from './common/promise-wrapper';
 export * from './common/constants';
 export * from './Anchor';
+export * from './RouterContext';
+export * from './RoutePropContext';