1"use strict";
2Object.defineProperty(exports, "__esModule", { value: true });
3exports.loadStaticParamsAsync = void 0;
4async function recurseAndFlattenNodes(nodes, props, func) {
5    const tarr = await Promise.all(nodes.map((node) => func(node, props)).flat());
6    return tarr.filter(Boolean);
7}
8async function loadStaticParamsAsync(route) {
9    const processed = (await Promise.all(route.children.map((route) => loadStaticParamsRecursive(route, { parentParams: {} })))).flat();
10    route.children = processed;
11    return route;
12}
13exports.loadStaticParamsAsync = loadStaticParamsAsync;
14function assertStaticParams(route, params) {
15    const matches = route.dynamic.every((dynamic) => {
16        const value = params[dynamic.name];
17        return value !== undefined && value !== null;
18    });
19    if (!matches) {
20        throw new Error(`generateStaticParams() must return an array of params that match the dynamic route. Received ${JSON.stringify(params)}`);
21    }
22    const validateSingleParam = (dynamic, value, allowMultipleSegments) => {
23        if (typeof value !== 'string') {
24            throw new Error(`generateStaticParams() for route "${route.contextKey}" expected param "${dynamic.name}" to be of type string, instead found "${typeof value}" while parsing "${value}".`);
25        }
26        const parts = value.split('/').filter(Boolean);
27        if (parts.length > 1 && !allowMultipleSegments) {
28            throw new Error(`generateStaticParams() for route "${route.contextKey}" expected param "${dynamic.name}" to not contain "/" (multiple segments) while parsing "${value}".`);
29        }
30        if (parts.length === 0) {
31            throw new Error(`generateStaticParams() for route "${route.contextKey}" expected param "${dynamic.name}" not to be empty while parsing "${value}".`);
32        }
33    };
34    route.dynamic.forEach((dynamic) => {
35        const value = params[dynamic.name];
36        if (dynamic.deep) {
37            // TODO: We could split strings by `/` and use that too.
38            if (!Array.isArray(value)) {
39                validateSingleParam(dynamic, value, true);
40            }
41            else {
42                validateSingleParam(dynamic, value.filter(Boolean).join('/'), true);
43            }
44        }
45        else {
46            validateSingleParam(dynamic, value);
47        }
48        return value !== undefined && value !== null;
49    });
50}
51/** lodash.uniqBy */
52function uniqBy(array, key) {
53    const seen = {};
54    return array.filter((item) => {
55        const k = key(item);
56        if (seen[k]) {
57            return false;
58        }
59        seen[k] = true;
60        return true;
61    });
62}
63async function loadStaticParamsRecursive(route, props) {
64    if (!route?.dynamic && !route?.children?.length) {
65        return [route];
66    }
67    const loaded = await route.loadRoute();
68    let staticParams = [];
69    if (loaded.generateStaticParams) {
70        staticParams = await loaded.generateStaticParams({
71            params: props.parentParams || {},
72        });
73        if (!Array.isArray(staticParams)) {
74            throw new Error(`generateStaticParams() must return an array of params, received ${staticParams}`);
75        }
76        // Assert that at least one param from each matches the dynamic route.
77        staticParams.forEach((params) => assertStaticParams(route, params));
78    }
79    route.children = uniqBy((await recurseAndFlattenNodes([...route.children], {
80        ...props,
81        parentParams: {
82            ...props.parentParams,
83            ...staticParams,
84        },
85    }, loadStaticParamsRecursive)).flat(), (i) => i.route);
86    const createParsedRouteName = (input, params) => {
87        let parsedRouteName = input;
88        route.dynamic?.map((query) => {
89            const param = params[query.name];
90            const formattedParameter = Array.isArray(param) ? param.join('/') : param;
91            if (query.deep) {
92                parsedRouteName = parsedRouteName.replace(`[...${query.name}]`, formattedParameter);
93            }
94            else {
95                parsedRouteName = parsedRouteName.replace(`[${query.name}]`, param);
96            }
97        });
98        return parsedRouteName;
99    };
100    const generatedRoutes = await Promise.all(staticParams.map(async (params) => {
101        const parsedRoute = createParsedRouteName(route.route, params);
102        const generatedContextKey = createParsedRouteName(route.contextKey, params);
103        return {
104            ...route,
105            // TODO: Add a new field for this
106            contextKey: generatedContextKey,
107            // Convert the dynamic route to a static route.
108            dynamic: null,
109            route: parsedRoute,
110            children: uniqBy((await recurseAndFlattenNodes([...route.children], {
111                ...props,
112                parentParams: {
113                    ...props.parentParams,
114                    ...staticParams,
115                },
116            }, loadStaticParamsRecursive)).flat(), (i) => i.route),
117        };
118    }));
119    return [route, ...generatedRoutes];
120}
121//# sourceMappingURL=loadStaticParamsAsync.js.map