feat: init

node_modules/nitropack/dist/presets/deno/preset-legacy.d.ts

@@ -0,0 +1 @@
+export declare const denoServerLegacy: any;

node_modules/nitropack/dist/presets/deno/preset-legacy.mjs

@@ -0,0 +1,121 @@
+import { builtinModules } from "node:module";
+import MagicString from "magic-string";
+import { findStaticImports } from "mlly";
+import { defineNitroPreset } from "nitropack/kit";
+import { writeFile } from "nitropack/kit";
+import { isAbsolute, resolve } from "pathe";
+const ImportMetaRe = /import\.meta|globalThis._importMeta_/;
+export const denoServerLegacy = defineNitroPreset(
+  {
+    extends: "node-server",
+    entry: "./runtime/deno-server",
+    exportConditions: ["deno"],
+    commands: {
+      preview: "deno task --config {{ output.dir }}/deno.json start"
+    },
+    unenv: {
+      inject: {
+        global: ["unenv/polyfill/globalthis-global", "default"],
+        Buffer: ["node:buffer", "Buffer"],
+        setTimeout: ["node:timers", "setTimeout"],
+        clearTimeout: ["node:timers", "clearTimeout"],
+        setInterval: ["node:timers", "setInterval"],
+        clearInterval: ["node:timers", "clearInterval"],
+        setImmediate: ["node:timers", "setImmediate"],
+        clearImmediate: ["node:timers", "clearImmediate"]
+        // process: ["node:process", "default"],
+      }
+    },
+    rollupConfig: {
+      output: {
+        hoistTransitiveImports: false
+      },
+      plugins: [
+        {
+          name: "rollup-plugin-node-deno",
+          resolveId(id) {
+            id = id.replace("node:", "");
+            if (builtinModules.includes(id)) {
+              return {
+                id: `node:${id}`,
+                moduleSideEffects: false,
+                external: true
+              };
+            }
+            if (isHTTPImport(id)) {
+              return {
+                id,
+                external: true
+              };
+            }
+          },
+          renderChunk(code) {
+            const s = new MagicString(code);
+            const imports = findStaticImports(code);
+            for (const i of imports) {
+              if (!i.specifier.startsWith(".") && !isAbsolute(i.specifier) && !isHTTPImport(i.specifier) && !i.specifier.startsWith("npm:")) {
+                const specifier = i.specifier.replace("node:", "");
+                s.replace(
+                  i.code,
+                  i.code.replace(
+                    new RegExp(`(?<quote>['"])${i.specifier}\\k<quote>`),
+                    JSON.stringify(
+                      builtinModules.includes(specifier) ? "node:" + specifier : "npm:" + specifier
+                    )
+                  )
+                );
+              }
+            }
+            if (s.hasChanged()) {
+              return {
+                code: s.toString(),
+                map: s.generateMap({ includeContent: true })
+              };
+            }
+          }
+        },
+        {
+          name: "inject-process",
+          renderChunk: {
+            order: "post",
+            handler(code, chunk) {
+              if (!chunk.isEntry && (!ImportMetaRe.test(code) || code.includes("ROLLUP_NO_REPLACE"))) {
+                return;
+              }
+              const s = new MagicString(code);
+              s.prepend(
+                "import __process__ from 'node:process';globalThis.process=globalThis.process||__process__;"
+              );
+              return {
+                code: s.toString(),
+                map: s.generateMap({ includeContent: true })
+              };
+            }
+          }
+        }
+      ]
+    },
+    hooks: {
+      async compiled(nitro) {
+        const denoJSON = {
+          tasks: {
+            start: "deno run --allow-net --allow-read --allow-write --allow-env --unstable-byonm ./server/index.mjs"
+          }
+        };
+        await writeFile(
+          resolve(nitro.options.output.dir, "deno.json"),
+          JSON.stringify(denoJSON, null, 2)
+        );
+      }
+    }
+  },
+  {
+    name: "deno-server-legacy",
+    aliases: ["deno-server"],
+    url: import.meta.url
+  }
+);
+const HTTP_IMPORT_RE = /^(https?:)?\/\//;
+function isHTTPImport(id) {
+  return HTTP_IMPORT_RE.test(id);
+}

node_modules/nitropack/dist/presets/deno/preset.d.ts

@@ -0,0 +1,2 @@
+declare const _default: readonly [any, any, any];
+export default _default;

node_modules/nitropack/dist/presets/deno/preset.mjs

@@ -0,0 +1,68 @@
+import { defineNitroPreset } from "nitropack/kit";
+import { writeFile } from "nitropack/kit";
+import { resolve } from "pathe";
+import { unenvDenoPreset } from "../_unenv/preset-deno.mjs";
+import { denoServerLegacy } from "./preset-legacy.mjs";
+const denoDeploy = defineNitroPreset(
+  {
+    entry: "./runtime/deno-deploy",
+    exportConditions: ["deno"],
+    node: false,
+    noExternals: true,
+    serveStatic: "deno",
+    commands: {
+      preview: "",
+      deploy: "cd {{ output.dir }} && deployctl deploy --project=<project_name> ./server/index.ts"
+    },
+    unenv: unenvDenoPreset,
+    rollupConfig: {
+      preserveEntrySignatures: false,
+      external: (id) => id.startsWith("https://") || id.startsWith("node:"),
+      output: {
+        entryFileNames: "index.ts",
+        manualChunks: (id) => "index",
+        format: "esm"
+      }
+    }
+  },
+  {
+    name: "deno-deploy",
+    aliases: ["deno"],
+    url: import.meta.url
+  }
+);
+const denoServer = defineNitroPreset(
+  {
+    extends: "node-server",
+    entry: "./runtime/deno-server",
+    exportConditions: ["deno"],
+    commands: {
+      preview: "deno task --config {{ output.dir }}/deno.json start"
+    },
+    rollupConfig: {
+      external: (id) => id.startsWith("https://"),
+      output: {
+        hoistTransitiveImports: false
+      }
+    },
+    hooks: {
+      async compiled(nitro) {
+        const denoJSON = {
+          tasks: {
+            start: "deno run --allow-net --allow-read --allow-write --allow-env --unstable-byonm --unstable-node-globals ./server/index.mjs"
+          }
+        };
+        await writeFile(
+          resolve(nitro.options.output.dir, "deno.json"),
+          JSON.stringify(denoJSON, null, 2)
+        );
+      }
+    }
+  },
+  {
+    name: "deno-server",
+    compatibilityDate: "2025-01-30",
+    url: import.meta.url
+  }
+);
+export default [denoServerLegacy, denoDeploy, denoServer];

node_modules/nitropack/dist/presets/deno/runtime/_deno-env-polyfill.mjs

@@ -0,0 +1 @@
+Object.assign(process.env, Deno.env.toObject());

node_modules/nitropack/dist/presets/deno/runtime/deno-deploy.d.ts

@@ -0,0 +1 @@
+import "#nitro-internal-pollyfills";

node_modules/nitropack/dist/presets/deno/runtime/deno-deploy.mjs

@@ -0,0 +1,31 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitropack/runtime";
+import wsAdapter from "crossws/adapters/deno";
+const nitroApp = useNitroApp();
+const ws = import.meta._websocket ? wsAdapter(nitroApp.h3App.websocket) : void 0;
+Deno.serve((request, info) => {
+  if (import.meta._websocket && request.headers.get("upgrade") === "websocket") {
+    return ws.handleUpgrade(request, info);
+  }
+  return handleRequest(request, info);
+});
+async function handleRequest(request, info) {
+  const url = new URL(request.url);
+  const headers = new Headers(request.headers);
+  headers.append("x-forwarded-for", info.remoteAddr.hostname);
+  if (!headers.has("x-forwarded-proto")) {
+    headers.set("x-forwarded-proto", "https");
+  }
+  let body;
+  if (request.body) {
+    body = await request.arrayBuffer();
+  }
+  return nitroApp.localFetch(url.pathname + url.search, {
+    host: url.hostname,
+    protocol: url.protocol,
+    headers,
+    method: request.method,
+    redirect: request.redirect,
+    body
+  });
+}

node_modules/nitropack/dist/presets/deno/runtime/deno-server.d.ts

@@ -0,0 +1,7 @@
+import "#nitro-internal-pollyfills";
+import "./_deno-env-polyfill";
+declare global {
+    const Deno: typeof import("@deno/types").Deno;
+}
+declare const _default: {};
+export default _default;

node_modules/nitropack/dist/presets/deno/runtime/deno-server.mjs

@@ -0,0 +1,66 @@
+import "#nitro-internal-pollyfills";
+import "./_deno-env-polyfill";
+import { useNitroApp } from "nitropack/runtime";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { startScheduleRunner } from "nitropack/runtime/internal";
+import wsAdapter from "crossws/adapters/deno";
+import destr from "destr";
+const nitroApp = useNitroApp();
+if (Deno.env.get("DEBUG")) {
+  addEventListener(
+    "unhandledrejection",
+    (event) => console.error("[unhandledRejection]", event.reason)
+  );
+  addEventListener(
+    "error",
+    (event) => console.error("[uncaughtException]", event.error)
+  );
+} else {
+  addEventListener(
+    "unhandledrejection",
+    (err) => console.error("[unhandledRejection] " + err)
+  );
+  addEventListener(
+    "error",
+    (event) => console.error("[uncaughtException] " + event.error)
+  );
+}
+const serveOptions = {
+  key: Deno.env.get("NITRO_SSL_KEY"),
+  cert: Deno.env.get("NITRO_SSL_CERT"),
+  port: destr(Deno.env.get("NITRO_PORT") || Deno.env.get("PORT")) || 3e3,
+  hostname: Deno.env.get("NITRO_HOST") || Deno.env.get("HOST"),
+  onListen: (opts) => {
+    const baseURL = (useRuntimeConfig().app.baseURL || "").replace(/\/$/, "");
+    const url = `${opts.hostname}:${opts.port}${baseURL}`;
+    console.log(`Listening ${url}`);
+  }
+};
+if (!serveOptions.key || !serveOptions.cert) {
+  delete serveOptions.key;
+  delete serveOptions.cert;
+}
+Deno.serve(serveOptions, handler);
+const ws = import.meta._websocket ? wsAdapter(nitroApp.h3App.websocket) : void 0;
+async function handler(request, info) {
+  if (import.meta._websocket && request.headers.get("upgrade") === "websocket") {
+    return ws.handleUpgrade(request, info);
+  }
+  const url = new URL(request.url);
+  let body;
+  if (request.body) {
+    body = await request.arrayBuffer();
+  }
+  return nitroApp.localFetch(url.pathname + url.search, {
+    host: url.hostname,
+    protocol: url.protocol,
+    headers: request.headers,
+    method: request.method,
+    redirect: request.redirect,
+    body
+  });
+}
+if (import.meta._tasks) {
+  startScheduleRunner();
+}
+export default {};