shieldcortex 4.2.1 → 4.2.3

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/lib/router-utils/typegen.js

@@ -1,613 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    generateLinkTypesFile: null,
-    generateRouteTypesFile: null,
-    generateValidatorFile: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    generateLinkTypesFile: function() {
-        return generateLinkTypesFile;
-    },
-    generateRouteTypesFile: function() {
-        return generateRouteTypesFile;
-    },
-    generateValidatorFile: function() {
-        return generateValidatorFile;
-    }
-});
-const _isdynamic = require("../../../shared/lib/router/utils/is-dynamic");
-function generateRouteTypes(routesManifest) {
-    const appRoutes = Object.keys(routesManifest.appRoutes).sort();
-    const pageRoutes = Object.keys(routesManifest.pageRoutes).sort();
-    const layoutRoutes = Object.keys(routesManifest.layoutRoutes).sort();
-    const redirectRoutes = Object.keys(routesManifest.redirectRoutes).sort();
-    const rewriteRoutes = Object.keys(routesManifest.rewriteRoutes).sort();
-    let result = '';
-    // Generate AppRoutes union type (pages only)
-    if (appRoutes.length > 0) {
-        result += `type AppRoutes = ${appRoutes.map((route)=>JSON.stringify(route)).join(' | ')}\n`;
-    } else {
-        result += 'type AppRoutes = never\n';
-    }
-    // Generate AppRouteHandlerRoutes union type for route handlers
-    const appRouteHandlerRoutes = Object.keys(routesManifest.appRouteHandlerRoutes).sort();
-    const hasAppRouteHandlers = appRouteHandlerRoutes.length > 0;
-    if (hasAppRouteHandlers) {
-        result += `type AppRouteHandlerRoutes = ${appRouteHandlerRoutes.map((route)=>JSON.stringify(route)).join(' | ')}\n`;
-    }
-    // Generate PageRoutes union type
-    if (pageRoutes.length > 0) {
-        result += `type PageRoutes = ${pageRoutes.map((route)=>JSON.stringify(route)).join(' | ')}\n`;
-    } else {
-        result += 'type PageRoutes = never\n';
-    }
-    // Generate LayoutRoutes union type
-    if (layoutRoutes.length > 0) {
-        result += `type LayoutRoutes = ${layoutRoutes.map((route)=>JSON.stringify(route)).join(' | ')}\n`;
-    } else {
-        result += 'type LayoutRoutes = never\n';
-    }
-    // Generate RedirectRoutes union type
-    if (redirectRoutes.length > 0) {
-        result += `type RedirectRoutes = ${redirectRoutes.map((route)=>JSON.stringify(route)).join(' | ')}\n`;
-    } else {
-        result += 'type RedirectRoutes = never\n';
-    }
-    // Generate RewriteRoutes union type
-    if (rewriteRoutes.length > 0) {
-        result += `type RewriteRoutes = ${rewriteRoutes.map((route)=>JSON.stringify(route)).join(' | ')}\n`;
-    } else {
-        result += 'type RewriteRoutes = never\n';
-    }
-    // Only include AppRouteHandlerRoutes in Routes union if there are actual route handlers
-    const routeUnionParts = [
-        'AppRoutes',
-        'PageRoutes',
-        'LayoutRoutes',
-        'RedirectRoutes',
-        'RewriteRoutes'
-    ];
-    if (hasAppRouteHandlers) {
-        routeUnionParts.push('AppRouteHandlerRoutes');
-    }
-    result += `type Routes = ${routeUnionParts.join(' | ')}\n`;
-    return result;
-}
-function generateParamTypes(routesManifest) {
-    const allRoutes = {
-        ...routesManifest.appRoutes,
-        ...routesManifest.appRouteHandlerRoutes,
-        ...routesManifest.pageRoutes,
-        ...routesManifest.layoutRoutes,
-        ...routesManifest.redirectRoutes,
-        ...routesManifest.rewriteRoutes
-    };
-    let paramTypes = 'interface ParamMap {\n';
-    // Sort routes deterministically for consistent output
-    const sortedRoutes = Object.entries(allRoutes).sort(([a], [b])=>a.localeCompare(b));
-    for (const [route, routeInfo] of sortedRoutes){
-        const { groups } = routeInfo;
-        // For static routes (no dynamic segments), we can produce an empty parameter map.
-        if (!(0, _isdynamic.isDynamicRoute)(route) || Object.keys(groups ?? {}).length === 0) {
-            paramTypes += `  ${JSON.stringify(route)}: {}\n`;
-            continue;
-        }
-        let paramType = '{';
-        // Process each group based on its properties
-        for (const [key, group] of Object.entries(groups)){
-            const escapedKey = JSON.stringify(key);
-            if (group.repeat) {
-                // Catch-all parameters
-                if (group.optional) {
-                    paramType += ` ${escapedKey}?: string[];`;
-                } else {
-                    paramType += ` ${escapedKey}: string[];`;
-                }
-            } else {
-                // Regular parameters
-                if (group.optional) {
-                    paramType += ` ${escapedKey}?: string;`;
-                } else {
-                    paramType += ` ${escapedKey}: string;`;
-                }
-            }
-        }
-        paramType += ' }';
-        paramTypes += `  ${JSON.stringify(route)}: ${paramType}\n`;
-    }
-    paramTypes += '}\n';
-    return paramTypes;
-}
-function generateLayoutSlotMap(routesManifest) {
-    let slotMap = 'interface LayoutSlotMap {\n';
-    // Sort routes deterministically for consistent output
-    const sortedLayoutRoutes = Object.entries(routesManifest.layoutRoutes).sort(([a], [b])=>a.localeCompare(b));
-    for (const [route, routeInfo] of sortedLayoutRoutes){
-        if ('slots' in routeInfo) {
-            const slots = routeInfo.slots.sort();
-            if (slots.length > 0) {
-                slotMap += `  ${JSON.stringify(route)}: ${slots.map((slot)=>JSON.stringify(slot)).join(' | ')}\n`;
-            } else {
-                slotMap += `  ${JSON.stringify(route)}: never\n`;
-            }
-        } else {
-            slotMap += `  ${JSON.stringify(route)}: never\n`;
-        }
-    }
-    slotMap += '}\n';
-    return slotMap;
-}
-// Helper function to format routes to route types (matches the plugin logic exactly)
-function formatRouteToRouteType(route) {
-    const isDynamic = (0, _isdynamic.isDynamicRoute)(route);
-    if (isDynamic) {
-        route = route.split('/').map((part)=>{
-            if (part.startsWith('[') && part.endsWith(']')) {
-                if (part.startsWith('[...')) {
-                    // /[...slug]
-                    return `\${CatchAllSlug<T>}`;
-                } else if (part.startsWith('[[...') && part.endsWith(']]')) {
-                    // /[[...slug]]
-                    return `\${OptionalCatchAllSlug<T>}`;
-                }
-                // /[slug]
-                return `\${SafeSlug<T>}`;
-            }
-            return part;
-        }).join('/');
-    }
-    return {
-        isDynamic,
-        routeType: route
-    };
-}
-// Helper function to serialize route types (matches the plugin logic exactly)
-function serializeRouteTypes(routeTypes) {
-    // route collection is not deterministic, this makes the output of the file deterministic
-    return routeTypes.sort().map((route)=>`\n    | \`${route}\``).join('');
-}
-function generateLinkTypesFile(routesManifest) {
-    // Generate serialized static and dynamic routes for the internal namespace
-    // Build a unified set of routes across app/pages/redirect/rewrite as well as
-    // app route handlers and Pages Router API routes.
-    const allRoutesSet = new Set([
-        ...Object.keys(routesManifest.appRoutes),
-        ...Object.keys(routesManifest.pageRoutes),
-        ...Object.keys(routesManifest.redirectRoutes),
-        ...Object.keys(routesManifest.rewriteRoutes),
-        // Allow linking to App Route Handlers (e.g. `/logout/route.ts`)
-        ...Object.keys(routesManifest.appRouteHandlerRoutes),
-        // Allow linking to Pages Router API routes (e.g. `/api/*`)
-        ...Array.from(routesManifest.pageApiRoutes)
-    ]);
-    const staticRouteTypes = [];
-    const dynamicRouteTypes = [];
-    // Process each route using the same logic as the plugin
-    for (const route of allRoutesSet){
-        const { isDynamic, routeType } = formatRouteToRouteType(route);
-        if (isDynamic) {
-            dynamicRouteTypes.push(routeType);
-        } else {
-            staticRouteTypes.push(routeType);
-        }
-    }
-    const serializedStaticRouteTypes = serializeRouteTypes(staticRouteTypes);
-    const serializedDynamicRouteTypes = serializeRouteTypes(dynamicRouteTypes);
-    // If both StaticRoutes and DynamicRoutes are empty, fallback to type 'string & {}'.
-    const routeTypesFallback = !serializedStaticRouteTypes && !serializedDynamicRouteTypes ? 'string & {}' : '';
-    return `// This file is generated automatically by Next.js
-// Do not edit this file manually
-
-// Type definitions for Next.js routes
-
-/**
- * Internal types used by the Next.js router and Link component.
- * These types are not meant to be used directly.
- * @internal
- */
-declare namespace __next_route_internal_types__ {
-  type SearchOrHash = \`?\${string}\` | \`#\${string}\`
-  type WithProtocol = \`\${string}:\${string}\`
-
-  type Suffix = '' | SearchOrHash
-
-  type SafeSlug<S extends string> = S extends \`\${string}/\${string}\`
-    ? never
-    : S extends \`\${string}\${SearchOrHash}\`
-    ? never
-    : S extends ''
-    ? never
-    : S
-
-  type CatchAllSlug<S extends string> = S extends \`\${string}\${SearchOrHash}\`
-    ? never
-    : S extends ''
-    ? never
-    : S
-
-  type OptionalCatchAllSlug<S extends string> =
-    S extends \`\${string}\${SearchOrHash}\` ? never : S
-
-  type StaticRoutes = ${serializedStaticRouteTypes || 'never'}
-  type DynamicRoutes<T extends string = string> = ${serializedDynamicRouteTypes || 'never'}
-
-  type RouteImpl<T> = ${routeTypesFallback || `
-    ${// This keeps autocompletion working for static routes.
-    '| StaticRoutes'}
-    | SearchOrHash
-    | WithProtocol
-    | \`\${StaticRoutes}\${SearchOrHash}\`
-    | (T extends \`\${DynamicRoutes<infer _>}\${Suffix}\` ? T : never)
-    `}
-}
-
-declare module 'next' {
-  export { default } from 'next/types.js'
-  export * from 'next/types.js'
-
-  export type Route<T extends string = string> =
-    __next_route_internal_types__.RouteImpl<T>
-}
-
-declare module 'next/link' {
-  export { useLinkStatus } from 'next/dist/client/link.js'
-
-  import type { LinkProps as OriginalLinkProps } from 'next/dist/client/link.js'
-  import type { AnchorHTMLAttributes, DetailedHTMLProps } from 'react'
-  import type { UrlObject } from 'url'
-
-  type LinkRestProps = Omit<
-    Omit<
-      DetailedHTMLProps<
-        AnchorHTMLAttributes<HTMLAnchorElement>,
-        HTMLAnchorElement
-      >,
-      keyof OriginalLinkProps
-    > &
-      OriginalLinkProps,
-    'href'
-  >
-
-  export type LinkProps<RouteInferType> = LinkRestProps & {
-    /**
-     * The path or URL to navigate to. This is the only required prop. It can also be an object.
-     * @see https://nextjs.org/docs/api-reference/next/link
-     */
-    href: __next_route_internal_types__.RouteImpl<RouteInferType> | UrlObject
-  }
-
-  export default function Link<RouteType>(props: LinkProps<RouteType>): JSX.Element
-}
-
-declare module 'next/navigation' {
-  export * from 'next/dist/client/components/navigation.js'
-
-  import type { NavigateOptions, AppRouterInstance as OriginalAppRouterInstance } from 'next/dist/shared/lib/app-router-context.shared-runtime.js'
-  import type { RedirectType } from 'next/dist/client/components/redirect-error.js'
-  
-  interface AppRouterInstance extends OriginalAppRouterInstance {
-    /**
-     * Navigate to the provided href.
-     * Pushes a new history entry.
-     */
-    push<RouteType>(href: __next_route_internal_types__.RouteImpl<RouteType>, options?: NavigateOptions): void
-    /**
-     * Navigate to the provided href.
-     * Replaces the current history entry.
-     */
-    replace<RouteType>(href: __next_route_internal_types__.RouteImpl<RouteType>, options?: NavigateOptions): void
-    /**
-     * Prefetch the provided href.
-     */
-    prefetch<RouteType>(href: __next_route_internal_types__.RouteImpl<RouteType>): void
-  }
-
-  export function useRouter(): AppRouterInstance;
-  
-  /**
-   * This function allows you to redirect the user to another URL. It can be used in
-   * [Server Components](https://nextjs.org/docs/app/building-your-application/rendering/server-components),
-   * [Route Handlers](https://nextjs.org/docs/app/building-your-application/routing/route-handlers), and
-   * [Server Actions](https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations).
-   *
-   * - In a Server Component, this will insert a meta tag to redirect the user to the target page.
-   * - In a Route Handler or Server Action, it will serve a 307/303 to the caller.
-   * - In a Server Action, type defaults to 'push' and 'replace' elsewhere.
-   *
-   * Read more: [Next.js Docs: redirect](https://nextjs.org/docs/app/api-reference/functions/redirect)
-   */
-  export function redirect<RouteType>(
-    /** The URL to redirect to */
-    url: __next_route_internal_types__.RouteImpl<RouteType>,
-    type?: RedirectType
-  ): never;
-  
-  /**
-   * This function allows you to redirect the user to another URL. It can be used in
-   * [Server Components](https://nextjs.org/docs/app/building-your-application/rendering/server-components),
-   * [Route Handlers](https://nextjs.org/docs/app/building-your-application/routing/route-handlers), and
-   * [Server Actions](https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations).
-   *
-   * - In a Server Component, this will insert a meta tag to redirect the user to the target page.
-   * - In a Route Handler or Server Action, it will serve a 308/303 to the caller.
-   *
-   * Read more: [Next.js Docs: redirect](https://nextjs.org/docs/app/api-reference/functions/redirect)
-   */
-  export function permanentRedirect<RouteType>(
-    /** The URL to redirect to */
-    url: __next_route_internal_types__.RouteImpl<RouteType>,
-    type?: RedirectType
-  ): never;
-}
-
-declare module 'next/form' {
-  import type { FormProps as OriginalFormProps } from 'next/dist/client/form.js'
-
-  type FormRestProps = Omit<OriginalFormProps, 'action'>
-
-  export type FormProps<RouteInferType> = {
-    /**
-     * \`action\` can be either a \`string\` or a function.
-     * - If \`action\` is a string, it will be interpreted as a path or URL to navigate to when the form is submitted.
-     *   The path will be prefetched when the form becomes visible.
-     * - If \`action\` is a function, it will be called when the form is submitted. See the [React docs](https://react.dev/reference/react-dom/components/form#props) for more.
-     */
-    action: __next_route_internal_types__.RouteImpl<RouteInferType> | ((formData: FormData) => void)
-  } & FormRestProps
-
-  export default function Form<RouteType>(props: FormProps<RouteType>): JSX.Element
-}
-`;
-}
-function generateValidatorFile(routesManifest) {
-    const generateValidations = (paths, type, pathToRouteMap)=>paths.sort()// Only validate TypeScript files - JavaScript files have too many type inference limitations
-        .filter((filePath)=>filePath.endsWith('.ts') || filePath.endsWith('.tsx')).filter(// Don't include metadata routes or pages
-        // (e.g. /manifest.webmanifest)
-        (filePath)=>type !== 'AppPageConfig' || filePath.endsWith('page.ts') || filePath.endsWith('page.tsx')).map((filePath)=>{
-            // Keep the file extension for TypeScript imports to support node16 module resolution
-            const importPath = filePath;
-            const route = pathToRouteMap == null ? void 0 : pathToRouteMap.get(filePath);
-            const typeWithRoute = route && (type === 'AppPageConfig' || type === 'LayoutConfig' || type === 'RouteHandlerConfig') ? `${type}<${JSON.stringify(route)}>` : type;
-            // NOTE: we previously used `satisfies` here, but it's not supported by TypeScript 4.8 and below.
-            // If we ever raise the TS minimum version, we can switch back.
-            return `// Validate ${filePath}
-{
-  type __IsExpected<Specific extends ${typeWithRoute}> = Specific
-  const handler = {} as typeof import(${JSON.stringify(importPath.replace(/\.tsx?$/, '.js'))})
-  type __Check = __IsExpected<typeof handler>
-  // @ts-ignore
-  type __Unused = __Check
-}`;
-        }).join('\n\n');
-    // Use direct mappings from the manifest
-    // Generate validations for different route types
-    const appPageValidations = generateValidations(Array.from(routesManifest.appPagePaths).sort(), 'AppPageConfig', routesManifest.filePathToRoute);
-    const appRouteHandlerValidations = generateValidations(Array.from(routesManifest.appRouteHandlers).sort(), 'RouteHandlerConfig', routesManifest.filePathToRoute);
-    const pagesRouterPageValidations = generateValidations(Array.from(routesManifest.pagesRouterPagePaths).sort(), 'PagesPageConfig');
-    const pagesApiRouteValidations = generateValidations(Array.from(routesManifest.pageApiRoutes).sort(), 'ApiRouteConfig');
-    const layoutValidations = generateValidations(Array.from(routesManifest.layoutPaths).sort(), 'LayoutConfig', routesManifest.filePathToRoute);
-    const hasAppRouteHandlers = Object.keys(routesManifest.appRouteHandlerRoutes).length > 0;
-    // Build type definitions based on what's actually used
-    let typeDefinitions = '';
-    if (appPageValidations) {
-        typeDefinitions += `type AppPageConfig<Route extends AppRoutes = AppRoutes> = {
-  default: React.ComponentType<{ params: Promise<ParamMap[Route]> } & any> | ((props: { params: Promise<ParamMap[Route]> } & any) => React.ReactNode | Promise<React.ReactNode> | never | void | Promise<void>)
-  generateStaticParams?: (props: { params: ParamMap[Route] }) => Promise<any[]> | any[]
-  generateMetadata?: (
-    props: { params: Promise<ParamMap[Route]> } & any,
-    parent: ResolvingMetadata
-  ) => Promise<any> | any
-  generateViewport?: (
-    props: { params: Promise<ParamMap[Route]> } & any,
-    parent: ResolvingViewport
-  ) => Promise<any> | any
-  metadata?: any
-  viewport?: any
-}
-
-`;
-    }
-    if (pagesRouterPageValidations) {
-        typeDefinitions += `type PagesPageConfig = {
-  default: React.ComponentType<any> | ((props: any) => React.ReactNode | Promise<React.ReactNode> | never | void)
-  getStaticProps?: (context: any) => Promise<any> | any
-  getStaticPaths?: (context: any) => Promise<any> | any
-  getServerSideProps?: (context: any) => Promise<any> | any
-  getInitialProps?: (context: any) => Promise<any> | any
-  /**
-   * Segment configuration for legacy Pages Router pages.
-   * Validated at build-time by parsePagesSegmentConfig.
-   */
-  config?: {
-    maxDuration?: number
-    runtime?: 'edge' | 'experimental-edge' | 'nodejs' | string // necessary unless config is exported as const
-    regions?: string[]
-  }
-}
-
-`;
-    }
-    if (layoutValidations) {
-        typeDefinitions += `type LayoutConfig<Route extends LayoutRoutes = LayoutRoutes> = {
-  default: React.ComponentType<LayoutProps<Route>> | ((props: LayoutProps<Route>) => React.ReactNode | Promise<React.ReactNode> | never | void | Promise<void>)
-  generateStaticParams?: (props: { params: ParamMap[Route] }) => Promise<any[]> | any[]
-  generateMetadata?: (
-    props: { params: Promise<ParamMap[Route]> } & any,
-    parent: ResolvingMetadata
-  ) => Promise<any> | any
-  generateViewport?: (
-    props: { params: Promise<ParamMap[Route]> } & any,
-    parent: ResolvingViewport
-  ) => Promise<any> | any
-  metadata?: any
-  viewport?: any
-}
-
-`;
-    }
-    if (appRouteHandlerValidations) {
-        typeDefinitions += `type RouteHandlerConfig<Route extends AppRouteHandlerRoutes = AppRouteHandlerRoutes> = {
-  GET?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
-  POST?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
-  PUT?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
-  PATCH?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
-  DELETE?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
-  HEAD?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
-  OPTIONS?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
-}
-
-`;
-    }
-    if (pagesApiRouteValidations) {
-        typeDefinitions += `type ApiRouteConfig = {
-  default: (req: any, res: any) => ReturnType<NextApiHandler>
-  config?: {
-    api?: {
-      bodyParser?: boolean | { sizeLimit?: string }
-      responseLimit?: string | number | boolean
-      externalResolver?: boolean
-    }
-    runtime?: 'edge' | 'experimental-edge' | 'nodejs' | string // necessary unless config is exported as const
-    maxDuration?: number
-  }
-}
-
-`;
-    }
-    // Build import statement based on what's actually needed
-    const routeImports = [];
-    // Only import AppRoutes if there are app pages
-    if (appPageValidations) {
-        routeImports.push('AppRoutes');
-    }
-    // Only import LayoutRoutes if there are layouts
-    if (layoutValidations) {
-        routeImports.push('LayoutRoutes');
-    }
-    // Only import ParamMap if there are routes that use it
-    if (appPageValidations || layoutValidations || appRouteHandlerValidations) {
-        routeImports.push('ParamMap');
-    }
-    if (hasAppRouteHandlers) {
-        routeImports.push('AppRouteHandlerRoutes');
-    }
-    const routeImportStatement = routeImports.length > 0 ? `import type { ${routeImports.join(', ')} } from "./routes.js"` : '';
-    const nextRequestImport = hasAppRouteHandlers ? "import type { NextRequest } from 'next/server.js'\n" : '';
-    // Conditionally import types from next/types, merged into a single statement
-    const nextTypes = [];
-    if (pagesApiRouteValidations) {
-        nextTypes.push('NextApiHandler');
-    }
-    if (appPageValidations || layoutValidations) {
-        nextTypes.push('ResolvingMetadata', 'ResolvingViewport');
-    }
-    const nextTypesImport = nextTypes.length > 0 ? `import type { ${nextTypes.join(', ')} } from "next/types.js"\n` : '';
-    return `// This file is generated automatically by Next.js
-// Do not edit this file manually
-// This file validates that all pages and layouts export the correct types
-
-${routeImportStatement}
-${nextTypesImport}${nextRequestImport}
-${typeDefinitions}
-${appPageValidations}
-
-${appRouteHandlerValidations}
-
-${pagesRouterPageValidations}
-
-${pagesApiRouteValidations}
-
-${layoutValidations}
-`;
-}
-function generateRouteTypesFile(routesManifest) {
-    const routeTypes = generateRouteTypes(routesManifest);
-    const paramTypes = generateParamTypes(routesManifest);
-    const layoutSlotMap = generateLayoutSlotMap(routesManifest);
-    const hasAppRouteHandlers = Object.keys(routesManifest.appRouteHandlerRoutes).length > 0;
-    // Build export statement based on what's actually generated
-    const routeExports = [
-        'AppRoutes',
-        'PageRoutes',
-        'LayoutRoutes',
-        'RedirectRoutes',
-        'RewriteRoutes',
-        'ParamMap'
-    ];
-    if (hasAppRouteHandlers) {
-        routeExports.push('AppRouteHandlerRoutes');
-    }
-    const exportStatement = `export type { ${routeExports.join(', ')} }`;
-    const routeContextInterface = hasAppRouteHandlers ? `
-
-  /**
-   * Context for Next.js App Router route handlers
-   * @example
-   * \`\`\`tsx
-   * export async function GET(request: NextRequest, context: RouteContext<'/api/users/[id]'>) {
-   *   const { id } = await context.params
-   *   return Response.json({ id })
-   * }
-   * \`\`\`
-   */
-  interface RouteContext<AppRouteHandlerRoute extends AppRouteHandlerRoutes> {
-    params: Promise<ParamMap[AppRouteHandlerRoute]>
-  }` : '';
-    return `// This file is generated automatically by Next.js
-// Do not edit this file manually
-
-${routeTypes}
-
-${paramTypes}
-
-export type ParamsOf<Route extends Routes> = ParamMap[Route]
-
-${layoutSlotMap}
-
-${exportStatement}
-
-declare global {
-  /**
-   * Props for Next.js App Router page components
-   * @example
-   * \`\`\`tsx
-   * export default function Page(props: PageProps<'/blog/[slug]'>) {
-   *   const { slug } = await props.params
-   *   return <div>Blog post: {slug}</div>
-   * }
-   * \`\`\`
-   */
-  interface PageProps<AppRoute extends AppRoutes> {
-    params: Promise<ParamMap[AppRoute]>
-    searchParams: Promise<Record<string, string | string[] | undefined>>
-  }
-
-  /**
-   * Props for Next.js App Router layout components
-   * @example
-   * \`\`\`tsx
-   * export default function Layout(props: LayoutProps<'/dashboard'>) {
-   *   return <div>{props.children}</div>
-   * }
-   * \`\`\`
-   */
-  type LayoutProps<LayoutRoute extends LayoutRoutes> = {
-    params: Promise<ParamMap[LayoutRoute]>
-    children: React.ReactNode
-  } & {
-    [K in LayoutSlotMap[LayoutRoute]]: React.ReactNode
-  }${routeContextInterface}
-}
-`;
-}
-
-//# sourceMappingURL=typegen.js.map

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/lib/router-utils/types.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-//# sourceMappingURL=types.js.map

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/lib/server-action-request-meta.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    getIsPossibleServerAction: null,
-    getServerActionRequestMetadata: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    getIsPossibleServerAction: function() {
-        return getIsPossibleServerAction;
-    },
-    getServerActionRequestMetadata: function() {
-        return getServerActionRequestMetadata;
-    }
-});
-const _approuterheaders = require("../../client/components/app-router-headers");
-function getServerActionRequestMetadata(req) {
-    let actionId;
-    let contentType;
-    if (req.headers instanceof Headers) {
-        actionId = req.headers.get(_approuterheaders.ACTION_HEADER) ?? null;
-        contentType = req.headers.get('content-type');
-    } else {
-        actionId = req.headers[_approuterheaders.ACTION_HEADER] ?? null;
-        contentType = req.headers['content-type'] ?? null;
-    }
-    // We don't actually support URL encoded actions, and the action handler will bail out if it sees one.
-    // But we still want it to flow through to the action handler, to prevent changes in behavior when a regular
-    // page component tries to handle a POST.
-    const isURLEncodedAction = Boolean(req.method === 'POST' && contentType === 'application/x-www-form-urlencoded');
-    const isMultipartAction = Boolean(req.method === 'POST' && (contentType == null ? void 0 : contentType.startsWith('multipart/form-data')));
-    const isFetchAction = Boolean(actionId !== undefined && typeof actionId === 'string' && req.method === 'POST');
-    const isPossibleServerAction = Boolean(isFetchAction || isURLEncodedAction || isMultipartAction);
-    return {
-        actionId,
-        isURLEncodedAction,
-        isMultipartAction,
-        isFetchAction,
-        isPossibleServerAction
-    };
-}
-function getIsPossibleServerAction(req) {
-    return getServerActionRequestMetadata(req).isPossibleServerAction;
-}
-
-//# sourceMappingURL=server-action-request-meta.js.map