@pajh/buldng 0.0.4 → 0.0.5

package/src/serve-lib.js

@@ -0,0 +1,567 @@
+// serve-lib.js
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { exec, spawn } from "node:child_process";
+
+export const VALID_FLAGS = {
+  "log": { type: "boolean" },
+  "hot": { type: "boolean" },
+  "dev-errors": { type: "boolean" },
+  "map": { type: "value" },
+  "root": { type: "value" },
+  "port": { type: "value" },
+  "browser": { type: "value" }
+};
+
+// --------------------------------------------------
+// STATE CREATION
+// --------------------------------------------------
+
+export function createState({ ROOT, PORT, MAPPINGS, MIME, LOG_ALL, HOT_REQUESTED, DEV_ERRORS }) {
+  return {
+    ROOT,
+    PORT,
+    MAPPINGS,
+    MIME,
+    LOG_ALL,
+    HOT_REQUESTED,
+    DEV_ERRORS,
+    hotEnabled: false,
+    injections: { html: [] },
+    running: false,
+    sseClients: [],
+    watchers: []
+  };
+}
+
+// backing store for parsed arguments
+export const ARGS = new Map();
+
+// --------------------------------------------------
+// LOCAL PATH HELPER
+// --------------------------------------------------
+
+export const local = (strings, ...values) => {
+  const raw = strings.reduce((acc, str, i) => acc + str + (values[i] ?? ""), "");
+  const cleaned = raw.replace(/^\.?\//, "");
+  return `${process.cwd()}/${cleaned}`;
+};
+
+export function processArgs() {
+    const args = process.argv.slice(2);
+
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+
+        // must start with --
+        if (!a.startsWith("--")) {
+            console.error(`Unexpected argument: ${a}`);
+            process.exit(1);
+        }
+
+        const key = a.slice(2); // trim "--"
+        const next = (i < args.length -1) ? args[i+1] : "--dummy";
+            
+        if (next.startsWith("--")) { // flag
+          validated_set(key, true);
+        } else {
+          validated_set(key, next);
+          i++; // skip next
+        }
+    }
+}
+
+
+// returns the value or undefined
+export function arg(key) {
+    return ARGS.get(key);
+}
+function validated_set(key, value) {
+
+    // --------------------------------------------------
+    // internal sanity checks
+    // --------------------------------------------------
+    if (typeof key !== "string" || key.length === 0) {
+        console.error(`internal error: bad argmap key "${key}"`);
+        process.exit(1);
+    }
+
+    const isStringValue = (typeof value === "string" && value.length > 0);
+    const isTrueValue   = (value === true);
+
+    if (!isStringValue && !isTrueValue) {
+        console.error(`internal error: bad argmap value for "${key}": ${value}`);
+        process.exit(1);
+    }
+
+    const spec = VALID_FLAGS[key];
+    if (!spec) {
+        console.error(`[args] Unknown argument: --${key}`);
+        process.exit(1);
+    }
+
+    if (spec.type === "boolean") {
+        if (!isTrueValue) {
+            console.error(`[args] Cannot set a value for boolean flag --${key}`);
+            process.exit(1);
+        }
+        ARGS.set(key, true);
+        return;
+    }
+
+    if (spec.type === "value") {
+        if (!isStringValue) {
+            console.error(`[args] Usage: --${key} <value>`);
+            process.exit(1);
+        }
+        ARGS.set(key, value);
+        return;
+    }
+
+    console.error(`internal error: bad VALID_FLAGS entry for "${key}"`);
+    process.exit(1);
+}
+
+// --------------------------------------------------
+// INJECTION SYSTEM
+// --------------------------------------------------
+
+export function registerInject(state, type, marker, content, mode = "pre") {
+  if (!["pre", "post", "replace"].includes(mode)) {
+    throw new Error(`Unknown injection mode: ${mode}`);
+  }
+  state.injections[type] ??= [];
+  state.injections[type].push({ marker, content, mode });
+}
+
+function inject(block, injection) {
+  const { marker, content, mode } = injection;
+  switch (mode) {
+    case "replace": return block.replace(marker, content);
+    case "pre":     return block.replace(marker, content + marker);
+    case "post":    return block.replace(marker, marker + content);
+    default: throw new Error(`Unknown injection mode: ${mode}`);
+  }
+}
+
+function applyInjections(data, type, state) {
+  const list = state.injections[type];
+  if (!list || list.length === 0) return data;
+
+  let text = data.toString("utf8");
+  for (const inj of list) text = inject(text, inj);
+  return Buffer.from(text, "utf8");
+}
+
+export function sanitisePort(port) {
+    const n = Number(port);
+
+    if (!Number.isInteger(n)) {
+        console.error(`[args] port must be an integer: ${port}`);
+        process.exit(1);
+    }
+
+    if (n < 1 || n > 65535) {
+        console.error(`[args] port must be between 1 and 65535: ${port}`);
+        process.exit(1);
+    }
+
+    return n;
+}
+
+export function sanitiseRoot(root) {
+    // must be a non-empty string
+    if (typeof root !== "string" || root.trim() === "") {
+        console.error(`[args] root must be a non-empty string`);
+        process.exit(1);
+    }
+
+    // resolve relative paths from where the server was launched
+    const resolved = path.resolve(root);
+
+    // check existence
+    let stat;
+    try {
+        stat = fs.statSync(resolved);
+    } catch {
+        console.error(`[args] root directory does not exist: ${resolved}`);
+        process.exit(1);
+    }
+
+    // check it's a directory
+    if (!stat.isDirectory()) {
+        console.error(`[args] root is not a directory: ${resolved}`);
+        process.exit(1);
+    }
+
+    // check user can read it
+    try {
+        fs.accessSync(resolved, fs.constants.R_OK);
+    } catch {
+        console.error(`[args] root directory is not readable by current user: ${resolved}`);
+        process.exit(1);
+    }
+
+    return resolved;
+}
+
+
+// --------------------------------------------------
+// MAPPING SYSTEM — unified, minimal, correct
+// --------------------------------------------------
+
+function resolveMappedPath(urlPath, MAPPINGS) {
+
+  if (!MAPPINGS || MAPPINGS.length === 0) return null;
+
+  let to = null;
+
+  // 1. FILE MAPPING
+  const exact = MAPPINGS.find(m => m.type === "file" && urlPath === m.from);
+  if (exact) {
+    to = exact.to;
+  }
+
+  // 2. DIRECTORY MAPPING
+  if (!to) {
+    const dir = MAPPINGS.find(
+      m => m.type === "directory" &&
+           (urlPath === m.from || urlPath.startsWith(m.from + "/"))
+    );
+
+    if (dir) {
+      const relative = urlPath.slice(dir.from.length).replace(/^\/+/, "");
+      to = path.join(dir.to, relative);
+    }
+  }
+
+  // 3. NOT MAPPED
+  if (!to) return null;
+
+  // 4. SINGLE buldng:// interception point
+  if (to.startsWith("buldng://")) {
+    const filename = to.slice("buldng://".length);
+
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+
+    return path.join(__dirname, filename);
+  }
+
+  // 5. Normal project-relative mapping
+  return path.resolve(process.cwd(), to);
+}
+
+// --------------------------------------------------
+// New file resolving system.
+// --------------------------------------------------
+function stripSuffix(url) {
+  const match = url.match(/^[^?#]*/);
+  const base = match[0];
+  const suffix = url.slice(base.length); // includes ? or #
+  return { base, suffix };
+}
+
+function rawResolve(base, ROOT, MAPPINGS) {
+  const mapped = resolveMappedPath(base, MAPPINGS);
+
+  const abs = mapped
+    ? mapped
+    : path.join(ROOT, base);
+
+  if (!fs.existsSync(abs)) {
+    return { type: "missing", absPath: abs };
+  }
+
+  const stat = fs.statSync(abs);
+
+  if (stat.isFile()) return { type: "file", absPath: abs };
+  if (stat.isDirectory()) return { type: "dir", absPath: abs };
+
+  return { type: "missing", absPath: abs };
+}
+
+function resolve(url, ROOT, MAPPINGS) {
+  const { base, suffix } = stripSuffix(url);
+  const raw = rawResolve(base, ROOT, MAPPINGS);
+
+  // If URL explicitly asks for a directory, but rawResolve found a file,
+  // treat it as missing (forced directory → 404).
+  if (base.endsWith("/") && raw.type === "file") {
+    return {
+      type: "missing",
+      absPath: raw.absPath,
+      resolvedUrl: base + suffix
+    };
+  }
+
+  // 1. Exact file always wins
+  if (raw.type === "file") {
+    return {
+      type: "file",
+      absPath: raw.absPath,
+      resolvedUrl: base + suffix
+    };
+  }
+
+  // 2. Missing → 404 immediately
+  if (raw.type === "missing") {
+    return {
+      type: "missing",
+      absPath: raw.absPath,
+      resolvedUrl: base + suffix
+    };
+  }
+
+  // 3. Directory → try index.html
+  const indexPath = path.join(raw.absPath, "index.html");
+
+  if (fs.existsSync(indexPath) && fs.statSync(indexPath).isFile()) {
+    return {
+      type: "file",
+      absPath: indexPath,
+      resolvedUrl: base + "/index.html" + suffix
+    };
+  }
+
+  // 4. Directory but no index.html → 404
+  return {
+    type: "missing",
+    absPath: indexPath,
+    resolvedUrl: base + suffix
+  };
+}
+
+// --------------------------------------------------
+// HOT RELOAD SYSTEM
+// --------------------------------------------------
+
+function loadManifest(state) {
+  const manifestPath = path.join(state.ROOT, "build-inputs.json");
+  if (!fs.existsSync(manifestPath)) return null;
+
+  try {
+    const list = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    return Array.isArray(list) ? list : null;
+  } catch {
+    return null;
+  }
+}
+
+function stopWatching(state) {
+  for (const w of state.watchers) w.close();
+  state.watchers = [];
+}
+
+function startWatching(files, state) {
+  stopWatching(state);
+
+  state.watchers = files.map(f => {
+    try {
+      return fs.watch(f, () => {
+        console.log(`[hot] change detected in ${f}`);
+        stopWatching(state);
+        rebuild(state);
+      });
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+
+  return state.watchers.length;
+}
+
+function disableHot(state, reason) {
+  state.hotEnabled = false;
+  stopWatching(state);
+  console.warn(`[hot] disabled: ${reason}`);
+}
+
+function rebuild(state) {
+  if (!state.hotEnabled) return;
+
+  console.log("[hot] rebuilding…");
+  const child = spawn("npm", ["run", "build"], { stdio: "inherit" });
+
+  child.on("exit", (code) => {
+    if (code !== 0) {
+      disableHot(state, `build exited with code ${code}`);
+      return;
+    }
+
+    console.log("[hot] rebuild complete");
+    sendSSE(state, "reload");
+
+    const newFiles = loadManifest(state);
+    if (!newFiles) {
+      disableHot(state, "build-inputs.json missing after rebuild");
+      return;
+    }
+
+    const watched = startWatching(newFiles, state);
+    if (watched === 0) {
+      disableHot(state, "no files watchable");
+      return;
+    }
+
+    console.log(`[hot] active — watching ${watched} files`);
+  });
+}
+
+function sendSSE(state, msg) {
+  for (const res of state.sseClients) {
+    res.write(`data: ${msg}\n\n`);
+  }
+}
+
+export function initHotReload(state) {
+  if (!state.HOT_REQUESTED) {
+    console.log("[hot] off — pass --hot to enable");
+    return;
+  }
+
+  console.log("[hot] requested");
+  const files = loadManifest(state);
+  if (!files) {
+    console.warn("[hot] no build-inputs.json; disabled");
+    return;
+  }
+
+  const watched = startWatching(files, state);
+  if (watched === 0) {
+    console.warn("[hot] no watchable files; disabled");
+    return;
+  }
+
+  state.hotEnabled = true;
+  console.log(`[hot] active — watching ${watched} files`);
+}
+
+// --------------------------------------------------
+// DEV ERRORS
+// --------------------------------------------------
+
+export function initDevErrors(state) {
+  if (!state.DEV_ERRORS) {
+    console.log("[dev-errors] off");
+    return;
+  }
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+
+  const devErrorsFile = path.join(__dirname, "dev-errors.js");
+  if (fs.existsSync(devErrorsFile)) {
+    console.log("[dev-errors] active");
+  } else {
+    state.DEV_ERRORS = false;
+    console.warn("[dev-errors] disabled (requested but missing:", devErrorsFile, ")");
+  }
+}
+
+// --------------------------------------------------
+// REQUEST HANDLER (called from serve.js)
+// --------------------------------------------------
+
+export function handleHttpRequest(urlPath, req, state) {
+  // --------------------------------------------------
+  // HOT RELOAD (unchanged)
+  // --------------------------------------------------
+  if (state.hotEnabled && req.url === "/__hot") {
+    return {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      },
+      body: Buffer.from("\n"),
+      send(res) {
+        res.writeHead(this.status, this.headers);
+        res.write(this.body);
+        state.sseClients.push(res);
+        req.on("close", () => {
+          state.sseClients = state.sseClients.filter(r => r !== res);
+        });
+      }
+    };
+  }
+
+const { absPath, type, resolvedUrl } = resolve(urlPath, state.ROOT, state.MAPPINGS);
+
+// --------------------------------------------------
+// 404 BEFORE FILE READ
+// --------------------------------------------------
+if (type === "missing") {
+  if (state.LOG_ALL) {
+    console.log(`[serve](404) ${urlPath} -> ${absPath}`);
+  }
+
+  return {
+    status: 404,
+    headers: {},
+    body: Buffer.from("Not found"),
+    send(res) {
+      res.writeHead(this.status);
+      res.end(this.body);
+    }
+  };
+}
+
+// --------------------------------------------------
+// INTERNAL ERROR: resolve() MUST NOT RETURN DIR HERE
+// --------------------------------------------------
+if (type !== "file") {
+  console.error("INTERNAL ERROR: resolve() returned non-file type");
+  return {
+    status: 500,
+    headers: {},
+    body: Buffer.from("Internal server error"),
+    send(res) {
+      res.writeHead(this.status);
+      res.end(this.body);
+    }
+  };
+}
+
+// --------------------------------------------------
+// FILE READ (ONLY FOR type === file)
+// --------------------------------------------------
+try {
+  let data = fs.readFileSync(absPath);
+  const ext = path.extname(absPath);
+  const mime = state.MIME[ext] || "application/octet-stream";
+
+  data = applyInjections(data, ext.slice(1), state);
+
+  if (state.LOG_ALL) {
+    console.log(`[serve](200) ${urlPath} -> ${absPath}`);
+  }
+
+  return {
+    status: 200,
+    headers: { "Content-Type": mime },
+    body: data,
+    send(res) {
+      res.writeHead(this.status, this.headers);
+      res.end(this.body);
+    }
+  };
+
+} catch (err) {
+  console.error("FILE READ ERROR:", err);
+
+  return {
+    status: 500,
+    headers: {},
+    body: Buffer.from("Internal server error"),
+    send(res) {
+      res.writeHead(this.status);
+      res.end(this.body);
+    }
+  };
+}
+
+}
+
+