feat: init

node_modules/nitropack/dist/presets/_nitro/base-worker.d.ts

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

node_modules/nitropack/dist/presets/_nitro/base-worker.mjs

@@ -0,0 +1,25 @@
+import { defineNitroPreset } from "nitropack/kit";
+const baseWorker = defineNitroPreset(
+  {
+    entry: null,
+    // Abstract
+    node: false,
+    minify: true,
+    noExternals: true,
+    rollupConfig: {
+      output: {
+        format: "iife",
+        generatedCode: {
+          symbols: true
+        }
+      }
+    },
+    inlineDynamicImports: true
+    // iffe does not support code-splitting
+  },
+  {
+    name: "base-worker",
+    url: import.meta.url
+  }
+);
+export default [baseWorker];

node_modules/nitropack/dist/presets/_nitro/nitro-dev.d.ts

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

node_modules/nitropack/dist/presets/_nitro/nitro-dev.mjs

@@ -0,0 +1,22 @@
+import { defineNitroPreset } from "nitropack/kit";
+const nitroDev = defineNitroPreset(
+  {
+    entry: "./runtime/nitro-dev",
+    output: {
+      dir: "{{ buildDir }}/dev",
+      serverDir: "{{ buildDir }}/dev",
+      publicDir: "{{ buildDir }}/dev"
+    },
+    externals: { trace: false },
+    serveStatic: true,
+    inlineDynamicImports: true,
+    // externals plugin limitation
+    sourceMap: true
+  },
+  {
+    name: "nitro-dev",
+    dev: true,
+    url: import.meta.url
+  }
+);
+export default [nitroDev];

node_modules/nitropack/dist/presets/_nitro/nitro-prerender.d.ts

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

node_modules/nitropack/dist/presets/_nitro/nitro-prerender.mjs

@@ -0,0 +1,17 @@
+import { defineNitroPreset } from "nitropack/kit";
+const nitroPrerender = defineNitroPreset(
+  {
+    extends: "node",
+    serveStatic: true,
+    entry: "./runtime/nitro-prerenderer",
+    output: {
+      serverDir: "{{ buildDir }}/prerender"
+    },
+    externals: { trace: false }
+  },
+  {
+    name: "nitro-prerender",
+    url: import.meta.url
+  }
+);
+export default [nitroPrerender];

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

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

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

@@ -0,0 +1,5 @@
+import worker from "./base-worker.mjs";
+import dev from "./nitro-dev.mjs";
+import prerender from "./nitro-prerender.mjs";
+import sw from "./service-worker.mjs";
+export default [...worker, ...dev, ...prerender, ...sw];

node_modules/nitropack/dist/presets/_nitro/runtime/nitro-dev.d.ts

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

node_modules/nitropack/dist/presets/_nitro/runtime/nitro-dev.mjs

@@ -0,0 +1,111 @@
+import "#nitro-internal-pollyfills";
+import { tmpdir } from "node:os";
+import { useNitroApp } from "nitropack/runtime";
+import { runTask } from "nitropack/runtime";
+import { trapUnhandledNodeErrors } from "nitropack/runtime/internal";
+import { startScheduleRunner } from "nitropack/runtime/internal";
+import { scheduledTasks, tasks } from "#nitro-internal-virtual/tasks";
+import { Server } from "node:http";
+import { join } from "node:path";
+import nodeCrypto from "node:crypto";
+import { parentPort, threadId } from "node:worker_threads";
+import wsAdapter from "crossws/adapters/node";
+import {
+  defineEventHandler,
+  getQuery,
+  getRouterParam,
+  readBody,
+  toNodeListener
+} from "h3";
+if (!globalThis.crypto) {
+  globalThis.crypto = nodeCrypto.webcrypto;
+}
+const { NITRO_NO_UNIX_SOCKET, NITRO_DEV_WORKER_ID } = process.env;
+trapUnhandledNodeErrors();
+parentPort?.on("message", (msg) => {
+  if (msg && msg.event === "shutdown") {
+    shutdown();
+  }
+});
+const nitroApp = useNitroApp();
+const server = new Server(toNodeListener(nitroApp.h3App));
+let listener;
+listen().catch(() => listen(
+  true
+  /* use random port */
+)).catch((error) => {
+  console.error("Dev worker failed to listen:", error);
+  return shutdown();
+});
+if (import.meta._websocket) {
+  const { handleUpgrade } = wsAdapter(nitroApp.h3App.websocket);
+  server.on("upgrade", handleUpgrade);
+}
+nitroApp.router.get(
+  "/_nitro/tasks",
+  defineEventHandler(async (event) => {
+    const _tasks = await Promise.all(
+      Object.entries(tasks).map(async ([name, task]) => {
+        const _task = await task.resolve?.();
+        return [name, { description: _task?.meta?.description }];
+      })
+    );
+    return {
+      tasks: Object.fromEntries(_tasks),
+      scheduledTasks
+    };
+  })
+);
+nitroApp.router.use(
+  "/_nitro/tasks/:name",
+  defineEventHandler(async (event) => {
+    const name = getRouterParam(event, "name");
+    const payload = {
+      ...getQuery(event),
+      ...await readBody(event).then((r) => r?.payload).catch(() => ({}))
+    };
+    return await runTask(name, { payload });
+  })
+);
+if (import.meta._tasks) {
+  startScheduleRunner();
+}
+function listen(useRandomPort = Boolean(
+  NITRO_NO_UNIX_SOCKET || process.versions.webcontainer || "Bun" in globalThis && process.platform === "win32"
+)) {
+  return new Promise((resolve, reject) => {
+    try {
+      listener = server.listen(useRandomPort ? 0 : getSocketAddress(), () => {
+        const address = server.address();
+        parentPort?.postMessage({
+          event: "listen",
+          address: typeof address === "string" ? { socketPath: address } : { host: "localhost", port: address?.port }
+        });
+        resolve();
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+function getSocketAddress() {
+  const socketName = `nitro-worker-${process.pid}-${threadId}-${NITRO_DEV_WORKER_ID}-${Math.round(Math.random() * 1e4)}.sock`;
+  if (process.platform === "win32") {
+    return join(String.raw`\\.\pipe`, socketName);
+  }
+  if (process.platform === "linux") {
+    const nodeMajor = Number.parseInt(process.versions.node.split(".")[0], 10);
+    if (nodeMajor >= 20) {
+      return `\0${socketName}`;
+    }
+  }
+  return join(tmpdir(), socketName);
+}
+async function shutdown() {
+  server.closeAllConnections?.();
+  await Promise.all([
+    new Promise((resolve) => listener?.close(resolve)),
+    nitroApp.hooks.callHook("close").catch(console.error)
+  ]);
+  parentPort?.postMessage({ event: "exit" });
+}

node_modules/nitropack/dist/presets/_nitro/runtime/nitro-prerenderer.d.ts

@@ -0,0 +1,3 @@
+import "#nitro-internal-pollyfills";
+export declare const localFetch: any;
+export declare const closePrerenderer: () => any;

node_modules/nitropack/dist/presets/_nitro/runtime/nitro-prerenderer.mjs

@@ -0,0 +1,7 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitropack/runtime";
+import { trapUnhandledNodeErrors } from "nitropack/runtime/internal";
+const nitroApp = useNitroApp();
+export const localFetch = nitroApp.localFetch;
+export const closePrerenderer = () => nitroApp.hooks.callHook("close");
+trapUnhandledNodeErrors();

node_modules/nitropack/dist/presets/_nitro/runtime/service-worker.d.ts

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

node_modules/nitropack/dist/presets/_nitro/runtime/service-worker.mjs

@@ -0,0 +1,31 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitropack/runtime";
+import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
+const nitroApp = useNitroApp();
+addEventListener("fetch", (event) => {
+  const url = new URL(event.request.url);
+  if (isPublicAssetURL(url.pathname) || url.pathname.includes("/_server/")) {
+    return;
+  }
+  event.respondWith(handleEvent(url, event));
+});
+async function handleEvent(url, event) {
+  let body;
+  if (event.request.body) {
+    body = await event.request.arrayBuffer();
+  }
+  return nitroApp.localFetch(url.pathname + url.search, {
+    host: url.hostname,
+    protocol: url.protocol,
+    headers: event.request.headers,
+    method: event.request.method,
+    redirect: event.request.redirect,
+    body
+  });
+}
+self.addEventListener("install", () => {
+  self.skipWaiting();
+});
+self.addEventListener("activate", (event) => {
+  event.waitUntil(self.clients.claim());
+});

node_modules/nitropack/dist/presets/_nitro/service-worker.d.ts

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

node_modules/nitropack/dist/presets/_nitro/service-worker.mjs

@@ -0,0 +1,110 @@
+import { existsSync, promises as fsp } from "node:fs";
+import { defineNitroPreset } from "nitropack/kit";
+import { resolve } from "pathe";
+import { joinURL } from "ufo";
+const serviceWorker = defineNitroPreset(
+  () => {
+    return {
+      extends: "base-worker",
+      entry: "./runtime/service-worker",
+      output: {
+        serverDir: "{{ output.dir }}/public/server"
+      },
+      commands: {
+        preview: "npx serve {{ output.publicDir }}"
+      },
+      hooks: {
+        "prerender:generate"(route, nitro) {
+          const script = scriptTemplate(nitro.options.baseURL);
+          route.contents = (route.contents || "").replace(
+            "</head>",
+            `${script}
+</head>`
+          );
+        },
+        async compiled(nitro) {
+          await fsp.writeFile(
+            resolve(nitro.options.output.publicDir, "sw.js"),
+            `self.importScripts('${joinURL(
+              nitro.options.baseURL,
+              "server/index.mjs"
+            )}');`,
+            "utf8"
+          );
+          const html = htmlTemplate(nitro.options.baseURL);
+          if (!existsSync(resolve(nitro.options.output.publicDir, "index.html"))) {
+            await fsp.writeFile(
+              resolve(nitro.options.output.publicDir, "index.html"),
+              html,
+              "utf8"
+            );
+          }
+          if (!existsSync(resolve(nitro.options.output.publicDir, "200.html"))) {
+            await fsp.writeFile(
+              resolve(nitro.options.output.publicDir, "200.html"),
+              html,
+              "utf8"
+            );
+          }
+          if (!existsSync(resolve(nitro.options.output.publicDir, "404.html"))) {
+            await fsp.writeFile(
+              resolve(nitro.options.output.publicDir, "404.html"),
+              html,
+              "utf8"
+            );
+          }
+        }
+      }
+    };
+  },
+  {
+    name: "service-worker",
+    url: import.meta.url
+  }
+);
+export default [serviceWorker];
+function htmlTemplate(baseURL = "/") {
+  return (
+    /* html */
+    `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <link rel="prefetch" href="${joinURL(baseURL, "sw.js")}">
+  <link rel="prefetch" href="${joinURL(baseURL, "server/index.mjs")}">
+  ${scriptTemplate(baseURL)}
+</head>
+<body>
+  Initializing nitro service worker...
+</body>
+</html>`
+  );
+}
+function scriptTemplate(baseURL = "/") {
+  return (
+    /* js */
+    `
+<script>
+async function register () {
+  const registration = await navigator.serviceWorker.register('${joinURL(
+      baseURL,
+      "sw.js"
+    )}')
+  await navigator.serviceWorker.ready
+  registration.active.addEventListener('statechange', (event) => {
+    if (event.target.state === 'activated') {
+      window.location.reload()
+    }
+  })
+}
+if ('serviceWorker' in navigator) {
+  if (location.hostname !== 'localhost' && location.protocol === 'http:') {
+    location.replace(location.href.replace('http://', 'https://'))
+  } else {
+    register()
+  }
+}
+<\/script>
+`
+  );
+}