@taskmark/ui 0.2.0 → 0.2.2

package/dist/standalone/node_modules/next/dist/shared/lib/router/utils/prepare-destination.js

@@ -1,292 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    compileNonPath: null,
-    matchHas: null,
-    parseDestination: null,
-    prepareDestination: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    compileNonPath: function() {
-        return compileNonPath;
-    },
-    matchHas: function() {
-        return matchHas;
-    },
-    parseDestination: function() {
-        return parseDestination;
-    },
-    prepareDestination: function() {
-        return prepareDestination;
-    }
-});
-const _escaperegexp = require("../../escape-regexp");
-const _parseurl = require("./parse-url");
-const _interceptionroutes = require("./interception-routes");
-const _getcookieparser = require("../../../../server/api-utils/get-cookie-parser");
-const _routematchutils = require("./route-match-utils");
-/**
- * Ensure only a-zA-Z are used for param names for proper interpolating
- * with path-to-regexp
- */ function getSafeParamName(paramName) {
-    let newParamName = '';
-    for(let i = 0; i < paramName.length; i++){
-        const charCode = paramName.charCodeAt(i);
-        if (charCode > 64 && charCode < 91 || // A-Z
-        charCode > 96 && charCode < 123 // a-z
-        ) {
-            newParamName += paramName[i];
-        }
-    }
-    return newParamName;
-}
-function escapeSegment(str, segmentName) {
-    return str.replace(new RegExp(`:${(0, _escaperegexp.escapeStringRegexp)(segmentName)}`, 'g'), `__ESC_COLON_${segmentName}`);
-}
-function unescapeSegments(str) {
-    return str.replace(/__ESC_COLON_/gi, ':');
-}
-function matchHas(req, query, has = [], missing = []) {
-    const params = {};
-    const hasMatch = (hasItem)=>{
-        let value;
-        let key = hasItem.key;
-        switch(hasItem.type){
-            case 'header':
-                {
-                    key = key.toLowerCase();
-                    value = req.headers[key];
-                    break;
-                }
-            case 'cookie':
-                {
-                    if ('cookies' in req) {
-                        value = req.cookies[hasItem.key];
-                    } else {
-                        const cookies = (0, _getcookieparser.getCookieParser)(req.headers)();
-                        value = cookies[hasItem.key];
-                    }
-                    break;
-                }
-            case 'query':
-                {
-                    value = query[key];
-                    break;
-                }
-            case 'host':
-                {
-                    const { host } = req?.headers || {};
-                    // remove port from host if present
-                    const hostname = host?.split(':', 1)[0].toLowerCase();
-                    value = hostname;
-                    break;
-                }
-            default:
-                {
-                    break;
-                }
-        }
-        if (!hasItem.value && value) {
-            params[getSafeParamName(key)] = value;
-            return true;
-        } else if (value) {
-            const matcher = new RegExp(`^${hasItem.value}$`);
-            const matches = Array.isArray(value) ? value.slice(-1)[0].match(matcher) : value.match(matcher);
-            if (matches) {
-                if (Array.isArray(matches)) {
-                    if (matches.groups) {
-                        Object.keys(matches.groups).forEach((groupKey)=>{
-                            params[groupKey] = matches.groups[groupKey];
-                        });
-                    } else if (hasItem.type === 'host' && matches[0]) {
-                        params.host = matches[0];
-                    }
-                }
-                return true;
-            }
-        }
-        return false;
-    };
-    const allMatch = has.every((item)=>hasMatch(item)) && !missing.some((item)=>hasMatch(item));
-    if (allMatch) {
-        return params;
-    }
-    return false;
-}
-function compileNonPath(value, params) {
-    if (!value.includes(':')) {
-        return value;
-    }
-    for (const key of Object.keys(params)){
-        if (value.includes(`:${key}`)) {
-            value = value.replace(new RegExp(`:${key}\\*`, 'g'), `:${key}--ESCAPED_PARAM_ASTERISKS`).replace(new RegExp(`:${key}\\?`, 'g'), `:${key}--ESCAPED_PARAM_QUESTION`).replace(new RegExp(`:${key}\\+`, 'g'), `:${key}--ESCAPED_PARAM_PLUS`).replace(new RegExp(`:${key}(?!\\w)`, 'g'), `--ESCAPED_PARAM_COLON${key}`);
-        }
-    }
-    value = value.replace(/(:|\*|\?|\+|\(|\)|\{|\})/g, '\\$1').replace(/--ESCAPED_PARAM_PLUS/g, '+').replace(/--ESCAPED_PARAM_COLON/g, ':').replace(/--ESCAPED_PARAM_QUESTION/g, '?').replace(/--ESCAPED_PARAM_ASTERISKS/g, '*');
-    // the value needs to start with a forward-slash to be compiled
-    // correctly
-    return (0, _routematchutils.safeCompile)(`/${value}`, {
-        validate: false
-    })(params).slice(1);
-}
-function parseDestination(args) {
-    let escaped = args.destination;
-    for (const param of Object.keys({
-        ...args.params,
-        ...args.query
-    })){
-        if (!param) continue;
-        escaped = escapeSegment(escaped, param);
-    }
-    const parsed = (0, _parseurl.parseUrl)(escaped);
-    let pathname = parsed.pathname;
-    if (pathname) {
-        pathname = unescapeSegments(pathname);
-    }
-    let href = parsed.href;
-    if (href) {
-        href = unescapeSegments(href);
-    }
-    let hostname = parsed.hostname;
-    if (hostname) {
-        hostname = unescapeSegments(hostname);
-    }
-    let hash = parsed.hash;
-    if (hash) {
-        hash = unescapeSegments(hash);
-    }
-    let search = parsed.search;
-    if (search) {
-        search = unescapeSegments(search);
-    }
-    let origin = parsed.origin;
-    if (origin) {
-        origin = unescapeSegments(origin);
-    }
-    return {
-        ...parsed,
-        pathname,
-        hostname,
-        href,
-        hash,
-        search,
-        origin
-    };
-}
-function prepareDestination(args) {
-    const parsedDestination = parseDestination(args);
-    const { hostname: destHostname, query: destQuery, search: destSearch } = parsedDestination;
-    // The following code assumes that the pathname here includes the hash if it's
-    // present.
-    let destPath = parsedDestination.pathname;
-    if (parsedDestination.hash) {
-        destPath = `${destPath}${parsedDestination.hash}`;
-    }
-    const destParams = [];
-    const destPathParamKeys = [];
-    (0, _routematchutils.safePathToRegexp)(destPath, destPathParamKeys);
-    for (const key of destPathParamKeys){
-        destParams.push(key.name);
-    }
-    if (destHostname) {
-        const destHostnameParamKeys = [];
-        (0, _routematchutils.safePathToRegexp)(destHostname, destHostnameParamKeys);
-        for (const key of destHostnameParamKeys){
-            destParams.push(key.name);
-        }
-    }
-    const destPathCompiler = (0, _routematchutils.safeCompile)(destPath, // we don't validate while compiling the destination since we should
-    // have already validated before we got to this point and validating
-    // breaks compiling destinations with named pattern params from the source
-    // e.g. /something:hello(.*) -> /another/:hello is broken with validation
-    // since compile validation is meant for reversing and not for inserting
-    // params from a separate path-regex into another
-    {
-        validate: false
-    });
-    let destHostnameCompiler;
-    if (destHostname) {
-        destHostnameCompiler = (0, _routematchutils.safeCompile)(destHostname, {
-            validate: false
-        });
-    }
-    // update any params in query values
-    for (const [key, strOrArray] of Object.entries(destQuery)){
-        // the value needs to start with a forward-slash to be compiled
-        // correctly
-        if (Array.isArray(strOrArray)) {
-            destQuery[key] = strOrArray.map((value)=>compileNonPath(unescapeSegments(value), args.params));
-        } else if (typeof strOrArray === 'string') {
-            destQuery[key] = compileNonPath(unescapeSegments(strOrArray), args.params);
-        }
-    }
-    // add path params to query if it's not a redirect and not
-    // already defined in destination query or path
-    let paramKeys = Object.keys(args.params).filter((name)=>name !== 'nextInternalLocale');
-    if (args.appendParamsToQuery && !paramKeys.some((key)=>destParams.includes(key))) {
-        for (const key of paramKeys){
-            if (!(key in destQuery)) {
-                destQuery[key] = args.params[key];
-            }
-        }
-    }
-    let newUrl;
-    // The compiler also that the interception route marker is an unnamed param, hence '0',
-    // so we need to add it to the params object.
-    if ((0, _interceptionroutes.isInterceptionRouteAppPath)(destPath)) {
-        for (const segment of destPath.split('/')){
-            const marker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m));
-            if (marker) {
-                if (marker === '(..)(..)') {
-                    args.params['0'] = '(..)';
-                    args.params['1'] = '(..)';
-                } else {
-                    args.params['0'] = marker;
-                }
-                break;
-            }
-        }
-    }
-    try {
-        newUrl = destPathCompiler(args.params);
-        const [pathname, hash] = newUrl.split('#', 2);
-        if (destHostnameCompiler) {
-            parsedDestination.hostname = destHostnameCompiler(args.params);
-        }
-        parsedDestination.pathname = pathname;
-        parsedDestination.hash = `${hash ? '#' : ''}${hash || ''}`;
-        parsedDestination.search = destSearch ? compileNonPath(destSearch, args.params) : '';
-    } catch (err) {
-        if (err.message.match(/Expected .*? to not repeat, but got an array/)) {
-            throw Object.defineProperty(new Error(`To use a multi-match in the destination you must add \`*\` at the end of the param name to signify it should repeat. https://nextjs.org/docs/messages/invalid-multi-match`), "__NEXT_ERROR_CODE", {
-                value: "E329",
-                enumerable: false,
-                configurable: true
-            });
-        }
-        throw err;
-    }
-    // Query merge order lowest priority to highest
-    // 1. initial URL query values
-    // 2. path segment values
-    // 3. destination specified query values
-    parsedDestination.query = {
-        ...args.query,
-        ...parsedDestination.query
-    };
-    return {
-        newUrl,
-        destQuery,
-        parsedDestination
-    };
-}
-
-//# sourceMappingURL=prepare-destination.js.map

package/dist/standalone/node_modules/next/dist/shared/lib/router/utils/querystring.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    assign: null,
-    searchParamsToUrlQuery: null,
-    urlQueryToSearchParams: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    assign: function() {
-        return assign;
-    },
-    searchParamsToUrlQuery: function() {
-        return searchParamsToUrlQuery;
-    },
-    urlQueryToSearchParams: function() {
-        return urlQueryToSearchParams;
-    }
-});
-function searchParamsToUrlQuery(searchParams) {
-    const query = {};
-    for (const [key, value] of searchParams.entries()){
-        const existing = query[key];
-        if (typeof existing === 'undefined') {
-            query[key] = value;
-        } else if (Array.isArray(existing)) {
-            existing.push(value);
-        } else {
-            query[key] = [
-                existing,
-                value
-            ];
-        }
-    }
-    return query;
-}
-function stringifyUrlQueryParam(param) {
-    if (typeof param === 'string') {
-        return param;
-    }
-    if (typeof param === 'number' && !isNaN(param) || typeof param === 'boolean') {
-        return String(param);
-    } else {
-        return '';
-    }
-}
-function urlQueryToSearchParams(query) {
-    const searchParams = new URLSearchParams();
-    for (const [key, value] of Object.entries(query)){
-        if (Array.isArray(value)) {
-            for (const item of value){
-                searchParams.append(key, stringifyUrlQueryParam(item));
-            }
-        } else {
-            searchParams.set(key, stringifyUrlQueryParam(value));
-        }
-    }
-    return searchParams;
-}
-function assign(target, ...searchParamsList) {
-    for (const searchParams of searchParamsList){
-        for (const key of searchParams.keys()){
-            target.delete(key);
-        }
-        for (const [key, value] of searchParams.entries()){
-            target.append(key, value);
-        }
-    }
-    return target;
-}
-
-//# sourceMappingURL=querystring.js.map

package/dist/standalone/node_modules/next/dist/shared/lib/router/utils/relativize-url.js

@@ -1,40 +0,0 @@
-/**
- * The result of parsing a URL relative to a base URL.
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    getRelativeURL: null,
-    parseRelativeURL: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    getRelativeURL: function() {
-        return getRelativeURL;
-    },
-    parseRelativeURL: function() {
-        return parseRelativeURL;
-    }
-});
-function parseRelativeURL(url, base) {
-    const baseURL = typeof base === 'string' ? new URL(base) : base;
-    const relative = new URL(url, base);
-    // The URL is relative if the origin is the same as the base URL.
-    const isRelative = relative.origin === baseURL.origin;
-    return {
-        url: isRelative ? relative.toString().slice(baseURL.origin.length) : relative.toString(),
-        isRelative
-    };
-}
-function getRelativeURL(url, base) {
-    const relative = parseRelativeURL(url, base);
-    return relative.url;
-}
-
-//# sourceMappingURL=relativize-url.js.map

package/dist/standalone/node_modules/next/dist/shared/lib/router/utils/remove-path-prefix.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "removePathPrefix", {
-    enumerable: true,
-    get: function() {
-        return removePathPrefix;
-    }
-});
-const _pathhasprefix = require("./path-has-prefix");
-function removePathPrefix(path, prefix) {
-    // If the path doesn't start with the prefix we can return it as is. This
-    // protects us from situations where the prefix is a substring of the path
-    // prefix such as:
-    //
-    // For prefix: /blog
-    //
-    //   /blog -> true
-    //   /blog/ -> true
-    //   /blog/1 -> true
-    //   /blogging -> false
-    //   /blogging/ -> false
-    //   /blogging/1 -> false
-    if (!(0, _pathhasprefix.pathHasPrefix)(path, prefix)) {
-        return path;
-    }
-    // Remove the prefix from the path via slicing.
-    const withoutPrefix = path.slice(prefix.length);
-    // If the path without the prefix starts with a `/` we can return it as is.
-    if (withoutPrefix.startsWith('/')) {
-        return withoutPrefix;
-    }
-    // If the path without the prefix doesn't start with a `/` we need to add it
-    // back to the path to make sure it's a valid path.
-    return `/${withoutPrefix}`;
-}
-
-//# sourceMappingURL=remove-path-prefix.js.map

package/dist/standalone/node_modules/next/dist/shared/lib/router/utils/remove-trailing-slash.js

@@ -1,21 +0,0 @@
-/**
- * Removes the trailing slash for a given route or page path. Preserves the
- * root page. Examples:
- *   - `/foo/bar/` -> `/foo/bar`
- *   - `/foo/bar` -> `/foo/bar`
- *   - `/` -> `/`
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "removeTrailingSlash", {
-    enumerable: true,
-    get: function() {
-        return removeTrailingSlash;
-    }
-});
-function removeTrailingSlash(route) {
-    return route.replace(/\/$/, '') || '/';
-}
-
-//# sourceMappingURL=remove-trailing-slash.js.map

package/dist/standalone/node_modules/next/dist/shared/lib/router/utils/resolve-param-value.js

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "resolveParamValue", {
-    enumerable: true,
-    get: function() {
-        return resolveParamValue;
-    }
-});
-const _invarianterror = require("../../invariant-error");
-const _interceptionprefixfromparamtype = require("./interception-prefix-from-param-type");
-/**
- * Extracts the param value from a path segment, handling interception markers
- * based on the expected param type.
- *
- * @param pathSegment - The path segment to extract the value from
- * @param params - The current params object for resolving dynamic param references
- * @param paramType - The expected param type which may include interception marker info
- * @returns The extracted param value
- */ function getParamValueFromSegment(pathSegment, params, paramType) {
-    // If the segment is dynamic, resolve it from the params object
-    if (pathSegment.type === 'dynamic') {
-        return params[pathSegment.param.paramName];
-    }
-    // If the paramType indicates this is an intercepted param, strip the marker
-    // that matches the interception marker in the param type
-    const interceptionPrefix = (0, _interceptionprefixfromparamtype.interceptionPrefixFromParamType)(paramType);
-    if (interceptionPrefix === pathSegment.interceptionMarker) {
-        return pathSegment.name.replace(pathSegment.interceptionMarker, '');
-    }
-    // For static segments, use the name
-    return pathSegment.name;
-}
-function resolveParamValue(paramName, paramType, depth, route, params) {
-    switch(paramType){
-        case 'catchall':
-        case 'optional-catchall':
-        case 'catchall-intercepted-(..)(..)':
-        case 'catchall-intercepted-(.)':
-        case 'catchall-intercepted-(..)':
-        case 'catchall-intercepted-(...)':
-            // For catchall routes, derive from pathname using depth to determine
-            // which segments to use
-            const processedSegments = [];
-            // Process segments to handle any embedded dynamic params
-            for(let index = depth; index < route.segments.length; index++){
-                const pathSegment = route.segments[index];
-                if (pathSegment.type === 'static') {
-                    let value = pathSegment.name;
-                    // For intercepted catch-all params, strip the marker from the first segment
-                    const interceptionPrefix = (0, _interceptionprefixfromparamtype.interceptionPrefixFromParamType)(paramType);
-                    if (interceptionPrefix && index === depth && interceptionPrefix === pathSegment.interceptionMarker) {
-                        // Strip the interception marker from the value
-                        value = value.replace(pathSegment.interceptionMarker, '');
-                    }
-                    processedSegments.push(value);
-                } else {
-                    // If the segment is a param placeholder, check if we have its value
-                    if (!params.hasOwnProperty(pathSegment.param.paramName)) {
-                        // If the segment is an optional catchall, we can break out of the
-                        // loop because it's optional!
-                        if (pathSegment.param.paramType === 'optional-catchall') {
-                            break;
-                        }
-                        // Unknown param placeholder in pathname - can't derive full value
-                        return undefined;
-                    }
-                    // If the segment matches a param, use the param value
-                    // We don't encode values here as that's handled during retrieval.
-                    const paramValue = params[pathSegment.param.paramName];
-                    if (Array.isArray(paramValue)) {
-                        processedSegments.push(...paramValue);
-                    } else {
-                        processedSegments.push(paramValue);
-                    }
-                }
-            }
-            if (processedSegments.length > 0) {
-                return processedSegments;
-            } else if (paramType === 'optional-catchall') {
-                return undefined;
-            } else {
-                // We shouldn't be able to match a catchall segment without any path
-                // segments if it's not an optional catchall
-                throw Object.defineProperty(new _invarianterror.InvariantError(`Unexpected empty path segments match for a route "${route.pathname}" with param "${paramName}" of type "${paramType}"`), "__NEXT_ERROR_CODE", {
-                    value: "E931",
-                    enumerable: false,
-                    configurable: true
-                });
-            }
-        case 'dynamic':
-        case 'dynamic-intercepted-(..)(..)':
-        case 'dynamic-intercepted-(.)':
-        case 'dynamic-intercepted-(..)':
-        case 'dynamic-intercepted-(...)':
-            // For regular dynamic parameters, take the segment at this depth
-            if (depth < route.segments.length) {
-                const pathSegment = route.segments[depth];
-                // Check if the segment at this depth is a placeholder for an unknown param
-                if (pathSegment.type === 'dynamic' && !params.hasOwnProperty(pathSegment.param.paramName)) {
-                    // The segment is a placeholder like [category] and we don't have the value
-                    return undefined;
-                }
-                // If the segment matches a param, use the param value from params object
-                // Otherwise it's a static segment, just use it directly
-                // We don't encode values here as that's handled during retrieval
-                return getParamValueFromSegment(pathSegment, params, paramType);
-            }
-            return undefined;
-        default:
-            paramType;
-    }
-}
-
-//# sourceMappingURL=resolve-param-value.js.map