@dnax/serve 0.0.0-stage → 0.0.1

package/src/listing.ts

@@ -0,0 +1,173 @@
+import { readdir, stat } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+import type { Dirent, Stats } from "node:fs";
+
+export interface ListingOptions {
+  hidePermissions: boolean;
+  dotfiles: boolean;
+}
+
+const DIR_COLOR = "#a06a00";
+
+function escapeHtml(value: string): string {
+  return value
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+function permissions(mode: number, isDir: boolean): string {
+  let result = isDir ? "d" : "-";
+  for (const shift of [6, 3, 0]) {
+    const bits = (mode >> shift) & 7;
+    result += bits & 4 ? "r" : "-";
+    result += bits & 2 ? "w" : "-";
+    result += bits & 1 ? "x" : "-";
+  }
+  return result;
+}
+
+function formatSize(size: number, isDir: boolean): string {
+  if (isDir) return "";
+  if (size < 1024) return `${size}B`;
+  const units = ["k", "M", "G", "T", "P", "E"];
+  let value = size;
+  let unit = -1;
+  do {
+    value /= 1024;
+    unit += 1;
+  } while (value >= 1024 && unit < units.length - 1);
+  return `${value.toFixed(1)}${units[unit] ?? "?"}`;
+}
+
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+
+function formatDate(date: Date): string {
+  const day = String(date.getDate()).padStart(2, "0");
+  const month = MONTHS[date.getMonth()] ?? "???";
+  const year = date.getFullYear();
+  const hour = String(date.getHours()).padStart(2, "0");
+  const minute = String(date.getMinutes()).padStart(2, "0");
+  return `${day}-${month}-${year} ${hour}:${minute}`;
+}
+
+interface ListingEntry {
+  name: string;
+  isDirectory: boolean;
+  stats?: Stats;
+}
+
+function sortEntries(entries: ListingEntry[]): ListingEntry[] {
+  const collator = new Intl.Collator();
+  return entries.sort((a, b) => {
+    if (a.isDirectory !== b.isDirectory) return a.isDirectory ? -1 : 1;
+    return collator.compare(a.name, b.name);
+  });
+}
+
+async function statOrUndefined(path: string): Promise<Stats | undefined> {
+  try {
+    return await stat(path);
+  } catch {
+    return undefined;
+  }
+}
+
+const STYLE = `
+  body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; margin: 2rem; color: #222; }
+  h1 { font-size: 1.25rem; font-weight: 600; margin-bottom: 1rem; }
+  table { border-collapse: collapse; font-size: 0.875rem; width: 100%; max-width: 64rem; }
+  th { text-align: left; font-weight: 600; border-bottom: 1px solid #ddd; padding: 0.25rem 0.75rem 0.25rem 0; }
+  td { white-space: nowrap; padding: 0.15rem 0.75rem 0.15rem 0; }
+  td.size { text-align: right; }
+  td.perms { color: #777; }
+  a { color: #0b5fff; text-decoration: none; }
+  a:hover { text-decoration: underline; }
+  tr.dir a { color: ${DIR_COLOR}; font-weight: 500; }
+  address { margin-top: 1.5rem; color: #888; font-size: 0.8125rem; font-style: normal; }
+`.trim();
+
+export async function renderDirectoryListing(
+  dir: string,
+  root: string,
+  urlPath: string,
+  host: string,
+  options: ListingOptions,
+): Promise<string> {
+  const entries: ListingEntry[] = [];
+
+  let dirents: Dirent[] = [];
+  try {
+    dirents = await readdir(dir, { withFileTypes: true });
+  } catch {
+    dirents = [];
+  }
+
+  for (const dirent of dirents) {
+    if (!options.dotfiles && dirent.name.startsWith(".")) continue;
+    const stats = await statOrUndefined(join(dir, dirent.name));
+    entries.push({
+      name: dirent.name,
+      isDirectory: stats ? stats.isDirectory() : dirent.isDirectory(),
+      stats,
+    });
+  }
+
+  if (relative(root, dir) !== "") {
+    const stats = await statOrUndefined(dirname(dir));
+    entries.push({ name: "..", isDirectory: true, stats });
+  }
+
+  sortEntries(entries);
+
+  const rows = entries.map((entry) => {
+    const stats = entry.stats;
+    const displayName = escapeHtml(entry.name) + (entry.isDirectory ? "/" : "");
+    let href = `./${encodeURIComponent(entry.name)}`;
+    if (entry.isDirectory && entry.name !== "..") href += "/";
+    const perms = stats && !options.hidePermissions ? `<code>(${permissions(stats.mode, entry.isDirectory)})</code>` : "";
+    const modified = stats ? formatDate(stats.mtime) : "???";
+    const size = stats ? formatSize(stats.size, entry.isDirectory) : "???";
+    return (
+      `<tr class="${entry.isDirectory ? "dir" : "file"}">` +
+      `<td class="perms">${perms}</td>` +
+      `<td class="modified">${modified}</td>` +
+      `<td class="size"><code>${size}</code></td>` +
+      `<td class="name"><a href="${href}">${displayName}</a></td>` +
+      `</tr>`
+    );
+  });
+
+  const title = `Index of ${escapeHtml(urlPath)}`;
+
+  return [
+    "<!doctype html>",
+    '<html lang="en">',
+    "<head>",
+    '  <meta charset="utf-8">',
+    '  <meta name="viewport" content="width=device-width, initial-scale=1">',
+    `  <title>${title}</title>`,
+    `  <style>${STYLE}</style>`,
+    "</head>",
+    "<body>",
+    `<h1>${title}</h1>`,
+    "<table>",
+    '<thead><tr><th></th><th>Last modified</th><th>Size</th><th>Name</th></tr></thead>',
+    "<tbody>",
+    ...rows,
+    "</tbody>",
+    "</table>",
+    `<address>dnx running @ ${escapeHtml(host)}</address>`,
+    "</body>",
+    "</html>",
+    "",
+  ].join("\n");
+}
+
+export function isDotfilePath(relativePath: string): boolean {
+  return relativePath
+    .split(sep)
+    .some((segment) => segment !== "." && segment !== ".." && segment.startsWith("."));
+}

package/src/mime.ts

@@ -0,0 +1,154 @@
+import { extname } from "node:path";
+
+const MIME: Readonly<Record<string, string>> = {
+  html: "text/html",
+  htm: "text/html",
+  xhtml: "application/xhtml+xml",
+  css: "text/css",
+  js: "text/javascript",
+  mjs: "text/javascript",
+  cjs: "text/javascript",
+  json: "application/json",
+  map: "application/json",
+  jsonld: "application/ld+json",
+  xml: "application/xml",
+  txt: "text/plain",
+  text: "text/plain",
+  md: "text/markdown",
+  markdown: "text/markdown",
+  csv: "text/csv",
+  tsv: "text/tab-separated-values",
+  yaml: "text/yaml",
+  yml: "text/yaml",
+  toml: "application/toml",
+  ini: "text/plain",
+  sh: "text/x-sh",
+  bash: "text/x-sh",
+  ts: "video/mp2t",
+  pdf: "application/pdf",
+  rtf: "application/rtf",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  odt: "application/vnd.oasis.opendocument.text",
+  ods: "application/vnd.oasis.opendocument.spreadsheet",
+  odp: "application/vnd.oasis.opendocument.presentation",
+  epub: "application/epub+zip",
+  zip: "application/zip",
+  gz: "application/gzip",
+  tar: "application/x-tar",
+  rar: "application/vnd.rar",
+  "7z": "application/x-7z-compressed",
+  bz2: "application/x-bzip2",
+  xz: "application/x-xz",
+  wasm: "application/wasm",
+  bin: "application/octet-stream",
+  exe: "application/octet-stream",
+  dmg: "application/octet-stream",
+  iso: "application/octet-stream",
+  svg: "image/svg+xml",
+  svgz: "image/svg+xml",
+  png: "image/png",
+  apng: "image/apng",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  jpe: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  ico: "image/x-icon",
+  bmp: "image/bmp",
+  tif: "image/tiff",
+  tiff: "image/tiff",
+  heic: "image/heic",
+  heif: "image/heif",
+  jxl: "image/jxl",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  eot: "application/vnd.ms-fontobject",
+  mp3: "audio/mpeg",
+  m4a: "audio/mp4",
+  aac: "audio/aac",
+  wav: "audio/wav",
+  oga: "audio/ogg",
+  ogg: "audio/ogg",
+  opus: "audio/ogg",
+  flac: "audio/flac",
+  weba: "audio/webm",
+  mid: "audio/midi",
+  midi: "audio/midi",
+  mp4: "video/mp4",
+  m4v: "video/mp4",
+  mpeg: "video/mpeg",
+  mpg: "video/mpeg",
+  mov: "video/quicktime",
+  webm: "video/webm",
+  ogv: "video/ogg",
+  avi: "video/x-msvideo",
+  mkv: "video/x-matroska",
+  m3u8: "application/vnd.apple.mpegurl",
+  webmanifest: "application/manifest+json",
+  manifest: "application/manifest+json",
+  appcache: "text/cache-manifest",
+  vtt: "text/vtt",
+  srt: "application/x-subrip",
+  ipynb: "application/x-ipynb+json",
+  sql: "application/sql",
+  rss: "application/rss+xml",
+  atom: "application/atom+xml",
+};
+
+export type MimeOverrides = Readonly<Record<string, string>>;
+
+export function lookupMime(filePath: string, overrides?: MimeOverrides): string {
+  const ext = extname(filePath).slice(1).toLowerCase();
+  return overrides?.[ext] ?? MIME[ext] ?? "application/octet-stream";
+}
+
+export function withCharset(type: string): string {
+  if (/;\s*charset=/i.test(type)) return type;
+  if (
+    type.startsWith("text/") ||
+    type === "application/json" ||
+    type === "application/xml" ||
+    type === "application/xhtml+xml" ||
+    type === "application/manifest+json" ||
+    type === "application/rss+xml" ||
+    type === "application/atom+xml" ||
+    type === "image/svg+xml"
+  ) {
+    return `${type}; charset=utf-8`;
+  }
+  return type;
+}
+
+export function parseMimeTypes(input: string): MimeOverrides {
+  const text = input.trim();
+  if (text.startsWith("{")) {
+    const parsed = JSON.parse(text) as Record<string, unknown>;
+    const result: Record<string, string> = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      if (Array.isArray(value)) {
+        for (const ext of value) result[String(ext).replace(/^\./, "").toLowerCase()] = key;
+      } else if (typeof value === "string") {
+        result[key.replace(/^\./, "").toLowerCase()] = value;
+      }
+    }
+    return result;
+  }
+
+  const result: Record<string, string> = {};
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.replace(/#.*/, "").trim();
+    if (!line) continue;
+    const [type, ...exts] = line.split(/\s+/);
+    if (!type) continue;
+    for (const ext of exts) result[ext.replace(/^\./, "").toLowerCase()] = type;
+  }
+  return result;
+}