@module-federation/nextjs-mf 5.2.2 → 5.3.0

package/lib/client/RemoteContainer.js

@@ -0,0 +1,161 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../_virtual/_tslib.js');
+var EventEmitter = require('eventemitter3');
+var utils = require('../utils.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
+
+/**
+ * This is a Lazy loader of webpack remote container with some NextJS-specific helper methods.
+ *
+ * It provides the ability to register remote, and load & init it on the first use.
+ */
+var RemoteContainer = /** @class */ (function () {
+    function RemoteContainer(opts) {
+        this.global = opts.global;
+        this.url = opts.url;
+        this.events = new EventEmitter__default["default"]();
+    }
+    /**
+     * Create or reuse existed remote entry.
+     *
+     * Be careful, Singleton pattern does not work well in webpack builds,
+     * because one module may be copied between different chunks. In such a way
+     * you obtain several lists of instances.
+     */
+    RemoteContainer.createSingleton = function (remote) {
+        var data;
+        if (typeof remote === 'string') {
+            var _a = _tslib.__read(remote.split('@'), 2), global_1 = _a[0], url = _a[1];
+            data = { global: global_1, url: url };
+        }
+        else if ((remote === null || remote === void 0 ? void 0 : remote.global) && (remote === null || remote === void 0 ? void 0 : remote.url)) {
+            data = { global: remote.global, url: remote.url };
+        }
+        if (!data) {
+            console.error("Cannot init RemoteContainer with following data", RemoteContainer);
+            throw Error('[nextjs-mf] RemoteContainer.createSingleton(remote) accepts string "shop@http://example.com/_next/static/chunks/remoteEntry.js" OR object { global: "shop", url: "http://example.com/_next/static/chunks/remoteEntry.js"}');
+        }
+        var container;
+        if (this.instances[data.global]) {
+            container = this.instances[data.global];
+        }
+        else {
+            container = new RemoteContainer(data);
+            this.instances[data.global] = container;
+        }
+        return container;
+    };
+    /**
+     * Check is the current remoteEntry.js loaded or not
+     */
+    RemoteContainer.prototype.isLoaded = function () {
+        return !!this.container;
+    };
+    /**
+     * Returns initialized webpack RemoteContainer.
+     * If its' script does not loaded - then load & init it firstly.
+     */
+    RemoteContainer.prototype.getContainer = function () {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var container, e_1;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.container) {
+                            return [2 /*return*/, this.container];
+                        }
+                        this.events.emit('loadStart', this);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, utils.injectScript({
+                                global: this.global,
+                                url: this.url,
+                            })];
+                    case 2:
+                        container = _a.sent();
+                        if (container) {
+                            this.container = container;
+                            this.events.emit('loadComplete', this);
+                            return [2 /*return*/, container];
+                        }
+                        throw Error("[nextjs-mf] Remote container ".concat(this.url, " is empty"));
+                    case 3:
+                        e_1 = _a.sent();
+                        this.error = e_1;
+                        this.events.emit('loadError', e_1.message, this);
+                        throw e_1;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Return remote module from container.
+     * If you provide `exportName` it automatically return exact property value from module.
+     *
+     * @example
+     *   remote.getModule('./pages/index', 'default')
+     */
+    RemoteContainer.prototype.getModule = function (modulePath, exportName) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var container, modFactory, mod;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getContainer()];
+                    case 1:
+                        container = _a.sent();
+                        return [4 /*yield*/, container.get(modulePath)];
+                    case 2:
+                        modFactory = _a.sent();
+                        if (!modFactory)
+                            return [2 /*return*/, undefined];
+                        mod = modFactory();
+                        if (exportName) {
+                            return [2 /*return*/, mod && typeof mod === 'object' ? mod[exportName] : undefined];
+                        }
+                        else {
+                            return [2 /*return*/, mod];
+                        }
+                }
+            });
+        });
+    };
+    /**
+     * Retrieve registered nextjs' routes from remote app
+     */
+    RemoteContainer.prototype.getPageMap = function () {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var pageMap;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.pageMap) {
+                            return [2 /*return*/, this.pageMap];
+                        }
+                        return [4 /*yield*/, this.getModule('./pages-map-v2', 'default')];
+                    case 1:
+                        pageMap = _a.sent();
+                        if (pageMap) {
+                            this.pageMap = pageMap;
+                        }
+                        else {
+                            this.pageMap = {};
+                            console.warn("[nextjs-mf] Container ".concat(this.global, " does not expose \"./pages-map-v2\" module."));
+                        }
+                        return [2 /*return*/, this.pageMap];
+                }
+            });
+        });
+    };
+    RemoteContainer.instances = {};
+    return RemoteContainer;
+}());
+
+exports.RemoteContainer = RemoteContainer;

package/lib/client/RemotePages.d.ts

@@ -0,0 +1,48 @@
+import { PageMap, RemoteContainer } from './RemoteContainer';
+export declare type PathPrefix = string;
+export declare type RemoteToRoutes = Map<RemoteContainer, PathPrefix | PathPrefix[]>;
+export declare type RouteInfo = {
+    component: any;
+    exports: any;
+    styles: string[];
+};
+/**
+ * A class which prepares/loads a list of remotes pages and knows how
+ * to prepare NextJS pseudo-module of route data.
+ */
+export declare class RemotePages {
+    paths: Record<PathPrefix, RemoteContainer>;
+    pageListCache: string[] | undefined;
+    private asyncLoadedPageMaps;
+    constructor(remoteToRoutes?: RemoteToRoutes);
+    /**
+     * Add remote routes for specific RemoteContainer which serves them.
+     */
+    addRoutes(routes: string | string[], remote: RemoteContainer): void;
+    /**
+     * Load a remote page map and add its routes to registry.
+     */
+    loadRemotePageMap(remote: RemoteContainer): Promise<PageMap | undefined>;
+    /**
+     * Get remote module according to provided next route.
+     * Under the hood it automatically determines which remote need to be used.
+     */
+    routeToPageModule(route: string): Promise<any>;
+    /**
+     * Check that provided route present in registry.
+     */
+    hasRoute(route: string): boolean;
+    /**
+     * Find remote according to provided route.
+     */
+    routeToRemote(route: string): RemoteContainer | undefined;
+    /**
+     * Get cached unsorted list of remote routes.
+     */
+    getPageList(): string[];
+    /**
+     * Get prepared pseudo-module which is consumed by Nextjs' router.
+     */
+    getRouteInfo(route: string): Promise<undefined | RouteInfo>;
+}
+//# sourceMappingURL=RemotePages.d.ts.map

package/lib/client/RemotePages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RemotePages.d.ts","sourceRoot":"","sources":["../../src/client/RemotePages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAE7D,oBAAY,UAAU,GAAG,MAAM,CAAC;AAEhC,oBAAY,cAAc,GAAG,GAAG,CAAC,eAAe,EAAE,UAAU,GAAG,UAAU,EAAE,CAAC,CAAC;AAE7E,oBAAY,SAAS,GAAG;IACtB,SAAS,EAAE,GAAG,CAAC;IACf,OAAO,EAAE,GAAG,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF;;;GAGG;AACH,qBAAa,WAAW;IACtB,KAAK,EAAE,MAAM,CAAC,UAAU,EAAE,eAAe,CAAC,CAAM;IAChD,aAAa,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IACpC,OAAO,CAAC,mBAAmB,CAAuB;gBAEtC,cAAc,CAAC,EAAE,cAAc;IAQ3C;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,MAAM,EAAE,eAAe;IAW5D;;OAEG;IACG,iBAAiB,CACrB,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC;IAc/B;;;OAGG;IACG,iBAAiB,CAAC,KAAK,EAAE,MAAM;IAmBrC;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAIhC;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAsBzD;;OAEG;IACH,WAAW;IAQX;;OAEG;IACG,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;CAuBlE"}

package/lib/client/RemotePages.js

@@ -0,0 +1,168 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../_virtual/_tslib.js');
+
+/**
+ * A class which prepares/loads a list of remotes pages and knows how
+ * to prepare NextJS pseudo-module of route data.
+ */
+var RemotePages = /** @class */ (function () {
+    function RemotePages(remoteToRoutes) {
+        var _this = this;
+        this.paths = {};
+        this.asyncLoadedPageMaps = new Set();
+        this.pageListCache = undefined;
+        remoteToRoutes === null || remoteToRoutes === void 0 ? void 0 : remoteToRoutes.forEach(function (routes, remote) {
+            _this.addRoutes(routes, remote);
+        });
+    }
+    /**
+     * Add remote routes for specific RemoteContainer which serves them.
+     */
+    RemotePages.prototype.addRoutes = function (routes, remote) {
+        var _this = this;
+        if (Array.isArray(routes)) {
+            routes.forEach(function (route) {
+                _this.paths[route] = remote;
+            });
+        }
+        else {
+            this.paths[routes] = remote;
+        }
+        this.pageListCache = Object.keys(this.paths);
+    };
+    /**
+     * Load a remote page map and add its routes to registry.
+     */
+    RemotePages.prototype.loadRemotePageMap = function (remote) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var pageMap;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, remote.getPageMap()];
+                    case 1:
+                        pageMap = _a.sent();
+                        if (!pageMap)
+                            return [2 /*return*/, undefined];
+                        // init once page map from remote if it wasn't done before
+                        // here we updating real routes received from remote app in runtime
+                        if (!this.asyncLoadedPageMaps.has(remote)) {
+                            this.asyncLoadedPageMaps.add(remote);
+                            this.addRoutes(Object.keys(pageMap), remote);
+                        }
+                        return [2 /*return*/, pageMap];
+                }
+            });
+        });
+    };
+    /**
+     * Get remote module according to provided next route.
+     * Under the hood it automatically determines which remote need to be used.
+     */
+    RemotePages.prototype.routeToPageModule = function (route) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var remote, pageMap, modulePath;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        remote = this.routeToRemote(route);
+                        if (!remote) {
+                            return [2 /*return*/, undefined];
+                        }
+                        return [4 /*yield*/, this.loadRemotePageMap(remote)];
+                    case 1:
+                        pageMap = _a.sent();
+                        if (!pageMap) {
+                            return [2 /*return*/, undefined];
+                        }
+                        modulePath = pageMap[route];
+                        if (!modulePath) {
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*return*/, remote.getModule(modulePath)];
+                }
+            });
+        });
+    };
+    /**
+     * Check that provided route present in registry.
+     */
+    RemotePages.prototype.hasRoute = function (route) {
+        var _a;
+        return !!((_a = this.pageListCache) === null || _a === void 0 ? void 0 : _a.includes(route));
+    };
+    /**
+     * Find remote according to provided route.
+     */
+    RemotePages.prototype.routeToRemote = function (route) {
+        var bestMatch;
+        for (var basepath in this.paths) {
+            if (route === basepath) {
+                return this.paths[basepath];
+            }
+            else if (route.startsWith("".concat(basepath, "/"))) {
+                if (!bestMatch) {
+                    bestMatch = basepath;
+                }
+                else if (bestMatch.length < basepath.length) {
+                    bestMatch = basepath;
+                }
+            }
+        }
+        if (bestMatch) {
+            return this.paths[bestMatch];
+        }
+        return undefined;
+    };
+    /**
+     * Get cached unsorted list of remote routes.
+     */
+    RemotePages.prototype.getPageList = function () {
+        // it's very important to return the same Array instance
+        // because it instance is used in CombinedPages for recalculation of sorted version of all routes
+        var pageList = this.pageListCache || Object.keys(this.paths);
+        this.pageListCache = pageList;
+        return pageList;
+    };
+    /**
+     * Get prepared pseudo-module which is consumed by Nextjs' router.
+     */
+    RemotePages.prototype.getRouteInfo = function (route) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var routeInfo, mod, e_1;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.routeToPageModule(route)];
+                    case 1:
+                        mod = _a.sent();
+                        if (mod) {
+                            routeInfo = {
+                                component: mod.default,
+                                exports: mod,
+                                styles: [],
+                            };
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        e_1 = _a.sent();
+                        routeInfo = {
+                            // TODO: provide ability to customize component with Error
+                            component: function () { return e_1.message; },
+                            exports: {},
+                            styles: [],
+                        };
+                        console.warn(e_1);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/, routeInfo];
+                }
+            });
+        });
+    };
+    return RemotePages;
+}());
+
+exports.RemotePages = RemotePages;

package/lib/client/UrlNode.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This class provides a logic of sorting dynamic routes in NextJS.
+ *
+ * It was copied from
+ * @see https://github.com/vercel/next.js/blob/canary/packages/next/shared/lib/router/utils/sorted-routes.ts
+ */
+export declare class UrlNode {
+    placeholder: boolean;
+    children: Map<string, UrlNode>;
+    slugName: string | null;
+    restSlugName: string | null;
+    optionalRestSlugName: string | null;
+    insert(urlPath: string): void;
+    smoosh(): string[];
+    private _smoosh;
+    private _insert;
+}
+//# sourceMappingURL=UrlNode.d.ts.map

package/lib/client/UrlNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UrlNode.d.ts","sourceRoot":"","sources":["../../src/client/UrlNode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qBAAa,OAAO;IAClB,WAAW,EAAE,OAAO,CAAQ;IAC5B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAa;IAC3C,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAQ;IAC/B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAQ;IACnC,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAQ;IAE3C,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAI7B,MAAM,IAAI,MAAM,EAAE;IAIlB,OAAO,CAAC,OAAO;IAoDf,OAAO,CAAC,OAAO;CAmIhB"}

package/lib/client/UrlNode.js

@@ -0,0 +1,162 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../_virtual/_tslib.js');
+
+/**
+ * This class provides a logic of sorting dynamic routes in NextJS.
+ *
+ * It was copied from
+ * @see https://github.com/vercel/next.js/blob/canary/packages/next/shared/lib/router/utils/sorted-routes.ts
+ */
+var UrlNode = /** @class */ (function () {
+    function UrlNode() {
+        this.placeholder = true;
+        this.children = new Map();
+        this.slugName = null;
+        this.restSlugName = null;
+        this.optionalRestSlugName = null;
+    }
+    UrlNode.prototype.insert = function (urlPath) {
+        this._insert(urlPath.split('/').filter(Boolean), [], false);
+    };
+    UrlNode.prototype.smoosh = function () {
+        return this._smoosh();
+    };
+    UrlNode.prototype._smoosh = function (prefix) {
+        var _this = this;
+        if (prefix === void 0) { prefix = '/'; }
+        var childrenPaths = _tslib.__spreadArray([], _tslib.__read(this.children.keys()), false).sort();
+        if (this.slugName !== null) {
+            childrenPaths.splice(childrenPaths.indexOf('[]'), 1);
+        }
+        if (this.restSlugName !== null) {
+            childrenPaths.splice(childrenPaths.indexOf('[...]'), 1);
+        }
+        if (this.optionalRestSlugName !== null) {
+            childrenPaths.splice(childrenPaths.indexOf('[[...]]'), 1);
+        }
+        var routes = childrenPaths
+            .map(function (c) { return _this.children.get(c)._smoosh("".concat(prefix).concat(c, "/")); })
+            .reduce(function (prev, curr) { return _tslib.__spreadArray(_tslib.__spreadArray([], _tslib.__read(prev), false), _tslib.__read(curr), false); }, []);
+        if (this.slugName !== null) {
+            routes.push.apply(routes, _tslib.__spreadArray([], _tslib.__read(this.children.get('[]')._smoosh("".concat(prefix, "[").concat(this.slugName, "]/"))), false));
+        }
+        if (!this.placeholder) {
+            var r = prefix === '/' ? '/' : prefix.slice(0, -1);
+            if (this.optionalRestSlugName != null) {
+                throw new Error("You cannot define a route with the same specificity as a optional catch-all route (\"".concat(r, "\" and \"").concat(r, "[[...").concat(this.optionalRestSlugName, "]]\")."));
+            }
+            routes.unshift(r);
+        }
+        if (this.restSlugName !== null) {
+            routes.push.apply(routes, _tslib.__spreadArray([], _tslib.__read(this.children
+                .get('[...]')
+                ._smoosh("".concat(prefix, "[...").concat(this.restSlugName, "]/"))), false));
+        }
+        if (this.optionalRestSlugName !== null) {
+            routes.push.apply(routes, _tslib.__spreadArray([], _tslib.__read(this.children
+                .get('[[...]]')
+                ._smoosh("".concat(prefix, "[[...").concat(this.optionalRestSlugName, "]]/"))), false));
+        }
+        return routes;
+    };
+    UrlNode.prototype._insert = function (urlPaths, slugNames, isCatchAll) {
+        if (urlPaths.length === 0) {
+            this.placeholder = false;
+            return;
+        }
+        if (isCatchAll) {
+            throw new Error("Catch-all must be the last part of the URL.");
+        }
+        // The next segment in the urlPaths list
+        var nextSegment = urlPaths[0];
+        // Check if the segment matches `[something]`
+        if (nextSegment.startsWith('[') && nextSegment.endsWith(']')) {
+            // Strip `[` and `]`, leaving only `something`
+            var segmentName = nextSegment.slice(1, -1);
+            var isOptional = false;
+            if (segmentName.startsWith('[') && segmentName.endsWith(']')) {
+                // Strip optional `[` and `]`, leaving only `something`
+                segmentName = segmentName.slice(1, -1);
+                isOptional = true;
+            }
+            if (segmentName.startsWith('...')) {
+                // Strip `...`, leaving only `something`
+                segmentName = segmentName.substring(3);
+                isCatchAll = true;
+            }
+            if (segmentName.startsWith('[') || segmentName.endsWith(']')) {
+                throw new Error("Segment names may not start or end with extra brackets ('".concat(segmentName, "')."));
+            }
+            if (segmentName.startsWith('.')) {
+                throw new Error("Segment names may not start with erroneous periods ('".concat(segmentName, "')."));
+            }
+            var handleSlug = function handleSlug(previousSlug, nextSlug) {
+                if (previousSlug !== null) {
+                    // If the specific segment already has a slug but the slug is not `something`
+                    // This prevents collisions like:
+                    // pages/[post]/index.js
+                    // pages/[id]/index.js
+                    // Because currently multiple dynamic params on the same segment level are not supported
+                    if (previousSlug !== nextSlug) {
+                        // TODO: This error seems to be confusing for users, needs an error link, the description can be based on above comment.
+                        throw new Error("You cannot use different slug names for the same dynamic path ('".concat(previousSlug, "' !== '").concat(nextSlug, "')."));
+                    }
+                }
+                slugNames.forEach(function (slug) {
+                    if (slug === nextSlug) {
+                        throw new Error("You cannot have the same slug name \"".concat(nextSlug, "\" repeat within a single dynamic path"));
+                    }
+                    if (slug.replace(/\W/g, '') === nextSegment.replace(/\W/g, '')) {
+                        throw new Error("You cannot have the slug names \"".concat(slug, "\" and \"").concat(nextSlug, "\" differ only by non-word symbols within a single dynamic path"));
+                    }
+                });
+                slugNames.push(nextSlug);
+            };
+            if (isCatchAll) {
+                if (isOptional) {
+                    if (this.restSlugName != null) {
+                        throw new Error("You cannot use both an required and optional catch-all route at the same level (\"[...".concat(this.restSlugName, "]\" and \"").concat(urlPaths[0], "\" )."));
+                    }
+                    handleSlug(this.optionalRestSlugName, segmentName);
+                    // slugName is kept as it can only be one particular slugName
+                    this.optionalRestSlugName = segmentName;
+                    // nextSegment is overwritten to [[...]] so that it can later be sorted specifically
+                    nextSegment = '[[...]]';
+                }
+                else {
+                    if (this.optionalRestSlugName != null) {
+                        throw new Error("You cannot use both an optional and required catch-all route at the same level (\"[[...".concat(this.optionalRestSlugName, "]]\" and \"").concat(urlPaths[0], "\")."));
+                    }
+                    handleSlug(this.restSlugName, segmentName);
+                    // slugName is kept as it can only be one particular slugName
+                    this.restSlugName = segmentName;
+                    // nextSegment is overwritten to [...] so that it can later be sorted specifically
+                    nextSegment = '[...]';
+                }
+            }
+            else {
+                if (isOptional) {
+                    throw new Error("Optional route parameters are not yet supported (\"".concat(urlPaths[0], "\")."));
+                }
+                handleSlug(this.slugName, segmentName);
+                // slugName is kept as it can only be one particular slugName
+                this.slugName = segmentName;
+                // nextSegment is overwritten to [] so that it can later be sorted specifically
+                nextSegment = '[]';
+            }
+        }
+        // If this UrlNode doesn't have the nextSegment yet we create a new child UrlNode
+        if (!this.children.has(nextSegment)) {
+            this.children.set(nextSegment, new UrlNode());
+        }
+        this.children
+            .get(nextSegment)
+            ._insert(urlPaths.slice(1), slugNames, isCatchAll);
+    };
+    return UrlNode;
+}());
+
+exports.UrlNode = UrlNode;

package/lib/client/helpers.d.ts

@@ -0,0 +1,17 @@
+export declare function isDynamicRoute(route: string): boolean;
+export declare function getRouteRegex(normalizedRoute: string): {
+    re: RegExp;
+    groups: {};
+};
+/**
+ * Convert browser pathname to NextJs route.
+ * This method is required for proper work of Dynamic routes  in NextJS.
+ */
+export declare function pathnameToRoute(cleanPathname: string, routes: string[]): string | undefined;
+/**
+ * Sort provided pages in correct nextjs order.
+ * This sorting is required if you are using dynamic routes in your apps.
+ * If order is incorrect then Nextjs may use dynamicRoute instead of exact page.
+ */
+export declare function sortNextPages(pages: string[]): string[];
+//# sourceMappingURL=helpers.d.ts.map

package/lib/client/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/client/helpers.ts"],"names":[],"mappings":"AAGA,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,WAE3C;AA4CD,wBAAgB,aAAa,CAAC,eAAe,EAAE,MAAM;;;EAMpD;AAYD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,EAAE,GACf,MAAM,GAAG,SAAS,CAYpB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAKvD"}