@pajh/buldng 0.0.3 → 0.0.5

package/src/serve.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+// serve.js
+import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import { exec } from "node:child_process";
+import MIME from "./MIME.json" with { type: "json" };
+
+import {
+  createState,
+  initHotReload,
+  initDevErrors,
+  handleHttpRequest,
+  processArgs,
+  registerInject,
+  sanitiseRoot,
+  sanitisePort,
+  local,
+  ARGS
+} from "./serve-lib.js";
+
+// --------------------------------------------------
+// CONFIG + STATIC DATA
+// --------------------------------------------------
+
+const DEFAULT_PORT = 5173;
+const DEFAULT_ROOT = "dist";
+
+// --------------------------------------------------
+// HTML INJECTIONS
+// --------------------------------------------------
+
+function registerHtmlInjections(state) {
+
+  if (state.DEV_ERRORS) {
+    console.log("[dev-errors] creating injection for dev-errors.js");
+
+    // add mapping entry
+    state.MAPPINGS.push({
+      from: "/dev-errors.js",
+      to: "buldng://dev-errors.js",
+      type: "file"
+    });
+
+    registerInject(state, "html", "<!--POSTLAYOUT-->", `
+      <script type="module" src="/dev-errors.js"></script>
+    `, "post");
+  }
+
+  if (state.hotEnabled) {
+    registerInject(state, "html", "</head>", `
+      <script>
+        const es = new EventSource("/__hot");
+        es.onmessage = () => location.reload();
+      </script>
+    `, "pre");
+  }
+}
+
+
+// --------------------------------------------------
+// INITIALIZATION
+// --------------------------------------------------
+
+function init() {
+
+  processArgs();
+  let ROOT = ARGS.get("root");
+  let PORT = ARGS.get("port");
+
+  if (!ROOT) {
+    ROOT = DEFAULT_ROOT;
+    console.log(`[args] root: ${ROOT} (DEFAULT)`);
+  } else {
+    console.log(`[args] root: ${ROOT}`);
+  }
+
+  ROOT = sanitiseRoot(ROOT);
+
+  if (!PORT) {
+    PORT = DEFAULT_PORT;
+    console.log(`[args] port: ${PORT} (DEFAULT)`);
+  } else {
+    console.log(`[args] port: ${PORT}`);
+  }
+
+  PORT = sanitisePort(PORT);
+
+  const state = createState({
+    ROOT: ROOT,
+    PORT: PORT,
+    MAPPINGS: [],
+    MIME: MIME,
+    LOG_ALL: ARGS.get("log"),
+    HOT_REQUESTED: ARGS.get("hot"),
+    DEV_ERRORS: ARGS.get("dev-errors")
+  });
+
+  loadMappings(state);
+  initHotReload(state);
+  initDevErrors(state);
+  registerHtmlInjections(state);
+
+  return state;
+}
+
+function loadMappings(state) {
+  const mapPath = ARGS.get("map");
+
+  if (!mapPath) {
+    console.log("[map] OFF");
+    state.MAPPINGS = [];
+    return;
+  }
+
+  try {
+    const full = path.resolve(mapPath);
+    const json = JSON.parse(fs.readFileSync(full, "utf8"));
+    state.MAPPINGS = json;
+    console.log(`[map] ${full} (${json.length} rules)`);
+  } catch (err) {
+    console.log(`[map] FAILED to load ${mapPath}`);
+    process.exit(13);
+  }
+}
+
+
+// --------------------------------------------------
+// SERVE LOOP (VISIBLE SKELETON)
+// --------------------------------------------------
+
+function serve(state) {
+  const server = http.createServer((req, res) => {
+    // -----------------------------
+    // The bones of the loop stay here
+    // -----------------------------
+
+    state.running = true;
+
+    // 1. Receive request
+    const urlPath = req.url;
+
+    // 2. Delegate to serve-lib.js to produce a response object
+    const response = handleHttpRequest(urlPath, req, state);
+
+    // 3. Send response
+    response.send(res);
+  });
+
+  process.on("SIGTERM", () => {
+    // clean shutdown logic
+    server.close(() => {
+        process.exit(0);
+    });
+  });
+
+  // Optional graceful shutdown
+  process.on("SIGINT", () => {
+    teardown(state);
+    server.close(() => process.exit(0));
+  });
+
+  server.listen(state.PORT, () => {
+    console.log(`[serve] root: ${state.ROOT} at http://localhost:${state.PORT}`);
+    const browser = ARGS.get("browser");
+    if (browser)
+      exec(`${browser} http://localhost:${state.PORT}`);
+  });
+
+  return server;
+}
+
+// --------------------------------------------------
+// TEARDOWN
+// --------------------------------------------------
+
+function teardown(state) {
+  state.running = false;
+  console.log("Server shutting down.");
+}
+
+// --------------------------------------------------
+// MAIN
+// --------------------------------------------------
+
+function main() {
+  const state = init();
+  const server = serve(state);
+
+
+}
+
+main();

package/src/types/global.d.ts

@@ -0,0 +1,19 @@
+export {};
+
+declare global {
+  interface Window {
+    __ready: {
+      a: Promise<void>;
+      _resolveA: () => void;
+    };
+
+    __error_handler?: (
+      event: ErrorEvent | PromiseRejectionEvent,
+      page: string
+    ) => void;
+
+    __buldngErrorOverlay?: boolean;
+
+    __buldng_listenersInstalled?: boolean;
+  }
+}

package/{dist → src}/wrapper.html

@@ -13,6 +13,7 @@
     window.__ready.a = new Promise((resolve) => { window.__ready._resolveA = resolve; });
   </script>
   <script type="module" src="/layout.js"></script>
+  <!--POSTLAYOUT-->
   <!--SCRIPTS-->
 </head>
 <body>
@@ -20,5 +21,6 @@
       <!-- Project outline (camera-style) will be stitched here -->
       <!--CAMERA-STYLE-->
     </div>
+    <div id="b-modal-root"></div>
 </body>
 </html>

package/dist/buldng-lib.js

@@ -1,408 +0,0 @@
-// tools/build-lib.js
-import fs from "node:fs";
-import path from "node:path";
-import esbuild from "esbuild";
-
-
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import { readFileSync } from "node:fs";
-
-import { WorkFile } from "./workfile.js";
-import { getDest, setSource, setDest, assertDestWrite, assertSourceRead, getInputs, looksLikeFilename, looksLikeHTML, 
-  looksLikeCSS, looksLikeJS, ensureLeadingSlash, ensureWorkFile } from "./buldng-validate.js";
-import { file, literal, wrap, append, replace, compile, materialise}
- from "./buldng-ops.js";
-export { file, literal, wrap, append, replace, compile, materialise } 
-  from "./buldng-ops.js";
-export { assertSourceRead, assertDestWrite, setSource, setDest, looksLikeFilename, 
-         looksLikeHTML, looksLikeCSS, looksLikeJS, ensureWorkFile, ensureLeadingSlash } from "./buldng-validate.js";
-
-export default {
-  setSource,
-  setDest,
-  mkdir,
-  deepCopy,
-  file,
-  literal,
-  wrap,
-  append,
-  replace,
-  materialise,
-  compile,
-  csslink,
-  scriptlink,
-  pageHTML,
-  buldngHTMLWrapper,
-  reg,
-  printHeader
-};
-
-const here = dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(readFileSync(join(here, "../package.json"), "utf8"));
-const registry = new Map();
-
-export function reg(key, value) {
-  if (typeof key !== "string") {
-    throw new Error(`reg(): key must be a string`);
-  }
-  
-  const wf = ensureWorkFile(value, "reg");
-  
-  if (registry.has(key)) {
-    console.log(`reg(): overwriting existing key '${key}'`);
-  }
-  
-  registry.set(key, wf);
-  return wf;
-}
-
-let headerPrinted = false;
-export function printHeader(importMeta) {
-  if (headerPrinted) return;
-  headerPrinted = true;
-  
-  const version = pkg.version;
-  const timestamp = new Date().toLocaleString("en-IE", { hour12: false });
-  
-  const callerFile = fileURLToPath(importMeta.url);
-  const callerDir = dirname(callerFile);
-  
-  console.log(`*local* buldng build system v${version} — ${timestamp}`);
-  console.log(`${callerDir}/${callerFile.split("/").pop()}`);
-}
-
-export function csslink(input) {
-  const pre  = `<link rel="stylesheet" href="`;
-  const post = `">`;
-  
-  // --------------------------------------------------
-  // Case 1: string
-  // --------------------------------------------------
-  if (typeof input === "string") {
-    if (!input.endsWith(".css")) {
-      throw new Error(`csslink(): expected a .css filename, got '${input}'`);
-    }
-    
-    return new WorkFile(
-      "literal",
-      { value: pre + ensureLeadingSlash(input) + post },
-      [],
-      "csslink"
-    );
-  }
-  
-  // --------------------------------------------------
-  // Case 2: WorkFile
-  // --------------------------------------------------
-  if (input instanceof WorkFile) {
-    return new WorkFile(
-      "wrap",
-      { pre, post },
-      [input],
-      "csslink"
-    );
-  }
-  
-  throw new Error(`csslink(): expected string or WorkFile, got ${typeof input}`);
-}
-
-export function scriptlink(input) {
-  const pre  = `<script type="module" src="/`;
-  const post = `"></script>`;
-  
-  // --------------------------------------------------
-  // Case 1: string
-  // --------------------------------------------------
-  if (typeof input === "string") {
-    if (!input.endsWith(".js")) {
-      throw new Error(`scriptlink(): expected a .js filename, got '${input}'`);
-    }
-    
-    return new WorkFile(
-      "literal",
-      { value: pre + input + post },
-      [],
-      "scriptlink"
-    );
-  }
-  
-  // --------------------------------------------------
-  // Case 2: WorkFile
-  // --------------------------------------------------
-  if (input instanceof WorkFile) {
-    return new WorkFile(
-      "wrap",
-      { pre, post },
-      [input],
-      "scriptlink"
-    );
-  }
-  
-  throw new Error(`scriptlink(): expected string or WorkFile, got ${typeof input}`);
-}
-
-
-// --------------------------------------------------
-// mkdir("puzzle")
-// --------------------------------------------------
-export function mkdir(relDir) {
-  const abs = assertDestWrite(relDir);
-  fs.mkdirSync(abs, { recursive: true });
-}
-
-// --------------------------------------------------
-// deepCopy — raw filesystem path
-// --------------------------------------------------
-export function deepCopy(from, to) {
-  let DEST = getDest();
-  
-  console.log(`deepCopy: ${from} → ${to}`);
-  
-  const absFrom = path.resolve(from);
-  
-  if (to.includes("..")) {
-    throw new Error("SECURITY: Illegal path traversal in deepCopy()");
-  }
-  
-  const absTo = to === "/" ? DEST : path.resolve(DEST, to);
-  
-  if (!absTo.startsWith(DEST)) {
-    throw new Error(`SECURITY: deepCopy target escapes dest:
-      dest: ${DEST}
-      target: ${absTo}`);
-    }
-    
-    if (!fs.existsSync(absFrom)) {
-      throw new Error(`deepCopy: source does not exist: ${absFrom}`);
-    }
-    
-    function copyRecursive(src, dst) {
-      const stat = fs.statSync(src);
-      
-      if (stat.isDirectory()) {
-        fs.mkdirSync(dst, { recursive: true });
-        const entries = fs.readdirSync(src);
-        for (const entry of entries) {
-          copyRecursive(path.join(src, entry), path.join(dst, entry));
-        }
-      } else {
-        fs.mkdirSync(path.dirname(dst), { recursive: true });
-        fs.copyFileSync(src, dst);
-      }
-    }
-    
-    copyRecursive(absFrom, absTo);
-  }
-  
-  export function header() {
-    printHeader(import.meta);
-  }
-  
-  
-  function packageFileAbs(filename) {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    return join(__dirname, filename);
-  }
-  
-  // wraps whatever you provide in the overall buldng html wrapper.
-  // also compiles buldng's layout.ts and saves layout.js to the site root.
-  export function buldngHTMLWrapper(source) {
-    const srcWF = ensureWorkFile(source, "source");
-    
-    // 1. Compile buldng's layout.ts (lazy)
-    const layoutTS = new WorkFile("file", { absPath: packageFileAbs("layout.ts") }, []);
-    const layoutJS = compile(layoutTS);
-    
-    // 2. Save compiled layout.js to the site root (this triggers execution)
-    layoutJS.save("layout.js");
-    
-    // 2.5 Save camera.css to the site root (this triggers execution)
-    const buldngCSS = new WorkFile("file", { absPath: packageFileAbs("buldng.css") }, []);
-    buldngCSS.save("buldng.css");
-    
-    // 3. Wrap project shell in buldng's wrapper.html
-    const wrapperWF = new WorkFile("file", { absPath: packageFileAbs("wrapper.html") }, []);
-    return replace(wrapperWF, "<!--CAMERA-STYLE-->", srcWF);
-  }
-  
-
-  
-  const _warned = {
-    shell: false,
-    projectCSS: false
-  };
-  
-  export function pageHTML({ app, css = null, js = null, out }) {
-    if (!out || typeof out !== "string") {
-      throw new Error("pageHTML(): 'out' must be a non-empty string");
-    }
-    
-    if (!app) {
-      throw new Error("pageHTML(): 'app' is required and cannot be null");
-    }
-    
-    const appWF = ensureWorkFile(app, "app");
-    
-    // Look up optional registered assets
-    const shellWF = registry.get("shell") ?? null;
-    const projectCSS = registry.get("projectCSS") ?? null;
-    
-    // One-time warnings
-    if (!shellWF && !_warned.shell) {
-      console.warn(
-        "pageHTML(): no 'shell' registered — building raw page HTML.\n" +
-        "To register a shell use: reg('shell', file`layout/shell.html`)"
-      );
-      _warned.shell = true;
-    }
-    
-    if (!projectCSS && !_warned.projectCSS) {
-      console.warn(
-        "pageHTML(): no 'projectCSS' registered — page will not include project CSS.\n" +
-        "To register project CSS use: reg('projectCSS', file`layout/buldng.css`)"
-      );
-      _warned.projectCSS = true;
-    }
-    
-    // --------------------------------------------------
-    // Build HTML WorkFile lazily
-    // --------------------------------------------------
-    
-    let htmlWF;
-    
-    if (shellWF) {
-      htmlWF = replace(shellWF, "<!--APP-->", appWF);
-    } else {
-      htmlWF = appWF;
-    }
-    
-    // Insert JS lazily
-    if (js) {
-      const jsWF = resolveAsset(js, {
-        ext: ".js",
-        tag: "scriptlink",
-        wrap: scriptlink,
-        autoPrefix: "js"
-      });
-      htmlWF = replace(htmlWF, "<!--SCRIPTS-->", jsWF);
-    }
-    
-    // Insert CSS lazily (project first)
-    const cssWFs = [];
-    
-    if (projectCSS) {
-      cssWFs.push(resolveAsset(projectCSS, {
-        ext: ".css",
-        tag: "csslink",
-        wrap: csslink,
-        autoPrefix: "css"
-      }));
-      console.log(`${out}: has projectCSS`);
-    }
-    
-    if (css) {
-      cssWFs.push(resolveAsset(css, {
-        ext: ".css",
-        tag: "csslink",
-        wrap: csslink,
-        autoPrefix: "css"
-      }));
-      console.log(`${out}: has pageCSS`);
-    }
-    
-    if (cssWFs.length === 0) {
-      // No CSS at all → do nothing
-      // (This is allowed)
-    } else if (cssWFs.length === 1) {
-      // One CSS → inject directly
-      htmlWF = replace(htmlWF, "<!--CSS-->", cssWFs[0]);
-    } else {
-      // Two CSS → append them
-      const cssListWF = append(...cssWFs);
-      htmlWF = replace(htmlWF, "<!--CSS-->", cssListWF);
-    }
-    
-    // The ONLY public collapse operator
-    return htmlWF.save(out);
-  }
-  
-  let autoCounter = 1;
-  
-function resolveAsset(input, {
-  ext,        // ".css" or ".js"
-  tag,        // "csslink" or "jslink"
-  wrap,       // csslink() or stylelink()
-  autoPrefix  // "css" or "js"
-}) {
-  if (input == null) return null;
-
-  // Case 1: string
-  if (typeof input === "string") {
-    if (!input.endsWith(ext)) {
-      throw new Error(`pageHTML(${ext}): expected a ${ext} filename, got '${input}'`);
-    }
-    return wrap(input);
-  }
-
-  // Case 2: must be WorkFile
-  if (!(input instanceof WorkFile)) {
-    throw new Error(`pageHTML(${ext}): expected string or WorkFile, got ${typeof input}`);
-  }
-
-  // Case 3: already a link
-  if (input.tag === tag) {
-    return input;
-  }
-
-  // Case 4: literal WorkFile
-  if (input.op === "literal") {
-    const value = input.config.value;
-
-    if (value.endsWith(ext)) {
-      return wrap(input);
-    }
-
-    throw new Error(
-      `pageHTML(${ext}): literal WorkFile does not end in ${ext} → '${value}'`
-    );
-  }
-
-  // Case 5a: materialise WorkFile
-  if (input.op === "materialise") {
-    const target = input.config.target;
-
-    if (!target.endsWith(ext)) {
-      throw new Error(
-        `pageHTML(${ext}): materialise target '${target}' does not end in ${ext}`
-      );
-    }
-
-    return wrap(input);
-  }
-
-  // Case 5b: blob → auto-materialise
-  const autoName = `${autoPrefix}${autoCounter++}${ext}`;
-
-  console.warn(
-    `pageHTML(${ext}): received non-literal WorkFile; auto-materialising as ${autoName}`
-  );
-
-  const mat = materialise(input, autoName);
-  return wrap(mat);
-}
-
-  
-  // --------------------------------------------------
-  // build-inputs.json manifest
-  // --------------------------------------------------
-  process.on("exit", () => {
-    if (process.env.BULDNG_HOT !== "1") return;
-    let DEST = getDest();
-    let INPUTS = getInputs();
-    const manifest = Array.from(INPUTS);
-    const out = path.join(DEST, "build-inputs.json");
-    fs.writeFileSync(out, JSON.stringify(manifest, null, 2));
-  });
-  

package/dist/types/global.d.ts

@@ -1,10 +0,0 @@
-export {};
-
-declare global {
-  interface Window {
-    __ready: {
-      a: Promise<void>;
-      _resolveA: () => void;
-    };
-  }
-}