@react-motion-router/core 1.0.4

package/build/RouterBase.d.ts

@@ -0,0 +1,76 @@
+import React from 'react';
+import NavigationBase, { NavigateEvent, BackEvent } from './NavigationBase';
+import { AnimationConfig, AnimationKeyframeEffectConfig, ReducedAnimationConfigSet, SwipeDirection, ScreenChild, PlainObject, RouterEventMap } from './common/types';
+import RouterData, { RoutesData } from './RouterData';
+import AnimationLayerData from './AnimationLayerData';
+import { PageAnimationEndEvent } from './MotionEvents';
+interface Config {
+    animation?: ReducedAnimationConfigSet | AnimationConfig | AnimationKeyframeEffectConfig;
+    defaultRoute?: string;
+    swipeAreaWidth?: number;
+    minFlingVelocity?: number;
+    hysteresis?: number;
+    basePathname?: string;
+    disableDiscovery?: boolean;
+    swipeDirection?: SwipeDirection;
+    disableBrowserRouting?: boolean;
+    paramsSerializer?(params: PlainObject): string;
+    paramsDeserializer?(queryString: string): PlainObject;
+}
+export interface RouterBaseProps {
+    id?: string;
+    config: Config;
+    children: ScreenChild | ScreenChild[];
+}
+export interface RouterBaseState {
+    currentPath: string;
+    backNavigating: boolean;
+    gestureNavigating: boolean;
+    routesData: RoutesData;
+    implicitBack: boolean;
+    defaultDocumentTitle: string;
+}
+export default abstract class RouterBase<P extends RouterBaseProps = RouterBaseProps, S extends RouterBaseState = RouterBaseState> extends React.Component<P, S> {
+    private readonly _id;
+    protected readonly animationLayerData: AnimationLayerData;
+    protected ref: HTMLElement | null;
+    protected abstract _routerData: RouterData;
+    protected config: Config;
+    protected dispatchEvent: ((event: Event) => Promise<boolean>) | null;
+    protected addEventListener: (<K extends keyof RouterEventMap>(type: K, listener: (this: HTMLElement, ev: RouterEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined) => void) | null;
+    protected removeEventListener: (<K extends keyof RouterEventMap>(type: K, listener: (this: HTMLElement, ev: RouterEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined) => void) | null;
+    static defaultProps: {
+        config: {
+            animation: {
+                in: {
+                    type: string;
+                    duration: number;
+                };
+            };
+        };
+    };
+    constructor(props: RouterBaseProps);
+    state: S;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    /**
+     * Initialises current path and routes data from URL search params.
+     */
+    protected initialise(navigation: NavigationBase): void;
+    get id(): string;
+    protected get parentRouterData(): RouterData<NavigationBase> | null;
+    protected get baseURL(): URL;
+    protected abstract get navigation(): NavigationBase;
+    abstract onAnimationEnd: (e: PageAnimationEndEvent) => void;
+    abstract onGestureNavigationStart: () => void;
+    abstract onGestureNavigationEnd: () => void;
+    abstract onPopStateListener: (e: Event) => void;
+    abstract onBackListener: (e: BackEvent) => void;
+    abstract onNavigateListener: (e: NavigateEvent) => void;
+    onDocumentTitleChange: (title: string | null) => void;
+    addNavigationEventListeners(ref: HTMLElement): void;
+    removeNavigationEventListeners(ref: HTMLElement): void;
+    private setRef;
+    render(): JSX.Element;
+}
+export {};

package/build/RouterData.d.ts

@@ -0,0 +1,64 @@
+import React from 'react';
+import { ScreenBase } from '.';
+import { AnimationConfigSet, PlainObject, RouterEventMap } from './common/types';
+import GhostLayer from './GhostLayer';
+import NavigationBase from './NavigationBase';
+import RouterBase from './RouterBase';
+import { ScrollRestorationData } from './ScrollRestorationData';
+export type RoutesData = Map<string | undefined, PlainObject>;
+export default class RouterData<N extends NavigationBase = NavigationBase> {
+    private routerInstance;
+    private _parentRouterData;
+    private _childRouterData;
+    private _dispatchEvent;
+    private _addEventListener;
+    private _removeEventListener;
+    private _currentPath;
+    private _routesData;
+    private static _scrollRestorationData;
+    private _navigation?;
+    private _backNavigating;
+    private _gestureNavigating;
+    private _paramsSerializer?;
+    private _paramsDeserializer?;
+    private _mountedScreen;
+    private _animation;
+    private _ghostLayer;
+    constructor(routerInstance: RouterBase, navigation?: N);
+    destructor(): void;
+    prefetchRoute(path: string): Promise<boolean>;
+    set parentRouterData(parentRouterData: RouterData<NavigationBase> | null);
+    set childRouterData(childRouterData: RouterData<NavigationBase> | null);
+    set dispatchEvent(_dispatchEvent: ((event: Event) => Promise<boolean>) | null);
+    set addEventListener(_addEventListener: (<K extends keyof RouterEventMap>(type: K, listener: (this: HTMLElement, ev: RouterEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined) => void) | null);
+    set removeEventListener(_removeEventListener: (<K extends keyof RouterEventMap>(type: K, listener: (this: HTMLElement, ev: RouterEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined) => void) | null);
+    set currentPath(_currentPath: string);
+    set routesData(_routesData: RoutesData);
+    set navigation(_navigation: N);
+    set animation(_animation: AnimationConfigSet);
+    set ghostLayer(_ghostLayer: GhostLayer | null);
+    set backNavigating(_backNavigating: boolean);
+    set gestureNavigating(_gestureNavigating: boolean);
+    set paramsSerializer(_paramsSerializer: ((params: PlainObject) => string) | undefined);
+    set paramsDeserializer(_paramsDeserializer: ((queryString: string) => PlainObject) | undefined);
+    set mountedScreen(_mountedScreen: ScreenBase | null);
+    get mountedScreen(): ScreenBase | null;
+    get routerId(): string;
+    get routes(): import(".").ScreenChild<import("./ScreenBase").ScreenBaseProps, typeof ScreenBase> | import(".").ScreenChild<import("./ScreenBase").ScreenBaseProps, typeof ScreenBase>[];
+    get parentRouterData(): RouterData<NavigationBase> | null;
+    get childRouterData(): RouterData<NavigationBase> | null;
+    get dispatchEvent(): ((event: Event) => Promise<boolean>) | null;
+    get addEventListener(): (<K extends keyof RouterEventMap>(type: K, listener: (this: HTMLElement, ev: RouterEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined) => void) | null;
+    get removeEventListener(): (<K extends keyof RouterEventMap>(type: K, listener: (this: HTMLElement, ev: RouterEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined) => void) | null;
+    get currentPath(): string;
+    get routesData(): RoutesData;
+    get scrollRestorationData(): ScrollRestorationData;
+    get navigation(): N;
+    get animation(): AnimationConfigSet;
+    get ghostLayer(): GhostLayer | null;
+    get backNavigating(): boolean;
+    get gestureNavigating(): boolean;
+    get paramsSerializer(): ((params: PlainObject) => string) | undefined;
+    get paramsDeserializer(): ((queryString: string) => PlainObject) | undefined;
+}
+export declare const RouterDataContext: React.Context<RouterData<NavigationBase> | null>;

package/build/ScreenBase.d.ts

@@ -0,0 +1,61 @@
+import React from "react";
+import { AnimationConfig, AnimationConfigFactory, AnimationConfigSet, AnimationKeyframeEffectConfig, LazyExoticComponent, PlainObject, ReducedAnimationConfigSet, SwipeDirection } from "./common/types";
+import { RouterDataContext } from "./RouterData";
+export interface ScreenBaseProps {
+    out?: boolean;
+    in?: boolean;
+    component: React.JSXElementConstructor<any> | LazyExoticComponent<any>;
+    fallback?: React.ReactNode;
+    path?: string;
+    resolvedPathname?: string;
+    defaultParams?: PlainObject;
+    name?: string;
+    config?: {
+        animation?: ReducedAnimationConfigSet | AnimationConfig | AnimationKeyframeEffectConfig | AnimationConfigFactory;
+        pseudoElement?: {
+            selector: string;
+            animation?: ReducedAnimationConfigSet | AnimationConfig | AnimationKeyframeEffectConfig | AnimationConfigFactory;
+        };
+        keepAlive?: boolean;
+        swipeDirection?: SwipeDirection;
+        swipeAreaWidth?: number;
+        minFlingVelocity?: number;
+        hysteresis?: number;
+        disableDiscovery?: boolean;
+    };
+}
+export interface ScreenBaseState {
+    fallback?: React.ReactNode;
+    shouldKeepAlive: boolean;
+}
+export default abstract class ScreenBase<P extends ScreenBaseProps = ScreenBaseProps, S extends ScreenBaseState = ScreenBaseState> extends React.Component<P, S> {
+    private name;
+    private sharedElementScene;
+    private ref;
+    private contextParams;
+    private onRef;
+    private animation;
+    private pseudoElementAnimation;
+    static contextType: React.Context<import("./RouterData").default<import("./NavigationBase").default> | null>;
+    context: React.ContextType<typeof RouterDataContext>;
+    static defaultProps: {
+        route: {
+            params: {};
+        };
+    };
+    state: S;
+    componentDidMount(): void;
+    shouldComponentUpdate(nextProps: P): boolean;
+    componentDidUpdate(prevProps: P): void;
+    setupAnimation(animation?: ReducedAnimationConfigSet | AnimationConfig | AnimationKeyframeEffectConfig | AnimationConfigFactory): (() => AnimationConfigSet) | {
+        in: (AnimationConfig | AnimationKeyframeEffectConfig | undefined) & (AnimationConfig | AnimationKeyframeEffectConfig);
+        out: (AnimationConfig | AnimationKeyframeEffectConfig | undefined) & (AnimationConfig | AnimationKeyframeEffectConfig);
+    } | null;
+    animationFactory(animation?: AnimationKeyframeEffectConfig | AnimationConfig | ReducedAnimationConfigSet | AnimationConfigFactory): AnimationConfigSet;
+    onExit: () => void;
+    onEnter: () => void;
+    private setTransforms;
+    private setRef;
+    get resolvedPathname(): P["resolvedPathname"] | undefined;
+    render(): JSX.Element;
+}

package/build/ScrollRestoration.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+interface ScrollRestorationProps extends React.HTMLAttributes<HTMLDivElement> {
+    id: string;
+    children: JSX.Element;
+    hashScrollConfig?: ScrollIntoViewOptions;
+    shouldRestore?: boolean;
+}
+export default class ScrollRestoration extends React.Component<ScrollRestorationProps> {
+    private ref;
+    private scrollPos;
+    private routerData;
+    private _mounted;
+    constructor(props: ScrollRestorationProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    onPageAnimationEnd: () => void;
+    onHashChange: () => void;
+    setRef: (ref: HTMLElement | null) => void;
+    get scrollTop(): number;
+    get scrollLeft(): number;
+    get scrollWidth(): number;
+    get scrollHeight(): number;
+    render(): JSX.Element;
+}
+export {};

package/build/ScrollRestorationData.d.ts

@@ -0,0 +1,6 @@
+import { Vec2 } from "./common/types";
+export declare class ScrollRestorationData {
+    private _map;
+    set(key: string, scrollPos?: Vec2): void;
+    get(key: string): Vec2 | undefined;
+}

package/build/SharedElement.d.ts

@@ -0,0 +1,141 @@
+import React from 'react';
+import { EasingFunction, PlainObject, Vec2 } from './common/types';
+declare enum TransformOriginKeywordEnum {
+    center = 0,
+    top = 1,
+    bottom = 2,
+    left = 3,
+    right = 4
+}
+declare enum TransformOriginLengthUnitEnum {
+    cap = 0,
+    ch = 1,
+    em = 2,
+    ex = 3,
+    ic = 4,
+    lh = 5,
+    rem = 6,
+    rlh = 7,
+    vh = 8,
+    vw = 9,
+    vi = 10,
+    vb = 11,
+    vmin = 12,
+    vmax = 13,
+    px = 14,
+    cm = 15,
+    mm = 16,
+    Q = 17,
+    in = 18,
+    pc = 19,
+    pt = 20,
+    '%' = 21
+}
+declare enum TransformOriginGlobalEnum {
+    inital = 0,
+    inherit = 1,
+    revert = 2,
+    unset = 3
+}
+declare enum TransitionAnimationEnum {
+    "morph" = 0,
+    "fade-through" = 1,
+    "fade" = 2,
+    "cross-fade" = 3
+}
+type TransitionAnimation = keyof typeof TransitionAnimationEnum;
+type TransformOriginGlobal = keyof typeof TransformOriginGlobalEnum;
+type TransformOriginLengthUnit = keyof typeof TransformOriginLengthUnitEnum;
+type TransformOriginLength = `${number}${TransformOriginLengthUnit}` | 0;
+type TransformOriginKeyword = keyof typeof TransformOriginKeywordEnum;
+type OneValueTransformOrigin = TransformOriginKeyword | TransformOriginLength;
+type TwoValueTransformOrigin = `${OneValueTransformOrigin} ${OneValueTransformOrigin}`;
+type ThreeValueTransformOrigin = `${OneValueTransformOrigin} ${OneValueTransformOrigin} ${TransformOriginLength}`;
+type TransformOrigin = TransformOriginGlobal | OneValueTransformOrigin | TwoValueTransformOrigin | ThreeValueTransformOrigin;
+export interface SharedElementNode {
+    id: string;
+    instance: SharedElement;
+}
+export type SharedElementNodeMap = Map<string, SharedElementNode>;
+export declare class SharedElementScene {
+    private _nodes;
+    private _name;
+    private _scrollPos;
+    private _x;
+    private _y;
+    private _xRatio;
+    private _yRatio;
+    private _keepAlive;
+    constructor(name: string);
+    addNode(node: SharedElementNode | null): void;
+    removeNode(_id: string): void;
+    get xRatio(): number;
+    get yRatio(): number;
+    get nodes(): SharedElementNodeMap;
+    get name(): string;
+    get scrollPos(): Vec2;
+    get x(): number;
+    get y(): number;
+    get keepAlive(): boolean;
+    set scrollPos(_scrollPos: Vec2);
+    set x(_x: number);
+    set y(_y: number);
+    set xRatio(_xRatio: number);
+    set yRatio(_yRatio: number);
+    set keepAlive(_keepAlive: boolean);
+    isEmpty(): boolean;
+}
+export declare const SharedElementSceneContext: React.Context<SharedElementScene | null>;
+interface SharedElementConfig {
+    type?: TransitionAnimation;
+    transformOrigin?: TransformOrigin;
+    easingFunction?: EasingFunction;
+    duration?: number;
+    delay?: number;
+    x?: {
+        delay?: number;
+        duration?: number;
+        easingFunction?: EasingFunction;
+    };
+    y?: {
+        delay?: number;
+        duration?: number;
+        easingFunction?: EasingFunction;
+    };
+}
+interface SharedElementProps {
+    id: string | number;
+    children: React.ReactChild;
+    config?: SharedElementConfig;
+}
+interface SharedElementState {
+    hidden: boolean;
+    keepAlive: boolean;
+}
+export declare class SharedElement extends React.Component<SharedElementProps, SharedElementState> {
+    private _id;
+    private _ref;
+    private _scene;
+    private _mutationObserver;
+    private _callbackID;
+    private _computedStyle;
+    private _isMounted;
+    private onRef;
+    state: SharedElementState;
+    get scene(): SharedElementScene | null;
+    get node(): HTMLElement | null;
+    get clientRect(): DOMRect;
+    get CSSData(): [string, PlainObject<string>];
+    get CSSText(): string;
+    get id(): string;
+    get transitionType(): "fade" | "morph" | "fade-through" | "cross-fade" | undefined;
+    keepAlive(_keepAlive: boolean): Promise<void>;
+    hidden(_hidden: boolean): Promise<void>;
+    private setRef;
+    updateScene(): void;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    render(): JSX.Element;
+}
+export {};

package/build/common/hooks.d.ts

@@ -0,0 +1,4 @@
+import { NavigationBase } from "..";
+export declare function useReducedMotion(): boolean;
+export declare function useNavigation<T extends NavigationBase = NavigationBase>(): NavigationBase;
+export declare function useMotion(): number;

package/build/common/types.d.ts

@@ -0,0 +1,80 @@
+/// <reference types="react" />
+import NavigationBase from '../NavigationBase';
+import ScreenBase, { ScreenBaseProps } from '../ScreenBase';
+export type ScreenChild<P extends ScreenBaseProps = ScreenBaseProps, E extends typeof ScreenBase = typeof ScreenBase> = React.ReactElement<P, React.JSXElementConstructor<E>>;
+declare enum AnimationDirectionEnum {
+    up = 0,
+    down = 1,
+    left = 2,
+    right = 3,
+    in = 4,
+    out = 5
+}
+declare enum AnimationTypeEnum {
+    slide = 0,
+    fade = 1,
+    zoom = 2,
+    none = 3
+}
+declare enum EasingFunctionKeywordEnum {
+    "ease" = 0,
+    "ease-in" = 1,
+    "ease-in-out" = 2,
+    "ease-out" = 3,
+    "linear" = 4
+}
+export type EasingFunctionKeyword = keyof typeof EasingFunctionKeywordEnum;
+export type EasingFunction = EasingFunctionKeyword | `cubic-bezier(${number},${' ' | ''}${number},${' ' | ''}${number},${' ' | ''}${number})`;
+export type ParamsSerializer = (params: PlainObject) => string;
+export type ParamsDeserializer = (queryString: string) => PlainObject;
+export type AnimationType = keyof typeof AnimationTypeEnum;
+export type AnimationDirection = keyof typeof AnimationDirectionEnum;
+export interface AnimationConfig {
+    type: AnimationType;
+    direction?: AnimationDirection;
+    duration: number;
+    easingFunction?: EasingFunction;
+}
+export interface AnimationKeyframeEffectConfig {
+    keyframes: Keyframe[] | PropertyIndexedKeyframes | null;
+    options?: number | KeyframeEffectOptions;
+}
+export interface AnimationConfigSet {
+    in: AnimationConfig | AnimationKeyframeEffectConfig;
+    out: AnimationConfig | AnimationKeyframeEffectConfig;
+}
+export type ReducedAnimationConfigSet = Partial<AnimationConfigSet> & Pick<AnimationConfigSet, 'in'>;
+export type AnimationConfigFactory = (currentPath: string, nextPath: string, gestureNavigating: boolean) => AnimationConfig | AnimationKeyframeEffectConfig | ReducedAnimationConfigSet;
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export type SwipeDirection = 'up' | 'down' | 'left' | 'right';
+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 type MetaTypeKey = 'http-equiv' | 'name' | 'itemprop' | 'property' | 'charset';
+export type MetaType = [MetaTypeKey, string];
+export type MetaKey = `${MetaTypeKey}=${string}`;
+export type SearchParamsDeserializer = (queryString: string) => PlainObject;
+export type SearchParamsSerializer = (params: PlainObject) => string;
+export interface LazyExoticComponent<T extends React.ComponentType<any>> extends React.LazyExoticComponent<T> {
+    preload: () => Promise<{
+        default: T;
+    }>;
+    preloaded: T | undefined;
+}
+export interface ScreenComponentBaseProps<T extends PlainObject = {}, N extends NavigationBase = NavigationBase> {
+    route: {
+        params: T;
+        preloaded: boolean;
+    };
+    navigation: N;
+    orientation: ScreenOrientation;
+}
+export type PlainObject<T = any> = {
+    [key: string]: T;
+};
+export type RouterEventMap = Pick<HTMLElementEventMap, "navigate" | "go-back" | "motion-progress" | "motion-progress-start" | "motion-progress-end" | "page-animation-start" | "page-animation-end" | "page-animation-cancel">;
+export {};

package/build/common/utils.d.ts

@@ -0,0 +1,31 @@
+import React from "react";
+import RouterData from "../RouterData";
+import { LazyExoticComponent, PlainObject, SearchParamsDeserializer, SearchParamsSerializer } from "./types";
+export declare function getCSSData(styles: CSSStyleDeclaration, object?: boolean): [string, PlainObject<string>];
+export declare function getStyleObject(styles: CSSStyleDeclaration): PlainObject<string>;
+export declare function clamp(num: number, min: number, max?: number): number;
+export interface MatchedRoute {
+    matchedPathname?: string;
+    rest?: string;
+    exact: boolean;
+}
+export declare function matchRoute(routeTest: string | undefined, route: string | undefined, baseURL?: string): MatchedRoute | null;
+export declare function includesRoute(routeString: string | undefined, routeTests: (string | undefined)[], baseURL?: string): boolean;
+export declare function dispatchEvent<T>(event: CustomEvent<T> | Event, target?: HTMLElement | EventTarget): Promise<boolean>;
+export declare function concatenateURL(path: string | URL, base: string | URL): URL;
+export declare function defaultSearchParamsToObject(searchPart: string): PlainObject<string> | undefined;
+export declare function searchParamsToObject(searchPart: string, paramsDeserializer: SearchParamsDeserializer | null): PlainObject<any>;
+export declare function searchParamsFromObject(params: {
+    [key: string]: any;
+}, paramsSerializer: SearchParamsSerializer | null): string;
+export declare function lazy<T extends React.ComponentType<any>>(factory: () => Promise<{
+    default: T;
+}>): LazyExoticComponent<T>;
+/**
+ * Searches router data tree for matching screen. Once the screen is found
+ * its component is preloaded.
+ * @param path
+ * @param routerData
+ * @returns
+ */
+export declare function prefetchRoute(path: string, routerData: RouterData): Promise<boolean>;

package/build/common/utils.js

@@ -0,0 +1 @@
+var e={689:e=>{e.exports=require("react")}},t={};function r(n){var a=t[n];if(void 0!==a)return a.exports;var o=t[n]={exports:{}};return e[n](o,o.exports,r),o.exports}r.n=e=>{var t=e&&e.__esModule?()=>e.default:()=>e;return r.d(t,{a:t}),t},r.d=(e,t)=>{for(var n in t)r.o(t,n)&&!r.o(e,n)&&Object.defineProperty(e,n,{enumerable:!0,get:t[n]})},r.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t);var n={};(()=>{r.d(n,{Nu:()=>u,Po:()=>d,QN:()=>i,Vo:()=>h,cT:()=>o,e1:()=>c,fJ:()=>p,hR:()=>a,kI:()=>m,r2:()=>l,rL:()=>f,uZ:()=>s});var e=r(689),t=r.n(e);function a(e,t=!0){let r="";const n={};let a=0;for(let o in e){if(a<e.length){const t=e[o];let n=e.getPropertyValue(t);if("visibility"===t)n="visible";r+=`${t}:${n};`}else{if(!t)break;let r=o,a=e[r];if("string"==typeof a&&"cssText"!==r&&!r.includes("webkit")&&!r.includes("grid")){switch(r){case"offset":r="cssOffset";break;case"float":r="cssFloat";break;case"visibility":a="visible"}n[r]=a}}a++}return[r,n]}function o(e){const t={};for(const r in e)if(e[r]&&e[r].length&&"function"!=typeof e[r]){if(/^\d+$/.test(r))continue;if("offset"===r)continue;t[r]=e[r]}return t}function s(e,t,r){return e<t?t:r&&e>r?r:e}function i(e,t,r=window.location.origin){if(void 0===e||void 0===t)return e===t?{exact:!0,matchedPathname:t}:null;const n=new URLPattern(e,r),a=new URL(t,r),o=n.exec(a);let s="",i="";for(let r=0;r<e.length;r++){if(e[r]!==t[r]){i=t.substring(r);break}s+=e[r]}return o?{exact:e===t,matchedPathname:s,rest:i}:null}function c(e,t,r=window.location.origin){return t.some((t=>i(t,e,r)))}function u(e,t=window){return new Promise((r=>{queueMicrotask((()=>r(t.dispatchEvent(e))))}))}function l(e,t){return"string"==typeof t&&(t=new URL(t)),"string"!=typeof e&&(e=e.pathname),e=e.replace(/^\//,""),t.pathname.endsWith("/")||(t=new URL(t.href+"/")),new URL(e,t)}function f(e){const t=new URLSearchParams(decodeURI(e)).entries(),r={};for(const[e,n]of t){let t="";try{t=JSON.parse(n)}catch(e){console.warn("Non JSON serialisable value was passed as URL route param."),t=n}r[e]=t}return Object.keys(r).length?r:void 0}function p(e,t){return(t||f)(e)||{}}function d(e,t){try{return(t||function(e){return new URLSearchParams(e).toString()})(e)}catch(e){console.error(e),console.warn("Non JSON serialisable value was passed as route param to Anchor.")}return""}function h(e){const r=t().lazy(e);return r.preload=()=>{const t=e();return t.then((e=>r.preloaded=e.default)).catch(console.error),t},r}function m(e,r){let n=r;return new Promise(((a,o)=>{let s=!1;for(;n;){const c=n.routes;if(t().Children.forEach(c,(r=>{if(s)return;if(!t().isValidElement(r))return;i(r.props.path,e)&&(s=!0,queueMicrotask((async()=>{if("preload"in r.props.component)try{await r.props.component.preload(),a(s)}catch(e){o(e)}})))})),s)break;n=r.parentRouterData}s||a(!1)}))}})();var a=n.uZ,o=n.r2,s=n.rL,i=n.Nu,c=n.hR,u=n.cT,l=n.e1,f=n.Vo,p=n.QN,d=n.kI,h=n.Po,m=n.fJ;export{a as clamp,o as concatenateURL,s as defaultSearchParamsToObject,i as dispatchEvent,c as getCSSData,u as getStyleObject,l as includesRoute,f as lazy,p as matchRoute,d as prefetchRoute,h as searchParamsFromObject,m as searchParamsToObject};

package/build/index.d.ts

@@ -0,0 +1,36 @@
+import { ScreenChild, AnimationConfig, AnimationConfigFactory } from './common/types';
+import RouterData from './RouterData';
+import NavigationBase from './NavigationBase';
+import type { BackEvent, BackEventDetail, NavigateEvent, NavigateEventDetail, NavigateOptions, NavigationOptions, GoBackOptions } from './NavigationBase';
+import RouterBase, { RouterBaseProps, RouterBaseState } from './RouterBase';
+import ScreenBase, { ScreenBaseProps, ScreenBaseState } from './ScreenBase';
+import HistoryBase from './HistoryBase';
+import Anchor from './Anchor';
+import { Motion } from './AnimationLayer';
+import type AnimationLayerData from './AnimationLayerData';
+import GestureRegion from './GestureRegion';
+import 'web-gesture-events';
+import { MotionProgressEndEvent, MotionProgressEvent, MotionProgressStartEvent, PageAnimationCancelEvent, PageAnimationEndEvent, PageAnimationStartEvent } from './MotionEvents';
+import ScrollRestoration from './ScrollRestoration';
+import { SharedElement } from './SharedElement';
+interface MotionEventsMap {
+    "page-animation-start": PageAnimationStartEvent;
+    "page-animation-cancel": PageAnimationCancelEvent;
+    "page-animation-end": PageAnimationEndEvent;
+    "motion-progress-start": MotionProgressStartEvent;
+    "motion-progress": MotionProgressEvent;
+    "motion-progress-end": MotionProgressEndEvent;
+    "go-back": BackEvent;
+    "navigate": NavigateEvent;
+}
+declare global {
+    interface GlobalEventHandlersEventMap extends MotionEventsMap {
+    }
+}
+export type { AnimationConfig, AnimationConfigFactory, ScreenChild, RouterBaseProps, RouterBaseState, ScreenBaseProps, ScreenBaseState };
+export { SharedElement, Anchor, Motion, GestureRegion, ScrollRestoration };
+export { NavigationBase, HistoryBase, RouterBase, RouterData, ScreenBase };
+export type { MotionProgressEndEvent, MotionProgressEvent, MotionProgressStartEvent, BackEvent, BackEventDetail, NavigateEvent, NavigateEventDetail, NavigateOptions, NavigationOptions, GoBackOptions, AnimationLayerData };
+export * from './common/hooks';
+export * from './common/types';
+export * from './common/utils';