@afonsograca/svelte-adapter 0.0.1

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2018-2025 the Deno authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# Deno SvelteKit adapter
+
+Official [Deno](https://deno.com/) adapter for
+[SvelteKit](https://svelte.dev/docs/kit/introduction).
+
+## Usage
+
+1. Install the adapter:
+
+```sh
+deno install -D npm:@deno/svelte-adapter
+# or
+npm install -D @deno/svelte-adapter
+# or
+pnpm install -D @deno/svelte-adapter
+```
+
+2. Update your `svelte.config.js` file to use the adapter:
+
+```diff
+- import adapter from '@sveltejs/adapter-auto';
++ import adapter from "@deno/svelte-adapter";
+  import { vitePreprocess } from "@sveltejs/vite-plugin-svelte";
+
+  /** @type {import('@sveltejs/kit').Config} */
+  const config = {
+    preprocess: vitePreprocess(),
+    kit: {
+      adapter: adapter(),
+    }
+  };
+
+  export default config;
+```
+
+3. Run the build:
+
+```sh
+deno task build
+# or
+npm run build
+# or
+pnpm run build
+```
+
+4. Run the built server:
+
+```sh
+deno run -A ./.deno-deploy/server.ts
+```
+
+## License
+
+MIT, see the [LICENSE](./LICENSE) file.

package/dist/__internal.d.ts

@@ -0,0 +1 @@
+export * from "@deno/experimental-route-config";

package/dist/__internal.js

@@ -0,0 +1 @@
+export * from "@deno/experimental-route-config";

package/dist/files/deploy.json

@@ -0,0 +1 @@
+{}

package/dist/files/handler.ts

@@ -0,0 +1,161 @@
+import { Server } from "./server/index.js";
+import { manifest } from "./server/manifest.js";
+import {
+  applyConfig,
+  DeployConfig,
+  parseConfig,
+} from "@deno/svelte-adapter/__internal";
+
+interface IsrConfig {
+  pattern: RegExp;
+  expiration: number;
+  bypassToken: string | null;
+  allowQuery: string[];
+}
+
+interface SvelteData {
+  isr?: Array<
+    {
+      pattern: {
+        source: string;
+        flags: string;
+      };
+      expiration: number;
+      bypassToken: string | null;
+      allowQuery: string[];
+    }
+  >;
+}
+
+interface ParsedSvelteData {
+  isr: IsrConfig[];
+}
+
+export function prepareServer(
+  rawSvelteData: SvelteData,
+  rawDeployConfig: DeployConfig,
+  cwd: string,
+): Deno.ServeHandler {
+  const svelteData: { isr: IsrConfig[] } = {
+    isr: (rawSvelteData.isr ?? []).map((data) => {
+      return {
+        ...data,
+        pattern: new RegExp(`${data.pattern.source}${data.pattern.flags}`),
+      };
+    }),
+  };
+
+  const deployConfig = parseConfig(rawDeployConfig, cwd);
+  const server = new Server(manifest);
+
+  const initialized = server.init({
+    env: Deno.env.toObject(),
+    // TODO: Svelte only supports sync
+    read(filePath) {
+      const file = Deno.openSync(filePath, { read: true });
+      return file.readable;
+    },
+  });
+
+  const hasIsr = svelteData.isr.length > 0;
+
+  const initCache = hasIsr
+    ? caches.open("svelte-isr") // TODO: Are caches global?
+    : Promise.resolve(null);
+
+  const handler: Deno.ServeHandler = async (req, info) => {
+    await initialized;
+
+    const url = new URL(req.url);
+
+    // Retrieve ISR cache if set for this route
+    const cache = await initCache;
+    let isr: IsrConfig | null = null;
+    if (hasIsr && cache !== null) {
+      isr = getIsrConfig(svelteData, req, url);
+
+      if (isr !== null) {
+        const key = toCacheKey(url, isr);
+        const cached = await cache.match(key);
+        if (cached !== undefined) return cached;
+      }
+    }
+
+    const responded = await applyConfig(deployConfig, url, cwd);
+    if (responded !== null) {
+      return responded;
+    }
+
+    const res = await server.respond(req, {
+      getClientAddress() {
+        if ("hostname" in info.remoteAddr) {
+          return info.remoteAddr.hostname;
+        }
+
+        // TODO: What to do for unix sockets?
+        return "127.0.0.1";
+      },
+    });
+
+    // Store ISR cache
+    if (isr !== null && cache !== null) {
+      const key = toCacheKey(url, isr);
+      const clone = res.clone();
+      clone.headers.set("Cache-Control", `max-age=${isr.expiration}`);
+      await cache.put(key, clone);
+    }
+
+    return res;
+  };
+
+  return handler;
+}
+
+function getIsrConfig(
+  svelteData: ParsedSvelteData,
+  req: Request,
+  url: URL,
+): IsrConfig | null {
+  for (let i = 0; i < svelteData.isr.length; i++) {
+    const data = svelteData.isr[i];
+    if (data.pattern.test(url.pathname)) {
+      let bypass: string | null = null;
+
+      // Check for bypass token in http headers
+      if (req.method === "GET" || req.method === "HEAD") {
+        bypass = req.headers.get("x-prerender-revalidate");
+        if (bypass !== null && bypass === data.bypassToken) {
+          return null;
+        }
+      }
+
+      // Check for bypass token in Cookie
+      const cookies = req.headers.getSetCookie();
+      for (let i = 0; i < cookies.length; i++) {
+        const [key, value] = cookies[i].split("=");
+        if (key === "__prerender_bypass" && value === data.bypassToken) {
+          return null;
+        }
+      }
+
+      return data;
+    }
+  }
+
+  return null;
+}
+
+function toCacheKey(url: URL, config: IsrConfig): Request {
+  const newUrl = new URL("http://c");
+  newUrl.pathname = url.pathname;
+
+  for (let i = 0; i < config.allowQuery.length; i++) {
+    const q = config.allowQuery[i];
+    const param = url.searchParams.get(q);
+    if (param !== null) {
+      newUrl.searchParams.append(q, param);
+    }
+  }
+
+  return new Request(newUrl);
+}

package/dist/files/server/index.js

@@ -0,0 +1 @@
+export { Server } from "@sveltejs/kit";

package/dist/files/server/manifest.js

@@ -0,0 +1,2 @@
+/** @type {import('@sveltejs/kit').SSRManifest} */
+export const manifest = null;

package/dist/files/server.ts

@@ -0,0 +1,7 @@
+import rawDeployConfig from "./deploy.json" with { type: "json" };
+import rawSvelteData from "./svelte.json" with { type: "json" };
+import { prepareServer } from "./handler.ts";
+
+const handler = prepareServer(rawSvelteData, rawDeployConfig, Deno.cwd());
+
+Deno.serve(handler);

package/dist/files/svelte.json

@@ -0,0 +1 @@
+{}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import type { Adapter } from "@sveltejs/kit";
+export interface Config {
+    isr?: {
+        expiration: number;
+        bypassToken?: string;
+        allowQuery?: string[];
+    };
+}
+export default function denoAdapter(): Adapter;

package/dist/index.js

@@ -0,0 +1,132 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+const OUT_DIR = ".deno-deploy";
+export default function denoAdapter() {
+    return {
+        name: "@deno/svelte-adapter",
+        async adapt(builder) {
+            builder.rimraf(OUT_DIR);
+            const dirs = {
+                static: `${OUT_DIR}/static${builder.config.kit.paths.base}`,
+                server: `${OUT_DIR}/server`,
+            };
+            try {
+                await fsp.mkdir(dirs.server, { recursive: true });
+            }
+            catch {
+                // ignore
+            }
+            builder.log.minor("Copying assets...");
+            builder.writeClient(dirs.static);
+            builder.writePrerendered(dirs.static);
+            builder.log.minor("Building server entry...");
+            builder.writeServer(dirs.server);
+            if (builder.hasServerInstrumentationFile()) {
+                builder.log.minor("Instrumenting server...");
+                builder.instrument({
+                    entrypoint: `${dirs.server}/index.js`,
+                    instrumentation: `${dirs.server}/instrumentation.server.js`,
+                    module: {
+                        exports: ["Server"],
+                    },
+                });
+            }
+            const staticFiles = [];
+            const redirects = [];
+            const rewrites = [];
+            for (const [pathname, data] of builder.prerendered.pages.entries()) {
+                staticFiles.push({
+                    source: pathname,
+                    destination: path.join(dirs.static, data.file),
+                });
+                // Add redirect
+                if (pathname !== "/") {
+                    const trailing = pathname.endsWith("/");
+                    redirects.push({
+                        source: trailing ? pathname.slice(0, -1) : pathname + "/",
+                        destination: pathname,
+                        permanent: true,
+                    });
+                }
+            }
+            const svelteData = {
+                isr: [],
+            };
+            // ISR
+            for (const page of builder.routes) {
+                // ISR cannot be use with prerendering together
+                if (page.prerender)
+                    continue;
+                const isr = page.config.isr;
+                if (isr !== undefined) {
+                    svelteData.isr.push({
+                        pattern: {
+                            source: page.pattern.source,
+                            flags: page.pattern.flags,
+                        },
+                        expiration: isr.expiration ?? 604800,
+                        bypassToken: isr.bypassToken ?? null,
+                        allowQuery: isr.allowQuery ?? [],
+                    });
+                }
+            }
+            const svelteMetaPath = path.join(OUT_DIR, "svelte.json");
+            await fsp.writeFile(svelteMetaPath, JSON.stringify(svelteData, null, 2), "utf-8");
+            staticFiles.push({
+                source: "/_app/immutable/:file*",
+                destination: ".deno-deploy/static/_app/immutable/:file*",
+            });
+            // Collect all remaining asset files
+            const assetDir = builder.config.kit.files.assets;
+            // TODO: What about generated assets
+            const assets = [];
+            await walk(assetDir, assets);
+            for (const asset of assets) {
+                const rel = path.relative(assetDir, asset);
+                staticFiles.push({
+                    source: `/${rel.replace(/\\+/, "/")}`,
+                    destination: path.join(dirs.static, rel),
+                });
+            }
+            const deploy = {
+                headers: [{
+                        source: "/_app/immutable/:file*",
+                        headers: [
+                            {
+                                key: "Cache-Control",
+                                value: "public, immutable, max-age=31536000",
+                            },
+                        ],
+                    }],
+                redirects,
+                rewrites,
+                staticFiles,
+            };
+            const out = path.join(OUT_DIR, "deploy.json");
+            await fsp.writeFile(out, JSON.stringify(deploy, null, 2), "utf-8");
+            const fileDir = path.join(import.meta.dirname, "files");
+            builder.copy(path.join(fileDir, "handler.ts"), path.join(OUT_DIR, "handler.ts"));
+            builder.copy(path.join(fileDir, "server.ts"), path.join(OUT_DIR, "server.ts"));
+        },
+        supports: {
+            read() {
+                // Deno Deploy V2 always supports reading from the file system
+                return true;
+            },
+            instrumentation() {
+                // Does it support SvelteKit's built-in observability features
+                return true;
+            },
+        },
+    };
+}
+async function walk(dir, result) {
+    for (const entry of await fsp.readdir(dir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            await walk(path.join(dir, entry.name), result);
+        }
+        else if (entry.isFile()) {
+            result.push(path.join(dir, entry.name));
+        }
+    }
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@afonsograca/svelte-adapter",
+  "version": "0.0.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/afonsograca/svelte-adapter.git"
+  },
+  "bugs": {
+    "url": "https://github.com/afonsograca/svelte-adapter/issues"
+  },
+  "author": "Afonso Graça",
+  "license": "MIT",
+  "description": "Fork of the Deno adapter for SvelteKit",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./__internal": {
+      "types": "./dist/__internal.d.ts",
+      "default": "./dist/__internal.js"
+    }
+  },
+  "scripts": {
+    "fixture-deps": "cd test/fixture && npm ci",
+    "test": "deno test -A",
+    "build": "tsc && node tools/build.mjs",
+    "prepublishOnly": "npm run build",
+    "prepare": "svelte-kit sync && npm run build"
+  },
+  "keywords": [
+    "Deno",
+    "Svelte",
+    "SvelteKit"
+  ],
+  "files": [
+    "dist/"
+  ],
+  "peerDependencies": {
+    "@sveltejs/kit": "^2.31.0"
+  },
+  "dependencies": {
+    "@deno/experimental-route-config": "^0.0.5"
+  },
+  "devDependencies": {
+    "@types/deno": "^2.0.0",
+    "@types/node": "^22.10.7",
+    "expect": "^29.7.0",
+    "linkedom": "^0.18.6",
+    "typescript": "^5.7.3",
+    "urlpattern-polyfill": "^10.0.0"
+  }
+}