@react-motion-router/core 2.0.0-beta.e30cd0d → 2.0.0-beta.sha-dfc284b

package/build/MetaData.d.ts

@@ -0,0 +1,19 @@
+import { MetaType } from "./common/types";
+export declare class MetaData {
+    #private;
+    private 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(): IterableIterator<[`http-equiv=${string}` | `name=${string}` | `itemprop=${string}` | `property=${string}` | `charset=${string}`, string | undefined]>;
+    [Symbol.iterator](): IterableIterator<[`http-equiv=${string}` | `name=${string}` | `itemprop=${string}` | `property=${string}` | `charset=${string}`, string | undefined]>;
+    get size(): number;
+    private observeMutations;
+    private metaDataFromNode;
+    private getMetaKey;
+    private getMetaContent;
+    private updateMetaElement;
+}

package/build/MotionContext.d.ts

@@ -0,0 +1 @@
+export declare const MotionContext: import("react").Context<number>;

package/build/NavigationBase.d.ts

@@ -0,0 +1,21 @@
+import { RouterHTMLElement, RouterBaseEventMap } from "./common/types";
+import { MetaData } from "./MetaData";
+import { RouterBase } from "./RouterBase";
+export declare abstract class NavigationBase<E extends RouterBaseEventMap = RouterBaseEventMap> {
+    protected readonly router: RouterBase;
+    private static rootNavigatorRef;
+    readonly metaData: MetaData;
+    constructor(router: RouterBase);
+    addEventListener<K extends keyof E>(type: K, listener: (this: RouterHTMLElement<E>, ev: E[K]) => any, 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(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;
+    preloadRoute(path: string): Promise<boolean>;
+    private get isInDocument();
+}

package/build/RoutePropContext.d.ts

@@ -0,0 +1,2 @@
+import { RoutePropBase } from "./common/types";
+export declare const RoutePropContext: import("react").Context<RoutePropBase<{}, import("./common/types").PlainObject<any>>>;

package/build/RouterBase.d.ts

@@ -0,0 +1,59 @@
+import { NavigationBase } from './NavigationBase';
+import { ScreenTransitionLayer } from './ScreenTransitionLayer';
+import { ScreenChild, RouterBaseEventMap, RouterHTMLElement, ScreenState } from './common/types';
+import { NestedRouterContext } from './RouterContext';
+import { Component } from 'react';
+import { ScreenBase } from './ScreenBase';
+export interface RouterBaseProps<S extends ScreenBase = ScreenBase> {
+    id?: string;
+    config: {
+        screenConfig?: S["props"]["config"];
+        basePath?: string;
+    };
+    children: ScreenChild<S["props"], S> | ScreenChild<S["props"], 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> {
+    #private;
+    protected readonly ref: import("react").RefObject<RouterHTMLElement<E>>;
+    protected screenTransitionLayer: import("react").RefObject<ScreenTransitionLayer>;
+    abstract readonly navigation: NavigationBase;
+    readonly screenState: ScreenState;
+    readonly parent: RouterBase | null;
+    private loadDispatched;
+    readonly parentScreen: ScreenBase | null;
+    private static rootRouterRef;
+    static readonly contextType: import("react").Context<{
+        parentRouter: RouterBase;
+        parentScreen: ScreenBase;
+    } | null>;
+    context: React.ContextType<typeof NestedRouterContext>;
+    constructor(props: P, context: React.ContextType<typeof NestedRouterContext>);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private handleNavigationDispatch;
+    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(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(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    preloadRoute(pathname: string): Promise<boolean>;
+    get id(): string;
+    get isRoot(): boolean;
+    get baseURL(): URL;
+    get baseURLPattern(): URLPattern;
+    get pathPatterns(): {
+        pattern: string;
+        caseSensitive: boolean;
+    }[];
+    get mounted(): boolean;
+    get child(): RouterBase | null;
+    set child(child: RouterBase | null);
+    protected abstract canIntercept(navigateEvent: NavigateEvent): boolean;
+    protected abstract shouldIntercept(navigateEvent: NavigateEvent): boolean;
+    protected abstract intercept(navigateEvent: NavigateEvent): void;
+    protected abstract get screens(): P["children"];
+    render(): JSX.Element | undefined;
+}

package/build/RouterContext.d.ts

@@ -0,0 +1,22 @@
+import { ScreenBase } from './ScreenBase';
+import { RouterBase } from './RouterBase';
+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(".").RoutePropBase<{}, import(".").PlainObject<any>>>, import("./ScreenBase").ScreenBaseState, import(".").RoutePropBase<{
+    header?: {
+        fallback?: React.ReactNode;
+        component: React.JSXElementConstructor<any> | import(".").LazyExoticComponent<any>;
+    };
+    footer?: {
+        fallback?: React.ReactNode;
+        component: React.JSXElementConstructor<any> | import(".").LazyExoticComponent<any>;
+    };
+    animation?: import(".").AnimationEffectFactory;
+    onEnter?: ((props: import("./ScreenBase").LifecycleProps<import(".").RoutePropBase<{}, import(".").PlainObject<any>>>) => void | Promise<void>) | undefined;
+    onExit?: ((props: import("./ScreenBase").LifecycleProps<import(".").RoutePropBase<{}, import(".").PlainObject<any>>>) => void | Promise<void>) | undefined;
+    onEntered?: ((props: import("./ScreenBase").LifecycleProps<import(".").RoutePropBase<{}, import(".").PlainObject<any>>>) => void | Promise<void>) | undefined;
+    onExited?: ((props: import("./ScreenBase").LifecycleProps<import(".").RoutePropBase<{}, import(".").PlainObject<any>>>) => void | Promise<void>) | undefined;
+    onLoad?: ((props: import("./ScreenBase").LifecycleProps<import(".").RoutePropBase<{}, import(".").PlainObject<any>>>) => void | Promise<void>) | undefined;
+} | undefined, import(".").PlainObject<any>>>>, import("./RouterBase").RouterBaseState, import(".").RouterBaseEventMap>>;

package/build/ScreenBase.d.ts

@@ -0,0 +1,105 @@
+import { Component, ElementType } from "react";
+import { ScreenTransitionProvider } from "./ScreenTransitionProvider";
+import { AnimationEffectFactory, LazyExoticComponent, PlainObject, RoutePropBase } from "./common/types";
+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;
+}
+export interface LifecycleProps<R extends RoutePropBase> extends ScreenBaseComponentProps<R, NavigationBase> {
+    signal: AbortSignal;
+}
+export interface ScreenBaseProps<R extends RoutePropBase = RoutePropBase> {
+    component: React.JSXElementConstructor<any> | LazyExoticComponent<any>;
+    fallback?: React.ReactNode;
+    path: string;
+    resolvedPathname?: string;
+    defaultParams?: PlainObject;
+    caseSensitive?: boolean;
+    id?: string;
+    config?: {
+        header?: {
+            fallback?: React.ReactNode;
+            component: React.JSXElementConstructor<any> | LazyExoticComponent<any>;
+        };
+        footer?: {
+            fallback?: React.ReactNode;
+            component: React.JSXElementConstructor<any> | LazyExoticComponent<any>;
+        };
+        animation?: AnimationEffectFactory;
+        onEnter?: (props: LifecycleProps<R>) => void | Promise<void>;
+        onExit?: (props: LifecycleProps<R>) => void | Promise<void>;
+        onEntered?: (props: LifecycleProps<R>) => void | Promise<void>;
+        onExited?: (props: LifecycleProps<R>) => void | Promise<void>;
+        onLoad?: (props: LifecycleProps<R>) => void | Promise<void>;
+    };
+}
+export interface ScreenBaseState {
+    focused: boolean;
+    elementType: ElementType;
+}
+export declare abstract class ScreenBase<P extends ScreenBaseProps = ScreenBaseProps, S extends ScreenBaseState = ScreenBaseState, R extends RoutePropBase<ScreenBaseProps["config"]> = RoutePropBase<ScreenBaseProps["config"]>> extends Component<P, S> {
+    #private;
+    readonly sharedElementScene: SharedElementScene;
+    protected readonly ref: import("react").RefObject<HTMLDivElement>;
+    protected readonly nestedRouterData: {
+        parentScreen: ScreenBase;
+        parentRouter: import("./RouterBase").RouterBase<import("./RouterBase").RouterBaseProps<ScreenBase<ScreenBaseProps<RoutePropBase<{}, PlainObject<any>>>, ScreenBaseState, RoutePropBase<{
+            header?: {
+                fallback?: React.ReactNode;
+                component: React.JSXElementConstructor<any> | LazyExoticComponent<any>;
+            };
+            footer?: {
+                fallback?: React.ReactNode;
+                component: React.JSXElementConstructor<any> | LazyExoticComponent<any>;
+            };
+            animation?: AnimationEffectFactory;
+            onEnter?: ((props: LifecycleProps<RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+            onExit?: ((props: LifecycleProps<RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+            onEntered?: ((props: LifecycleProps<RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+            onExited?: ((props: LifecycleProps<RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+            onLoad?: ((props: LifecycleProps<RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+        } | undefined, PlainObject<any>>>>, import("./RouterBase").RouterBaseState, import("./common/types").RouterBaseEventMap>;
+    };
+    static readonly contextType: import("react").Context<import("./RouterBase").RouterBase<import("./RouterBase").RouterBaseProps<ScreenBase<ScreenBaseProps<RoutePropBase<{}, PlainObject<any>>>, ScreenBaseState, RoutePropBase<{
+        header?: {
+            fallback?: React.ReactNode;
+            component: React.JSXElementConstructor<any> | LazyExoticComponent<any>;
+        };
+        footer?: {
+            fallback?: React.ReactNode;
+            component: React.JSXElementConstructor<any> | LazyExoticComponent<any>;
+        };
+        animation?: AnimationEffectFactory;
+        onEnter?: ((props: LifecycleProps<RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+        onExit?: ((props: LifecycleProps<RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+        onEntered?: ((props: LifecycleProps<RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+        onExited?: ((props: LifecycleProps<RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+        onLoad?: ((props: LifecycleProps<RoutePropBase<{}, PlainObject<any>>>) => void | Promise<void>) | undefined;
+    } | undefined, PlainObject<any>>>>, import("./RouterBase").RouterBaseState, import("./common/types").RouterBaseEventMap>>;
+    context: React.ContextType<typeof RouterContext>;
+    state: S;
+    constructor(props: P, context: React.ContextType<typeof RouterContext>);
+    protected setParams(params: PlainObject): void;
+    protected setConfig(config: P['config']): void;
+    get id(): string;
+    get focused(): boolean;
+    blur(): Promise<void>;
+    focus(): Promise<void>;
+    load(signal: AbortSignal): Promise<{
+        default: any;
+    }>;
+    abstract get routeProp(): R;
+    abstract get config(): R["config"];
+    abstract get params(): R["params"];
+    onExited(signal: AbortSignal): Promise<void>;
+    onExit(signal: AbortSignal): Promise<void>;
+    onEnter(signal: AbortSignal): Promise<void>;
+    onEntered(signal: AbortSignal): Promise<void>;
+    get resolvedPathname(): P["resolvedPathname"] | undefined;
+    get path(): P["path"];
+    get transitionProvider(): import("react").RefObject<ScreenTransitionProvider>;
+    render(): JSX.Element;
+}

package/build/ScreenTransitionLayer.d.ts

@@ -0,0 +1,32 @@
+import { Component, RefObject } from 'react';
+import { SharedElementTransitionLayer } from './SharedElementTransitionLayer';
+import { Animation } from 'web-animations-extension';
+import { ScreenChild } from './common/types';
+import { NavigationBase } from './NavigationBase';
+import { ScreenBase } from './ScreenBase';
+interface ScreenTransitionLayerProps {
+    children: ScreenChild | ScreenChild[];
+    navigation: NavigationBase;
+}
+interface ScreenTransitionLayerState {
+    gestureNavigating: boolean;
+    progress: number;
+}
+export declare class ScreenTransitionLayer extends Component<ScreenTransitionLayerProps, ScreenTransitionLayerState> {
+    #private;
+    readonly sharedElementTransitionLayer: RefObject<SharedElementTransitionLayer>;
+    readonly animation: Animation;
+    state: ScreenTransitionLayerState;
+    private onAnimationFrame;
+    private onTransitionCancel;
+    private onTransitionStart;
+    private onTransitionEnd;
+    private onProgress;
+    get screens(): RefObject<ScreenBase>[];
+    set screens(screens: RefObject<ScreenBase>[]);
+    set direction(direction: PlaybackDirection);
+    get direction(): PlaybackDirection;
+    transition(): Animation;
+    render(): JSX.Element;
+}
+export {};

package/build/ScreenTransitionLayerContext.d.ts

@@ -0,0 +1,2 @@
+import { ScreenTransitionLayer } from "./ScreenTransitionLayer";
+export declare const ScreenTransitionLayerContext: import("react").Context<ScreenTransitionLayer>;

package/build/ScreenTransitionProvider.d.ts

@@ -0,0 +1,31 @@
+import { ScreenTransitionLayerContext } from './ScreenTransitionLayerContext';
+import { AnimationEffectFactory } from './common/types';
+import { NavigationBase } from './NavigationBase';
+import { Component, ElementType } from 'react';
+interface ScreenTransitionProviderProps {
+    id: string;
+    animation?: AnimationEffectFactory;
+    children: React.ReactNode;
+    navigation: NavigationBase;
+    renderAs: ElementType;
+    focused: boolean;
+}
+interface ScreenTransitionProviderState {
+    zIndex: React.CSSProperties["zIndex"];
+}
+export declare class ScreenTransitionProvider extends Component<ScreenTransitionProviderProps, ScreenTransitionProviderState> {
+    readonly ref: import("react").RefObject<HTMLElement>;
+    static readonly contextType: import("react").Context<import("./ScreenTransitionLayer").ScreenTransitionLayer>;
+    context: React.ContextType<typeof ScreenTransitionLayerContext>;
+    index: number;
+    exiting: boolean;
+    state: ScreenTransitionProviderState;
+    private onAnimationEnd;
+    private onAnimationStart;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    get animationEffect(): AnimationEffect | null;
+    setZIndex(zIndex: React.CSSProperties["zIndex"]): Promise<void>;
+    render(): JSX.Element;
+}
+export {};

package/build/SharedElement.d.ts

@@ -0,0 +1,36 @@
+import { Component } from 'react';
+import { SharedElementTransitionType, StyleKeyList } from './common/types';
+import { SharedElementSceneContext } from './SharedElementSceneContext';
+interface SharedElementConfig extends OptionalEffectTiming {
+    type?: SharedElementTransitionType;
+    transformOrigin?: React.CSSProperties["transformOrigin"];
+    styles?: StyleKeyList;
+    deepClone?: boolean;
+}
+interface SharedElementProps {
+    id: string;
+    children: React.ReactElement;
+    disabled?: boolean;
+    config?: SharedElementConfig;
+}
+interface SharedElementState {
+}
+export declare class SharedElement extends Component<SharedElementProps, SharedElementState> {
+    readonly ref: import("react").RefObject<HTMLDivElement>;
+    static readonly contextType: import("react").Context<import("./SharedElementScene").SharedElementScene>;
+    context: React.ContextType<typeof SharedElementSceneContext>;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: SharedElementProps): void;
+    componentWillUnmount(): void;
+    get styles(): StyleKeyList;
+    get canTransition(): boolean;
+    get scene(): import("./SharedElementScene").SharedElementScene;
+    get id(): string;
+    get transitionType(): SharedElementTransitionType;
+    getBoundingClientRect(): DOMRect;
+    clone(): HTMLElement | null;
+    hide(): void;
+    unhide(): void;
+    render(): JSX.Element;
+}
+export {};

package/build/SharedElementScene.d.ts

@@ -0,0 +1,17 @@
+import { SharedElement } from "./SharedElement";
+export declare class SharedElementScene {
+    readonly id: string;
+    readonly nodes: Map<string, SharedElement>;
+    getScreenRect: () => DOMRect;
+    keepAlive: boolean;
+    previousScene: SharedElementScene | null;
+    canTransition: boolean;
+    constructor(id: string);
+    addNode(node: SharedElement | null): void;
+    removeNode(_id: string): void;
+    get xRatio(): number;
+    get yRatio(): number;
+    get x(): number;
+    get y(): number;
+    isEmpty(): boolean;
+}

package/build/SharedElementSceneContext.d.ts

@@ -0,0 +1,2 @@
+import { SharedElementScene } from "./SharedElementScene";
+export declare const SharedElementSceneContext: import("react").Context<SharedElementScene>;

package/build/SharedElementTransitionLayer.d.ts

@@ -0,0 +1,29 @@
+import { StylableElement, StyleKeyList } from './common/types';
+import { Component, RefObject } from 'react';
+import { NavigationBase } from './NavigationBase';
+import { ScreenBase } from './ScreenBase';
+import { ParallelEffect } from 'web-animations-extension';
+import { SharedElement } from './SharedElement';
+interface SharedElementTransitionLayerProps {
+    navigation: NavigationBase;
+}
+interface SharedElementTransitionLayerState {
+}
+export declare class SharedElementTransitionLayer extends Component<SharedElementTransitionLayerProps, SharedElementTransitionLayerState> {
+    #private;
+    readonly ref: RefObject<HTMLDialogElement>;
+    state: SharedElementTransitionLayerState;
+    set outgoingScreen(outgoingScreen: RefObject<ScreenBase> | null);
+    set incomingScreen(incomingScreen: RefObject<ScreenBase> | null);
+    get outgoingScreen(): RefObject<ScreenBase> | null;
+    get incomingScreen(): RefObject<ScreenBase> | null;
+    getKeyframeProperties(element: Element, styleList: StyleKeyList): Record<string, string>;
+    copyStyles(srcElement: StylableElement, cloneElement: StylableElement, styleList: StyleKeyList): void;
+    getAnimationEffect<T extends {
+        instance: SharedElement;
+        clone: HTMLElement;
+    }>(start: T, end: T): ParallelEffect;
+    get animationEffect(): ParallelEffect | null;
+    render(): JSX.Element;
+}
+export {};

package/build/common/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const MAX_Z_INDEX = 2147483647;
+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;

package/build/common/events.d.ts

@@ -0,0 +1,38 @@
+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 MotionProgressEvent extends Event {
+    readonly progress: number;
+    constructor(progress: number);
+}
+export declare class MotionProgressEndEvent extends Event {
+    constructor();
+}
+export declare class LoadEvent extends Event implements Omit<NavigateEvent, 'navigationType'> {
+    #private;
+    constructor();
+    intercept(options?: NavigationInterceptOptions | undefined): void;
+    scroll(): void;
+    get transition(): {
+        from: NavigationHistoryEntry | null;
+        finished: Promise<void>;
+        navigationType: "load";
+    } | null;
+    get navigationType(): "load";
+    get userInitiated(): boolean;
+    get canIntercept(): boolean;
+    get hashChange(): boolean;
+    get formData(): FormData | null;
+    get downloadRequest(): string | null;
+    get destination(): NavigationDestination;
+    get signal(): AbortSignal;
+}

package/build/common/hooks.d.ts

@@ -0,0 +1,7 @@
+import { NavigationBase } from "../NavigationBase";
+import { RouterBase } from "../RouterBase";
+import { RoutePropBase } from "./types";
+export declare function useNavigationBase<T extends NavigationBase = NavigationBase>(): T;
+export declare function useRouterBase<T extends RouterBase = RouterBase>(): T;
+export declare function useMotion(): number;
+export declare function useRouteBase<R extends RoutePropBase>(): R;

package/build/common/types.d.ts

@@ -0,0 +1,82 @@
+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<P extends ScreenBaseProps = ScreenBaseProps, E extends ScreenBase<P> = ScreenBase<P>> = React.CElement<P, E>;
+export interface AnimationEffectFactoryProps<R extends HTMLElement = HTMLElement> {
+    ref: R | null;
+    index: number;
+    exiting: boolean;
+    timeline: AnimationTimeline | null;
+    playbackRate: number;
+    direction: PlaybackDirection;
+}
+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 interface LazyExoticComponent<T extends React.ComponentType<any>> extends React.LazyExoticComponent<T> {
+    load: () => Promise<{
+        default: T;
+    }>;
+    module?: {
+        default: T;
+    };
+}
+export type ScreenState<P extends ScreenBaseProps = ScreenBaseProps> = Map<string, Pick<RoutePropBase<P["config"], PlainObject>, "config" | "params">>;
+export interface RoutePropBase<C extends ScreenBaseProps["config"] = {}, P extends PlainObject = PlainObject> {
+    path: string;
+    resolvedPathname?: string;
+    config: Partial<NonNullable<C>>;
+    focused: boolean;
+    params: P;
+    setParams(params: Partial<P>): void;
+    setConfig(config: Partial<NonNullable<C>>): void;
+}
+export declare function isValidScreenChild<S extends ScreenBase>(value: any): value is ScreenChild<S["props"], S>;
+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;
+}
+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;
+    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(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+};
+export type CustomElementType = `${string}-${string}`;
+export interface MatchedRoute {
+    params?: PlainObject<string | undefined>;
+}
+export interface PathPattern {
+    pattern: string;
+    caseSensitive: boolean;
+}
+export type AnimationDirection = "normal" | "reverse";
+declare enum SharedElementTransitionTypeEnum {
+    "morph" = 0,
+    "fade-through" = 1,
+    "fade" = 2,
+    "cross-fade" = 3
+}
+export type SharedElementTransitionType = keyof typeof SharedElementTransitionTypeEnum;
+export interface SharedElementNode {
+    id: string;
+    instance: SharedElement;
+}
+export type SharedElementNodeMap = Map<string, SharedElementNode>;
+export type StyleKeyList = (keyof StandardPropertiesHyphen | string)[];
+export declare function isNativeLazyExoticComponent(value: any): value is React.LazyExoticComponent<any>;
+export declare function isLazyExoticComponent(value: any): value is LazyExoticComponent<any>;
+export type StylableElement = Element & {
+    style: CSSStyleDeclaration;
+};
+export declare function isStylableElement(element: any): element is StylableElement;
+export {};

package/build/common/utils.d.ts

@@ -0,0 +1,14 @@
+import { LazyExoticComponent, MatchedRoute, PathPattern } 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;
+}>): LazyExoticComponent<T>;
+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 toCamelCase(value: string): string;