import _async_to_generator from "@swc/helpers/src/_async_to_generator.mjs";
import React from 'react';
import { CacheStates } from '../../../../shared/lib/app-router-context';
import { createInitialRouterState } from '../create-initial-router-state';
import { ACTION_NAVIGATE, ACTION_PREFETCH } from '../router-reducer-types';
import { navigateReducer } from './navigate-reducer';
import { prefetchReducer } from './prefetch-reducer';
import { fetchServerResponse } from '../fetch-server-response';
const flightData = [
    [
        'children',
        'linking',
        'children',
        'about',
        [
            'about',
            {
                children: [
                    '',
                    {}
                ]
            }, 
        ],
        /*#__PURE__*/ React.createElement("h1", null, "About Page!"),
        /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement("title", null, "About page!")), 
    ], 
];
jest.mock('../fetch-server-response', ()=>{
    return {
        fetchServerResponse: (url)=>{
            if (url.pathname === '/linking/about') {
                return Promise.resolve([
                    flightData,
                    undefined
                ]);
            }
            throw new Error('unknown url in mock');
        }
    };
});
const getInitialRouterStateTree = ()=>[
        '',
        {
            children: [
                'linking',
                {
                    children: [
                        '',
                        {}
                    ]
                }, 
            ]
        },
        undefined,
        undefined,
        true, 
    ];
function runPromiseThrowChain(fn) {
    return _runPromiseThrowChain.apply(this, arguments);
}
function _runPromiseThrowChain() {
    _runPromiseThrowChain = _async_to_generator(function*(fn) {
        try {
            return yield fn();
        } catch (err) {
            if (err instanceof Promise) {
                yield err;
                return yield runPromiseThrowChain(fn);
            }
            throw err;
        }
    });
    return _runPromiseThrowChain.apply(this, arguments);
}
describe('navigateReducer', ()=>{
    it('should apply navigation', _async_to_generator(function*() {
        const initialTree = getInitialRouterStateTree();
        const initialCanonicalUrl = '/linking';
        const children = /*#__PURE__*/ React.createElement("html", null, /*#__PURE__*/ React.createElement("head", null), /*#__PURE__*/ React.createElement("body", null, "Root layout"));
        const initialParallelRoutes = new Map([
            [
                'children',
                new Map([
                    [
                        'linking',
                        {
                            status: CacheStates.READY,
                            parallelRoutes: new Map([
                                [
                                    'children',
                                    new Map([
                                        [
                                            '',
                                            {
                                                status: CacheStates.READY,
                                                data: null,
                                                subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking page"),
                                                parallelRoutes: new Map()
                                            }, 
                                        ], 
                                    ]), 
                                ], 
                            ]),
                            data: null,
                            subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking layout level")
                        }, 
                    ], 
                ]), 
            ], 
        ]);
        const state = createInitialRouterState({
            initialTree,
            initialCanonicalUrl,
            children,
            initialParallelRoutes,
            isServer: false,
            location: new URL('/linking', 'https://localhost')
        });
        const action = {
            type: ACTION_NAVIGATE,
            url: new URL('/linking/about', 'https://localhost'),
            isExternalUrl: false,
            locationSearch: '',
            navigateType: 'push',
            forceOptimisticNavigation: false,
            cache: {
                status: CacheStates.LAZY_INITIALIZED,
                data: null,
                subTreeData: null,
                parallelRoutes: new Map()
            },
            mutable: {}
        };
        const newState = yield runPromiseThrowChain(()=>navigateReducer(state, action));
        const expectedState = {
            prefetchCache: new Map(),
            pushRef: {
                mpaNavigation: false,
                pendingPush: true
            },
            focusAndScrollRef: {
                apply: true
            },
            canonicalUrl: '/linking/about',
            cache: {
                status: CacheStates.READY,
                data: null,
                subTreeData: /*#__PURE__*/ React.createElement("html", null, /*#__PURE__*/ React.createElement("head", null), /*#__PURE__*/ React.createElement("body", null, "Root layout")),
                parallelRoutes: new Map([
                    [
                        'children',
                        new Map([
                            [
                                'linking',
                                {
                                    status: CacheStates.READY,
                                    parallelRoutes: new Map([
                                        [
                                            'children',
                                            new Map([
                                                [
                                                    '',
                                                    {
                                                        status: CacheStates.READY,
                                                        data: null,
                                                        subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking page"),
                                                        parallelRoutes: new Map()
                                                    }, 
                                                ],
                                                [
                                                    'about',
                                                    {
                                                        status: CacheStates.READY,
                                                        data: null,
                                                        subTreeData: /*#__PURE__*/ React.createElement("h1", null, "About Page!"),
                                                        parallelRoutes: new Map([
                                                            [
                                                                'children',
                                                                new Map([
                                                                    [
                                                                        '',
                                                                        {
                                                                            status: CacheStates.LAZY_INITIALIZED,
                                                                            data: null,
                                                                            head: /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement("title", null, "About page!")),
                                                                            parallelRoutes: new Map(),
                                                                            subTreeData: null
                                                                        }, 
                                                                    ], 
                                                                ]), 
                                                            ], 
                                                        ])
                                                    }, 
                                                ], 
                                            ]), 
                                        ], 
                                    ]),
                                    data: null,
                                    subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking layout level")
                                }, 
                            ], 
                        ]), 
                    ], 
                ])
            },
            tree: [
                '',
                {
                    children: [
                        'linking',
                        {
                            children: [
                                'about',
                                {
                                    children: [
                                        '',
                                        {}
                                    ]
                                }
                            ]
                        }, 
                    ]
                },
                undefined,
                undefined,
                true, 
            ]
        };
        expect(newState).toMatchObject(expectedState);
    }));
    it('should apply navigation when called twice (concurrent)', _async_to_generator(function*() {
        const initialTree = getInitialRouterStateTree();
        const initialCanonicalUrl = '/linking';
        const children = /*#__PURE__*/ React.createElement("html", null, /*#__PURE__*/ React.createElement("head", null), /*#__PURE__*/ React.createElement("body", null, "Root layout"));
        const initialParallelRoutes = new Map([
            [
                'children',
                new Map([
                    [
                        'linking',
                        {
                            status: CacheStates.READY,
                            parallelRoutes: new Map([
                                [
                                    'children',
                                    new Map([
                                        [
                                            '',
                                            {
                                                status: CacheStates.READY,
                                                data: null,
                                                subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking page"),
                                                parallelRoutes: new Map()
                                            }, 
                                        ], 
                                    ]), 
                                ], 
                            ]),
                            data: null,
                            subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking layout level")
                        }, 
                    ], 
                ]), 
            ], 
        ]);
        const state = createInitialRouterState({
            initialTree,
            initialCanonicalUrl,
            children,
            initialParallelRoutes,
            isServer: false,
            location: new URL('/linking', 'https://localhost')
        });
        const state2 = createInitialRouterState({
            initialTree,
            initialCanonicalUrl,
            children,
            initialParallelRoutes,
            isServer: false,
            location: new URL('/linking', 'https://localhost')
        });
        const action = {
            type: ACTION_NAVIGATE,
            url: new URL('/linking/about', 'https://localhost'),
            isExternalUrl: false,
            locationSearch: '',
            navigateType: 'push',
            forceOptimisticNavigation: false,
            cache: {
                status: CacheStates.LAZY_INITIALIZED,
                data: null,
                subTreeData: null,
                parallelRoutes: new Map()
            },
            mutable: {}
        };
        yield runPromiseThrowChain(()=>navigateReducer(state, action));
        const newState = yield runPromiseThrowChain(()=>navigateReducer(state2, action));
        const expectedState = {
            prefetchCache: new Map(),
            pushRef: {
                mpaNavigation: false,
                pendingPush: true
            },
            focusAndScrollRef: {
                apply: true
            },
            canonicalUrl: '/linking/about',
            cache: {
                status: CacheStates.READY,
                data: null,
                subTreeData: /*#__PURE__*/ React.createElement("html", null, /*#__PURE__*/ React.createElement("head", null), /*#__PURE__*/ React.createElement("body", null, "Root layout")),
                parallelRoutes: new Map([
                    [
                        'children',
                        new Map([
                            [
                                'linking',
                                {
                                    status: CacheStates.READY,
                                    parallelRoutes: new Map([
                                        [
                                            'children',
                                            new Map([
                                                [
                                                    '',
                                                    {
                                                        status: CacheStates.READY,
                                                        data: null,
                                                        subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking page"),
                                                        parallelRoutes: new Map()
                                                    }, 
                                                ],
                                                [
                                                    'about',
                                                    {
                                                        status: CacheStates.READY,
                                                        data: null,
                                                        subTreeData: /*#__PURE__*/ React.createElement("h1", null, "About Page!"),
                                                        parallelRoutes: new Map([
                                                            [
                                                                'children',
                                                                new Map([
                                                                    [
                                                                        '',
                                                                        {
                                                                            status: CacheStates.LAZY_INITIALIZED,
                                                                            data: null,
                                                                            head: /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement("title", null, "About page!")),
                                                                            parallelRoutes: new Map(),
                                                                            subTreeData: null
                                                                        }, 
                                                                    ], 
                                                                ]), 
                                                            ], 
                                                        ])
                                                    }, 
                                                ], 
                                            ]), 
                                        ], 
                                    ]),
                                    data: null,
                                    subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking layout level")
                                }, 
                            ], 
                        ]), 
                    ], 
                ])
            },
            tree: [
                '',
                {
                    children: [
                        'linking',
                        {
                            children: [
                                'about',
                                {
                                    children: [
                                        '',
                                        {}
                                    ]
                                }
                            ]
                        }, 
                    ]
                },
                undefined,
                undefined,
                true, 
            ]
        };
        expect(newState).toMatchObject(expectedState);
    }));
    it('should apply navigation for external url (push)', _async_to_generator(function*() {
        const initialTree = getInitialRouterStateTree();
        const initialCanonicalUrl = '/linking';
        const children = /*#__PURE__*/ React.createElement("html", null, /*#__PURE__*/ React.createElement("head", null), /*#__PURE__*/ React.createElement("body", null, "Root layout"));
        const initialParallelRoutes = new Map([
            [
                'children',
                new Map([
                    [
                        'linking',
                        {
                            status: CacheStates.READY,
                            parallelRoutes: new Map([
                                [
                                    'children',
                                    new Map([
                                        [
                                            '',
                                            {
                                                status: CacheStates.READY,
                                                data: null,
                                                subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking page"),
                                                parallelRoutes: new Map()
                                            }, 
                                        ], 
                                    ]), 
                                ], 
                            ]),
                            data: null,
                            subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking layout level")
                        }, 
                    ], 
                ]), 
            ], 
        ]);
        const state = createInitialRouterState({
            initialTree,
            initialCanonicalUrl,
            children,
            initialParallelRoutes,
            isServer: false,
            location: new URL('/linking', 'https://localhost')
        });
        const state2 = createInitialRouterState({
            initialTree,
            initialCanonicalUrl,
            children,
            initialParallelRoutes,
            isServer: false,
            location: new URL('/linking', 'https://localhost')
        });
        const url = new URL('https://example.vercel.sh', 'https://localhost');
        const isExternalUrl = url.origin !== 'localhost';
        const action = {
            type: ACTION_NAVIGATE,
            url,
            isExternalUrl,
            locationSearch: '',
            navigateType: 'push',
            forceOptimisticNavigation: false,
            cache: {
                status: CacheStates.LAZY_INITIALIZED,
                data: null,
                subTreeData: null,
                parallelRoutes: new Map()
            },
            mutable: {}
        };
        yield runPromiseThrowChain(()=>navigateReducer(state, action));
        const newState = yield runPromiseThrowChain(()=>navigateReducer(state2, action));
        const expectedState = {
            prefetchCache: new Map(),
            pushRef: {
                mpaNavigation: true,
                pendingPush: true
            },
            focusAndScrollRef: {
                apply: false
            },
            canonicalUrl: 'https://example.vercel.sh/',
            cache: {
                status: CacheStates.READY,
                data: null,
                subTreeData: /*#__PURE__*/ React.createElement("html", null, /*#__PURE__*/ React.createElement("head", null), /*#__PURE__*/ React.createElement("body", null, "Root layout")),
                parallelRoutes: new Map([
                    [
                        'children',
                        new Map([
                            [
                                'linking',
                                {
                                    status: CacheStates.READY,
                                    parallelRoutes: new Map([
                                        [
                                            'children',
                                            new Map([
                                                [
                                                    '',
                                                    {
                                                        status: CacheStates.READY,
                                                        data: null,
                                                        subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking page"),
                                                        parallelRoutes: new Map()
                                                    }, 
                                                ], 
                                            ]), 
                                        ], 
                                    ]),
                                    data: null,
                                    subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking layout level")
                                }, 
                            ], 
                        ]), 
                    ], 
                ])
            },
            tree: [
                '',
                {
                    children: [
                        'linking',
                        {
                            children: [
                                '',
                                {}
                            ]
                        }, 
                    ]
                },
                undefined,
                undefined,
                true, 
            ]
        };
        expect(newState).toMatchObject(expectedState);
    }));
    it('should apply navigation for external url (replace)', _async_to_generator(function*() {
        const initialTree = getInitialRouterStateTree();
        const initialCanonicalUrl = '/linking';
        const children = /*#__PURE__*/ React.createElement("html", null, /*#__PURE__*/ React.createElement("head", null), /*#__PURE__*/ React.createElement("body", null, "Root layout"));
        const initialParallelRoutes = new Map([
            [
                'children',
                new Map([
                    [
                        'linking',
                        {
                            status: CacheStates.READY,
                            parallelRoutes: new Map([
                                [
                                    'children',
                                    new Map([
                                        [
                                            '',
                                            {
                                                status: CacheStates.READY,
                                                data: null,
                                                subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking page"),
                                                parallelRoutes: new Map()
                                            }, 
                                        ], 
                                    ]), 
                                ], 
                            ]),
                            data: null,
                            subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking layout level")
                        }, 
                    ], 
                ]), 
            ], 
        ]);
        const state = createInitialRouterState({
            initialTree,
            initialCanonicalUrl,
            children,
            initialParallelRoutes,
            isServer: false,
            location: new URL('/linking', 'https://localhost')
        });
        const state2 = createInitialRouterState({
            initialTree,
            initialCanonicalUrl,
            children,
            initialParallelRoutes,
            isServer: false,
            location: new URL('/linking', 'https://localhost')
        });
        const url = new URL('https://example.vercel.sh', 'https://localhost');
        const isExternalUrl = url.origin !== 'localhost';
        const action = {
            type: ACTION_NAVIGATE,
            url,
            isExternalUrl,
            locationSearch: '',
            navigateType: 'replace',
            forceOptimisticNavigation: false,
            cache: {
                status: CacheStates.LAZY_INITIALIZED,
                data: null,
                subTreeData: null,
                parallelRoutes: new Map()
            },
            mutable: {}
        };
        yield runPromiseThrowChain(()=>navigateReducer(state, action));
        const newState = yield runPromiseThrowChain(()=>navigateReducer(state2, action));
        const expectedState = {
            prefetchCache: new Map(),
            pushRef: {
                mpaNavigation: true,
                pendingPush: false
            },
            focusAndScrollRef: {
                apply: false
            },
            canonicalUrl: 'https://example.vercel.sh/',
            cache: {
                status: CacheStates.READY,
                data: null,
                subTreeData: /*#__PURE__*/ React.createElement("html", null, /*#__PURE__*/ React.createElement("head", null), /*#__PURE__*/ React.createElement("body", null, "Root layout")),
                parallelRoutes: new Map([
                    [
                        'children',
                        new Map([
                            [
                                'linking',
                                {
                                    status: CacheStates.READY,
                                    parallelRoutes: new Map([
                                        [
                                            'children',
                                            new Map([
                                                [
                                                    '',
                                                    {
                                                        status: CacheStates.READY,
                                                        data: null,
                                                        subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking page"),
                                                        parallelRoutes: new Map()
                                                    }, 
                                                ], 
                                            ]), 
                                        ], 
                                    ]),
                                    data: null,
                                    subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking layout level")
                                }, 
                            ], 
                        ]), 
                    ], 
                ])
            },
            tree: [
                '',
                {
                    children: [
                        'linking',
                        {
                            children: [
                                '',
                                {}
                            ]
                        }, 
                    ]
                },
                undefined,
                undefined,
                true, 
            ]
        };
        expect(newState).toMatchObject(expectedState);
    }));
    it('should apply navigation for forceOptimisticNavigation', _async_to_generator(function*() {
        const initialTree = getInitialRouterStateTree();
        const initialCanonicalUrl = '/linking';
        const children = /*#__PURE__*/ React.createElement("html", null, /*#__PURE__*/ React.createElement("head", null), /*#__PURE__*/ React.createElement("body", null, "Root layout"));
        const initialParallelRoutes = new Map([
            [
                'children',
                new Map([
                    [
                        'linking',
                        {
                            status: CacheStates.READY,
                            parallelRoutes: new Map([
                                [
                                    'children',
                                    new Map([
                                        [
                                            '',
                                            {
                                                status: CacheStates.READY,
                                                data: null,
                                                subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking page"),
                                                parallelRoutes: new Map()
                                            }, 
                                        ], 
                                    ]), 
                                ], 
                            ]),
                            data: null,
                            subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking layout level")
                        }, 
                    ], 
                ]), 
            ], 
        ]);
        const state = createInitialRouterState({
            initialTree,
            initialCanonicalUrl,
            children,
            initialParallelRoutes,
            isServer: false,
            location: new URL('/linking', 'https://localhost')
        });
        const state2 = createInitialRouterState({
            initialTree,
            initialCanonicalUrl,
            children,
            initialParallelRoutes,
            isServer: false,
            location: new URL('/linking', 'https://localhost')
        });
        const action = {
            type: ACTION_NAVIGATE,
            url: new URL('/linking/about', 'https://localhost'),
            isExternalUrl: false,
            locationSearch: '',
            navigateType: 'push',
            forceOptimisticNavigation: true,
            cache: {
                status: CacheStates.LAZY_INITIALIZED,
                data: null,
                subTreeData: null,
                parallelRoutes: new Map()
            },
            mutable: {}
        };
        yield runPromiseThrowChain(()=>navigateReducer(state, action));
        const newState = yield runPromiseThrowChain(()=>navigateReducer(state2, action));
        const expectedState = {
            prefetchCache: new Map(),
            pushRef: {
                mpaNavigation: false,
                pendingPush: true
            },
            focusAndScrollRef: {
                apply: true
            },
            canonicalUrl: '/linking/about',
            cache: {
                status: CacheStates.READY,
                data: null,
                subTreeData: /*#__PURE__*/ React.createElement("html", null, /*#__PURE__*/ React.createElement("head", null), /*#__PURE__*/ React.createElement("body", null, "Root layout")),
                parallelRoutes: new Map([
                    [
                        'children',
                        new Map([
                            [
                                'linking',
                                {
                                    status: CacheStates.READY,
                                    parallelRoutes: new Map([
                                        [
                                            'children',
                                            new Map([
                                                [
                                                    '',
                                                    {
                                                        status: CacheStates.READY,
                                                        data: null,
                                                        subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking page"),
                                                        parallelRoutes: new Map()
                                                    }, 
                                                ],
                                                [
                                                    'about',
                                                    {
                                                        status: CacheStates.DATA_FETCH,
                                                        // Real promise is not needed here.
                                                        data: Promise.resolve(),
                                                        parallelRoutes: new Map(),
                                                        subTreeData: null
                                                    }, 
                                                ], 
                                            ]), 
                                        ], 
                                    ]),
                                    data: null,
                                    subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking layout level")
                                }, 
                            ], 
                        ]), 
                    ], 
                ])
            },
            tree: [
                '',
                {
                    children: [
                        'linking',
                        {
                            children: [
                                'about',
                                {
                                    children: [
                                        '',
                                        {}
                                    ]
                                },
                                undefined,
                                'refetch'
                            ]
                        }, 
                    ]
                }, 
            ]
        };
        expect(newState).toMatchObject(expectedState);
    }));
    it('should apply navigation with prefetched data', _async_to_generator(function*() {
        const initialTree = getInitialRouterStateTree();
        const initialCanonicalUrl = '/linking';
        const children = /*#__PURE__*/ React.createElement("html", null, /*#__PURE__*/ React.createElement("head", null), /*#__PURE__*/ React.createElement("body", null, "Root layout"));
        const initialParallelRoutes = new Map([
            [
                'children',
                new Map([
                    [
                        'linking',
                        {
                            status: CacheStates.READY,
                            parallelRoutes: new Map([
                                [
                                    'children',
                                    new Map([
                                        [
                                            '',
                                            {
                                                status: CacheStates.READY,
                                                data: null,
                                                subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking page"),
                                                parallelRoutes: new Map()
                                            }, 
                                        ], 
                                    ]), 
                                ], 
                            ]),
                            data: null,
                            subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking layout level")
                        }, 
                    ], 
                ]), 
            ], 
        ]);
        const url = new URL('/linking/about', 'https://localhost');
        const serverResponse = yield fetchServerResponse(url, initialTree, true);
        const prefetchAction = {
            type: ACTION_PREFETCH,
            url,
            tree: initialTree,
            serverResponse
        };
        const state = createInitialRouterState({
            initialTree,
            initialCanonicalUrl,
            children,
            initialParallelRoutes,
            isServer: false,
            location: new URL('/linking', 'https://localhost')
        });
        yield runPromiseThrowChain(()=>prefetchReducer(state, prefetchAction));
        const state2 = createInitialRouterState({
            initialTree,
            initialCanonicalUrl,
            children,
            initialParallelRoutes,
            isServer: false,
            location: new URL('/linking', 'https://localhost')
        });
        yield runPromiseThrowChain(()=>prefetchReducer(state2, prefetchAction));
        const action = {
            type: ACTION_NAVIGATE,
            url: new URL('/linking/about', 'https://localhost'),
            isExternalUrl: false,
            navigateType: 'push',
            locationSearch: '',
            forceOptimisticNavigation: false,
            cache: {
                status: CacheStates.LAZY_INITIALIZED,
                data: null,
                subTreeData: null,
                parallelRoutes: new Map()
            },
            mutable: {}
        };
        yield runPromiseThrowChain(()=>navigateReducer(state, action));
        const newState = yield runPromiseThrowChain(()=>navigateReducer(state2, action));
        const expectedState = {
            prefetchCache: new Map([
                [
                    '/linking/about',
                    {
                        canonicalUrlOverride: undefined,
                        flightData: [
                            [
                                'children',
                                'linking',
                                'children',
                                'about',
                                [
                                    'about',
                                    {
                                        children: [
                                            '',
                                            {}
                                        ]
                                    }, 
                                ],
                                /*#__PURE__*/ React.createElement("h1", null, "About Page!"),
                                /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement("title", null, "About page!")), 
                            ], 
                        ],
                        tree: [
                            '',
                            {
                                children: [
                                    'linking',
                                    {
                                        children: [
                                            'about',
                                            {
                                                children: [
                                                    '',
                                                    {}
                                                ]
                                            }, 
                                        ]
                                    }, 
                                ]
                            },
                            undefined,
                            undefined,
                            true, 
                        ]
                    }, 
                ], 
            ]),
            pushRef: {
                mpaNavigation: false,
                pendingPush: true
            },
            focusAndScrollRef: {
                apply: true
            },
            canonicalUrl: '/linking/about',
            cache: {
                status: CacheStates.READY,
                data: null,
                subTreeData: /*#__PURE__*/ React.createElement("html", null, /*#__PURE__*/ React.createElement("head", null), /*#__PURE__*/ React.createElement("body", null, "Root layout")),
                parallelRoutes: new Map([
                    [
                        'children',
                        new Map([
                            [
                                'linking',
                                {
                                    status: CacheStates.READY,
                                    parallelRoutes: new Map([
                                        [
                                            'children',
                                            new Map([
                                                [
                                                    '',
                                                    {
                                                        status: CacheStates.READY,
                                                        data: null,
                                                        subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking page"),
                                                        parallelRoutes: new Map()
                                                    }, 
                                                ],
                                                [
                                                    'about',
                                                    {
                                                        status: CacheStates.READY,
                                                        data: null,
                                                        parallelRoutes: new Map([
                                                            [
                                                                'children',
                                                                new Map([
                                                                    [
                                                                        '',
                                                                        {
                                                                            status: CacheStates.LAZY_INITIALIZED,
                                                                            subTreeData: null,
                                                                            data: null,
                                                                            head: /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement("title", null, "About page!")),
                                                                            parallelRoutes: new Map()
                                                                        }, 
                                                                    ], 
                                                                ]), 
                                                            ], 
                                                        ]),
                                                        subTreeData: /*#__PURE__*/ React.createElement("h1", null, "About Page!")
                                                    }, 
                                                ], 
                                            ]), 
                                        ], 
                                    ]),
                                    data: null,
                                    subTreeData: /*#__PURE__*/ React.createElement(React.Fragment, null, "Linking layout level")
                                }, 
                            ], 
                        ]), 
                    ], 
                ])
            },
            tree: [
                '',
                {
                    children: [
                        'linking',
                        {
                            children: [
                                'about',
                                {
                                    children: [
                                        '',
                                        {}
                                    ]
                                }
                            ]
                        }, 
                    ]
                },
                undefined,
                undefined,
                true, 
            ]
        };
        expect(newState).toMatchObject(expectedState);
    }));
});

//# sourceMappingURL=navigate-reducer.test.js.map