{"version":3,"file":"7143.0e281cf29b101b30e623.js","mappings":"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","sources":["webpack:///../node_modules/@ionic/react-router/dist/index.esm.js"],"sourcesContent":["import { __rest } from 'tslib';\nimport { createBrowserHistory, createHashHistory } from 'history';\nimport React from 'react';\nimport { matchPath as matchPath$1, withRouter, Router } from 'react-router-dom';\nimport { ViewStacks, generateId, IonRoute, ViewLifeCycleManager, StackContext, RouteManagerContext, getConfig, LocationHistory, NavManager } from '@ionic/react';\nimport { Route, matchPath, Router as Router$1 } from 'react-router';\n\nclass IonRouteInner extends React.PureComponent {\n    render() {\n        return (React.createElement(Route, { path: this.props.path, exact: this.props.exact, render: this.props.render, \n            /**\n             * `computedMatch` is a private API in react-router v5 that\n             * has been removed in v6.\n             *\n             * This needs to be removed when we support v6.\n             *\n             * TODO: FW-647\n             */\n            computedMatch: this.props.computedMatch }));\n    }\n}\n\nclass ReactRouterViewStack extends ViewStacks {\n    constructor() {\n        super();\n        this.createViewItem = this.createViewItem.bind(this);\n        this.findViewItemByRouteInfo = this.findViewItemByRouteInfo.bind(this);\n        this.findLeavingViewItemByRouteInfo = this.findLeavingViewItemByRouteInfo.bind(this);\n        this.getChildrenToRender = this.getChildrenToRender.bind(this);\n        this.findViewItemByPathname = this.findViewItemByPathname.bind(this);\n    }\n    createViewItem(outletId, reactElement, routeInfo, page) {\n        const viewItem = {\n            id: generateId('viewItem'),\n            outletId,\n            ionPageElement: page,\n            reactElement,\n            mount: true,\n            ionRoute: false,\n        };\n        const matchProps = {\n            exact: reactElement.props.exact,\n            path: reactElement.props.path || reactElement.props.from,\n            component: reactElement.props.component,\n        };\n        const match = matchPath(routeInfo.pathname, matchProps);\n        if (reactElement.type === IonRoute) {\n            viewItem.ionRoute = true;\n            viewItem.disableIonPageManagement = reactElement.props.disableIonPageManagement;\n        }\n        viewItem.routeData = {\n            match,\n            childProps: reactElement.props,\n        };\n        return viewItem;\n    }\n    getChildrenToRender(outletId, ionRouterOutlet, routeInfo) {\n        const viewItems = this.getViewItemsForOutlet(outletId);\n        // Sync latest routes with viewItems\n        React.Children.forEach(ionRouterOutlet.props.children, (child) => {\n            const viewItem = viewItems.find((v) => {\n                return matchComponent$1(child, v.routeData.childProps.path || v.routeData.childProps.from);\n            });\n            if (viewItem) {\n                viewItem.reactElement = child;\n            }\n        });\n        const children = viewItems.map((viewItem) => {\n            let clonedChild;\n            if (viewItem.ionRoute && !viewItem.disableIonPageManagement) {\n                clonedChild = (React.createElement(ViewLifeCycleManager, { key: `view-${viewItem.id}`, mount: viewItem.mount, removeView: () => this.remove(viewItem) }, React.cloneElement(viewItem.reactElement, {\n                    computedMatch: viewItem.routeData.match,\n                })));\n            }\n            else {\n                const match = matchComponent$1(viewItem.reactElement, routeInfo.pathname);\n                clonedChild = (React.createElement(ViewLifeCycleManager, { key: `view-${viewItem.id}`, mount: viewItem.mount, removeView: () => this.remove(viewItem) }, React.cloneElement(viewItem.reactElement, {\n                    computedMatch: viewItem.routeData.match,\n                })));\n                if (!match && viewItem.routeData.match) {\n                    viewItem.routeData.match = undefined;\n                    viewItem.mount = false;\n                }\n            }\n            return clonedChild;\n        });\n        return children;\n    }\n    findViewItemByRouteInfo(routeInfo, outletId, updateMatch) {\n        const { viewItem, match } = this.findViewItemByPath(routeInfo.pathname, outletId);\n        const shouldUpdateMatch = updateMatch === undefined || updateMatch === true;\n        if (shouldUpdateMatch && viewItem && match) {\n            viewItem.routeData.match = match;\n        }\n        return viewItem;\n    }\n    findLeavingViewItemByRouteInfo(routeInfo, outletId, mustBeIonRoute = true) {\n        const { viewItem } = this.findViewItemByPath(routeInfo.lastPathname, outletId, false, mustBeIonRoute);\n        return viewItem;\n    }\n    findViewItemByPathname(pathname, outletId) {\n        const { viewItem } = this.findViewItemByPath(pathname, outletId);\n        return viewItem;\n    }\n    findViewItemByPath(pathname, outletId, forceExact, mustBeIonRoute) {\n        let viewItem;\n        let match;\n        let viewStack;\n        if (outletId) {\n            viewStack = this.getViewItemsForOutlet(outletId);\n            viewStack.some(matchView);\n            if (!viewItem) {\n                viewStack.some(matchDefaultRoute);\n            }\n        }\n        else {\n            const viewItems = this.getAllViewItems();\n            viewItems.some(matchView);\n            if (!viewItem) {\n                viewItems.some(matchDefaultRoute);\n            }\n        }\n        return { viewItem, match };\n        function matchView(v) {\n            if (mustBeIonRoute && !v.ionRoute) {\n                return false;\n            }\n            const matchProps = {\n                exact: forceExact ? true : v.routeData.childProps.exact,\n                path: v.routeData.childProps.path || v.routeData.childProps.from,\n                component: v.routeData.childProps.component,\n            };\n            const myMatch = matchPath(pathname, matchProps);\n            if (myMatch) {\n                viewItem = v;\n                match = myMatch;\n                return true;\n            }\n            return false;\n        }\n        function matchDefaultRoute(v) {\n            // try to find a route that doesn't have a path or from prop, that will be our default route\n            if (!v.routeData.childProps.path && !v.routeData.childProps.from) {\n                match = {\n                    path: pathname,\n                    url: pathname,\n                    isExact: true,\n                    params: {},\n                };\n                viewItem = v;\n                return true;\n            }\n            return false;\n        }\n    }\n}\nfunction matchComponent$1(node, pathname, forceExact) {\n    const matchProps = {\n        exact: forceExact ? true : node.props.exact,\n        path: node.props.path || node.props.from,\n        component: node.props.component,\n    };\n    const match = matchPath(pathname, matchProps);\n    return match;\n}\n\nfunction clonePageElement(leavingViewHtml) {\n    let html;\n    if (typeof leavingViewHtml === 'string') {\n        html = leavingViewHtml;\n    }\n    else {\n        html = leavingViewHtml.outerHTML;\n    }\n    if (document) {\n        const newEl = document.createElement('div');\n        newEl.innerHTML = html;\n        newEl.style.zIndex = '';\n        // Remove an existing back button so the new element doesn't get two of them\n        const ionBackButton = newEl.getElementsByTagName('ion-back-button');\n        if (ionBackButton[0]) {\n            ionBackButton[0].remove();\n        }\n        return newEl.firstChild;\n    }\n    return undefined;\n}\n\nconst isViewVisible = (el) => !el.classList.contains('ion-page-invisible') && !el.classList.contains('ion-page-hidden');\nclass StackManager extends React.PureComponent {\n    constructor(props) {\n        super(props);\n        this.stackContextValue = {\n            registerIonPage: this.registerIonPage.bind(this),\n            isInOutlet: () => true,\n        };\n        this.pendingPageTransition = false;\n        this.registerIonPage = this.registerIonPage.bind(this);\n        this.transitionPage = this.transitionPage.bind(this);\n        this.handlePageTransition = this.handlePageTransition.bind(this);\n        this.id = generateId('routerOutlet');\n        this.prevProps = undefined;\n        this.skipTransition = false;\n    }\n    componentDidMount() {\n        if (this.clearOutletTimeout) {\n            /**\n             * The clearOutlet integration with React Router is a bit hacky.\n             * It uses a timeout to clear the outlet after a transition.\n             * In React v18, components are mounted and unmounted in development mode\n             * to check for side effects.\n             *\n             * This clearTimeout prevents the outlet from being cleared when the component is re-mounted,\n             * which should only happen in development mode and as a result of a hot reload.\n             */\n            clearTimeout(this.clearOutletTimeout);\n        }\n        if (this.routerOutletElement) {\n            this.setupRouterOutlet(this.routerOutletElement);\n            this.handlePageTransition(this.props.routeInfo);\n        }\n    }\n    componentDidUpdate(prevProps) {\n        const { pathname } = this.props.routeInfo;\n        const { pathname: prevPathname } = prevProps.routeInfo;\n        if (pathname !== prevPathname) {\n            this.prevProps = prevProps;\n            this.handlePageTransition(this.props.routeInfo);\n        }\n        else if (this.pendingPageTransition) {\n            this.handlePageTransition(this.props.routeInfo);\n            this.pendingPageTransition = false;\n        }\n    }\n    componentWillUnmount() {\n        this.clearOutletTimeout = this.context.clearOutlet(this.id);\n    }\n    async handlePageTransition(routeInfo) {\n        var _a, _b;\n        if (!this.routerOutletElement || !this.routerOutletElement.commit) {\n            /**\n             * The route outlet has not mounted yet. We need to wait for it to render\n             * before we can transition the page.\n             *\n             * Set a flag to indicate that we should transition the page after\n             * the component has updated.\n             */\n            this.pendingPageTransition = true;\n        }\n        else {\n            let enteringViewItem = this.context.findViewItemByRouteInfo(routeInfo, this.id);\n            let leavingViewItem = this.context.findLeavingViewItemByRouteInfo(routeInfo, this.id);\n            if (!leavingViewItem && routeInfo.prevRouteLastPathname) {\n                leavingViewItem = this.context.findViewItemByPathname(routeInfo.prevRouteLastPathname, this.id);\n            }\n            // Check if leavingViewItem should be unmounted\n            if (leavingViewItem) {\n                if (routeInfo.routeAction === 'replace') {\n                    leavingViewItem.mount = false;\n                }\n                else if (!(routeInfo.routeAction === 'push' && routeInfo.routeDirection === 'forward')) {\n                    if (routeInfo.routeDirection !== 'none' && enteringViewItem !== leavingViewItem) {\n                        leavingViewItem.mount = false;\n                    }\n                }\n                else if ((_a = routeInfo.routeOptions) === null || _a === void 0 ? void 0 : _a.unmount) {\n                    leavingViewItem.mount = false;\n                }\n            }\n            const enteringRoute = matchRoute((_b = this.ionRouterOutlet) === null || _b === void 0 ? void 0 : _b.props.children, routeInfo);\n            if (enteringViewItem) {\n                enteringViewItem.reactElement = enteringRoute;\n            }\n            else if (enteringRoute) {\n                enteringViewItem = this.context.createViewItem(this.id, enteringRoute, routeInfo);\n                this.context.addViewItem(enteringViewItem);\n            }\n            if (enteringViewItem && enteringViewItem.ionPageElement) {\n                /**\n                 * If the entering view item is the same as the leaving view item,\n                 * then we don't need to transition.\n                 */\n                if (enteringViewItem === leavingViewItem) {\n                    /**\n                     * If the entering view item is the same as the leaving view item,\n                     * we are either transitioning using parameterized routes to the same view\n                     * or a parent router outlet is re-rendering as a result of React props changing.\n                     *\n                     * If the route data does not match the current path, the parent router outlet\n                     * is attempting to transition and we cancel the operation.\n                     */\n                    if (enteringViewItem.routeData.match.url !== routeInfo.pathname) {\n                        return;\n                    }\n                }\n                /**\n                 * If there isn't a leaving view item, but the route info indicates\n                 * that the user has routed from a previous path, then we need\n                 * to find the leaving view item to transition between.\n                 */\n                if (!leavingViewItem && this.props.routeInfo.prevRouteLastPathname) {\n                    leavingViewItem = this.context.findViewItemByPathname(this.props.routeInfo.prevRouteLastPathname, this.id);\n                }\n                /**\n                 * If the entering view is already visible and the leaving view is not, the transition does not need to occur.\n                 */\n                if (isViewVisible(enteringViewItem.ionPageElement) &&\n                    leavingViewItem !== undefined &&\n                    !isViewVisible(leavingViewItem.ionPageElement)) {\n                    return;\n                }\n                /**\n                 * The view should only be transitioned in the following cases:\n                 * 1. Performing a replace or pop action, such as a swipe to go back gesture\n                 * to animation the leaving view off the screen.\n                 *\n                 * 2. Navigating between top-level router outlets, such as /page-1 to /page-2;\n                 * or navigating within a nested outlet, such as /tabs/tab-1 to /tabs/tab-2.\n                 *\n                 * 3. The entering view is an ion-router-outlet containing a page\n                 * matching the current route and that hasn't already transitioned in.\n                 *\n                 * This should only happen when navigating directly to a nested router outlet\n                 * route or on an initial page load (i.e. refreshing). In cases when loading\n                 * /tabs/tab-1, we need to transition the /tabs page element into the view.\n                 */\n                this.transitionPage(routeInfo, enteringViewItem, leavingViewItem);\n            }\n            else if (leavingViewItem && !enteringRoute && !enteringViewItem) {\n                // If we have a leavingView but no entering view/route, we are probably leaving to\n                // another outlet, so hide this leavingView. We do it in a timeout to give time for a\n                // transition to finish.\n                // setTimeout(() => {\n                if (leavingViewItem.ionPageElement) {\n                    leavingViewItem.ionPageElement.classList.add('ion-page-hidden');\n                    leavingViewItem.ionPageElement.setAttribute('aria-hidden', 'true');\n                }\n                // }, 250);\n            }\n            this.forceUpdate();\n        }\n    }\n    registerIonPage(page, routeInfo) {\n        const foundView = this.context.findViewItemByRouteInfo(routeInfo, this.id);\n        if (foundView) {\n            const oldPageElement = foundView.ionPageElement;\n            foundView.ionPageElement = page;\n            foundView.ionRoute = true;\n            /**\n             * React 18 will unmount and remount IonPage\n             * elements in development mode when using createRoot.\n             * This can cause duplicate page transitions to occur.\n             */\n            if (oldPageElement === page) {\n                return;\n            }\n        }\n        this.handlePageTransition(routeInfo);\n    }\n    async setupRouterOutlet(routerOutlet) {\n        const canStart = () => {\n            const config = getConfig();\n            const swipeEnabled = config && config.get('swipeBackEnabled', routerOutlet.mode === 'ios');\n            if (!swipeEnabled) {\n                return false;\n            }\n            const { routeInfo } = this.props;\n            const propsToUse = this.prevProps && this.prevProps.routeInfo.pathname === routeInfo.pushedByRoute\n                ? this.prevProps.routeInfo\n                : { pathname: routeInfo.pushedByRoute || '' };\n            const enteringViewItem = this.context.findViewItemByRouteInfo(propsToUse, this.id, false);\n            return (!!enteringViewItem &&\n                /**\n                 * The root url '/' is treated as\n                 * the first view item (but is never mounted),\n                 * so we do not want to swipe back to the\n                 * root url.\n                 */\n                enteringViewItem.mount &&\n                /**\n                 * When on the first page (whatever view\n                 * you land on after the root url) it\n                 * is possible for findViewItemByRouteInfo to\n                 * return the exact same view you are currently on.\n                 * Make sure that we are not swiping back to the same\n                 * instances of a view.\n                 */\n                enteringViewItem.routeData.match.path !== routeInfo.pathname);\n        };\n        const onStart = async () => {\n            const { routeInfo } = this.props;\n            const propsToUse = this.prevProps && this.prevProps.routeInfo.pathname === routeInfo.pushedByRoute\n                ? this.prevProps.routeInfo\n                : { pathname: routeInfo.pushedByRoute || '' };\n            const enteringViewItem = this.context.findViewItemByRouteInfo(propsToUse, this.id, false);\n            const leavingViewItem = this.context.findViewItemByRouteInfo(routeInfo, this.id, false);\n            /**\n             * When the gesture starts, kick off\n             * a transition that is controlled\n             * via a swipe gesture.\n             */\n            if (enteringViewItem && leavingViewItem) {\n                await this.transitionPage(routeInfo, enteringViewItem, leavingViewItem, 'back', true);\n            }\n            return Promise.resolve();\n        };\n        const onEnd = (shouldContinue) => {\n            if (shouldContinue) {\n                this.skipTransition = true;\n                this.context.goBack();\n            }\n            else {\n                /**\n                 * In the event that the swipe\n                 * gesture was aborted, we should\n                 * re-hide the page that was going to enter.\n                 */\n                const { routeInfo } = this.props;\n                const propsToUse = this.prevProps && this.prevProps.routeInfo.pathname === routeInfo.pushedByRoute\n                    ? this.prevProps.routeInfo\n                    : { pathname: routeInfo.pushedByRoute || '' };\n                const enteringViewItem = this.context.findViewItemByRouteInfo(propsToUse, this.id, false);\n                const leavingViewItem = this.context.findViewItemByRouteInfo(routeInfo, this.id, false);\n                /**\n                 * Ionic React has a design defect where it\n                 * a) Unmounts the leaving view item when using parameterized routes\n                 * b) Considers the current view to be the entering view when using\n                 * parameterized routes\n                 *\n                 * As a result, we should not hide the view item here\n                 * as it will cause the current view to be hidden.\n                 */\n                if (enteringViewItem !== leavingViewItem && (enteringViewItem === null || enteringViewItem === void 0 ? void 0 : enteringViewItem.ionPageElement) !== undefined) {\n                    const { ionPageElement } = enteringViewItem;\n                    ionPageElement.setAttribute('aria-hidden', 'true');\n                    ionPageElement.classList.add('ion-page-hidden');\n                }\n            }\n        };\n        routerOutlet.swipeHandler = {\n            canStart,\n            onStart,\n            onEnd,\n        };\n    }\n    async transitionPage(routeInfo, enteringViewItem, leavingViewItem, direction, progressAnimation = false) {\n        const runCommit = async (enteringEl, leavingEl) => {\n            const skipTransition = this.skipTransition;\n            /**\n             * If the transition was handled\n             * via the swipe to go back gesture,\n             * then we do not want to perform\n             * another transition.\n             *\n             * We skip adding ion-page or ion-page-invisible\n             * because the entering view already exists in the DOM.\n             * If we added the classes, there would be a flicker where\n             * the view would be briefly hidden.\n             */\n            if (skipTransition) {\n                /**\n                 * We need to reset skipTransition before\n                 * we call routerOutlet.commit otherwise\n                 * the transition triggered by the swipe\n                 * to go back gesture would reset it. In\n                 * that case you would see a duplicate\n                 * transition triggered by handlePageTransition\n                 * in componentDidUpdate.\n                 */\n                this.skipTransition = false;\n            }\n            else {\n                enteringEl.classList.add('ion-page');\n                enteringEl.classList.add('ion-page-invisible');\n            }\n            await routerOutlet.commit(enteringEl, leavingEl, {\n                deepWait: true,\n                duration: skipTransition || directionToUse === undefined ? 0 : undefined,\n                direction: directionToUse,\n                showGoBack: !!routeInfo.pushedByRoute,\n                progressAnimation,\n                animationBuilder: routeInfo.routeAnimation,\n            });\n        };\n        const routerOutlet = this.routerOutletElement;\n        const routeInfoFallbackDirection = routeInfo.routeDirection === 'none' || routeInfo.routeDirection === 'root' ? undefined : routeInfo.routeDirection;\n        const directionToUse = direction !== null && direction !== void 0 ? direction : routeInfoFallbackDirection;\n        if (enteringViewItem && enteringViewItem.ionPageElement && this.routerOutletElement) {\n            if (leavingViewItem && leavingViewItem.ionPageElement && enteringViewItem === leavingViewItem) {\n                // If a page is transitioning to another version of itself\n                // we clone it so we can have an animation to show\n                const match = matchComponent(leavingViewItem.reactElement, routeInfo.pathname, true);\n                if (match) {\n                    const newLeavingElement = clonePageElement(leavingViewItem.ionPageElement.outerHTML);\n                    if (newLeavingElement) {\n                        this.routerOutletElement.appendChild(newLeavingElement);\n                        await runCommit(enteringViewItem.ionPageElement, newLeavingElement);\n                        this.routerOutletElement.removeChild(newLeavingElement);\n                    }\n                }\n                else {\n                    await runCommit(enteringViewItem.ionPageElement, undefined);\n                }\n            }\n            else {\n                await runCommit(enteringViewItem.ionPageElement, leavingViewItem === null || leavingViewItem === void 0 ? void 0 : leavingViewItem.ionPageElement);\n                if (leavingViewItem && leavingViewItem.ionPageElement && !progressAnimation) {\n                    leavingViewItem.ionPageElement.classList.add('ion-page-hidden');\n                    leavingViewItem.ionPageElement.setAttribute('aria-hidden', 'true');\n                }\n            }\n        }\n    }\n    render() {\n        const { children } = this.props;\n        const ionRouterOutlet = React.Children.only(children);\n        this.ionRouterOutlet = ionRouterOutlet;\n        const components = this.context.getChildrenToRender(this.id, this.ionRouterOutlet, this.props.routeInfo, () => {\n            this.forceUpdate();\n        });\n        return (React.createElement(StackContext.Provider, { value: this.stackContextValue }, React.cloneElement(ionRouterOutlet, {\n            ref: (node) => {\n                if (ionRouterOutlet.props.setRef) {\n                    ionRouterOutlet.props.setRef(node);\n                }\n                if (ionRouterOutlet.props.forwardedRef) {\n                    ionRouterOutlet.props.forwardedRef.current = node;\n                }\n                this.routerOutletElement = node;\n                const { ref } = ionRouterOutlet;\n                if (typeof ref === 'function') {\n                    ref(node);\n                }\n            },\n        }, components)));\n    }\n    static get contextType() {\n        return RouteManagerContext;\n    }\n}\nfunction matchRoute(node, routeInfo) {\n    let matchedNode;\n    React.Children.forEach(node, (child) => {\n        const matchProps = {\n            exact: child.props.exact,\n            path: child.props.path || child.props.from,\n            component: child.props.component,\n        };\n        const match = matchPath$1(routeInfo.pathname, matchProps);\n        if (match) {\n            matchedNode = child;\n        }\n    });\n    if (matchedNode) {\n        return matchedNode;\n    }\n    // If we haven't found a node\n    // try to find one that doesn't have a path or from prop, that will be our not found route\n    React.Children.forEach(node, (child) => {\n        if (!(child.props.path || child.props.from)) {\n            matchedNode = child;\n        }\n    });\n    return matchedNode;\n}\nfunction matchComponent(node, pathname, forceExact) {\n    const matchProps = {\n        exact: forceExact ? true : node.props.exact,\n        path: node.props.path || node.props.from,\n        component: node.props.component,\n    };\n    const match = matchPath$1(pathname, matchProps);\n    return match;\n}\n\nclass IonRouterInner extends React.PureComponent {\n    constructor(props) {\n        super(props);\n        this.exitViewFromOtherOutletHandlers = [];\n        this.locationHistory = new LocationHistory();\n        this.viewStack = new ReactRouterViewStack();\n        this.routeMangerContextState = {\n            canGoBack: () => this.locationHistory.canGoBack(),\n            clearOutlet: this.viewStack.clear,\n            findViewItemByPathname: this.viewStack.findViewItemByPathname,\n            getChildrenToRender: this.viewStack.getChildrenToRender,\n            goBack: () => this.handleNavigateBack(),\n            createViewItem: this.viewStack.createViewItem,\n            findViewItemByRouteInfo: this.viewStack.findViewItemByRouteInfo,\n            findLeavingViewItemByRouteInfo: this.viewStack.findLeavingViewItemByRouteInfo,\n            addViewItem: this.viewStack.add,\n            unMountViewItem: this.viewStack.remove,\n        };\n        const routeInfo = {\n            id: generateId('routeInfo'),\n            pathname: this.props.location.pathname,\n            search: this.props.location.search,\n        };\n        this.locationHistory.add(routeInfo);\n        this.handleChangeTab = this.handleChangeTab.bind(this);\n        this.handleResetTab = this.handleResetTab.bind(this);\n        this.handleNativeBack = this.handleNativeBack.bind(this);\n        this.handleNavigate = this.handleNavigate.bind(this);\n        this.handleNavigateBack = this.handleNavigateBack.bind(this);\n        this.props.registerHistoryListener(this.handleHistoryChange.bind(this));\n        this.handleSetCurrentTab = this.handleSetCurrentTab.bind(this);\n        this.state = {\n            routeInfo,\n        };\n    }\n    handleChangeTab(tab, path, routeOptions) {\n        if (!path) {\n            return;\n        }\n        const routeInfo = this.locationHistory.getCurrentRouteInfoForTab(tab);\n        const [pathname, search] = path.split('?');\n        if (routeInfo) {\n            this.incomingRouteParams = Object.assign(Object.assign({}, routeInfo), { routeAction: 'push', routeDirection: 'none' });\n            if (routeInfo.pathname === pathname) {\n                this.incomingRouteParams.routeOptions = routeOptions;\n                this.props.history.push(routeInfo.pathname + (routeInfo.search || ''));\n            }\n            else {\n                this.incomingRouteParams.pathname = pathname;\n                this.incomingRouteParams.search = search ? '?' + search : undefined;\n                this.incomingRouteParams.routeOptions = routeOptions;\n                this.props.history.push(pathname + (search ? '?' + search : ''));\n            }\n        }\n        else {\n            this.handleNavigate(pathname, 'push', 'none', undefined, routeOptions, tab);\n        }\n    }\n    handleHistoryChange(location, action) {\n        var _a, _b, _c;\n        let leavingLocationInfo;\n        if (this.incomingRouteParams) {\n            if (this.incomingRouteParams.routeAction === 'replace') {\n                leavingLocationInfo = this.locationHistory.previous();\n            }\n            else {\n                leavingLocationInfo = this.locationHistory.current();\n            }\n        }\n        else {\n            leavingLocationInfo = this.locationHistory.current();\n        }\n        const leavingUrl = leavingLocationInfo.pathname + leavingLocationInfo.search;\n        if (leavingUrl !== location.pathname) {\n            if (!this.incomingRouteParams) {\n                if (action === 'REPLACE') {\n                    this.incomingRouteParams = {\n                        routeAction: 'replace',\n                        routeDirection: 'none',\n                        tab: this.currentTab,\n                    };\n                }\n                if (action === 'POP') {\n                    const currentRoute = this.locationHistory.current();\n                    if (currentRoute && currentRoute.pushedByRoute) {\n                        const prevInfo = this.locationHistory.findLastLocation(currentRoute);\n                        this.incomingRouteParams = Object.assign(Object.assign({}, prevInfo), { routeAction: 'pop', routeDirection: 'back' });\n                    }\n                    else {\n                        this.incomingRouteParams = {\n                            routeAction: 'pop',\n                            routeDirection: 'none',\n                            tab: this.currentTab,\n                        };\n                    }\n                }\n                if (!this.incomingRouteParams) {\n                    this.incomingRouteParams = {\n                        routeAction: 'push',\n                        routeDirection: ((_a = location.state) === null || _a === void 0 ? void 0 : _a.direction) || 'forward',\n                        routeOptions: (_b = location.state) === null || _b === void 0 ? void 0 : _b.routerOptions,\n                        tab: this.currentTab,\n                    };\n                }\n            }\n            let routeInfo;\n            if ((_c = this.incomingRouteParams) === null || _c === void 0 ? void 0 : _c.id) {\n                routeInfo = Object.assign(Object.assign({}, this.incomingRouteParams), { lastPathname: leavingLocationInfo.pathname });\n                this.locationHistory.add(routeInfo);\n            }\n            else {\n                const isPushed = this.incomingRouteParams.routeAction === 'push' && this.incomingRouteParams.routeDirection === 'forward';\n                routeInfo = Object.assign(Object.assign({ id: generateId('routeInfo') }, this.incomingRouteParams), { lastPathname: leavingLocationInfo.pathname, pathname: location.pathname, search: location.search, params: this.props.match.params, prevRouteLastPathname: leavingLocationInfo.lastPathname });\n                if (isPushed) {\n                    routeInfo.tab = leavingLocationInfo.tab;\n                    routeInfo.pushedByRoute = leavingLocationInfo.pathname;\n                }\n                else if (routeInfo.routeAction === 'pop') {\n                    const r = this.locationHistory.findLastLocation(routeInfo);\n                    routeInfo.pushedByRoute = r === null || r === void 0 ? void 0 : r.pushedByRoute;\n                }\n                else if (routeInfo.routeAction === 'push' && routeInfo.tab !== leavingLocationInfo.tab) {\n                    // If we are switching tabs grab the last route info for the tab and use its pushedByRoute\n                    const lastRoute = this.locationHistory.getCurrentRouteInfoForTab(routeInfo.tab);\n                    routeInfo.pushedByRoute = lastRoute === null || lastRoute === void 0 ? void 0 : lastRoute.pushedByRoute;\n                }\n                else if (routeInfo.routeAction === 'replace') {\n                    // Make sure to set the lastPathname, etc.. to the current route so the page transitions out\n                    const currentRouteInfo = this.locationHistory.current();\n                    /**\n                     * If going from /home to /child, then replacing from\n                     * /child to /home, we don't want the route info to\n                     * say that /home was pushed by /home which is not correct.\n                     */\n                    const currentPushedBy = currentRouteInfo === null || currentRouteInfo === void 0 ? void 0 : currentRouteInfo.pushedByRoute;\n                    const pushedByRoute = currentPushedBy !== undefined && currentPushedBy !== routeInfo.pathname\n                        ? currentPushedBy\n                        : routeInfo.pushedByRoute;\n                    routeInfo.lastPathname = (currentRouteInfo === null || currentRouteInfo === void 0 ? void 0 : currentRouteInfo.pathname) || routeInfo.lastPathname;\n                    routeInfo.prevRouteLastPathname = currentRouteInfo === null || currentRouteInfo === void 0 ? void 0 : currentRouteInfo.lastPathname;\n                    routeInfo.pushedByRoute = pushedByRoute;\n                    routeInfo.routeDirection = (currentRouteInfo === null || currentRouteInfo === void 0 ? void 0 : currentRouteInfo.routeDirection) || routeInfo.routeDirection;\n                    routeInfo.routeAnimation = (currentRouteInfo === null || currentRouteInfo === void 0 ? void 0 : currentRouteInfo.routeAnimation) || routeInfo.routeAnimation;\n                }\n                this.locationHistory.add(routeInfo);\n            }\n            this.setState({\n                routeInfo,\n            });\n        }\n        this.incomingRouteParams = undefined;\n    }\n    /**\n     * history@4.x uses goBack(), history@5.x uses back()\n     * TODO: If support for React Router <=5 is dropped\n     * this logic is no longer needed. We can just\n     * assume back() is available.\n     */\n    handleNativeBack() {\n        const history = this.props.history;\n        const goBack = history.goBack || history.back;\n        goBack();\n    }\n    handleNavigate(path, routeAction, routeDirection, routeAnimation, routeOptions, tab) {\n        this.incomingRouteParams = Object.assign(this.incomingRouteParams || {}, {\n            routeAction,\n            routeDirection,\n            routeOptions,\n            routeAnimation,\n            tab,\n        });\n        if (routeAction === 'push') {\n            this.props.history.push(path);\n        }\n        else {\n            this.props.history.replace(path);\n        }\n    }\n    handleNavigateBack(defaultHref = '/', routeAnimation) {\n        const config = getConfig();\n        defaultHref = defaultHref ? defaultHref : config && config.get('backButtonDefaultHref');\n        const routeInfo = this.locationHistory.current();\n        if (routeInfo && routeInfo.pushedByRoute) {\n            const prevInfo = this.locationHistory.findLastLocation(routeInfo);\n            if (prevInfo) {\n                this.incomingRouteParams = Object.assign(Object.assign({}, prevInfo), { routeAction: 'pop', routeDirection: 'back', routeAnimation: routeAnimation || routeInfo.routeAnimation });\n                if (routeInfo.lastPathname === routeInfo.pushedByRoute ||\n                    /**\n                     * We need to exclude tab switches/tab\n                     * context changes here because tabbed\n                     * navigation is not linear, but router.back()\n                     * will go back in a linear fashion.\n                     */\n                    (prevInfo.pathname === routeInfo.pushedByRoute && routeInfo.tab === '' && prevInfo.tab === '')) {\n                    /**\n                     * history@4.x uses goBack(), history@5.x uses back()\n                     * TODO: If support for React Router <=5 is dropped\n                     * this logic is no longer needed. We can just\n                     * assume back() is available.\n                     */\n                    const history = this.props.history;\n                    const goBack = history.goBack || history.back;\n                    goBack();\n                }\n                else {\n                    this.handleNavigate(prevInfo.pathname + (prevInfo.search || ''), 'pop', 'back');\n                }\n            }\n            else {\n                this.handleNavigate(defaultHref, 'pop', 'back');\n            }\n        }\n        else {\n            this.handleNavigate(defaultHref, 'pop', 'back');\n        }\n    }\n    handleResetTab(tab, originalHref, originalRouteOptions) {\n        const routeInfo = this.locationHistory.getFirstRouteInfoForTab(tab);\n        if (routeInfo) {\n            const newRouteInfo = Object.assign({}, routeInfo);\n            newRouteInfo.pathname = originalHref;\n            newRouteInfo.routeOptions = originalRouteOptions;\n            this.incomingRouteParams = Object.assign(Object.assign({}, newRouteInfo), { routeAction: 'pop', routeDirection: 'back' });\n            this.props.history.push(newRouteInfo.pathname + (newRouteInfo.search || ''));\n        }\n    }\n    handleSetCurrentTab(tab) {\n        this.currentTab = tab;\n        const ri = Object.assign({}, this.locationHistory.current());\n        if (ri.tab !== tab) {\n            ri.tab = tab;\n            this.locationHistory.update(ri);\n        }\n    }\n    render() {\n        return (React.createElement(RouteManagerContext.Provider, { value: this.routeMangerContextState },\n            React.createElement(NavManager, { ionRoute: IonRouteInner, ionRedirect: {}, stackManager: StackManager, routeInfo: this.state.routeInfo, onNativeBack: this.handleNativeBack, onNavigateBack: this.handleNavigateBack, onNavigate: this.handleNavigate, onSetCurrentTab: this.handleSetCurrentTab, onChangeTab: this.handleChangeTab, onResetTab: this.handleResetTab, locationHistory: this.locationHistory }, this.props.children)));\n    }\n}\nconst IonRouter = withRouter(IonRouterInner);\nIonRouter.displayName = 'IonRouter';\n\nclass IonReactRouter extends React.Component {\n    constructor(props) {\n        super(props);\n        const { history } = props, rest = __rest(props, [\"history\"]);\n        this.history = history || createBrowserHistory(rest);\n        this.history.listen(this.handleHistoryChange.bind(this));\n        this.registerHistoryListener = this.registerHistoryListener.bind(this);\n    }\n    /**\n     * history@4.x passes separate location and action\n     * params. history@5.x passes location and action\n     * together as a single object.\n     * TODO: If support for React Router <=5 is dropped\n     * this logic is no longer needed. We can just assume\n     * a single object with both location and action.\n     */\n    handleHistoryChange(location, action) {\n        const locationValue = location.location || location;\n        const actionValue = location.action || action;\n        if (this.historyListenHandler) {\n            this.historyListenHandler(locationValue, actionValue);\n        }\n    }\n    registerHistoryListener(cb) {\n        this.historyListenHandler = cb;\n    }\n    render() {\n        const _a = this.props, { children } = _a, props = __rest(_a, [\"children\"]);\n        return (React.createElement(Router, Object.assign({ history: this.history }, props),\n            React.createElement(IonRouter, { registerHistoryListener: this.registerHistoryListener }, children)));\n    }\n}\n\nclass IonReactMemoryRouter extends React.Component {\n    constructor(props) {\n        super(props);\n        this.history = props.history;\n        this.history.listen(this.handleHistoryChange.bind(this));\n        this.registerHistoryListener = this.registerHistoryListener.bind(this);\n    }\n    /**\n     * history@4.x passes separate location and action\n     * params. history@5.x passes location and action\n     * together as a single object.\n     * TODO: If support for React Router <=5 is dropped\n     * this logic is no longer needed. We can just assume\n     * a single object with both location and action.\n     */\n    handleHistoryChange(location, action) {\n        const locationValue = location.location || location;\n        const actionValue = location.action || action;\n        if (this.historyListenHandler) {\n            this.historyListenHandler(locationValue, actionValue);\n        }\n    }\n    registerHistoryListener(cb) {\n        this.historyListenHandler = cb;\n    }\n    render() {\n        const _a = this.props, { children } = _a, props = __rest(_a, [\"children\"]);\n        return (React.createElement(Router$1, Object.assign({}, props),\n            React.createElement(IonRouter, { registerHistoryListener: this.registerHistoryListener }, children)));\n    }\n}\n\nclass IonReactHashRouter extends React.Component {\n    constructor(props) {\n        super(props);\n        const { history } = props, rest = __rest(props, [\"history\"]);\n        this.history = history || createHashHistory(rest);\n        this.history.listen(this.handleHistoryChange.bind(this));\n        this.registerHistoryListener = this.registerHistoryListener.bind(this);\n    }\n    /**\n     * history@4.x passes separate location and action\n     * params. history@5.x passes location and action\n     * together as a single object.\n     * TODO: If support for React Router <=5 is dropped\n     * this logic is no longer needed. We can just assume\n     * a single object with both location and action.\n     */\n    handleHistoryChange(location, action) {\n        const locationValue = location.location || location;\n        const actionValue = location.action || action;\n        if (this.historyListenHandler) {\n            this.historyListenHandler(locationValue, actionValue);\n        }\n    }\n    registerHistoryListener(cb) {\n        this.historyListenHandler = cb;\n    }\n    render() {\n        const _a = this.props, { children } = _a, props = __rest(_a, [\"children\"]);\n        return (React.createElement(Router, Object.assign({ history: this.history }, props),\n            React.createElement(IonRouter, { registerHistoryListener: this.registerHistoryListener }, children)));\n    }\n}\n\nexport { IonReactHashRouter, IonReactMemoryRouter, IonReactRouter };\n//# sourceMappingURL=index.esm.js.map\n"],"names":["IonRouteInner","render","path","this","props","exact","computedMatch","ReactRouterViewStack","constructor","super","createViewItem","bind","findViewItemByRouteInfo","findLeavingViewItemByRouteInfo","getChildrenToRender","findViewItemByPathname","outletId","reactElement","routeInfo","page","viewItem","id","ionPageElement","mount","ionRoute","matchProps","from","component","match","pathname","type","disableIonPageManagement","routeData","childProps","ionRouterOutlet","viewItems","getViewItemsForOutlet","children","child","find","v","matchComponent$1","map","clonedChild","key","removeView","remove","undefined","updateMatch","findViewItemByPath","mustBeIonRoute","lastPathname","forceExact","viewStack","some","matchView","matchDefaultRoute","getAllViewItems","myMatch","url","isExact","params","node","isViewVisible","el","classList","contains","StackManager","stackContextValue","registerIonPage","isInOutlet","pendingPageTransition","transitionPage","handlePageTransition","prevProps","skipTransition","componentDidMount","clearOutletTimeout","clearTimeout","routerOutletElement","setupRouterOutlet","componentDidUpdate","prevPathname","componentWillUnmount","context","clearOutlet","async","_a","_b","commit","enteringViewItem","leavingViewItem","prevRouteLastPathname","routeAction","routeDirection","routeOptions","unmount","enteringRoute","matchedNode","matchRoute","addViewItem","add","setAttribute","forceUpdate","foundView","oldPageElement","routerOutlet","swipeHandler","canStart","config","get","mode","propsToUse","pushedByRoute","onStart","Promise","resolve","onEnd","shouldContinue","goBack","direction","progressAnimation","runCommit","enteringEl","leavingEl","deepWait","duration","directionToUse","showGoBack","animationBuilder","routeAnimation","routeInfoFallbackDirection","matchComponent","newLeavingElement","leavingViewHtml","html","outerHTML","document","newEl","createElement","innerHTML","style","zIndex","ionBackButton","getElementsByTagName","firstChild","clonePageElement","appendChild","removeChild","components","value","ref","setRef","forwardedRef","current","contextType","IonRouterInner","exitViewFromOtherOutletHandlers","locationHistory","routeMangerContextState","canGoBack","clear","handleNavigateBack","unMountViewItem","location","search","handleChangeTab","handleResetTab","handleNativeBack","handleNavigate","registerHistoryListener","handleHistoryChange","handleSetCurrentTab","state","tab","getCurrentRouteInfoForTab","split","incomingRouteParams","Object","assign","history","push","action","_c","leavingLocationInfo","previous","currentTab","currentRoute","prevInfo","findLastLocation","routerOptions","isPushed","r","lastRoute","currentRouteInfo","currentPushedBy","setState","back","replace","defaultHref","originalHref","originalRouteOptions","getFirstRouteInfoForTab","newRouteInfo","ri","update","ionRedirect","stackManager","onNativeBack","onNavigateBack","onNavigate","onSetCurrentTab","onChangeTab","onResetTab","IonRouter","displayName","IonReactRouter","rest","listen","locationValue","actionValue","historyListenHandler","cb","IonReactMemoryRouter","__rest","React","Router$1","IonReactHashRouter","createHashHistory","Router"],"sourceRoot":""}