@react-motion-router/core 2.0.0-beta.sha-20ff5ff → 2.0.0-beta.sha-4c84f16

package/build/Anchor.d.ts

@@ -0,0 +1,35 @@
+import { default as React, RefObject } from 'react';
+type AnchorState = {
+    href?: string | null;
+};
+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;
+    componentDidMount(): void;
+    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?: 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/MetaData.d.ts

@@ -1,19 +1,19 @@
 import { MetaType } from './common/types';
 export declare class MetaData {
     #private;
-    private mutationObserver;
+    private readonly mutationObserver;
     constructor();
     get(key: string | MetaType): string | [string, string][] | undefined;
     set(key: string | MetaType, content?: string | [string, string][]): void;
     has(key: string | MetaType): boolean;
     delete(key: string | MetaType): void;
     clear(): void;
-    entries(): MapIterator<[`http-equiv=${string}` | `name=${string}` | `itemprop=${string}` | `property=${string}` | `charset=${string}`, string | undefined]>;
-    [Symbol.iterator](): MapIterator<[`http-equiv=${string}` | `name=${string}` | `itemprop=${string}` | `property=${string}` | `charset=${string}`, string | undefined]>;
+    entries(): MapIterator<[`${string}=${string}`, string | undefined]>;
+    [Symbol.iterator](): MapIterator<[`${string}=${string}`, string | undefined]>;
     get size(): number;
     private observeMutations;
     private metaDataFromNode;
-    private getMetaKey;
-    private getMetaContent;
+    private formatMetaKey;
+    private formatMetaContent;
     private updateMetaElement;
 }

package/build/NavigationBase.d.ts

@@ -1,20 +1,39 @@
-import { RouterHTMLElement, RouterBaseEventMap } from './common/types';
+import { RouterBaseHTMLElement } from './common/types';
 import { MetaData } from './MetaData';
-import { RouterBase } from './RouterBase';
-export declare abstract class NavigationBase<E extends RouterBaseEventMap = RouterBaseEventMap> {
-    protected abstract readonly router: RouterBase;
-    private static rootNavigatorRef;
-    readonly metaData: MetaData;
-    constructor();
-    addEventListener<K extends keyof E>(type: K, listener: (this: RouterHTMLElement<E>, ev: E[K]) => any, 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;
-    removeEventListener<K extends keyof E>(type: K, listener: (this: RouterHTMLElement<E>, ev: E[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): () => 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>;
-    get parent(): NavigationBase | null;
-    get routerId(): string;
-    get baseURL(): URL;
-    get baseURLPattern(): URLPattern;
-    getNavigatorById(routerId: string): NavigationBase<RouterBaseEventMap> | null;
+    parent: NavigationBase | null;
+    routerId: string;
+    baseURL: URL;
+    baseURLPattern: URLPattern;
+    getNavigatorById(routerId: string): NavigationBase | null;
+}
+export declare abstract class NavigationBase {
+    private static rootNavigatorRef;
+    readonly metaData: MetaData;
+    readonly addEventListener: {
+        <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 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 | null;
+    readonly routerId: string;
+    readonly baseURL: URL;
+    readonly baseURLPattern: URLPattern;
+    readonly getNavigatorById: (routerId: string) => NavigationBase | null;
+    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';
@@ -14,12 +14,11 @@ export interface RouterBaseProps<S extends ScreenBase = ScreenBase> {
     config?: RouterBaseConfig;
     children: ScreenChild<S> | ScreenChild<S>[];
 }
-export interface RouterBaseState {
-}
-export declare abstract class RouterBase<P extends RouterBaseProps = RouterBaseProps, S extends RouterBaseState = RouterBaseState, E extends RouterBaseEventMap = RouterBaseEventMap> extends Component<P, S> {
+export type RouterBaseState = object;
+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>>;
-    protected screenTransitionLayer: import('react').RefObject<ScreenTransitionLayer>;
+    protected readonly ref: import('react').RefObject<RouterBaseHTMLElement | null>;
+    protected screenTransitionLayer: import('react').RefObject<ScreenTransitionLayer | null>;
     abstract readonly navigation: NavigationBase;
     readonly parent: RouterBase | null;
     private loadDispatched;
@@ -32,20 +31,23 @@ 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]) => any, 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]) => any, 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;
     } | null;
     protected preloadScreen(screen: ScreenChild): Promise<void>;
+    includesRoute(pathname: string, baseURLPattern?: string): boolean;
     get id(): string;
     get isRoot(): boolean;
     get baseURL(): URL;
@@ -61,6 +63,6 @@ export declare abstract class RouterBase<P extends RouterBaseProps = RouterBaseP
     protected abstract shouldIntercept(navigateEvent: NavigateEvent): boolean;
     protected abstract intercept(navigateEvent: NavigateEvent): void;
     protected abstract get screens(): P['children'];
-    render(): JSX.Element | undefined;
+    render(): import("react/jsx-runtime").JSX.Element | undefined;
 }
 export {};

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>>>>, import('./RouterBase').RouterBaseState, 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

@@ -5,8 +5,8 @@ import { RouterContext } from './RouterContext';
 import { NavigationBase } from './NavigationBase';
 import { SharedElementScene } from './SharedElementScene';
 export interface ScreenBaseComponentProps<R extends RoutePropBase = RoutePropBase, N extends NavigationBase = NavigationBase> {
-    route: R;
-    navigation: N;
+    readonly route: R;
+    readonly navigation: N;
 }
 export type LifecycleProps<R extends RoutePropBase, N extends NavigationBase = NavigationBase> = ({
     signal: AbortSignal;
@@ -51,12 +51,12 @@ export interface ScreenBaseState<C extends ScreenBaseProps['config'] = ScreenBas
 export declare abstract class ScreenBase<P extends ScreenBaseProps = ScreenBaseProps, S extends ScreenBaseState<P['config']> = ScreenBaseState<P['config']>, R extends RoutePropBase<P['config']> = RoutePropBase<P['config']>> extends Component<P, S> {
     #private;
     readonly sharedElementScene: SharedElementScene;
-    protected readonly ref: import('react').RefObject<HTMLDivElement>;
+    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>>>>, import('./RouterBase').RouterBaseState, 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>>>>, import('./RouterBase').RouterBaseState, 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>);
@@ -79,6 +79,6 @@ export declare abstract class ScreenBase<P extends ScreenBaseProps = ScreenBaseP
     onEnter(signal: AbortSignal): Promise<void>;
     onEntered(signal: AbortSignal): Promise<void>;
     get path(): P["path"];
-    get transitionProvider(): import('react').RefObject<ScreenTransitionProvider>;
-    render(): JSX.Element;
+    get transitionProvider(): import('react').RefObject<ScreenTransitionProvider | null>;
+    render(): import("react/jsx-runtime").JSX.Element;
 }

package/build/ScreenTransitionLayer.d.ts

@@ -15,7 +15,7 @@ interface ScreenTransitionLayerState {
 }
 export declare class ScreenTransitionLayer extends Component<ScreenTransitionLayerProps, ScreenTransitionLayerState> {
     #private;
-    readonly sharedElementTransitionLayer: RefObject<SharedElementTransitionLayer>;
+    readonly sharedElementTransitionLayer: RefObject<SharedElementTransitionLayer | null>;
     readonly animation: Animation;
     state: ScreenTransitionLayerState;
     private onTransitionCancel;
@@ -27,6 +27,6 @@ export declare class ScreenTransitionLayer extends Component<ScreenTransitionLay
     get direction(): PlaybackDirection;
     get hasUAVisualTransition(): boolean;
     transition(): Animation;
-    render(): JSX.Element;
+    render(): import("react/jsx-runtime").JSX.Element;
 }
 export {};

package/build/ScreenTransitionProvider.d.ts

@@ -14,18 +14,18 @@ interface ScreenTransitionProviderState {
     zIndex: React.CSSProperties['zIndex'];
 }
 export declare class ScreenTransitionProvider extends Component<ScreenTransitionProviderProps, ScreenTransitionProviderState> {
-    readonly ref: import('react').RefObject<HTMLElement>;
+    readonly ref: import('react').RefObject<HTMLElement | null>;
     static readonly contextType: import('react').Context<import('./ScreenTransitionLayer').ScreenTransitionLayer>;
     context: React.ContextType<typeof ScreenTransitionLayerContext>;
     index: number;
     exiting: boolean;
     state: ScreenTransitionProviderState;
-    private onAnimationEnd;
-    private onAnimationStart;
+    private onroutertransitionend;
+    private onroutertransitionstart;
     componentDidMount(): void;
     componentWillUnmount(): void;
     get animationEffect(): AnimationEffect | null;
     setZIndex(zIndex: React.CSSProperties['zIndex']): Promise<void>;
-    render(): JSX.Element;
+    render(): import("react/jsx-runtime").JSX.Element;
 }
 export {};

package/build/SharedElement.d.ts

@@ -3,7 +3,7 @@ import { SharedElementTransitionType, StyleKeyList } from './common/types';
 import { SharedElementSceneContext } from './SharedElementSceneContext';
 interface SharedElementConfig extends OptionalEffectTiming {
     type?: SharedElementTransitionType;
-    transformOrigin?: React.CSSProperties["transformOrigin"];
+    transformOrigin?: React.CSSProperties['transformOrigin'];
     styles?: StyleKeyList;
     deepClone?: boolean;
 }
@@ -13,10 +13,8 @@ interface SharedElementProps {
     disabled?: boolean;
     config?: SharedElementConfig;
 }
-interface SharedElementState {
-}
-export declare class SharedElement extends Component<SharedElementProps, SharedElementState> {
-    readonly ref: import('react').RefObject<HTMLDivElement>;
+export declare class SharedElement extends Component<SharedElementProps> {
+    readonly ref: import('react').RefObject<HTMLDivElement | null>;
     static readonly contextType: import('react').Context<import('./SharedElementScene').SharedElementScene>;
     context: React.ContextType<typeof SharedElementSceneContext>;
     componentDidMount(): void;
@@ -31,6 +29,6 @@ export declare class SharedElement extends Component<SharedElementProps, SharedE
     clone(): HTMLElement | null;
     hide(): void;
     unhide(): void;
-    render(): JSX.Element;
+    render(): import("react/jsx-runtime").JSX.Element;
 }
 export {};

package/build/SharedElementTransitionLayer.d.ts

@@ -12,7 +12,7 @@ interface SharedElementTransitionLayerState {
 }
 export declare class SharedElementTransitionLayer extends Component<SharedElementTransitionLayerProps, SharedElementTransitionLayerState> {
     #private;
-    readonly ref: RefObject<HTMLDialogElement>;
+    readonly ref: RefObject<HTMLDialogElement | null>;
     state: SharedElementTransitionLayerState;
     set outgoingScreen(outgoingScreen: RefObject<ScreenBase> | null);
     set incomingScreen(incomingScreen: RefObject<ScreenBase> | null);
@@ -26,6 +26,6 @@ export declare class SharedElementTransitionLayer extends Component<SharedElemen
         rect: DOMRect;
     }>(start: T, end: T): ParallelEffect;
     get animationEffect(): ParallelEffect | null;
-    render(): JSX.Element;
+    render(): import("react/jsx-runtime").JSX.Element;
 }
 export {};

package/build/__tests__/Anchor/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/Anchor/push.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/Anchor/reload.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/Anchor/replace.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/Anchor/traverse.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/RouterBase/get-router-by-id.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/RouterBase/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/RouterBase/preload-screen.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/RouterBase/screen-child-from-pathname.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,33 @@
+import { default as React } from 'react';
+import { NavigationBase } from '../../NavigationBase';
+import { RouterBase, RouterBaseProps } from '../../RouterBase';
+import { NestedRouterContext } from '../../RouterContext';
+import { ScreenBase } from '../../ScreenBase';
+export declare class TestNavigation extends NavigationBase {
+}
+export declare class TestRouter extends RouterBase {
+    navigation: TestNavigation;
+    state: {
+        screens: RouterBase["screens"];
+    };
+    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> | 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>;
+    get resolvedPathname(): string;
+    protected get routeProp(): {
+        config: import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase>;
+        params: import('../..').PlainObject;
+        focused: boolean;
+        path: string;
+        resolvedPathname: string;
+        setConfig(): void;
+        setParams(): void;
+    };
+}

package/build/__tests__/lazy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/load-event.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/meta-data.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/screen.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/common/constants.d.ts

@@ -3,3 +3,7 @@ export declare const MAX_PROGRESS = 100;
 export declare const MIN_PROGRESS = 0;
 export declare const MIN_NORM_PROGRESS = 0;
 export declare const MAX_NORM_PROGRESS = 1;
+export declare const LAST_INDEX = -1;
+export declare const FIRST_INDEX = 0;
+export declare const SINGLE_ELEMENT_LENGTH = 1;
+export declare const EMPTY_COLLECTION_LENGTH = 0;

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/test-utils.d.ts

@@ -0,0 +1,12 @@
+export declare function useRerender(): CSSNumberish | null;
+export declare function useRerenderCallback<T extends () => unknown>(callback: T): void;
+export declare function triggerRerender(): void;
+export declare function createHistoryEntry(url: string, index: number): NavigationHistoryEntry;
+export declare function assertNavigationAvailable(): void;
+export declare function waitForNavigateSuccess(): Promise<void>;
+export declare function navTo(url: string): Promise<void>;
+export declare function traverseTo(key: string): Promise<void>;
+export declare function traverseToStart(): Promise<void>;
+export declare function seedHistory(): Promise<void>;
+export declare function installInterceptor(): Promise<void>;
+export declare function uninstallInterceptor(): Promise<void>;

package/build/common/types.d.ts

@@ -1,5 +1,4 @@
 import { ScreenBase, ScreenBaseProps } from '../ScreenBase';
-import { MotionProgressEndEvent, MotionProgressEvent, 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;
@@ -14,9 +13,8 @@ export interface AnimationEffectFactoryProps<R extends HTMLElement = HTMLElement
     hasUAVisualTransition: boolean;
 }
 export type AnimationEffectFactory<R extends HTMLElement = HTMLElement> = (props: AnimationEffectFactoryProps<R>) => AnimationEffect;
-export type MetaTypeKey = 'http-equiv' | 'name' | 'itemprop' | 'property' | 'charset';
-export type MetaType = [MetaTypeKey, string];
-export type MetaKey = `${MetaTypeKey}=${string}`;
+export type MetaType = [string, string];
+export type MetaKey = `${string}=${string}`;
 export interface LazyExoticComponent<T extends React.ComponentType<any>> extends React.LazyExoticComponent<T> {
     load: () => Promise<{
         default: T;
@@ -39,18 +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': MotionProgressEvent;
-    '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}`;
@@ -83,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

@@ -1,7 +1,6 @@
-import { ClonedElementType, ElementPropType, LazyExoticComponent, MatchedRoute, PathPattern } from './types';
+import { ClonedElementType, ElementPropType, LazyExoticComponent, MatchedRoute } from './types';
 export declare function resolveBaseURLFromPattern(pattern: string, pathname: string): URL | null;
 export declare function matchRoute(pathnamePattern: string, pathname: string, baseURLPattern?: string, caseSensitive?: boolean): MatchedRoute | null;
-export declare function includesRoute(pathnamePatterns: PathPattern[], pathname: string, baseURL?: string): boolean;
 export declare function dispatchEvent<T>(event: CustomEvent<T> | Event, target?: HTMLElement | EventTarget): Promise<boolean>;
 export declare function lazy<T extends React.ComponentType<any>>(factory: () => Promise<{
     default: T;
@@ -10,6 +9,8 @@ export declare function isNavigationSupported(): boolean;
 export declare function isURLPatternSupported(): boolean;
 export declare function polyfillURLPattern(): Promise<void>;
 export declare function polyfillNavigation(): Promise<void>;
-export declare function PromiseAllDynamic<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;
+export declare function PromiseAllSequential<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;
 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

@@ -7,4 +7,9 @@ export * from './common/hooks';
 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';