lkd-web-kit 0.7.9 → 0.7.10

package/dist/node_modules/next/dist/shared/lib/router/utils/sorted-routes.js

@@ -0,0 +1,252 @@
+import { __exports as sortedRoutes } from '../../../../../../../_virtual/sorted-routes.js';
+
+var hasRequiredSortedRoutes;
+
+function requireSortedRoutes () {
+	if (hasRequiredSortedRoutes) return sortedRoutes;
+	hasRequiredSortedRoutes = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		function _export(target, all) {
+		    for(var name in all)Object.defineProperty(target, name, {
+		        enumerable: true,
+		        get: all[name]
+		    });
+		}
+		_export(exports, {
+		    getSortedRouteObjects: function() {
+		        return getSortedRouteObjects;
+		    },
+		    getSortedRoutes: function() {
+		        return getSortedRoutes;
+		    }
+		});
+		class UrlNode {
+		    insert(urlPath) {
+		        this._insert(urlPath.split('/').filter(Boolean), [], false);
+		    }
+		    smoosh() {
+		        return this._smoosh();
+		    }
+		    _smoosh(prefix = '/') {
+		        const childrenPaths = [
+		            ...this.children.keys()
+		        ].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);
+		        }
+		        const routes = childrenPaths.map((c)=>this.children.get(c)._smoosh(`${prefix}${c}/`)).reduce((prev, curr)=>[
+		                ...prev,
+		                ...curr
+		            ], []);
+		        if (this.slugName !== null) {
+		            routes.push(...this.children.get('[]')._smoosh(`${prefix}[${this.slugName}]/`));
+		        }
+		        if (!this.placeholder) {
+		            const r = prefix === '/' ? '/' : prefix.slice(0, -1);
+		            if (this.optionalRestSlugName != null) {
+		                throw Object.defineProperty(new Error(`You cannot define a route with the same specificity as a optional catch-all route ("${r}" and "${r}[[...${this.optionalRestSlugName}]]").`), "__NEXT_ERROR_CODE", {
+		                    value: "E458",
+		                    enumerable: false,
+		                    configurable: true
+		                });
+		            }
+		            routes.unshift(r);
+		        }
+		        if (this.restSlugName !== null) {
+		            routes.push(...this.children.get('[...]')._smoosh(`${prefix}[...${this.restSlugName}]/`));
+		        }
+		        if (this.optionalRestSlugName !== null) {
+		            routes.push(...this.children.get('[[...]]')._smoosh(`${prefix}[[...${this.optionalRestSlugName}]]/`));
+		        }
+		        return routes;
+		    }
+		    _insert(urlPaths, slugNames, isCatchAll) {
+		        if (urlPaths.length === 0) {
+		            this.placeholder = false;
+		            return;
+		        }
+		        if (isCatchAll) {
+		            throw Object.defineProperty(new Error(`Catch-all must be the last part of the URL.`), "__NEXT_ERROR_CODE", {
+		                value: "E392",
+		                enumerable: false,
+		                configurable: true
+		            });
+		        }
+		        // The next segment in the urlPaths list
+		        let nextSegment = urlPaths[0];
+		        // Check if the segment matches `[something]`
+		        if (nextSegment.startsWith('[') && nextSegment.endsWith(']')) {
+		            // Strip `[` and `]`, leaving only `something`
+		            let segmentName = nextSegment.slice(1, -1);
+		            let isOptional = false;
+		            if (segmentName.startsWith('[') && segmentName.endsWith(']')) {
+		                // Strip optional `[` and `]`, leaving only `something`
+		                segmentName = segmentName.slice(1, -1);
+		                isOptional = true;
+		            }
+		            if (segmentName.startsWith('…')) {
+		                throw Object.defineProperty(new Error(`Detected a three-dot character ('…') at ('${segmentName}'). Did you mean ('...')?`), "__NEXT_ERROR_CODE", {
+		                    value: "E147",
+		                    enumerable: false,
+		                    configurable: true
+		                });
+		            }
+		            if (segmentName.startsWith('...')) {
+		                // Strip `...`, leaving only `something`
+		                segmentName = segmentName.substring(3);
+		                isCatchAll = true;
+		            }
+		            if (segmentName.startsWith('[') || segmentName.endsWith(']')) {
+		                throw Object.defineProperty(new Error(`Segment names may not start or end with extra brackets ('${segmentName}').`), "__NEXT_ERROR_CODE", {
+		                    value: "E421",
+		                    enumerable: false,
+		                    configurable: true
+		                });
+		            }
+		            if (segmentName.startsWith('.')) {
+		                throw Object.defineProperty(new Error(`Segment names may not start with erroneous periods ('${segmentName}').`), "__NEXT_ERROR_CODE", {
+		                    value: "E288",
+		                    enumerable: false,
+		                    configurable: true
+		                });
+		            }
+		            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 Object.defineProperty(new Error(`You cannot use different slug names for the same dynamic path ('${previousSlug}' !== '${nextSlug}').`), "__NEXT_ERROR_CODE", {
+		                            value: "E337",
+		                            enumerable: false,
+		                            configurable: true
+		                        });
+		                    }
+		                }
+		                slugNames.forEach((slug)=>{
+		                    if (slug === nextSlug) {
+		                        throw Object.defineProperty(new Error(`You cannot have the same slug name "${nextSlug}" repeat within a single dynamic path`), "__NEXT_ERROR_CODE", {
+		                            value: "E247",
+		                            enumerable: false,
+		                            configurable: true
+		                        });
+		                    }
+		                    if (slug.replace(/\W/g, '') === nextSegment.replace(/\W/g, '')) {
+		                        throw Object.defineProperty(new Error(`You cannot have the slug names "${slug}" and "${nextSlug}" differ only by non-word symbols within a single dynamic path`), "__NEXT_ERROR_CODE", {
+		                            value: "E499",
+		                            enumerable: false,
+		                            configurable: true
+		                        });
+		                    }
+		                });
+		                slugNames.push(nextSlug);
+		            }
+		            if (isCatchAll) {
+		                if (isOptional) {
+		                    if (this.restSlugName != null) {
+		                        throw Object.defineProperty(new Error(`You cannot use both an required and optional catch-all route at the same level ("[...${this.restSlugName}]" and "${urlPaths[0]}" ).`), "__NEXT_ERROR_CODE", {
+		                            value: "E299",
+		                            enumerable: false,
+		                            configurable: true
+		                        });
+		                    }
+		                    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 Object.defineProperty(new Error(`You cannot use both an optional and required catch-all route at the same level ("[[...${this.optionalRestSlugName}]]" and "${urlPaths[0]}").`), "__NEXT_ERROR_CODE", {
+		                            value: "E300",
+		                            enumerable: false,
+		                            configurable: true
+		                        });
+		                    }
+		                    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 Object.defineProperty(new Error(`Optional route parameters are not yet supported ("${urlPaths[0]}").`), "__NEXT_ERROR_CODE", {
+		                        value: "E435",
+		                        enumerable: false,
+		                        configurable: true
+		                    });
+		                }
+		                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);
+		    }
+		    constructor(){
+		        this.placeholder = true;
+		        this.children = new Map();
+		        this.slugName = null;
+		        this.restSlugName = null;
+		        this.optionalRestSlugName = null;
+		    }
+		}
+		function getSortedRoutes(normalizedPages) {
+		    // First the UrlNode is created, and every UrlNode can have only 1 dynamic segment
+		    // Eg you can't have pages/[post]/abc.js and pages/[hello]/something-else.js
+		    // Only 1 dynamic segment per nesting level
+		    // So in the case that is test/integration/dynamic-routing it'll be this:
+		    // pages/[post]/comments.js
+		    // pages/blog/[post]/comment/[id].js
+		    // Both are fine because `pages/[post]` and `pages/blog` are on the same level
+		    // So in this case `UrlNode` created here has `this.slugName === 'post'`
+		    // And since your PR passed through `slugName` as an array basically it'd including it in too many possibilities
+		    // Instead what has to be passed through is the upwards path's dynamic names
+		    const root = new UrlNode();
+		    // Here the `root` gets injected multiple paths, and insert will break them up into sublevels
+		    normalizedPages.forEach((pagePath)=>root.insert(pagePath));
+		    // Smoosh will then sort those sublevels up to the point where you get the correct route definition priority
+		    return root.smoosh();
+		}
+		function getSortedRouteObjects(objects, getter) {
+		    // We're assuming here that all the pathnames are unique, that way we can
+		    // sort the list and use the index as the key.
+		    const indexes = {};
+		    const pathnames = [];
+		    for(let i = 0; i < objects.length; i++){
+		        const pathname = getter(objects[i]);
+		        indexes[pathname] = i;
+		        pathnames[i] = pathname;
+		    }
+		    // Sort the pathnames.
+		    const sorted = getSortedRoutes(pathnames);
+		    // Map the sorted pathnames back to the original objects using the new sorted
+		    // index.
+		    return sorted.map((pathname)=>objects[indexes[pathname]]);
+		}
+
+		
+	} (sortedRoutes));
+	return sortedRoutes;
+}
+
+export { requireSortedRoutes as __require };

package/dist/node_modules/next/dist/shared/lib/router-context.shared-runtime.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const routerContext_sharedRuntime = require('../../../../../_virtual/router-context.shared-runtime.cjs');
+const _interop_require_default = require('../../../../@swc/helpers/cjs/_interop_require_default.cjs');
+const React = require('react');
+
+var hasRequiredRouterContext_sharedRuntime;
+
+function requireRouterContext_sharedRuntime () {
+	if (hasRequiredRouterContext_sharedRuntime) return routerContext_sharedRuntime.__exports;
+	hasRequiredRouterContext_sharedRuntime = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "RouterContext", {
+		    enumerable: true,
+		    get: function() {
+		        return RouterContext;
+		    }
+		});
+		const _interop_require_default$1 = /*@__PURE__*/ _interop_require_default.__require();
+		const _react = /*#__PURE__*/ _interop_require_default$1._(React);
+		const RouterContext = _react.default.createContext(null);
+		if (process.env.NODE_ENV !== 'production') {
+		    RouterContext.displayName = 'RouterContext';
+		}
+
+		
+	} (routerContext_sharedRuntime.__exports));
+	return routerContext_sharedRuntime.__exports;
+}
+
+exports.__require = requireRouterContext_sharedRuntime;

package/dist/node_modules/next/dist/shared/lib/router-context.shared-runtime.js

@@ -0,0 +1,32 @@
+import { __exports as routerContext_sharedRuntime } from '../../../../../_virtual/router-context.shared-runtime.js';
+import { __require as require_interop_require_default } from '../../../../@swc/helpers/cjs/_interop_require_default.js';
+import React__default from 'react';
+
+var hasRequiredRouterContext_sharedRuntime;
+
+function requireRouterContext_sharedRuntime () {
+	if (hasRequiredRouterContext_sharedRuntime) return routerContext_sharedRuntime;
+	hasRequiredRouterContext_sharedRuntime = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "RouterContext", {
+		    enumerable: true,
+		    get: function() {
+		        return RouterContext;
+		    }
+		});
+		const _interop_require_default = /*@__PURE__*/ require_interop_require_default();
+		const _react = /*#__PURE__*/ _interop_require_default._(React__default);
+		const RouterContext = _react.default.createContext(null);
+		if (process.env.NODE_ENV !== 'production') {
+		    RouterContext.displayName = 'RouterContext';
+		}
+
+		
+	} (routerContext_sharedRuntime));
+	return routerContext_sharedRuntime;
+}
+
+export { requireRouterContext_sharedRuntime as __require };

package/dist/node_modules/next/dist/shared/lib/segment.cjs

@@ -0,0 +1,103 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const segment = require('../../../../../_virtual/segment.cjs');
+
+var hasRequiredSegment;
+
+function requireSegment () {
+	if (hasRequiredSegment) return segment.__exports;
+	hasRequiredSegment = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		function _export(target, all) {
+		    for(var name in all)Object.defineProperty(target, name, {
+		        enumerable: true,
+		        get: all[name]
+		    });
+		}
+		_export(exports, {
+		    DEFAULT_SEGMENT_KEY: function() {
+		        return DEFAULT_SEGMENT_KEY;
+		    },
+		    PAGE_SEGMENT_KEY: function() {
+		        return PAGE_SEGMENT_KEY;
+		    },
+		    addSearchParamsIfPageSegment: function() {
+		        return addSearchParamsIfPageSegment;
+		    },
+		    computeSelectedLayoutSegment: function() {
+		        return computeSelectedLayoutSegment;
+		    },
+		    getSegmentValue: function() {
+		        return getSegmentValue;
+		    },
+		    getSelectedLayoutSegmentPath: function() {
+		        return getSelectedLayoutSegmentPath;
+		    },
+		    isGroupSegment: function() {
+		        return isGroupSegment;
+		    },
+		    isParallelRouteSegment: function() {
+		        return isParallelRouteSegment;
+		    }
+		});
+		function getSegmentValue(segment) {
+		    return Array.isArray(segment) ? segment[1] : segment;
+		}
+		function isGroupSegment(segment) {
+		    // Use array[0] for performant purpose
+		    return segment[0] === '(' && segment.endsWith(')');
+		}
+		function isParallelRouteSegment(segment) {
+		    return segment.startsWith('@') && segment !== '@children';
+		}
+		function addSearchParamsIfPageSegment(segment, searchParams) {
+		    const isPageSegment = segment.includes(PAGE_SEGMENT_KEY);
+		    if (isPageSegment) {
+		        const stringifiedQuery = JSON.stringify(searchParams);
+		        return stringifiedQuery !== '{}' ? PAGE_SEGMENT_KEY + '?' + stringifiedQuery : PAGE_SEGMENT_KEY;
+		    }
+		    return segment;
+		}
+		function computeSelectedLayoutSegment(segments, parallelRouteKey) {
+		    if (!segments || segments.length === 0) {
+		        return null;
+		    }
+		    // For 'children', use first segment; for other parallel routes, use last segment
+		    const rawSegment = parallelRouteKey === 'children' ? segments[0] : segments[segments.length - 1];
+		    // If the default slot is showing, return null since it's not technically "selected" (it's a fallback)
+		    // Returning an internal value like `__DEFAULT__` would be confusing
+		    return rawSegment === DEFAULT_SEGMENT_KEY ? null : rawSegment;
+		}
+		function getSelectedLayoutSegmentPath(tree, parallelRouteKey, first = true, segmentPath = []) {
+		    let node;
+		    if (first) {
+		        // Use the provided parallel route key on the first parallel route
+		        node = tree[1][parallelRouteKey];
+		    } else {
+		        // After first parallel route prefer children, if there's no children pick the first parallel route.
+		        const parallelRoutes = tree[1];
+		        node = parallelRoutes.children ?? Object.values(parallelRoutes)[0];
+		    }
+		    if (!node) return segmentPath;
+		    const segment = node[0];
+		    let segmentValue = getSegmentValue(segment);
+		    if (!segmentValue || segmentValue.startsWith(PAGE_SEGMENT_KEY)) {
+		        return segmentPath;
+		    }
+		    segmentPath.push(segmentValue);
+		    return getSelectedLayoutSegmentPath(node, parallelRouteKey, false, segmentPath);
+		}
+		const PAGE_SEGMENT_KEY = '__PAGE__';
+		const DEFAULT_SEGMENT_KEY = '__DEFAULT__';
+
+		
+	} (segment.__exports));
+	return segment.__exports;
+}
+
+exports.__require = requireSegment;

package/dist/node_modules/next/dist/shared/lib/segment.js

@@ -0,0 +1,99 @@
+import { __exports as segment } from '../../../../../_virtual/segment.js';
+
+var hasRequiredSegment;
+
+function requireSegment () {
+	if (hasRequiredSegment) return segment;
+	hasRequiredSegment = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		function _export(target, all) {
+		    for(var name in all)Object.defineProperty(target, name, {
+		        enumerable: true,
+		        get: all[name]
+		    });
+		}
+		_export(exports, {
+		    DEFAULT_SEGMENT_KEY: function() {
+		        return DEFAULT_SEGMENT_KEY;
+		    },
+		    PAGE_SEGMENT_KEY: function() {
+		        return PAGE_SEGMENT_KEY;
+		    },
+		    addSearchParamsIfPageSegment: function() {
+		        return addSearchParamsIfPageSegment;
+		    },
+		    computeSelectedLayoutSegment: function() {
+		        return computeSelectedLayoutSegment;
+		    },
+		    getSegmentValue: function() {
+		        return getSegmentValue;
+		    },
+		    getSelectedLayoutSegmentPath: function() {
+		        return getSelectedLayoutSegmentPath;
+		    },
+		    isGroupSegment: function() {
+		        return isGroupSegment;
+		    },
+		    isParallelRouteSegment: function() {
+		        return isParallelRouteSegment;
+		    }
+		});
+		function getSegmentValue(segment) {
+		    return Array.isArray(segment) ? segment[1] : segment;
+		}
+		function isGroupSegment(segment) {
+		    // Use array[0] for performant purpose
+		    return segment[0] === '(' && segment.endsWith(')');
+		}
+		function isParallelRouteSegment(segment) {
+		    return segment.startsWith('@') && segment !== '@children';
+		}
+		function addSearchParamsIfPageSegment(segment, searchParams) {
+		    const isPageSegment = segment.includes(PAGE_SEGMENT_KEY);
+		    if (isPageSegment) {
+		        const stringifiedQuery = JSON.stringify(searchParams);
+		        return stringifiedQuery !== '{}' ? PAGE_SEGMENT_KEY + '?' + stringifiedQuery : PAGE_SEGMENT_KEY;
+		    }
+		    return segment;
+		}
+		function computeSelectedLayoutSegment(segments, parallelRouteKey) {
+		    if (!segments || segments.length === 0) {
+		        return null;
+		    }
+		    // For 'children', use first segment; for other parallel routes, use last segment
+		    const rawSegment = parallelRouteKey === 'children' ? segments[0] : segments[segments.length - 1];
+		    // If the default slot is showing, return null since it's not technically "selected" (it's a fallback)
+		    // Returning an internal value like `__DEFAULT__` would be confusing
+		    return rawSegment === DEFAULT_SEGMENT_KEY ? null : rawSegment;
+		}
+		function getSelectedLayoutSegmentPath(tree, parallelRouteKey, first = true, segmentPath = []) {
+		    let node;
+		    if (first) {
+		        // Use the provided parallel route key on the first parallel route
+		        node = tree[1][parallelRouteKey];
+		    } else {
+		        // After first parallel route prefer children, if there's no children pick the first parallel route.
+		        const parallelRoutes = tree[1];
+		        node = parallelRoutes.children ?? Object.values(parallelRoutes)[0];
+		    }
+		    if (!node) return segmentPath;
+		    const segment = node[0];
+		    let segmentValue = getSegmentValue(segment);
+		    if (!segmentValue || segmentValue.startsWith(PAGE_SEGMENT_KEY)) {
+		        return segmentPath;
+		    }
+		    segmentPath.push(segmentValue);
+		    return getSelectedLayoutSegmentPath(node, parallelRouteKey, false, segmentPath);
+		}
+		const PAGE_SEGMENT_KEY = '__PAGE__';
+		const DEFAULT_SEGMENT_KEY = '__DEFAULT__';
+
+		
+	} (segment));
+	return segment;
+}
+
+export { requireSegment as __require };

package/dist/node_modules/next/dist/shared/lib/utils/warn-once.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const warnOnce = require('../../../../../../_virtual/warn-once.cjs');
+
+var hasRequiredWarnOnce;
+
+function requireWarnOnce () {
+	if (hasRequiredWarnOnce) return warnOnce.__exports;
+	hasRequiredWarnOnce = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "warnOnce", {
+		    enumerable: true,
+		    get: function() {
+		        return warnOnce;
+		    }
+		});
+		let warnOnce = (_)=>{};
+		if (process.env.NODE_ENV !== 'production') {
+		    const warnings = new Set();
+		    warnOnce = (msg)=>{
+		        if (!warnings.has(msg)) {
+		            console.warn(msg);
+		        }
+		        warnings.add(msg);
+		    };
+		}
+
+		
+	} (warnOnce.__exports));
+	return warnOnce.__exports;
+}
+
+exports.__require = requireWarnOnce;

package/dist/node_modules/next/dist/shared/lib/utils/warn-once.js

@@ -0,0 +1,34 @@
+import { __exports as warnOnce } from '../../../../../../_virtual/warn-once.js';
+
+var hasRequiredWarnOnce;
+
+function requireWarnOnce () {
+	if (hasRequiredWarnOnce) return warnOnce;
+	hasRequiredWarnOnce = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "warnOnce", {
+		    enumerable: true,
+		    get: function() {
+		        return warnOnce;
+		    }
+		});
+		let warnOnce = (_)=>{};
+		if (process.env.NODE_ENV !== 'production') {
+		    const warnings = new Set();
+		    warnOnce = (msg)=>{
+		        if (!warnings.has(msg)) {
+		            console.warn(msg);
+		        }
+		        warnings.add(msg);
+		    };
+		}
+
+		
+	} (warnOnce));
+	return warnOnce;
+}
+
+export { requireWarnOnce as __require };