@eighty4/dank 0.0.4-1 → 0.0.4-3

package/lib_js/http.js

@@ -1,230 +1,211 @@
-import { createReadStream } from 'node:fs';
-import { stat } from 'node:fs/promises';
-import { createServer, } from 'node:http';
-import { extname, join } from 'node:path';
-import { Readable } from 'node:stream';
-import mime from 'mime';
-export function startWebServer(serve, frontendFetcher, httpServices, pageRoutes) {
-    const serverAddress = 'http://localhost:' + serve.dankPort;
-    const handler = (req, res) => {
-        if (!req.url || !req.method) {
-            res.end();
-        }
-        else {
-            const url = new URL(serverAddress + req.url);
-            const headers = convertHeadersToFetch(req.headers);
-            frontendFetcher(url, headers, res, () => onNotFound(req, url, headers, httpServices, pageRoutes, serve, res));
-        }
-    };
-    createServer(serve.logHttp ? createLogWrapper(handler) : handler).listen(serve.dankPort);
-    console.log(serve.preview ? 'preview' : 'dev', `server is live at http://127.0.0.1:${serve.dankPort}`);
-}
-async function onNotFound(req, url, headers, httpServices, pageRoutes, serve, res) {
-    if (req.method === 'GET' && extname(url.pathname) === '') {
-        const urlRewrite = tryUrlRewrites(url, pageRoutes, serve);
-        if (urlRewrite) {
-            streamFile(urlRewrite, res);
-            return;
-        }
-    }
-    const fetchResponse = await tryHttpServices(req, url, headers, httpServices);
-    if (fetchResponse) {
-        sendFetchResponse(res, fetchResponse);
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { createServer } from "node:http";
+import { extname, join } from "node:path";
+import { Readable } from "node:stream";
+import mime from "mime";
+function startWebServer(port, flags, dirs, urlRewriteProvider, frontendFetcher, httpServices) {
+  const serverAddress = "http://localhost:" + port;
+  const handler = (req, res) => {
+    if (!req.url || !req.method) {
+      res.end();
+    } else {
+      const url = new URL(serverAddress + req.url);
+      const headers = convertHeadersToFetch(req.headers);
+      frontendFetcher(url, headers, res, () => onNotFound(req, url, headers, httpServices, flags, dirs, urlRewriteProvider, res));
     }
-    else {
-        res.writeHead(404);
-        res.end();
+  };
+  createServer(flags.logHttp ? createLogWrapper(handler) : handler).listen(port);
+  console.log(flags.preview ? "preview" : "dev", `server is live at http://127.0.0.1:${port}`);
+}
+async function onNotFound(req, url, headers, httpServices, flags, dirs, urlRewriteProvider, res) {
+  if (req.method === "GET" && extname(url.pathname) === "") {
+    const urlRewrite = tryUrlRewrites(flags, dirs, urlRewriteProvider.urlRewrites, url);
+    if (urlRewrite) {
+      streamFile(urlRewrite, res);
+      return;
     }
+  }
+  const fetchResponse = await tryHttpServices(req, url, headers, httpServices);
+  if (fetchResponse) {
+    sendFetchResponse(res, fetchResponse);
+  } else {
+    res.writeHead(404);
+    res.end();
+  }
 }
 async function sendFetchResponse(res, fetchResponse) {
-    res.writeHead(fetchResponse.status, undefined, convertHeadersFromFetch(fetchResponse.headers));
-    if (fetchResponse.body) {
-        Readable.fromWeb(fetchResponse.body).pipe(res);
-    }
-    else {
-        res.end();
-    }
+  res.writeHead(fetchResponse.status, void 0, convertHeadersFromFetch(fetchResponse.headers));
+  if (fetchResponse.body) {
+    Readable.fromWeb(fetchResponse.body).pipe(res);
+  } else {
+    res.end();
+  }
 }
-function tryUrlRewrites(url, pageRoutes, serve) {
-    const urlRewrite = pageRoutes.urlRewrites.find(urlRewrite => urlRewrite.pattern.test(url.pathname));
-    return urlRewrite
-        ? join(serve.dirs.buildWatch, urlRewrite.url, 'index.html')
-        : null;
+function tryUrlRewrites(flags, dirs, urlRewrites, url) {
+  const urlRewrite = urlRewrites.find((urlRewrite2) => urlRewrite2.pattern.test(url.pathname));
+  return urlRewrite ? join(flags.preview ? dirs.buildDist : dirs.buildWatch, urlRewrite.url, "index.html") : null;
 }
 async function tryHttpServices(req, url, headers, httpServices) {
-    if (url.pathname.startsWith('/.well-known/')) {
-        return null;
-    }
-    const body = await collectReqBody(req);
-    const { running } = httpServices;
-    for (const httpService of running) {
-        const proxyUrl = new URL(url);
-        proxyUrl.port = `${httpService.port}`;
-        try {
-            const response = await retryFetchWithTimeout(proxyUrl, {
-                body,
-                headers,
-                method: req.method,
-                redirect: 'manual',
-            });
-            if (response.status === 404 || response.status === 405) {
-                continue;
-            }
-            else {
-                return response;
-            }
-        }
-        catch (e) {
-            if (e === 'retrytimeout') {
-                continue;
-            }
-            else {
-                errorExit(`unexpected error http proxying to port ${httpService.port}: ${e.message}`);
-            }
-        }
-    }
+  if (url.pathname.startsWith("/.well-known/")) {
     return null;
+  }
+  const body = await collectReqBody(req);
+  const { running } = httpServices;
+  for (const httpService of running) {
+    const proxyUrl = new URL(url);
+    proxyUrl.port = `${httpService.port}`;
+    try {
+      const response = await retryFetchWithTimeout(proxyUrl, {
+        body,
+        headers,
+        method: req.method,
+        redirect: "manual"
+      });
+      if (response.status === 404 || response.status === 405) {
+        continue;
+      } else {
+        return response;
+      }
+    } catch (e) {
+      if (e === "retrytimeout") {
+        continue;
+      } else {
+        errorExit(`unexpected error http proxying to port ${httpService.port}: ${e.message}`);
+      }
+    }
+  }
+  return null;
 }
 function collectReqBody(req) {
-    let body = '';
-    req.on('data', data => (body += data.toString()));
-    return new Promise(res => req.on('end', () => res(body.length ? body : null)));
+  let body = "";
+  req.on("data", (data) => body += data.toString());
+  return new Promise((res) => req.on("end", () => res(body.length ? body : null)));
 }
 function createLogWrapper(handler) {
-    return (req, res) => {
-        console.log('  > ', req.method, req.url);
-        res.on('close', () => {
-            console.log('', res.statusCode, req.method, req.url);
-        });
-        handler(req, res);
-    };
-}
-export function createBuiltDistFilesFetcher(dir, manifest) {
-    return (url, _headers, res, notFound) => {
-        if (manifest.pageUrls.has(url.pathname)) {
-            streamFile(join(dir, url.pathname, 'index.html'), res);
-        }
-        else if (manifest.files.has(url.pathname)) {
-            streamFile(join(dir, url.pathname), res);
-        }
-        else {
-            notFound();
-        }
-    };
-}
-// todo replace PageRouteState with WebsiteRegistry
-export function createDevServeFilesFetcher(pageRoutes, serve) {
-    const proxyAddress = 'http://127.0.0.1:' + serve.esbuildPort;
-    return (url, _headers, res, notFound) => {
-        if (pageRoutes.urls.includes(url.pathname)) {
-            streamFile(join(serve.dirs.buildWatch, url.pathname, 'index.html'), res);
-        }
-        else {
-            const maybePublicPath = join(serve.dirs.public, url.pathname);
-            exists(maybePublicPath).then(fromPublic => {
-                if (fromPublic) {
-                    streamFile(maybePublicPath, res);
-                }
-                else {
-                    retryFetchWithTimeout(proxyAddress + url.pathname)
-                        .then(fetchResponse => {
-                        if (fetchResponse.status === 404) {
-                            notFound();
-                        }
-                        else {
-                            res.writeHead(fetchResponse.status, convertHeadersFromFetch(fetchResponse.headers));
-                            fetchResponse
-                                .bytes()
-                                .then(data => res.end(data));
-                        }
-                    })
-                        .catch(e => {
-                        if (isFetchRetryTimeout(e)) {
-                            res.writeHead(504);
-                        }
-                        else {
-                            console.error('unknown frontend proxy fetch error:', e);
-                            res.writeHead(502);
-                        }
-                        res.end();
-                    });
-                }
-            });
+  return (req, res) => {
+    console.log("  > ", req.method, req.url);
+    res.on("close", () => {
+      console.log("", res.statusCode, req.method, req.url);
+    });
+    handler(req, res);
+  };
+}
+function createBuiltDistFilesFetcher(dirs, manifest) {
+  return (url, _headers, res, notFound) => {
+    if (manifest.pageUrls.has(url.pathname)) {
+      streamFile(join(dirs.projectResolved, dirs.buildDist, url.pathname, "index.html"), res);
+    } else if (manifest.files.has(url.pathname)) {
+      streamFile(join(dirs.projectResolved, dirs.buildDist, url.pathname), res);
+    } else {
+      notFound();
+    }
+  };
+}
+function createDevServeFilesFetcher(esbuildPort, dirs, registry) {
+  const proxyAddress = "http://127.0.0.1:" + esbuildPort;
+  return (url, _headers, res, notFound) => {
+    if (registry.pageUrls.includes(url.pathname)) {
+      streamFile(join(dirs.buildWatch, url.pathname, "index.html"), res);
+    } else {
+      const maybePublicPath = join(dirs.public, url.pathname);
+      exists(maybePublicPath).then((fromPublic) => {
+        if (fromPublic) {
+          streamFile(maybePublicPath, res);
+        } else {
+          retryFetchWithTimeout(proxyAddress + url.pathname).then((fetchResponse) => {
+            if (fetchResponse.status === 404) {
+              notFound();
+            } else {
+              res.writeHead(fetchResponse.status, convertHeadersFromFetch(fetchResponse.headers));
+              fetchResponse.bytes().then((data) => res.end(data));
+            }
+          }).catch((e) => {
+            if (isFetchRetryTimeout(e)) {
+              res.writeHead(504);
+            } else {
+              console.error("unknown frontend proxy fetch error:", e);
+              res.writeHead(502);
+            }
+            res.end();
+          });
         }
-    };
+      });
+    }
+  };
 }
 const PROXY_FETCH_RETRY_INTERVAL = 27;
-const PROXY_FETCH_RETRY_TIMEOUT = 1000;
+const PROXY_FETCH_RETRY_TIMEOUT = 1e3;
 async function retryFetchWithTimeout(url, requestInit) {
-    let timeout = Date.now() + PROXY_FETCH_RETRY_TIMEOUT;
-    while (true) {
-        try {
-            return await fetch(url, requestInit);
-        }
-        catch (e) {
-            if (isNodeFailedFetch(e) || isBunFailedFetch(e)) {
-                if (timeout < Date.now()) {
-                    throw 'retrytimeout';
-                }
-                else {
-                    await new Promise(res => setTimeout(res, PROXY_FETCH_RETRY_INTERVAL));
-                }
-            }
-            else {
-                throw e;
-            }
+  let timeout = Date.now() + PROXY_FETCH_RETRY_TIMEOUT;
+  while (true) {
+    try {
+      return await fetch(url, requestInit);
+    } catch (e) {
+      if (isNodeFailedFetch(e) || isBunFailedFetch(e)) {
+        if (timeout < Date.now()) {
+          throw "retrytimeout";
+        } else {
+          await new Promise((res) => setTimeout(res, PROXY_FETCH_RETRY_INTERVAL));
         }
+      } else {
+        throw e;
+      }
     }
+  }
 }
 function isFetchRetryTimeout(e) {
-    return e === 'retrytimeout';
+  return e === "retrytimeout";
 }
 function isBunFailedFetch(e) {
-    return e.code === 'ConnectionRefused';
+  return e.code === "ConnectionRefused";
 }
 function isNodeFailedFetch(e) {
-    return e.message === 'fetch failed';
+  return e.message === "fetch failed";
 }
 async function exists(p) {
-    try {
-        const maybe = stat(p);
-        return (await maybe).isFile();
-    }
-    catch (ignore) {
-        return false;
-    }
+  try {
+    const maybe = stat(p);
+    return (await maybe).isFile();
+  } catch (ignore) {
+    return false;
+  }
 }
 function streamFile(p, res) {
-    res.setHeader('Content-Type', mime.getType(p) || 'application/octet-stream');
-    const reading = createReadStream(p);
-    reading.pipe(res);
-    reading.on('error', err => {
-        console.error(`file read ${reading.path} error ${err.message}`);
-        res.statusCode = 500;
-        res.end();
-    });
+  res.setHeader("Content-Type", mime.getType(p) || "application/octet-stream");
+  const reading = createReadStream(p);
+  reading.pipe(res);
+  reading.on("error", (err) => {
+    console.error(`file read ${reading.path} error ${err.message}`);
+    res.statusCode = 500;
+    res.end();
+  });
 }
 function convertHeadersFromFetch(from) {
-    const to = {};
-    for (const name of from.keys()) {
-        to[name] = from.get(name);
-    }
-    return to;
+  const to = {};
+  for (const name of from.keys()) {
+    to[name] = from.get(name);
+  }
+  return to;
 }
 function convertHeadersToFetch(from) {
-    const to = new Headers();
-    for (const [name, values] of Object.entries(from)) {
-        if (Array.isArray(values)) {
-            for (const value of values)
-                to.append(name, value);
-        }
-        else if (values) {
-            to.set(name, values);
-        }
+  const to = new Headers();
+  for (const [name, values] of Object.entries(from)) {
+    if (Array.isArray(values)) {
+      for (const value of values)
+        to.append(name, value);
+    } else if (values) {
+      to.set(name, values);
     }
-    return to;
+  }
+  return to;
 }
 function errorExit(msg) {
-    console.log(`\u001b[31merror:\u001b[0m`, msg);
-    process.exit(1);
-}
+  console.log(`\x1B[31merror:\x1B[0m`, msg);
+  process.exit(1);
+}
+export {
+  createBuiltDistFilesFetcher,
+  createDevServeFilesFetcher,
+  startWebServer
+};

package/lib_js/public.js

@@ -1,51 +1,50 @@
-import { copyFile, mkdir, readdir, stat } from 'node:fs/promises';
-import { platform } from 'node:os';
-import { join } from 'node:path';
-export async function copyAssets(build) {
-    try {
-        const stats = await stat(build.dirs.public);
-        if (stats.isDirectory()) {
-            await mkdir(build.dirs.buildDist, { recursive: true });
-            return await recursiveCopyAssets(build);
-        }
-        else {
-            throw Error('./public cannot be a file');
-        }
-    }
-    catch (e) {
-        return null;
+import { copyFile, mkdir, readdir, stat } from "node:fs/promises";
+import { platform } from "node:os";
+import { join } from "node:path";
+async function copyAssets(dirs) {
+  try {
+    const stats = await stat(dirs.public);
+    if (stats.isDirectory()) {
+      await mkdir(dirs.buildDist, { recursive: true });
+      return await recursiveCopyAssets(dirs);
+    } else {
+      throw Error("./public cannot be a file");
     }
+  } catch (e) {
+    return null;
+  }
 }
-const IGNORE = platform() === 'darwin' ? ['.DS_Store'] : [];
-async function recursiveCopyAssets(build, dir = '') {
-    const copied = [];
-    const to = join(build.dirs.buildDist, dir);
-    let madeDir = dir === '';
-    const listingDir = join(build.dirs.public, dir);
-    for (const p of await readdir(listingDir)) {
-        if (IGNORE.includes(p)) {
-            continue;
-        }
-        try {
-            const stats = await stat(join(listingDir, p));
-            if (stats.isDirectory()) {
-                copied.push(...(await recursiveCopyAssets(build, join(dir, p))));
-            }
-            else {
-                if (!madeDir) {
-                    await mkdir(join(build.dirs.buildDist, dir), {
-                        recursive: true,
-                    });
-                    madeDir = true;
-                }
-                await copyFile(join(listingDir, p), join(to, p));
-                copied.push('/' + join(dir, p).replaceAll('\\', '/'));
-            }
-        }
-        catch (e) {
-            console.error('stat error', e);
-            process.exit(1);
+const IGNORE = platform() === "darwin" ? [".DS_Store"] : [];
+async function recursiveCopyAssets(dirs, dir = "") {
+  const copied = [];
+  const to = join(dirs.buildDist, dir);
+  let madeDir = dir === "";
+  const listingDir = join(dirs.public, dir);
+  for (const p of await readdir(listingDir)) {
+    if (IGNORE.includes(p)) {
+      continue;
+    }
+    try {
+      const stats = await stat(join(listingDir, p));
+      if (stats.isDirectory()) {
+        copied.push(...await recursiveCopyAssets(dirs, join(dir, p)));
+      } else {
+        if (!madeDir) {
+          await mkdir(join(dirs.buildDist, dir), {
+            recursive: true
+          });
+          madeDir = true;
         }
+        await copyFile(join(listingDir, p), join(to, p));
+        copied.push("/" + join(dir, p).replaceAll("\\", "/"));
+      }
+    } catch (e) {
+      console.error("stat error", e);
+      process.exit(1);
     }
-    return copied;
+  }
+  return copied;
 }
+export {
+  copyAssets
+};