@torpor/build 0.1.1 → 0.1.2

package/dist/chunk-ENB7RXFX.js

@@ -0,0 +1,669 @@
+import {
+  serverError
+} from "./chunk-VAGHGWM5.js";
+import {
+  prepareTemplate
+} from "./chunk-V4XTDQEV.js";
+import {
+  flattenHeaders
+} from "./chunk-5X4T3PZN.js";
+
+// src/site/runBuild.ts
+import torpor from "@torpor/unplugin/vite";
+import { existsSync, promises as fs } from "node:fs";
+import path2 from "node:path";
+import { build, defineConfig } from "vite";
+
+// src/site/manifest.ts
+import { readFileSync } from "node:fs";
+import path from "node:path";
+var moduleId = "@torpor/build/manifest";
+function manifest(site, server = false) {
+  return {
+    name: "torpor-manifest",
+    resolveId: {
+      order: "pre",
+      handler(id) {
+        if (id === moduleId) {
+          return id;
+        }
+      }
+    },
+    load(id) {
+      if (id === moduleId) {
+        return `
+${!server ? "const load = { default: { load: true } };" : ""}
+export default {
+  routes: [
+    ${site.routes.map((r) => {
+          if (server || !/server\.(ts|js)$/.test(r.file)) {
+            return `{ path: "${r.path}", file: "${r.file}", type: ${r.type}, endPoint: ${server || !/server\.(ts|js)$/.test(r.file) ? `() => import(/* @vite-ignore */ "${path.join(site.root, r.file)}")` : "undefined"} }`;
+          } else {
+            const haveLoad = readFileSync(path.join(site.root, r.file)).includes("load:");
+            return `{ path: "${r.path}", file: "${r.file}", type: ${r.type}, endPoint: ${haveLoad ? "() => load" : "undefined"} }`;
+          }
+        }).join(",\n    ")}
+  ],
+};
+`;
+      }
+    }
+  };
+}
+
+// src/site/runBuild.ts
+async function runBuild(site) {
+  const distFolder = path2.resolve(site.root, "dist");
+  if (existsSync(distFolder)) {
+    await fs.rm(distFolder, { recursive: true });
+  }
+  const clientFolder = path2.join(distFolder, "client");
+  const serverFolder = path2.join(distFolder, "server");
+  if (site.adapter.prebuild) {
+    await site.adapter.prebuild(site);
+  }
+  let siteHtml = path2.resolve(site.root, "src/site.html");
+  const siteFolder = path2.resolve(site.root, "./node_modules/@torpor/build/src/site/");
+  let clientScript = path2.join(siteFolder, "clientEntry.ts");
+  let serverScript = path2.join(siteFolder, "serverEntry.ts");
+  await build(
+    defineConfig({
+      plugins: [
+        manifest(site),
+        // @ts-ignore
+        torpor(),
+        ...site.plugins
+      ],
+      build: {
+        outDir: clientFolder,
+        rollupOptions: {
+          input: [
+            siteHtml,
+            clientScript,
+            ...site.routes.filter((r) => !/server\.(ts|js)$/.test(r.file)).map((r) => path2.resolve(site.root, r.file))
+          ]
+        },
+        ssrManifest: true
+      }
+    })
+  );
+  await build(
+    defineConfig({
+      plugins: [
+        manifest(site, true),
+        // @ts-ignore
+        torpor(),
+        ...site.plugins
+      ],
+      build: {
+        outDir: serverFolder,
+        rollupOptions: {
+          input: [serverScript, ...site.routes.map((r) => path2.resolve(site.root, r.file))]
+        },
+        ssr: serverScript
+      }
+    })
+  );
+  siteHtml = path2.join(clientFolder, "site.html");
+  await fs.rename(path2.join(clientFolder, "src", "site.html"), siteHtml);
+  await fs.rm(path2.join(clientFolder, "src"), { recursive: true });
+  if (site.adapter.postbuild) {
+    await site.adapter.postbuild(site);
+  }
+}
+
+// src/site/runDev.ts
+import torpor2 from "@torpor/unplugin/vite";
+import { configDotenv } from "dotenv";
+import { promises as fs2 } from "node:fs";
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+import { createServer as createViteServer } from "vite";
+
+// src/adapters/node/nodeMessageToNodeResponse.ts
+import {
+  ServerResponse
+} from "node:http";
+import { PassThrough, Readable } from "node:stream";
+function nodeMessageToNodeResponse(incomingMessage) {
+  const res = new ServerResponse(incomingMessage);
+  const passThrough = new PassThrough();
+  let handled = false;
+  const onReadable = (cb) => {
+    const handleReadable = () => {
+      if (handled) return;
+      handled = true;
+      cb({
+        readable: Readable.from(passThrough),
+        headers: res.getHeaders(),
+        status: res.statusCode
+      });
+    };
+    passThrough.once("readable", handleReadable);
+    passThrough.once("end", handleReadable);
+  };
+  passThrough.once("finish", () => {
+    res.emit("finish");
+  });
+  passThrough.once("close", () => {
+    res.destroy();
+    res.emit("close");
+  });
+  passThrough.on("drain", () => {
+    res.emit("drain");
+  });
+  res.write = passThrough.write.bind(passThrough);
+  res.end = passThrough.end.bind(passThrough);
+  res.writeHead = function writeHead(statusCode, statusMessage, headers) {
+    res.statusCode = statusCode;
+    if (typeof statusMessage === "object") {
+      headers = statusMessage;
+      statusMessage = void 0;
+    }
+    if (headers) {
+      for (const [key, value] of Object.entries(headers)) {
+        if (value !== void 0) {
+          res.setHeader(key, value);
+        }
+      }
+    }
+    return res;
+  };
+  return {
+    res,
+    onReadable
+  };
+}
+
+// src/adapters/node/readableToBuffer.ts
+function readableToBuffer(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      resolve(Buffer.concat(chunks));
+    });
+    req.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+// src/adapters/node/requestToNodeMessage.ts
+import { Readable as Readable2 } from "node:stream";
+var DUMMY_BASE_URL = "http://localhost";
+function requestToNodeMessage(request) {
+  const parsedUrl = new URL(request.url, DUMMY_BASE_URL);
+  const pathAndQuery = (parsedUrl.pathname || "") + (parsedUrl.search || "");
+  const body = (
+    /*request.body ? Readable.fromWeb(request.body as any) :*/
+    Readable2.from([])
+  );
+  return Object.assign(body, {
+    url: pathAndQuery,
+    method: request.method,
+    headers: Object.fromEntries(request.headers)
+  });
+}
+
+// src/adapters/node/createMiddlewareHandler.ts
+function createMiddlewareHandler(handler) {
+  return async (ev, next) => {
+    const req = requestToNodeMessage(ev.request);
+    const { res, onReadable } = nodeMessageToNodeResponse(req);
+    return new Promise(async (resolve, reject) => {
+      onReadable(async ({ readable, headers, status }) => {
+        const responseBody = statusCodesWithoutBody.includes(status) ? null : (
+          //(Readable.toWeb(readable) as ReadableStream);
+          // HACK: Chunked bodies are not being
+          // read correctly somewhere...
+          await readableToBuffer(readable)
+        );
+        ev.response = new Response(responseBody, {
+          status,
+          headers: flattenHeaders(headers)
+        });
+        resolve();
+      });
+      const cnext = async (error) => {
+        if (error) {
+          reject(error instanceof Error ? error : new Error(String(error)));
+        } else {
+          await next();
+          resolve();
+        }
+      };
+      try {
+        const handled = await handler(req, res, cnext);
+        if (handled === false) {
+          res.destroy();
+          resolve();
+        }
+      } catch (e) {
+        cnext(e);
+      }
+    });
+  };
+}
+var statusCodesWithoutBody = [
+  100,
+  // Continue
+  101,
+  // Switching Protocols
+  102,
+  // Processing (WebDAV)
+  103,
+  // Early Hints
+  204,
+  // No Content
+  205,
+  // Reset Content
+  304
+  // Not Modified
+];
+
+// src/site/pathToRegex.ts
+function pathToRegex(path6) {
+  const pattern = path6.split("/").map((p) => {
+    return p.replace(/\[([^\/]+?)\]/, "(?<$1>[^\\/]+?)");
+  }).join("\\/").replaceAll("*", ".*");
+  return new RegExp(`^${pattern}$`);
+}
+
+// src/server/CookieHelper.ts
+import { parse, serialize } from "cookie";
+var CookieHelper = class {
+  request;
+  cookies = /* @__PURE__ */ new Map();
+  constructor(request) {
+    this.request = request;
+  }
+  get(name) {
+    if (this.cookies.has(name)) {
+      return this.cookies.get(name);
+    }
+    const header = this.request.headers.get("cookie");
+    return parse(header ?? "")[name];
+  }
+  set(name, value, options) {
+    options ??= {};
+    options.httpOnly ??= true;
+    options.secure ??= true;
+    options.sameSite ??= "lax";
+    this.cookies.set(name, serialize(name, value, options));
+  }
+  delete(name, options) {
+    options ??= {};
+    options.expires = /* @__PURE__ */ new Date(0);
+    this.cookies.set(name, serialize(name, "", options));
+  }
+};
+
+// src/server/HeaderHelper.ts
+var HeaderHelper = class {
+  request;
+  headers = /* @__PURE__ */ new Map();
+  constructor(request) {
+    this.request = request;
+  }
+  get(name) {
+    if (this.headers.has(name)) {
+      return this.headers.get(name);
+    }
+    return this.request.headers.get(name) ?? void 0;
+  }
+  set(name, value) {
+    this.headers.set(name, value);
+  }
+  delete(name) {
+    this.headers.delete(name);
+  }
+};
+
+// src/server/ServerEvent.ts
+var ServerEvent = class {
+  request;
+  response;
+  // TODO: Should we cast types??
+  params;
+  cookies;
+  headers;
+  constructor(request, params) {
+    this.request = request;
+    this.params = params;
+    this.cookies = new CookieHelper(request);
+    this.headers = new HeaderHelper(request);
+  }
+  addHeaders() {
+    if (!this.response) {
+      throw new Error("Response not created yet");
+    }
+    for (let cookie of this.cookies.cookies.values()) {
+      this.response.headers.append("set-cookie", cookie);
+    }
+    for (let header of this.headers.headers.entries()) {
+      this.response.headers.append(header[0], header[1]);
+    }
+  }
+};
+
+// src/server/Server.ts
+var noop = () => {
+};
+var Server = class {
+  // TODO: We don't use any of the routes, just add("*") in runDev/runBuild...
+  routes = [];
+  // TODO: We only use the Vite middleware here
+  middleware = [];
+  constructor() {
+    this.routes = [];
+    this.middleware = [];
+  }
+  /**
+   * The standard Fetch API method that should work in any runtime (including
+   * Node with polyfills).
+   * @returns
+   */
+  fetch = async (input, init) => {
+    const request = new Request(input, init);
+    const url = new URL(request.url);
+    const match = this.match(url.pathname);
+    let ev = new ServerEvent(request, match?.params);
+    if (this.middleware.length) {
+      let buildNext2 = function(middleware, i) {
+        if (ev.response) {
+          return noop;
+        }
+        if (i < middleware.length - 1) {
+          let next = middleware[i + 1];
+          return async () => next(ev, buildNext2(middleware, i + 1));
+        } else {
+          return match ? async () => {
+            ev.response = await match.fn(ev);
+          } : noop;
+        }
+      };
+      var buildNext = buildNext2;
+      await this.middleware[0](ev, buildNext2(this.middleware, 0));
+    } else if (match) {
+      ev.response = await match.fn(ev);
+    } else {
+      return new Response(null, { status: 404 });
+    }
+    ev.response ??= new Response(null, { status: 200 });
+    ev.addHeaders();
+    return ev.response;
+  };
+  /**
+   * Adds a server function at a route path.
+   * @param path The route path pattern.
+   * @param fn The function to call when the pattern is matched.
+   * @returns
+   */
+  add(path6, fn) {
+    this.routes.push(new RouteHandler(path6, fn));
+    return this;
+  }
+  match(path6) {
+    for (let handler of this.routes) {
+      let match = path6.match(handler.regex);
+      if (match) {
+        return {
+          fn: handler.fn,
+          params: match.groups
+        };
+      }
+    }
+    console.log(`Server path not found: ${path6}`);
+  }
+  // TODO:
+  //use(path: string, ...fn: MiddlewareFunction[])
+  use(...fn) {
+    this.middleware = this.middleware.concat(fn);
+    return this;
+  }
+};
+var RouteHandler = class {
+  path;
+  regex;
+  fn;
+  constructor(path6, fn) {
+    this.path = path6;
+    this.regex = pathToRegex(path6);
+    this.fn = fn;
+  }
+};
+
+// src/site/runDev.ts
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+async function runDev(site) {
+  const server = new Server();
+  const vite = await createViteServer({
+    server: { middlewareMode: true },
+    appType: "custom",
+    plugins: [
+      manifest(site, true),
+      // @ts-ignore not sure...
+      torpor2(),
+      ...site.plugins
+    ]
+  });
+  const templateFile = path3.resolve(site.root, "src/site.html");
+  let template = await fs2.readFile(templateFile, "utf-8");
+  template = await vite.transformIndexHtml("", template);
+  const clientScript = path3.resolve(__dirname, "../../src/site/clientEntry.ts");
+  const serverScript = path3.resolve(__dirname, "../../src/site/serverEntry.ts");
+  template = prepareTemplate(template, clientScript);
+  server.use(createMiddlewareHandler(vite.middlewares));
+  server.add("*", async (ev) => {
+    try {
+      const { load } = await vite.ssrLoadModule(serverScript);
+      return await load(ev, template);
+    } catch (e) {
+      vite.ssrFixStacktrace(e);
+      return serverError(e);
+    }
+  });
+  configDotenv();
+  process.env.PROTOCOL ??= "http:";
+  process.env.HOST ??= "localhost";
+  process.env.PORT ??= "7059";
+  site.adapter.serve(server, site);
+}
+
+// src/site/runPreview.ts
+import { configDotenv as configDotenv2 } from "dotenv";
+import { existsSync as existsSync2, promises as fs3 } from "node:fs";
+import path4 from "node:path";
+
+// src/server/contentType.ts
+function contentType(extension) {
+  return types[extension] || "application/octet-stream";
+}
+var types = {
+  ".aac": "audio/aac",
+  ".abw": "application/x-abiword",
+  ".apng": "image/apng",
+  ".arc": "application/x-freearc",
+  ".avif": "image/avif",
+  ".avi": "video/x-msvideo",
+  ".azw": "application/vnd.amazon.ebook",
+  ".bin": "application/octet-stream",
+  ".bmp": "image/bmp",
+  ".bz": "application/x-bzip",
+  ".bz2": "application/x-bzip2",
+  ".cda": "application/x-cdf",
+  ".csh": "application/x-csh",
+  ".css": "text/css",
+  ".csv": "text/csv",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".eot": "application/vnd.ms-fontobject",
+  ".epub": "application/epub+zip",
+  ".gz": "application/gzip",
+  ".gif": "image/gif",
+  ".htm": "text/html",
+  ".html": "text/html",
+  ".ico": "image/vnd.microsoft.icon",
+  ".ics": "text/calendar",
+  ".jar": "application/java-archive",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript",
+  ".json": "application/json",
+  ".jsonld": "application/ld+json",
+  ".mid": "audio/midi",
+  ".midi": "audio/midi",
+  ".mjs": "text/javascript",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".mpeg": "video/mpeg",
+  ".mpkg": "application/vnd.apple.installer+xml",
+  ".odp": "application/vnd.oasis.opendocument.presentation",
+  ".ods": "application/vnd.oasis.opendocument.spreadsheet",
+  ".odt": "application/vnd.oasis.opendocument.text",
+  ".oga": "audio/ogg",
+  ".ogv": "video/ogg",
+  ".ogx": "application/ogg",
+  ".opus": "audio/ogg",
+  ".otf": "font/otf",
+  ".png": "image/png",
+  ".pdf": "application/pdf",
+  ".php": "application/x-httpd-php",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".rar": "application/vnd.rar",
+  ".rtf": "application/rtf",
+  ".sh": "application/x-sh",
+  ".svg": "image/svg+xml",
+  ".tar": "application/x-tar",
+  ".tif": "image/tiff",
+  ".tiff": "image/tiff",
+  ".ts": "video/mp2t",
+  ".ttf": "font/ttf",
+  ".txt": "text/plain",
+  ".vsd": "application/vnd.visio",
+  ".wav": "audio/wav",
+  ".weba": "audio/webm",
+  ".webm": "video/webm",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".xhtml": "application/xhtml+xml",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".xml": "application/xml",
+  ".xul": "application/vnd.mozilla.xul+xml",
+  ".zip": "application/zip",
+  ".3gp": "video/3gpp",
+  ".3g2": "video/3gpp2",
+  ".7z": "application/x-7z-compressed"
+};
+
+// src/site/runPreview.ts
+async function runPreview(site) {
+  await runBuild(site);
+  const distFolder = path4.resolve(site.root, "dist");
+  const clientFolder = path4.join(distFolder, "client");
+  const serverFolder = path4.join(distFolder, "server");
+  let clientScript = (await fs3.readdir(path4.join(clientFolder, "assets"))).find(
+    (f) => f.startsWith("clientEntry-")
+  );
+  if (!clientScript) {
+    throw new Error("clientEntry.js not found");
+  }
+  clientScript = `/assets/${clientScript}`;
+  let siteHtml = path4.join(clientFolder, "site.html");
+  let template = await fs3.readFile(siteHtml, "utf-8");
+  template = prepareTemplate(template, clientScript);
+  const server = new Server();
+  server.add("/assets/*", async (ev) => {
+    try {
+      const url = new URL(ev.request.url);
+      const file = path4.join(site.root, "dist", "client", url.pathname);
+      if (existsSync2(file)) {
+        return new Response(await fs3.readFile(file), {
+          status: 200,
+          headers: {
+            "Content-Type": contentType(path4.extname(file))
+          }
+        });
+      }
+    } catch (e) {
+      return serverError(e);
+    }
+  });
+  const serverScript = path4.resolve(serverFolder, "serverEntry.js");
+  server.add("*", async (ev) => {
+    try {
+      const { load } = await import(serverScript);
+      return await load(ev, template);
+    } catch (e) {
+      return serverError(e);
+    }
+  });
+  configDotenv2();
+  process.env.PROTOCOL ??= "http:";
+  process.env.HOST ??= "localhost";
+  process.env.PORT ??= "7059";
+  site.adapter.serve(server, site);
+}
+
+// src/site/run.ts
+import fs4 from "node:fs";
+import path5 from "node:path";
+import { transformWithEsbuild } from "vite";
+async function run(folder, mode) {
+  let configFile = "";
+  let deleteConfigFile = false;
+  const jsConfigFile = path5.join(folder, "site.config.js");
+  const tsConfigFile = path5.join(folder, "site.config.ts");
+  if (fs4.existsSync(jsConfigFile)) {
+    configFile = jsConfigFile;
+  } else if (fs4.existsSync(tsConfigFile)) {
+    configFile = path5.join(folder, "site.config.temp.js");
+    let source = (await transformWithEsbuild(fs4.readFileSync(tsConfigFile, "utf-8"), tsConfigFile, {
+      loader: "ts"
+    })).code;
+    fs4.writeFileSync(configFile, source);
+    deleteConfigFile = true;
+  } else {
+    throw new Error("site.config file not found");
+  }
+  const site = (await import(configFile)).default;
+  if (!site || !site.root || !site.routes) {
+    throw new Error("Invalid site in config file");
+  }
+  if (deleteConfigFile) {
+    fs4.rmSync(configFile);
+  }
+  switch (mode) {
+    case "dev": {
+      await runDev(site);
+      break;
+    }
+    case "build": {
+      await runBuild(site);
+      break;
+    }
+    case "preview": {
+      await runPreview(site);
+      break;
+    }
+    default: {
+      console.log("No mode passed, running in dev");
+      await runDev(site);
+      break;
+    }
+  }
+}
+
+export {
+  runBuild,
+  runDev,
+  runPreview,
+  run
+};
+//# sourceMappingURL=chunk-ENB7RXFX.js.map