astro 4.4.0 → 4.4.2

package/dist/core/preview/static-preview-server.js

@@ -1,6 +1,5 @@
 import { fileURLToPath } from "node:url";
 import { performance } from "perf_hooks";
-import enableDestroy from "server-destroy";
 import { preview } from "vite";
 import * as msg from "../messages.js";
 import { getResolvedHostForHttpServer } from "./util.js";
@@ -30,7 +29,6 @@ async function createStaticPreviewServer(settings, logger) {
     }
     throw err;
   }
-  enableDestroy(previewServer.httpServer);
   logger.info(
     "SKIP_FORMAT",
     msg.serverStart({
@@ -51,11 +49,7 @@ async function createStaticPreviewServer(settings, logger) {
     port: settings.config.server.port,
     closed,
     server: previewServer.httpServer,
-    stop: async () => {
-      await new Promise((resolve, reject) => {
-        previewServer.httpServer.destroy((err) => err ? reject(err) : resolve(void 0));
-      });
-    }
+    stop: previewServer.close.bind(previewServer)
   };
 }
 export {

package/dist/core/redirects/helpers.d.ts

@@ -1,5 +1,3 @@
-import type { Params, RedirectRouteData, RouteData, ValidRedirectStatus } from '../../@types/astro.js';
+import type { RedirectRouteData, RouteData } from '../../@types/astro.js';
 export declare function routeIsRedirect(route: RouteData | undefined): route is RedirectRouteData;
 export declare function routeIsFallback(route: RouteData | undefined): route is RedirectRouteData;
-export declare function redirectRouteGenerate(redirectRoute: RouteData, data: Params): string;
-export declare function redirectRouteStatus(redirectRoute: RouteData, method?: string): ValidRedirectStatus;

package/dist/core/redirects/helpers.js

@@ -4,36 +4,7 @@ function routeIsRedirect(route) {
 function routeIsFallback(route) {
   return route?.type === "fallback";
 }
-function redirectRouteGenerate(redirectRoute, data) {
-  const routeData = redirectRoute.redirectRoute;
-  const route = redirectRoute.redirect;
-  if (typeof routeData !== "undefined") {
-    return routeData?.generate(data) || routeData?.pathname || "/";
-  } else if (typeof route === "string") {
-    let target = route;
-    for (const param of Object.keys(data)) {
-      const paramValue = data[param];
-      target = target.replace(`[${param}]`, paramValue);
-      target = target.replace(`[...${param}]`, paramValue);
-    }
-    return target;
-  } else if (typeof route === "undefined") {
-    return "/";
-  }
-  return route.destination;
-}
-function redirectRouteStatus(redirectRoute, method = "GET") {
-  const routeData = redirectRoute.redirectRoute;
-  if (routeData && typeof redirectRoute.redirect === "object") {
-    return redirectRoute.redirect.status;
-  } else if (method !== "GET") {
-    return 308;
-  }
-  return 301;
-}
 export {
-  redirectRouteGenerate,
-  redirectRouteStatus,
   routeIsFallback,
   routeIsRedirect
 };

package/dist/core/redirects/index.d.ts

@@ -1,3 +1,4 @@
 export { RedirectComponentInstance, RedirectSinglePageBuiltModule } from './component.js';
-export { redirectRouteGenerate, redirectRouteStatus, routeIsRedirect } from './helpers.js';
+export { routeIsRedirect } from './helpers.js';
 export { getRedirectLocationOrThrow } from './validate.js';
+export { renderRedirect } from './render.js';

package/dist/core/redirects/index.js

@@ -1,11 +1,11 @@
 import { RedirectComponentInstance, RedirectSinglePageBuiltModule } from "./component.js";
-import { redirectRouteGenerate, redirectRouteStatus, routeIsRedirect } from "./helpers.js";
+import { routeIsRedirect } from "./helpers.js";
 import { getRedirectLocationOrThrow } from "./validate.js";
+import { renderRedirect } from "./render.js";
 export {
   RedirectComponentInstance,
   RedirectSinglePageBuiltModule,
   getRedirectLocationOrThrow,
-  redirectRouteGenerate,
-  redirectRouteStatus,
+  renderRedirect,
   routeIsRedirect
 };

package/dist/core/redirects/render.d.ts

@@ -0,0 +1,2 @@
+import type { RenderContext } from '../render-context.js';
+export declare function renderRedirect(renderContext: RenderContext): Promise<Response>;

package/dist/core/redirects/render.js

@@ -0,0 +1,33 @@
+async function renderRedirect(renderContext) {
+  const {
+    request: { method },
+    routeData
+  } = renderContext;
+  const { redirect, redirectRoute } = routeData;
+  const status = redirectRoute && typeof redirect === "object" ? redirect.status : method === "GET" ? 301 : 308;
+  const headers = { location: redirectRouteGenerate(renderContext) };
+  return new Response(null, { status, headers });
+}
+function redirectRouteGenerate(renderContext) {
+  const {
+    params,
+    routeData: { redirect, redirectRoute }
+  } = renderContext;
+  if (typeof redirectRoute !== "undefined") {
+    return redirectRoute?.generate(params) || redirectRoute?.pathname || "/";
+  } else if (typeof redirect === "string") {
+    let target = redirect;
+    for (const param of Object.keys(params)) {
+      const paramValue = params[param];
+      target = target.replace(`[${param}]`, paramValue);
+      target = target.replace(`[...${param}]`, paramValue);
+    }
+    return target;
+  } else if (typeof redirect === "undefined") {
+    return "/";
+  }
+  return redirect.destination;
+}
+export {
+  renderRedirect
+};

package/dist/core/render/index.d.ts

@@ -1,14 +1,12 @@
-import type { AstroMiddlewareInstance, ComponentInstance, RouteData } from '../../@types/astro.js';
-import type { Environment } from './environment.js';
-export { computePreferredLocale, createRenderContext } from './context.js';
-export type { RenderContext } from './context.js';
-export { createEnvironment } from './environment.js';
-export { getParamsAndProps } from './params-and-props.js';
+import type { ComponentInstance, RouteData } from '../../@types/astro.js';
+import type { Pipeline } from '../base-pipeline.js';
+export { Pipeline } from '../base-pipeline.js';
+export { getParams, getProps } from './params-and-props.js';
 export { loadRenderer } from './renderer.js';
-export type { Environment };
+export { createResult } from './result.js';
 export interface SSROptions {
-    /** The environment instance */
-    env: Environment;
+    /** The pipeline instance */
+    pipeline: Pipeline;
     /** location of file on disk */
     filePath: URL;
     /** the web request (needed for dynamic routes) */
@@ -19,8 +17,4 @@ export interface SSROptions {
     request: Request;
     /** optional, in case we need to render something outside a dev server */
     route: RouteData;
-    /**
-     * Optional middlewares
-     */
-    middleware?: AstroMiddlewareInstance;
 }

package/dist/core/render/index.js

@@ -1,11 +1,11 @@
-import { computePreferredLocale, createRenderContext } from "./context.js";
-import { createEnvironment } from "./environment.js";
-import { getParamsAndProps } from "./params-and-props.js";
+import { Pipeline } from "../base-pipeline.js";
+import { getParams, getProps } from "./params-and-props.js";
 import { loadRenderer } from "./renderer.js";
+import { createResult } from "./result.js";
 export {
-  computePreferredLocale,
-  createEnvironment,
-  createRenderContext,
-  getParamsAndProps,
+  Pipeline,
+  createResult,
+  getParams,
+  getProps,
   loadRenderer
 };

package/dist/core/render/params-and-props.d.ts

@@ -3,11 +3,16 @@ import type { Logger } from '../logger/core.js';
 import type { RouteCache } from './route-cache.js';
 interface GetParamsAndPropsOptions {
     mod: ComponentInstance | undefined;
-    route?: RouteData | undefined;
+    routeData?: RouteData | undefined;
     routeCache: RouteCache;
     pathname: string;
     logger: Logger;
-    ssr: boolean;
+    serverLike: boolean;
 }
-export declare function getParamsAndProps(opts: GetParamsAndPropsOptions): Promise<[Params, Props]>;
+export declare function getProps(opts: GetParamsAndPropsOptions): Promise<Props>;
+/**
+ * When given a route with the pattern `/[x]/[y]/[z]/svelte`, and a pathname `/a/b/c/svelte`,
+ * returns the params object: { x: "a", y: "b", z: "c" }.
+ */
+export declare function getParams(route: RouteData, pathname: string): Params;
 export {};

package/dist/core/render/params-and-props.js

@@ -1,17 +1,16 @@
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { routeIsFallback } from "../redirects/helpers.js";
 import { routeIsRedirect } from "../redirects/index.js";
-import { getParams } from "../routing/params.js";
 import { callGetStaticPaths, findPathItemByKey } from "./route-cache.js";
-async function getParamsAndProps(opts) {
-  const { logger, mod, route, routeCache, pathname, ssr } = opts;
+async function getProps(opts) {
+  const { logger, mod, routeData: route, routeCache, pathname, serverLike } = opts;
   if (!route || route.pathname) {
-    return [{}, {}];
+    return {};
   }
-  const params = getRouteParams(route, pathname) ?? {};
   if (routeIsRedirect(route) || routeIsFallback(route)) {
-    return [params, {}];
+    return {};
   }
+  const params = getParams(route, pathname);
   if (mod) {
     validatePrerenderEndpointCollision(route, mod, params);
   }
@@ -20,10 +19,10 @@ async function getParamsAndProps(opts) {
     route,
     routeCache,
     logger,
-    ssr
+    ssr: serverLike
   });
   const matchedStaticPath = findPathItemByKey(staticPaths, params, route, logger);
-  if (!matchedStaticPath && (ssr ? route.prerender : true)) {
+  if (!matchedStaticPath && (serverLike ? route.prerender : true)) {
     throw new AstroError({
       ...AstroErrorData.NoMatchingStaticPathFound,
       message: AstroErrorData.NoMatchingStaticPathFound.message(pathname),
@@ -31,15 +30,23 @@ async function getParamsAndProps(opts) {
     });
   }
   const props = matchedStaticPath?.props ? { ...matchedStaticPath.props } : {};
-  return [params, props];
+  return props;
 }
-function getRouteParams(route, pathname) {
-  if (route.params.length) {
-    const paramsMatch = route.pattern.exec(decodeURIComponent(pathname));
-    if (paramsMatch) {
-      return getParams(route.params)(paramsMatch);
+function getParams(route, pathname) {
+  if (!route.params.length)
+    return {};
+  const paramsMatch = route.pattern.exec(decodeURIComponent(pathname));
+  if (!paramsMatch)
+    return {};
+  const params = {};
+  route.params.forEach((key, i) => {
+    if (key.startsWith("...")) {
+      params[key.slice(3)] = paramsMatch[i + 1] ? paramsMatch[i + 1] : void 0;
+    } else {
+      params[key] = paramsMatch[i + 1];
     }
-  }
+  });
+  return params;
 }
 function validatePrerenderEndpointCollision(route, mod, params) {
   if (route.type === "endpoint" && mod.getStaticPaths) {
@@ -59,5 +66,6 @@ function validatePrerenderEndpointCollision(route, mod, params) {
   }
 }
 export {
-  getParamsAndProps
+  getParams,
+  getProps
 };

package/dist/core/render/result.d.ts

@@ -1,7 +1,7 @@
 import type { Locales, Params, SSRElement, SSRLoadedRenderer, SSRResult } from '../../@types/astro.js';
 import { AstroCookies } from '../cookies/index.js';
 import type { Logger } from '../logger/core.js';
-import type { RoutingStrategies } from '../config/schema.js';
+import { type RoutingStrategies } from '../../i18n/utils.js';
 export interface CreateResultArgs {
     /**
      * Used to provide better error messages for `Astro.clientAddress`
@@ -23,16 +23,17 @@ export interface CreateResultArgs {
      * Used for `Astro.site`
      */
     site: string | undefined;
-    links?: Set<SSRElement>;
-    scripts?: Set<SSRElement>;
-    styles?: Set<SSRElement>;
-    componentMetadata?: SSRResult['componentMetadata'];
+    links: Set<SSRElement>;
+    scripts: Set<SSRElement>;
+    styles: Set<SSRElement>;
+    componentMetadata: SSRResult['componentMetadata'];
     request: Request;
     status: number;
     locals: App.Locals;
-    cookies?: AstroCookies;
+    cookies: AstroCookies;
     locales: Locales | undefined;
     defaultLocale: string | undefined;
-    routingStrategy: RoutingStrategies | undefined;
+    route: string;
+    strategy: RoutingStrategies | undefined;
 }
 export declare function createResult(args: CreateResultArgs): SSRResult;

package/dist/core/render/result.js

@@ -7,9 +7,8 @@ import {
   computeCurrentLocale,
   computePreferredLocale,
   computePreferredLocaleList
-} from "./context.js";
-const clientAddressSymbol = Symbol.for("astro.clientAddress");
-const responseSentSymbol = Symbol.for("astro.responseSent");
+} from "../../i18n/utils.js";
+import { clientAddressSymbol, responseSentSymbol } from "../constants.js";
 function getFunctionExpression(slot) {
   if (!slot)
     return;
@@ -160,9 +159,9 @@ function createResult(args) {
           }
           if (args.locales) {
             currentLocale = computeCurrentLocale(
-              request,
+              url.pathname,
               args.locales,
-              args.routingStrategy,
+              args.strategy,
               args.defaultLocale
             );
             if (currentLocale) {

package/dist/core/render-context.d.ts

@@ -0,0 +1,32 @@
+import type { APIContext, ComponentInstance, MiddlewareHandler, RouteData } from '../@types/astro.js';
+import { AstroCookies } from './cookies/index.js';
+import { type Pipeline } from './render/index.js';
+export declare class RenderContext {
+    #private;
+    readonly pipeline: Pipeline;
+    locals: App.Locals;
+    readonly middleware: MiddlewareHandler;
+    readonly pathname: string;
+    readonly request: Request;
+    readonly routeData: RouteData;
+    status: number;
+    readonly cookies: AstroCookies;
+    readonly params: import("../@types/astro.js").Params;
+    private constructor();
+    static create({ locals, middleware, pathname, pipeline, request, routeData, status, }: Pick<RenderContext, 'pathname' | 'pipeline' | 'request' | 'routeData'> & Partial<Pick<RenderContext, 'locals' | 'middleware' | 'status'>>): RenderContext;
+    /**
+     * The main function of the RenderContext.
+     *
+     * Use this function to render any route known to Astro.
+     * It attempts to render a route. A route can be a:
+     *
+     * - page
+     * - redirect
+     * - endpoint
+     * - fallback
+     */
+    render(componentInstance: ComponentInstance | undefined): Promise<Response>;
+    createAPIContext(props: APIContext['props']): APIContext;
+    createResult(mod: ComponentInstance): Promise<import("../@types/astro.js").SSRResult>;
+    get i18nData(): Pick<APIContext<Record<string, any>, Record<string, string | undefined>>, "currentLocale" | "preferredLocale" | "preferredLocaleList">;
+}

package/dist/core/render-context.js

@@ -0,0 +1,219 @@
+import { renderEndpoint } from "../runtime/server/endpoint.js";
+import { attachCookiesToResponse } from "./cookies/index.js";
+import { callMiddleware } from "./middleware/callMiddleware.js";
+import { sequence } from "./middleware/index.js";
+import { AstroCookies } from "./cookies/index.js";
+import { createResult } from "./render/index.js";
+import { renderPage } from "../runtime/server/index.js";
+import {
+  ASTRO_VERSION,
+  ROUTE_TYPE_HEADER,
+  clientAddressSymbol,
+  clientLocalsSymbol
+} from "./constants.js";
+import { getParams, getProps } from "./render/index.js";
+import { AstroError, AstroErrorData } from "./errors/index.js";
+import {
+  computeCurrentLocale,
+  computePreferredLocale,
+  computePreferredLocaleList
+} from "../i18n/utils.js";
+import { renderRedirect } from "./redirects/render.js";
+class RenderContext {
+  constructor(pipeline, locals, middleware, pathname, request, routeData, status, cookies = new AstroCookies(request), params = getParams(routeData, pathname)) {
+    this.pipeline = pipeline;
+    this.locals = locals;
+    this.middleware = middleware;
+    this.pathname = pathname;
+    this.request = request;
+    this.routeData = routeData;
+    this.status = status;
+    this.cookies = cookies;
+    this.params = params;
+  }
+  static create({
+    locals = {},
+    middleware,
+    pathname,
+    pipeline,
+    request,
+    routeData,
+    status = 200
+  }) {
+    return new RenderContext(
+      pipeline,
+      locals,
+      sequence(...pipeline.internalMiddleware, middleware ?? pipeline.middleware),
+      pathname,
+      request,
+      routeData,
+      status
+    );
+  }
+  /**
+   * The main function of the RenderContext.
+   *
+   * Use this function to render any route known to Astro.
+   * It attempts to render a route. A route can be a:
+   *
+   * - page
+   * - redirect
+   * - endpoint
+   * - fallback
+   */
+  async render(componentInstance) {
+    const { cookies, middleware, pathname, pipeline, routeData } = this;
+    const { logger, routeCache, serverLike, streaming } = pipeline;
+    const props = await getProps({
+      mod: componentInstance,
+      routeData,
+      routeCache,
+      pathname,
+      logger,
+      serverLike
+    });
+    const apiContext = this.createAPIContext(props);
+    const { type } = routeData;
+    const lastNext = type === "endpoint" ? () => renderEndpoint(componentInstance, apiContext, serverLike, logger) : type === "redirect" ? () => renderRedirect(this) : type === "page" ? async () => {
+      const result = await this.createResult(componentInstance);
+      const response2 = await renderPage(
+        result,
+        componentInstance?.default,
+        props,
+        {},
+        streaming,
+        routeData
+      );
+      response2.headers.set(ROUTE_TYPE_HEADER, "page");
+      return response2;
+    } : type === "fallback" ? () => new Response(null, { status: 500, headers: { [ROUTE_TYPE_HEADER]: "fallback" } }) : () => {
+      throw new Error("Unknown type of route: " + type);
+    };
+    const response = await callMiddleware(middleware, apiContext, lastNext);
+    if (response.headers.get(ROUTE_TYPE_HEADER)) {
+      response.headers.delete(ROUTE_TYPE_HEADER);
+    }
+    attachCookiesToResponse(response, cookies);
+    return response;
+  }
+  createAPIContext(props) {
+    const renderContext = this;
+    const { cookies, i18nData, params, pipeline, request } = this;
+    const { currentLocale, preferredLocale, preferredLocaleList } = i18nData;
+    const generator = `Astro v${ASTRO_VERSION}`;
+    const redirect = (path, status = 302) => new Response(null, { status, headers: { Location: path } });
+    const site = pipeline.site ? new URL(pipeline.site) : void 0;
+    const url = new URL(request.url);
+    return {
+      cookies,
+      currentLocale,
+      generator,
+      params,
+      preferredLocale,
+      preferredLocaleList,
+      props,
+      redirect,
+      request,
+      site,
+      url,
+      get clientAddress() {
+        if (clientAddressSymbol in request) {
+          return Reflect.get(request, clientAddressSymbol);
+        }
+        if (pipeline.adapterName) {
+          throw new AstroError({
+            ...AstroErrorData.ClientAddressNotAvailable,
+            message: AstroErrorData.ClientAddressNotAvailable.message(pipeline.adapterName)
+          });
+        } else {
+          throw new AstroError(AstroErrorData.StaticClientAddressNotAvailable);
+        }
+      },
+      get locals() {
+        return renderContext.locals;
+      },
+      // TODO(breaking): disallow replacing the locals object
+      set locals(val) {
+        if (typeof val !== "object") {
+          throw new AstroError(AstroErrorData.LocalsNotAnObject);
+        } else {
+          renderContext.locals = val;
+          Reflect.set(request, clientLocalsSymbol, val);
+        }
+      }
+    };
+  }
+  async createResult(mod) {
+    const { cookies, locals, params, pathname, pipeline, request, routeData, status } = this;
+    const {
+      adapterName,
+      clientDirectives,
+      compressHTML,
+      i18n,
+      manifest,
+      logger,
+      renderers,
+      resolve,
+      site,
+      serverLike
+    } = pipeline;
+    const { links, scripts, styles } = await pipeline.headElements(routeData);
+    const componentMetadata = await pipeline.componentMetadata(routeData) ?? manifest.componentMetadata;
+    const { defaultLocale, locales, strategy } = i18n ?? {};
+    const partial = Boolean(mod.partial);
+    return createResult({
+      adapterName,
+      clientDirectives,
+      componentMetadata,
+      compressHTML,
+      cookies,
+      defaultLocale,
+      locales,
+      locals,
+      logger,
+      links,
+      params,
+      partial,
+      pathname,
+      renderers,
+      resolve,
+      request,
+      route: routeData.route,
+      strategy,
+      site,
+      scripts,
+      ssr: serverLike,
+      status,
+      styles
+    });
+  }
+  /**
+   * API Context may be created multiple times per request, i18n data needs to be computed only once.
+   * So, it is computed and saved here on creation of the first APIContext and reused for later ones.
+   */
+  #i18nData;
+  get i18nData() {
+    if (this.#i18nData)
+      return this.#i18nData;
+    const {
+      pipeline: { i18n },
+      request,
+      routeData
+    } = this;
+    if (!i18n)
+      return {
+        currentLocale: void 0,
+        preferredLocale: void 0,
+        preferredLocaleList: void 0
+      };
+    const { defaultLocale, locales, strategy } = i18n;
+    return this.#i18nData = {
+      currentLocale: computeCurrentLocale(routeData.route, locales, strategy, defaultLocale),
+      preferredLocale: computePreferredLocale(request, locales),
+      preferredLocaleList: computePreferredLocaleList(request, locales)
+    };
+  }
+}
+export {
+  RenderContext
+};

package/dist/core/routing/index.d.ts

@@ -1,5 +1,4 @@
 export { createRouteManifest } from './manifest/create.js';
 export { deserializeRouteData, serializeRouteData } from './manifest/serialization.js';
 export { matchAllRoutes, matchRoute } from './match.js';
-export { getParams } from './params.js';
 export { validateDynamicRouteModule, validateGetStaticPathsResult } from './validation.js';

package/dist/core/routing/index.js

@@ -1,12 +1,10 @@
 import { createRouteManifest } from "./manifest/create.js";
 import { deserializeRouteData, serializeRouteData } from "./manifest/serialization.js";
 import { matchAllRoutes, matchRoute } from "./match.js";
-import { getParams } from "./params.js";
 import { validateDynamicRouteModule, validateGetStaticPathsResult } from "./validation.js";
 export {
   createRouteManifest,
   deserializeRouteData,
-  getParams,
   matchAllRoutes,
   matchRoute,
   serializeRouteData,

package/dist/core/routing/manifest/create.js

@@ -10,6 +10,7 @@ import { AstroError } from "../../errors/index.js";
 import { removeLeadingForwardSlash, slash } from "../../path.js";
 import { resolvePages } from "../../util.js";
 import { getRouteGenerator } from "./generator.js";
+import { toRoutingStrategy } from "../../../i18n/utils.js";
 const require2 = createRequire(import.meta.url);
 function countOccurrences(needle, haystack) {
   let count = 0;
@@ -423,7 +424,8 @@ function createRouteManifest(params, logger) {
   }
   const i18n = settings.config.i18n;
   if (i18n) {
-    if (i18n.routing === "pathname-prefix-always") {
+    const strategy = toRoutingStrategy(i18n);
+    if (strategy === "pathname-prefix-always") {
       let index = routes.find((route) => route.route === "/");
       if (!index) {
         let relativePath = path.relative(
@@ -475,7 +477,7 @@ function createRouteManifest(params, logger) {
       }
       setRoutes.delete(route);
     }
-    if (i18n.routing === "pathname-prefix-always") {
+    if (strategy === "pathname-prefix-always") {
       const defaultLocaleRoutes = routesByLocale.get(i18n.defaultLocale);
       if (defaultLocaleRoutes) {
         const indexDefaultRoute = defaultLocaleRoutes.find(({ route }) => route === "/") ?? defaultLocaleRoutes.find(({ route }) => route === `/${i18n.defaultLocale}`);
@@ -523,7 +525,7 @@ function createRouteManifest(params, logger) {
             if (!hasRoute) {
               let pathname;
               let route;
-              if (fallbackToLocale === i18n.defaultLocale && i18n.routing === "pathname-prefix-other-locales") {
+              if (fallbackToLocale === i18n.defaultLocale && strategy === "pathname-prefix-other-locales") {
                 if (fallbackToRoute.pathname) {
                   pathname = `/${fallbackFromLocale}${fallbackToRoute.pathname}`;
                 }

package/dist/core/routing/params.d.ts

@@ -1,10 +1,4 @@
-import type { GetStaticPathsItem, Params, RouteData } from '../../@types/astro.js';
-/**
- * given an array of params like `['x', 'y', 'z']` for
- * src/routes/[x]/[y]/[z]/svelte, create a function
- * that turns a RegExpExecArray into ({ x, y, z })
- */
-export declare function getParams(array: string[]): (match: RegExpExecArray) => Params;
+import type { GetStaticPathsItem, RouteData } from '../../@types/astro.js';
 /**
  * given a route's Params object, validate parameter
  * values and create a stringified key for the route