nodality 1.0.161 → 1.0.163

package/bin/nodality.js

@@ -47,14 +47,88 @@ Prerender flags (all optional; fall through to nodality.config.json, then defaul
   --tolerate-async          Install uncaught/unhandledRejection handlers so a single page's
                             late throw (from a deferred animation/fetch timer) doesn't abort
                             the whole batch — useful for sites with span-animation entries.
+  --verbose                 Print every console.log() emitted by the library during render.
+                            Default is quiet — only progress lines, page sizes, and the
+                            final summary are shown. Use this when debugging.
 
 Examples:
   nodality prerender
   nodality prerender --origin=https://example.com --tolerate-async
+  nodality prerender --verbose
 `);
   process.exit(1);
 }
 
+/**
+ * Install a stdout filter that hides the library's internal debug
+ * chatter (OGA, MBO, BRIS, APPENDED-, 0P, TAGS SET, date stamps, raw
+ * object dumps, "Appending brand:" lines, etc.) during prerender.
+ * Progress banners from `prerenderSite` (page-name lines, `→ … KB`,
+ * `✅ Prerender done`) and our own `[nodality] …` banner pass through
+ * unmodified.
+ *
+ * Bypassed with --verbose (or NODALITY_VERBOSE=1) when you need the
+ * full chatter to debug a render that silently goes wrong.
+ *
+ * We hook process.stdout.write (not console.log) because the library
+ * has 100+ scattered console.log calls across 30 files, AND because
+ * jsdom's virtual console forwards differently than expected, AND
+ * because some output uses process.stdout.write directly. Filtering
+ * at the byte stream catches every path uniformly.
+ */
+function installLogFilter() {
+  const origWrite = process.stdout.write.bind(process.stdout);
+
+  // Strict whitelist: only lines matching one of these patterns
+  // survive. Everything else (dev markers, object dumps, stack traces
+  // from page scripts, HTML fragments leaking out of jsdom, media-
+  // query strings, date stamps, …) is dropped.
+  const ALLOW = [
+    /^\[nodality\]/,                       // our CLI banner
+    /^🌍/,                                  // prerenderSite progress banner
+    /^✅/, /^❌/, /^⚠/,                       // status emojis
+    /^── /,                                 // locale separators
+    /^  [a-z0-9\-]+\.html\s/,              // page progress: "  index.html ..."
+    /^→ /,                                  // result lines
+    /^$/,                                   // blank lines (preserve spacing)
+  ];
+
+  function shouldDropLine(line) {
+    for (const rx of ALLOW) if (rx.test(line)) return false;
+    return true;
+  }
+
+  // Buffer partial lines so we can decide on line boundaries.
+  let buf = "";
+
+  process.stdout.write = function (chunk, encoding, cb) {
+    const s = typeof chunk === "string" ? chunk : chunk?.toString?.(encoding || "utf8") ?? "";
+    buf += s;
+
+    let out = "";
+    let nl;
+    while ((nl = buf.indexOf("\n")) !== -1) {
+      const line = buf.slice(0, nl);
+      buf = buf.slice(nl + 1);
+      if (!shouldDropLine(line)) out += line + "\n";
+    }
+
+    // A trailing buffer with no newline is a progress write like
+    // `  index.html             ` from prerender-site.js. Pass it
+    // through so the user sees progress before the line completes.
+    // We only do this when the buffered fragment passes the page-
+    // progress check; otherwise hold until newline.
+    if (buf && /^  [a-z0-9\-]+\.html\s/.test(buf)) {
+      out += buf;
+      buf = "";
+    }
+
+    if (out) origWrite(out, encoding, cb);
+    else if (cb) cb();
+    return true;
+  };
+}
+
 // ─── Flag parsing — minimal, no deps ────────────────────────────
 
 function parseFlags(argv) {
@@ -81,6 +155,90 @@ function loadConfigFile(cwd) {
   }
 }
 
+// ─── SSG bootstrap ──────────────────────────────────────────────
+
+/**
+ * On first run, derive the upload/ structure from the project's root
+ * files so a freshly scaffolded project can prerender without manual
+ * setup. For each `src/<name>.js` we generate `upload/pages/<name>.js`
+ * (verbatim copy) and an `upload/<name>.html` whose importmap points
+ * at `./lib.bundle.js` and whose `<script src>` points at the page
+ * entry. The first src file (alphabetically) is also written as
+ * `upload/index.html` when no explicit index entry exists, so the
+ * dev server has a default landing page.
+ *
+ * If the user has already populated upload/ themselves, we touch
+ * nothing. Bootstrap only runs when upload/ is missing OR contains
+ * no .html files.
+ */
+function bootstrapUpload(cwd, uploadDir) {
+  const srcDir = path.join(cwd, "src");
+  if (!fs.existsSync(srcDir)) return false;
+
+  const srcFiles = fs.readdirSync(srcDir).filter((f) => f.endsWith(".js"));
+  if (srcFiles.length === 0) return false;
+
+  fs.mkdirSync(uploadDir, { recursive: true });
+  const pagesDir = path.join(uploadDir, "pages");
+  fs.mkdirSync(pagesDir, { recursive: true });
+
+  const projectName = path.basename(cwd);
+  let wrote = 0;
+  for (const srcFile of srcFiles) {
+    const base = path.basename(srcFile, ".js");
+    // Convention: src/app.js → upload/index.html + upload/pages/index.js.
+    // All others: src/<name>.js → upload/<name>.html + upload/pages/<name>.js.
+    const pageName = base === "app" ? "index" : base;
+
+    const entryPath = path.join(pagesDir, `${pageName}.js`);
+    if (!fs.existsSync(entryPath)) {
+      fs.copyFileSync(path.join(srcDir, srcFile), entryPath);
+      wrote++;
+    }
+
+    const htmlPath = path.join(uploadDir, `${pageName}.html`);
+    if (!fs.existsSync(htmlPath)) {
+      fs.writeFileSync(htmlPath, renderUploadHtml(projectName, pageName));
+      wrote++;
+    }
+  }
+
+  if (wrote > 0) {
+    console.log(`[nodality] Bootstrapped upload/ from src/ (${wrote} file(s) written)`);
+  }
+
+  if (!fs.existsSync(path.join(uploadDir, "lib.bundle.js"))) {
+    console.warn(
+      `[nodality] ⚠ upload/lib.bundle.js missing — run \`npm run build\` first ` +
+        `so the prerendered HTML can load the library bundle at runtime.`,
+    );
+  }
+  return true;
+}
+
+function renderUploadHtml(projectName, pageName) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${projectName}</title>
+  <script type="importmap">
+  {
+    "imports": {
+      "nodality": "./lib.bundle.js"
+    }
+  }
+  </script>
+</head>
+<body>
+  <div id="mount"></div>
+  <script type="module" src="./pages/${pageName}.js"></script>
+</body>
+</html>
+`;
+}
+
 // ─── Page auto-discovery ────────────────────────────────────────
 
 /**
@@ -145,6 +303,18 @@ async function runPrerender(rawArgs) {
     flags["tolerate-async"] === "true" ||
     fileConfig.tolerateAsyncErrors === true;
 
+  // Quiet by default; --verbose or NODALITY_VERBOSE=1 turns the
+  // library's internal chatter back on. Only install the filter once
+  // (the multi-locale fanout re-enters this function in the parent
+  // process for the no-locales path, but on the child path
+  // NODALITY_SSG_LOCALE is set and we still want the filter on).
+  const verbose =
+    flags.verbose === true ||
+    flags.verbose === "true" ||
+    process.env.NODALITY_VERBOSE === "1" ||
+    fileConfig.verbose === true;
+  if (!verbose) installLogFilter();
+
   if (!origin) {
     console.error(`[nodality] --origin not given and no "origin" in nodality.config.json.`);
     process.exit(1);
@@ -165,6 +335,16 @@ async function runPrerender(rawArgs) {
     );
   }
 
+  // First-run bootstrap: if upload/ is missing or has no HTML pages
+  // yet, derive it from the project's src/ + root index.html. This is
+  // what create-nodality projects rely on so the scaffolder doesn't
+  // have to ship duplicate copies of source files. No-op if upload/
+  // is already populated.
+  const needsBootstrap =
+    !fs.existsSync(uploadDir) ||
+    fs.readdirSync(uploadDir).filter((f) => f.endsWith(".html")).length === 0;
+  if (needsBootstrap) bootstrapUpload(cwd, uploadDir);
+
   // Explicit `pages` from config wins over auto-discovery. The
   // discovery rules (pages/<base>.js, <base>.js) can't infer
   // irregular pairs like h7-nodality's `index.html → app.js`; for