@rooted-adapters/azure-static-webapp 1.0.0-alpha.25 → 1.0.0-alpha.27

package/dist/azure-static-webapp.d.mts

@@ -1,10 +1,22 @@
 import { AdapterRoutes } from "@rooted/adapter";
 import { Plugin } from "vite";
 //#region src/adapter.d.mts
+/**
+ * What Azure answers for a `:param` route. There's no default, because both are wrong somewhere,
+ * and which one hurts less depends on your site. See {@link azureStaticWebappAdapter}.
+ */
+export type AzureDynamicRoutes = 'not-found' | 'catch-all';
 /**
  * Options for {@link azureStaticWebappAdapter}.
  */
 export type AzureStaticWebappAdapterOptions = {
+  /**
+   * What Azure answers for a `:param` route. Required, see {@link azureStaticWebappAdapter} for the trade-off.
+   *
+   * - `'not-found'`: real dynamic pages answer `404`. Every status for a path that isn't a route is right.
+   * - `'catch-all'`: real dynamic pages answer `200`, and so does anything deeper under the same prefix.
+   */
+  dynamicRoutes: AzureDynamicRoutes;
   /**
    * Manual route list for projects that don't use `generateRouteManifest`.
    * See {@link AdapterRoutes}.
@@ -14,16 +26,27 @@ export type AzureStaticWebappAdapterOptions = {
 /**
  * Adapter for Azure Static Web Apps.
  *
- * Writes `staticwebapp.config.json` to the output directory with routing rules built from the route manifest and/or manual `routes` option:
- * - Pre-rendered routes get explicit `200` entries so Azure serves their HTML directly.
- * - Everything else returns a `404` response that serves `404.html`, matching the
- *   standard SPA behaviour: the shell loads and the client-side router takes over.
+ * Writes `staticwebapp.config.json` to the output directory. Pre-rendered pages are plain files, which Azure serves with a `200` on its own,
+ * and a path that doesn't resolve gets `404.html` with a real `404`.
+ *
+ * Azure can't match a `:param` route exactly. A wildcard is only allowed at the end of a rule and there's no per-segment match,
+ * so there's no rule that means "`/recipe/` plus exactly one segment". You have to pick which way it's wrong:
+ *
+ * **`'not-found'`** writes no rule for dynamic routes.
+ * - `/recipe/42/` serves the shell with a `404`. The page renders, because the browser-side router takes over, but crawlers drop it.
+ *   If your dynamic pages are content you want found, that's most of your site gone from search.
+ * - Everything that isn't a route answers `404`, so there are no soft 404s.
+ *
+ * **`'catch-all'`** writes `/recipe/*` for `/recipe/:id/`, cut at the first `:param`.
+ * - `/recipe/42/` answers `200`.
+ * - So does `/recipe/42/extra/`, which isn't a route. The browser-side router renders your not-found page with a `200`.
+ *   Nothing links there, so crawlers rarely see it, but it's a soft 404 when they do.
+ * - A route that starts with a `:param`, like `/:slug/`, becomes `/*`: every unknown path on the site answers `200`. The build warns when that happens.
+ * - Azure checks rules before files, so every real file under a wildcard gets a rule of its own to stay reachable.
+ *   With `/*` that's every file in the build, and Azure caps the config at 20 KB. The build fails if it goes over.
  *
- * "Everything else" includes your `:param` routes, so `/recipe/42/` renders but answers `404`.
- * That's why this adapter leaves `dynamicRoutes` at its default.
- * Azure only supports a wildcard at the end of a route and has no per-segment match, so a `/recipe/*` rule would also claim `/recipe/42/extra/`,
- * trading a wrong `404` on a real page for a wrong `200` on a path that isn't one.
- * See [issue #311](https://github.com/Marvin-Brouwer/rooted/issues/311).
+ * `vite dev` and `vite preview` answer the same way as the option you pick.
+ * Neither option gives an exact answer. For that you need something that runs the route matching itself, like `@rooted-adapters/fastify`.
  *
  * @example `vite.config.ts`
  * ```ts
@@ -34,11 +57,12 @@ export type AzureStaticWebappAdapterOptions = {
  * export default rootedManifest({
  *   plugins: [
  *     generateRouteManifest({ glob: './src/**\/_routes.mts', root: './src/_routes.g.mts' }),
- *     azureStaticWebappAdapter(),
+ *     // Recipe pages should be indexed; a 200 on /recipe/42/extra/ is the price.
+ *     azureStaticWebappAdapter({ dynamicRoutes: 'catch-all' }),
  *   ],
  * })
  * ```
  */
-export declare function azureStaticWebappAdapter(options?: AzureStaticWebappAdapterOptions): Plugin[];
+export declare function azureStaticWebappAdapter(options: AzureStaticWebappAdapterOptions): Plugin[];
 //#endregion
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXp1cmUtc3RhdGljLXdlYmFwcC5kLm10cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi9zcmMvYWRhcHRlci5tdHMiXSwibWFwcGluZ3MiOiI7Ozs7OztZQVdZOzs7OztFQUtYLFNBQVM7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozt3QkErQk0seUJBQXlCLFVBQVUsa0NBQWtDIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXp1cmUtc3RhdGljLXdlYmFwcC5kLm10cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi9zcmMvYWRhcHRlci5tdHMiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7WUFnQlk7Ozs7WUFLQTs7Ozs7OztFQU9YLGVBQWU7Ozs7O0VBS2YsU0FBUzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O3dCQTJDTSx5QkFBeUIsU0FBUyxrQ0FBa0MifQ==

package/dist/azure-static-webapp.mjs

@@ -1,20 +1,72 @@
-import { writeFile } from "node:fs/promises";
+import { Buffer } from "node:buffer";
+import { readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { staticAdapter } from "@rooted/adapter";
+import { catchAllPrefixes, staticAdapter, withTrailingSlash } from "@rooted/adapter";
+//#region src/adapter/routes.mts
+const configFileName = "staticwebapp.config.json";
+/**
+* Builds the `routes` array for `staticwebapp.config.json`.
+*
+* Azure only supports a wildcard at the end of a route, so a dynamic pattern can't be matched per segment.
+* Each pattern is cut at its first `:param` and becomes a `<prefix>*` rule that rewrites to the fallback file, which answers `200`.
+* That over-matches: `/recipe/:id/` becomes `/recipe/*`, so `/recipe/42/extra/` answers `200` too, and the browser-side router renders not-found.
+* A pattern that starts with a `:param` becomes `/*`, which turns every unknown path into a soft 404.
+*
+* Azure applies route rules before it looks for a file, so a wildcard would also swallow the real files under its prefix.
+* Every output file and pre-rendered page under a prefix gets a rule with no action ahead of the wildcards. Rules are first-match,
+* so that stops evaluation and Azure serves the file as usual. Pages are listed as their `index.html`, because Azure matches that rule for the folder too.
+* They're passed in as static paths rather than files, since the adapter runs before the pages are written.
+*
+* @example
+* ```ts
+* buildAzureRoutes(
+*   { staticPaths: ['/recipe/new/', '/about/'], dynamicPatterns: ['/recipe/:id/', '/recipe/:id/ingredients/'] },
+*   ['recipe/photo.jpg', 'assets/index.js'],
+*   '404.html',
+* )
+* // [
+* //   { route: '/recipe/photo.jpg' },
+* //   { route: '/recipe/new/index.html' },
+* //   { route: '/recipe/*', rewrite: '/404.html' },
+* // ]
+* ```
+*/
+function buildAzureRoutes(routes, outputFiles, fallbackFileName) {
+	const prefixes = catchAllPrefixes(routes.dynamicPatterns);
+	const files = [...outputFiles.map((file) => `/${file}`).filter((file) => file !== `/${configFileName}`), ...routes.staticPaths.map((staticPath) => `${withTrailingSlash(staticPath)}index.html`)];
+	const passThrough = [...new Set(files)].filter((file) => prefixes.some((prefix) => file.startsWith(prefix))).map((file) => ({ route: file }));
+	const wildcards = prefixes.map((prefix) => ({
+		route: `${prefix}*`,
+		rewrite: `/${fallbackFileName}`
+	}));
+	return [...passThrough, ...wildcards];
+}
+//#endregion
 //#region src/adapter.mts
 /**
 * Adapter for Azure Static Web Apps.
 *
-* Writes `staticwebapp.config.json` to the output directory with routing rules built from the route manifest and/or manual `routes` option:
-* - Pre-rendered routes get explicit `200` entries so Azure serves their HTML directly.
-* - Everything else returns a `404` response that serves `404.html`, matching the
-*   standard SPA behaviour: the shell loads and the client-side router takes over.
+* Writes `staticwebapp.config.json` to the output directory. Pre-rendered pages are plain files, which Azure serves with a `200` on its own,
+* and a path that doesn't resolve gets `404.html` with a real `404`.
+*
+* Azure can't match a `:param` route exactly. A wildcard is only allowed at the end of a rule and there's no per-segment match,
+* so there's no rule that means "`/recipe/` plus exactly one segment". You have to pick which way it's wrong:
+*
+* **`'not-found'`** writes no rule for dynamic routes.
+* - `/recipe/42/` serves the shell with a `404`. The page renders, because the browser-side router takes over, but crawlers drop it.
+*   If your dynamic pages are content you want found, that's most of your site gone from search.
+* - Everything that isn't a route answers `404`, so there are no soft 404s.
 *
-* "Everything else" includes your `:param` routes, so `/recipe/42/` renders but answers `404`.
-* That's why this adapter leaves `dynamicRoutes` at its default.
-* Azure only supports a wildcard at the end of a route and has no per-segment match, so a `/recipe/*` rule would also claim `/recipe/42/extra/`,
-* trading a wrong `404` on a real page for a wrong `200` on a path that isn't one.
-* See [issue #311](https://github.com/Marvin-Brouwer/rooted/issues/311).
+* **`'catch-all'`** writes `/recipe/*` for `/recipe/:id/`, cut at the first `:param`.
+* - `/recipe/42/` answers `200`.
+* - So does `/recipe/42/extra/`, which isn't a route. The browser-side router renders your not-found page with a `200`.
+*   Nothing links there, so crawlers rarely see it, but it's a soft 404 when they do.
+* - A route that starts with a `:param`, like `/:slug/`, becomes `/*`: every unknown path on the site answers `200`. The build warns when that happens.
+* - Azure checks rules before files, so every real file under a wildcard gets a rule of its own to stay reachable.
+*   With `/*` that's every file in the build, and Azure caps the config at 20 KB. The build fails if it goes over.
+*
+* `vite dev` and `vite preview` answer the same way as the option you pick.
+* Neither option gives an exact answer. For that you need something that runs the route matching itself, like `@rooted-adapters/fastify`.
 *
 * @example `vite.config.ts`
 * ```ts
@@ -25,33 +77,49 @@ import { staticAdapter } from "@rooted/adapter";
 * export default rootedManifest({
 *   plugins: [
 *     generateRouteManifest({ glob: './src/**\/_routes.mts', root: './src/_routes.g.mts' }),
-*     azureStaticWebappAdapter(),
+*     // Recipe pages should be indexed; a 200 on /recipe/42/extra/ is the price.
+*     azureStaticWebappAdapter({ dynamicRoutes: 'catch-all' }),
 *   ],
 * })
 * ```
 */
 function azureStaticWebappAdapter(options) {
+	const dynamicRoutes = requireDynamicRoutes(options);
 	return staticAdapter({
 		name: "rooted:azure-static-webapp",
-		routes: options?.routes,
-		async setup({ outputDirectory, resolvedRoutes }) {
-			const config = {
-				routes: resolvedRoutes.staticPaths.filter((p) => p.split("/").filter(Boolean).length > 0).map((p) => ({
-					route: p,
-					serve: `/${p.split("/").filter(Boolean).join("/")}/index.html`,
-					statusCode: 200
-				})),
+		routes: options.routes,
+		dynamicRoutes,
+		async setup({ config, outputDirectory, resolvedRoutes }) {
+			const routes = dynamicRoutes === "catch-all" ? buildAzureRoutes(resolvedRoutes, await listFiles(outputDirectory), "404.html") : [];
+			if (dynamicRoutes === "catch-all" && catchAllPrefixes(resolvedRoutes.dynamicPatterns).includes("/")) config.logger.warn("[rooted:azure-static-webapp] a route starts with a :param, so the catch-all rule is /*. Every unknown path on the site now answers 200.");
+			const contents = JSON.stringify({
+				routes,
 				trailingSlash: "auto",
 				responseOverrides: { 404: {
 					rewrite: "/404.html",
 					statusCode: 404
 				} }
-			};
-			await writeFile(path.join(outputDirectory, "staticwebapp.config.json"), JSON.stringify(config, void 0, 2), "utf8");
+			}, void 0, 2);
+			const size = Buffer.byteLength(contents, "utf8");
+			if (size > maxConfigSize) throw new Error(`[rooted:azure-static-webapp] staticwebapp.config.json is ${size} bytes, over Azure's limit of ${maxConfigSize}. Every file under a catch-all prefix needs its own rule, and a route that starts with a :param (like /:slug/) puts every file in the build under it.`);
+			await writeFile(path.join(outputDirectory, "staticwebapp.config.json"), contents, "utf8");
 		}
 	});
 }
+const maxConfigSize = 20480;
+function requireDynamicRoutes(options) {
+	const value = options?.dynamicRoutes;
+	if (value === "not-found" || value === "catch-all") return value;
+	throw new Error(`[rooted:azure-static-webapp] dynamicRoutes is required, and has to be 'not-found' or 'catch-all' (got ${JSON.stringify(value)}). Azure can't match a :param route exactly, so pick which way it's wrong: 'not-found' answers 404 on real dynamic pages, 'catch-all' answers 200 on paths below them that aren't routes.`);
+}
+/** Every file in the output directory, relative to it and with `/` separators. */
+async function listFiles(outputDirectory) {
+	return (await readdir(outputDirectory, {
+		recursive: true,
+		withFileTypes: true
+	})).filter((entry) => entry.isFile()).map((entry) => path.relative(outputDirectory, path.join(entry.parentPath, entry.name)).split(path.sep).join("/"));
+}
 //#endregion
 export { azureStaticWebappAdapter };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"azure-static-webapp.mjs","names":[],"sources":["../src/adapter/routes.mts","../src/adapter.mts"],"sourcesContent":["import { catchAllPrefixes, withTrailingSlash } from '@rooted/adapter'\n\nimport type { ResolvedAdapterRoutes } from '@rooted/adapter'\n\n/** One entry in the `routes` array of `staticwebapp.config.json`. */\nexport type AzureRoute = { route: string; rewrite?: string }\n\nconst configFileName = 'staticwebapp.config.json'\n\n/**\n * Builds the `routes` array for `staticwebapp.config.json`.\n *\n * Azure only supports a wildcard at the end of a route, so a dynamic pattern can't be matched per segment.\n * Each pattern is cut at its first `:param` and becomes a `<prefix>*` rule that rewrites to the fallback file, which answers `200`.\n * That over-matches: `/recipe/:id/` becomes `/recipe/*`, so `/recipe/42/extra/` answers `200` too, and the browser-side router renders not-found.\n * A pattern that starts with a `:param` becomes `/*`, which turns every unknown path into a soft 404.\n *\n * Azure applies route rules before it looks for a file, so a wildcard would also swallow the real files under its prefix.\n * Every output file and pre-rendered page under a prefix gets a rule with no action ahead of the wildcards. Rules are first-match,\n * so that stops evaluation and Azure serves the file as usual. Pages are listed as their `index.html`, because Azure matches that rule for the folder too.\n * They're passed in as static paths rather than files, since the adapter runs before the pages are written.\n *\n * @example\n * ```ts\n * buildAzureRoutes(\n *   { staticPaths: ['/recipe/new/', '/about/'], dynamicPatterns: ['/recipe/:id/', '/recipe/:id/ingredients/'] },\n *   ['recipe/photo.jpg', 'assets/index.js'],\n *   '404.html',\n * )\n * // [\n * //   { route: '/recipe/photo.jpg' },\n * //   { route: '/recipe/new/index.html' },\n * //   { route: '/recipe/*', rewrite: '/404.html' },\n * // ]\n * ```\n */\nexport function buildAzureRoutes(\n\troutes: ResolvedAdapterRoutes,\n\toutputFiles: string[],\n\tfallbackFileName: string,\n): AzureRoute[] {\n\tconst prefixes = catchAllPrefixes(routes.dynamicPatterns)\n\n\tconst files = [\n\t\t...outputFiles.map(file => `/${file}`).filter(file => file !== `/${configFileName}`),\n\t\t...routes.staticPaths.map(staticPath => `${withTrailingSlash(staticPath)}index.html`),\n\t]\n\tconst passThrough: AzureRoute[] = [...new Set(files)]\n\t\t.filter(file => prefixes.some(prefix => file.startsWith(prefix)))\n\t\t.map(file => ({ route: file }))\n\n\tconst wildcards: AzureRoute[] = prefixes\n\t\t.map(prefix => ({ route: `${prefix}*`, rewrite: `/${fallbackFileName}` }))\n\n\treturn [...passThrough, ...wildcards]\n}\n","import { Buffer } from 'node:buffer'\nimport { readdir, writeFile } from 'node:fs/promises'\nimport path from 'node:path'\n\nimport { catchAllPrefixes, staticAdapter } from '@rooted/adapter'\n\nimport { buildAzureRoutes } from './adapter/routes.mts'\n\nimport type { AzureRoute } from './adapter/routes.mts'\nimport type { AdapterRoutes } from '@rooted/adapter'\nimport type { Plugin } from 'vite'\n\n/**\n * What Azure answers for a `:param` route. There's no default, because both are wrong somewhere,\n * and which one hurts less depends on your site. See {@link azureStaticWebappAdapter}.\n */\nexport type AzureDynamicRoutes = 'not-found' | 'catch-all'\n\n/**\n * Options for {@link azureStaticWebappAdapter}.\n */\nexport type AzureStaticWebappAdapterOptions = {\n\t/**\n\t * What Azure answers for a `:param` route. Required, see {@link azureStaticWebappAdapter} for the trade-off.\n\t *\n\t * - `'not-found'`: real dynamic pages answer `404`. Every status for a path that isn't a route is right.\n\t * - `'catch-all'`: real dynamic pages answer `200`, and so does anything deeper under the same prefix.\n\t */\n\tdynamicRoutes: AzureDynamicRoutes\n\t/**\n\t * Manual route list for projects that don't use `generateRouteManifest`.\n\t * See {@link AdapterRoutes}.\n\t */\n\troutes?: AdapterRoutes\n}\n\n/**\n * Adapter for Azure Static Web Apps.\n *\n * Writes `staticwebapp.config.json` to the output directory. Pre-rendered pages are plain files, which Azure serves with a `200` on its own,\n * and a path that doesn't resolve gets `404.html` with a real `404`.\n *\n * Azure can't match a `:param` route exactly. A wildcard is only allowed at the end of a rule and there's no per-segment match,\n * so there's no rule that means \"`/recipe/` plus exactly one segment\". You have to pick which way it's wrong:\n *\n * **`'not-found'`** writes no rule for dynamic routes.\n * - `/recipe/42/` serves the shell with a `404`. The page renders, because the browser-side router takes over, but crawlers drop it.\n *   If your dynamic pages are content you want found, that's most of your site gone from search.\n * - Everything that isn't a route answers `404`, so there are no soft 404s.\n *\n * **`'catch-all'`** writes `/recipe/*` for `/recipe/:id/`, cut at the first `:param`.\n * - `/recipe/42/` answers `200`.\n * - So does `/recipe/42/extra/`, which isn't a route. The browser-side router renders your not-found page with a `200`.\n *   Nothing links there, so crawlers rarely see it, but it's a soft 404 when they do.\n * - A route that starts with a `:param`, like `/:slug/`, becomes `/*`: every unknown path on the site answers `200`. The build warns when that happens.\n * - Azure checks rules before files, so every real file under a wildcard gets a rule of its own to stay reachable.\n *   With `/*` that's every file in the build, and Azure caps the config at 20 KB. The build fails if it goes over.\n *\n * `vite dev` and `vite preview` answer the same way as the option you pick.\n * Neither option gives an exact answer. For that you need something that runs the route matching itself, like `@rooted-adapters/fastify`.\n *\n * @example `vite.config.ts`\n * ```ts\n * import { rootedManifest } from '@rooted/application'\n * import { generateRouteManifest } from '@rooted/router/manifest'\n * import { azureStaticWebappAdapter } from '@rooted-adapters/azure-static-webapp'\n *\n * export default rootedManifest({\n *   plugins: [\n *     generateRouteManifest({ glob: './src/**\\/_routes.mts', root: './src/_routes.g.mts' }),\n *     // Recipe pages should be indexed; a 200 on /recipe/42/extra/ is the price.\n *     azureStaticWebappAdapter({ dynamicRoutes: 'catch-all' }),\n *   ],\n * })\n * ```\n */\nexport function azureStaticWebappAdapter(options: AzureStaticWebappAdapterOptions): Plugin[] {\n\tconst dynamicRoutes = requireDynamicRoutes(options)\n\n\treturn staticAdapter({\n\t\tname: 'rooted:azure-static-webapp',\n\t\troutes: options.routes,\n\t\tdynamicRoutes,\n\t\tasync setup({ config, outputDirectory, resolvedRoutes }) {\n\t\t\tconst routes = dynamicRoutes === 'catch-all'\n\t\t\t\t? buildAzureRoutes(resolvedRoutes, await listFiles(outputDirectory), '404.html')\n\t\t\t\t: []\n\n\t\t\tif (dynamicRoutes === 'catch-all' && catchAllPrefixes(resolvedRoutes.dynamicPatterns).includes('/')) {\n\t\t\t\tconfig.logger.warn(\n\t\t\t\t\t'[rooted:azure-static-webapp] a route starts with a :param, so the catch-all rule is /*. '\n\t\t\t\t\t+ 'Every unknown path on the site now answers 200.',\n\t\t\t\t)\n\t\t\t}\n\n\t\t\tconst azureConfig: AzureStaticWebAppConfig = {\n\t\t\t\troutes,\n\t\t\t\ttrailingSlash: 'auto',\n\t\t\t\tresponseOverrides: {\n\t\t\t\t\t404: { rewrite: '/404.html', statusCode: 404 },\n\t\t\t\t},\n\t\t\t}\n\n\t\t\tconst contents = JSON.stringify(azureConfig, undefined, 2)\n\t\t\tconst size = Buffer.byteLength(contents, 'utf8')\n\t\t\tif (size > maxConfigSize) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`[rooted:azure-static-webapp] staticwebapp.config.json is ${size} bytes, over Azure's limit of ${maxConfigSize}. `\n\t\t\t\t\t+ 'Every file under a catch-all prefix needs its own rule, '\n\t\t\t\t\t+ 'and a route that starts with a :param (like /:slug/) puts every file in the build under it.',\n\t\t\t\t)\n\t\t\t}\n\n\t\t\tawait writeFile(path.join(outputDirectory, 'staticwebapp.config.json'), contents, 'utf8')\n\t\t},\n\t})\n}\n\n// Azure's documented maximum for staticwebapp.config.json.\nconst maxConfigSize = 20 * 1024\n\ntype AzureStaticWebAppConfig = {\n\troutes: AzureRoute[]\n\ttrailingSlash: 'always' | 'never' | 'auto'\n\tresponseOverrides: { 404: { rewrite: string; statusCode: 404 } }\n}\n\n// The type already requires it, this is for config written in plain JS.\nfunction requireDynamicRoutes(options: AzureStaticWebappAdapterOptions | undefined): AzureDynamicRoutes {\n\tconst value = options?.dynamicRoutes\n\tif (value === 'not-found' || value === 'catch-all') return value\n\tthrow new Error(\n\t\t`[rooted:azure-static-webapp] dynamicRoutes is required, and has to be 'not-found' or 'catch-all' (got ${JSON.stringify(value)}). `\n\t\t+ 'Azure can\\'t match a :param route exactly, so pick which way it\\'s wrong: '\n\t\t+ '\\'not-found\\' answers 404 on real dynamic pages, \\'catch-all\\' answers 200 on paths below them that aren\\'t routes.',\n\t)\n}\n\n/** Every file in the output directory, relative to it and with `/` separators. */\nasync function listFiles(outputDirectory: string): Promise<string[]> {\n\tconst entries = await readdir(outputDirectory, { recursive: true, withFileTypes: true })\n\treturn entries\n\t\t.filter(entry => entry.isFile())\n\t\t.map(entry => path.relative(outputDirectory, path.join(entry.parentPath, entry.name)).split(path.sep).join('/'))\n}\n"],"mappings":";;;;;AAOA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BvB,SAAgB,iBACf,QACA,aACA,kBACe;CACf,MAAM,WAAW,iBAAiB,OAAO,eAAe;CAExD,MAAM,QAAQ,CACb,GAAG,YAAY,KAAI,SAAQ,IAAI,MAAM,CAAC,CAAC,QAAO,SAAQ,SAAS,IAAI,gBAAgB,GACnF,GAAG,OAAO,YAAY,KAAI,eAAc,GAAG,kBAAkB,UAAU,EAAE,WAAW,CACrF;CACA,MAAM,cAA4B,CAAC,GAAG,IAAI,IAAI,KAAK,CAAC,CAAC,CACnD,QAAO,SAAQ,SAAS,MAAK,WAAU,KAAK,WAAW,MAAM,CAAC,CAAC,CAAC,CAChE,KAAI,UAAS,EAAE,OAAO,KAAK,EAAE;CAE/B,MAAM,YAA0B,SAC9B,KAAI,YAAW;EAAE,OAAO,GAAG,OAAO;EAAI,SAAS,IAAI;CAAmB,EAAE;CAE1E,OAAO,CAAC,GAAG,aAAa,GAAG,SAAS;AACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACqBA,SAAgB,yBAAyB,SAAoD;CAC5F,MAAM,gBAAgB,qBAAqB,OAAO;CAElD,OAAO,cAAc;EACpB,MAAM;EACN,QAAQ,QAAQ;EAChB;EACA,MAAM,MAAM,EAAE,QAAQ,iBAAiB,kBAAkB;GACxD,MAAM,SAAS,kBAAkB,cAC9B,iBAAiB,gBAAgB,MAAM,UAAU,eAAe,GAAG,UAAU,IAC7E,CAAC;GAEJ,IAAI,kBAAkB,eAAe,iBAAiB,eAAe,eAAe,CAAC,CAAC,SAAS,GAAG,GACjG,OAAO,OAAO,KACb,yIAED;GAWD,MAAM,WAAW,KAAK,UAAU;IAP/B;IACA,eAAe;IACf,mBAAmB,EAClB,KAAK;KAAE,SAAS;KAAa,YAAY;IAAI,EAC9C;GAGyC,GAAG,KAAA,GAAW,CAAC;GACzD,MAAM,OAAO,OAAO,WAAW,UAAU,MAAM;GAC/C,IAAI,OAAO,eACV,MAAM,IAAI,MACT,4DAA4D,KAAK,gCAAgC,cAAc,sJAGhH;GAGD,MAAM,UAAU,KAAK,KAAK,iBAAiB,0BAA0B,GAAG,UAAU,MAAM;EACzF;CACD,CAAC;AACF;AAGA,MAAM,gBAAgB;AAStB,SAAS,qBAAqB,SAA0E;CACvG,MAAM,QAAQ,SAAS;CACvB,IAAI,UAAU,eAAe,UAAU,aAAa,OAAO;CAC3D,MAAM,IAAI,MACT,yGAAyG,KAAK,UAAU,KAAK,EAAE,0LAGhI;AACD;;AAGA,eAAe,UAAU,iBAA4C;CAEpE,QAAO,MADe,QAAQ,iBAAiB;EAAE,WAAW;EAAM,eAAe;CAAK,CAAC,EAAA,CAErF,QAAO,UAAS,MAAM,OAAO,CAAC,CAAC,CAC/B,KAAI,UAAS,KAAK,SAAS,iBAAiB,KAAK,KAAK,MAAM,YAAY,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,GAAG,CAAC;AACjH"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rooted-adapters/azure-static-webapp",
-	"version": "1.0.0-alpha.25",
+	"version": "1.0.0-alpha.27",
 	"description": "Adapter for Azure Static Web Apps",
 	"keywords": [
 		"web-components",
@@ -37,11 +37,11 @@
 		}
 	},
 	"peerDependencies": {
-		"@rooted/adapter": "1.0.0-alpha.24",
+		"@rooted/adapter": "1.0.0-alpha.26",
 		"vite": ">= 8.0.1"
 	},
 	"devDependencies": {
-		"@rooted/adapter": "1.0.0-alpha.24",
+		"@rooted/adapter": "1.0.0-alpha.26",
 		"@rooted/development": "workspace:*",
 		"@rooted/tsdown": "workspace:^",
 		"@types/node": "^26.6.1",

package/readme.md

@@ -2,7 +2,11 @@
 
 Deployment adapter for Azure Static Web Apps. Part of the [`@rooted/*`](https://github.com/Marvin-Brouwer/rooted#rooted) framework.
 
-Writes `staticwebapp.config.json` to the output directory with explicit route rules for pre-rendered paths and parameterized routes.
+Writes `staticwebapp.config.json` to the output directory.
+
+Azure can't match a `:param` route exactly, so you have to pick how it's wrong with the required `dynamicRoutes` option.
+`'not-found'` answers `404` on real dynamic pages. `'catch-all'` answers `200` on them, and also on paths below them that aren't routes.
+The [adapters guide](https://github.com/Marvin-Brouwer/rooted/blob/main/docs/guide/adapters.md#azure-static-web-apps-pick-one) has the full trade-off.
 
 > [!IMPORTANT]
 > This package is still in alpha.
@@ -20,7 +24,7 @@ import { azureStaticWebappAdapter } from '@rooted-adapters/azure-static-webapp'
 export default rootedManifest({
   plugins: [
     generateRouteManifest({ glob: './src/**/_routes.mts', routeManifestPath: './src/_routes.g.mts' }),
-    azureStaticWebappAdapter(),
+    azureStaticWebappAdapter({ dynamicRoutes: 'catch-all' }),
   ],
 })
 ```