@zvndev/darkmown 1.5.0 → 2.0.0

package/src/compiler/body.js

@@ -82,9 +82,9 @@ export function compileBody(lines, ctx) {
     }
     if (/^@loop\s/.test(line)) {
       flush();
-      const block = scanBlock(lines, i, /^@loop\s/, "@endloop", ctx.file);
+      const block = scanBlock(lines, i, /^@loop\s/, "@endloop", ctx);
       const split = splitEmptyBranch(block.body);
-      out.push(handleLoop(line, split.body, split.empty, ctx));
+      out.push(handleLoop(line, split.body, split.empty, ctx, i, split.emptyStart));
       i = block.end;
       continue;
     }
@@ -93,7 +93,7 @@ export function compileBody(lines, ctx) {
       flush();
       if (!container[1].trim())
         throw new Error(`Stray ::: close with no open container in ${ctx.file}`);
-      const block = scanContainer(lines, i, ctx.file);
+      const block = scanContainer(lines, i, ctx);
       out.push(handleContainer(container[1].trim(), block.body, ctx, i));
       i = block.end;
       continue;
@@ -152,14 +152,14 @@ export function compileBody(lines, ctx) {
     }
     if (/^:form\s/.test(line)) {
       flush();
-      const block = scanBlock(lines, i, /^:form\s/, ":endform", ctx.file);
+      const block = scanBlock(lines, i, /^:form\s/, ":endform", ctx);
       out.push(handleForm(line, block.body, ctx, i));
       i = block.end;
       continue;
     }
     if (/^:carousel(?:\s|$)/.test(line)) {
       flush();
-      const block = scanBlock(lines, i, /^:carousel(?:\s|$)/, ":endcarousel", ctx.file);
+      const block = scanBlock(lines, i, /^:carousel(?:\s|$)/, ":endcarousel", ctx);
       out.push(handleCarousel(line, block.body, ctx, i));
       i = block.end;
       continue;
@@ -223,8 +223,8 @@ export function compileBody(lines, ctx) {
     }
     if (/^:if\s/.test(line)) {
       flush();
-      const block = scanConditional(lines, i, ctx.file);
-      out.push(handleIf(line, block.truthy, block.falsy, ctx, i));
+      const block = scanConditional(lines, i, ctx);
+      out.push(handleIf(line, block.truthy, block.falsy, ctx, i, block.falsyStart));
       i = block.end;
       continue;
     }
@@ -342,10 +342,10 @@ function joinValueDirective(lines, start) {
  * @param {number} start Index of the opening line.
  * @param {RegExp} openRe Pattern that re-opens a nested block.
  * @param {string} endToken Literal closing token (e.g. `@endloop`).
- * @param {string} file Source path for errors.
+ * @param {Ctx} ctx Compile context, for `file:line` errors.
  * @returns {{ body: string[], end: number }}
  */
-function scanBlock(lines, start, openRe, endToken, file) {
+function scanBlock(lines, start, openRe, endToken, ctx) {
   /** @type {string[]} */
   const body = [];
   let depth = 0;
@@ -371,25 +371,29 @@ function scanBlock(lines, start, openRe, endToken, file) {
     }
     body.push(line);
   }
-  throw new Error(`Missing ${endToken} for "${lines[start]}" in ${at(file, start)}`);
+  throw new Error(`Missing ${endToken} for "${lines[start]}" in ${at(ctx, start)}`);
 }
 
 /**
  * Split a `@loop` body at a top-level `@empty` into the rows body and the empty
  * branch. Honors nested `@loop … @endloop` (so an inner loop's `@empty` is not
- * mistaken for the outer one) and fenced code.
+ * mistaken for the outer one) and fenced code. `emptyStart` is the index within
+ * `body` the empty branch starts at (the line after `@empty`), so nested errors
+ * in that branch still report the true file line.
  * @param {string[]} body
- * @returns {{ body: string[], empty: string[] | null }}
+ * @returns {{ body: string[], empty: string[] | null, emptyStart: number }}
  */
 function splitEmptyBranch(body) {
   /** @type {string[]} */
   const rows = [];
   /** @type {string[] | null} */
   let empty = null;
+  let emptyStart = 0;
   let target = rows;
   let depth = 0;
   let fence = null;
-  for (const line of body) {
+  for (let i = 0; i < body.length; i++) {
+    const line = body[i];
     const fenceMatch = line.match(/^(```+|~~~+)/);
     if (fence) {
       if (fenceMatch && fenceMatch[1][0] === fence[0] && fenceMatch[1].length >= fence.length)
@@ -406,22 +410,23 @@ function splitEmptyBranch(body) {
     if (line.trim() === "@endloop") depth--;
     if (depth === 0 && line.trim() === "@empty") {
       empty = [];
+      emptyStart = i + 1;
       target = empty;
       continue;
     }
     target.push(line);
   }
-  return { body: rows, empty };
+  return { body: rows, empty, emptyStart };
 }
 
 /**
  * Capture the body of a `:::` container up to its matching close, honoring nesting.
  * @param {string[]} lines
  * @param {number} start Index of the opening line.
- * @param {string} file Source path for errors.
+ * @param {Ctx} ctx Compile context, for `file:line` errors.
  * @returns {{ body: string[], end: number }}
  */
-function scanContainer(lines, start, file) {
+function scanContainer(lines, start, ctx) {
   /** @type {string[]} */
   const body = [];
   let depth = 0;
@@ -452,7 +457,7 @@ function scanContainer(lines, start, file) {
     }
     body.push(line);
   }
-  throw new Error(`Missing closing ::: for "${lines[start]}" in ${at(file, start)}`);
+  throw new Error(`Missing closing ::: for "${lines[start]}" in ${at(ctx, start)}`);
 }
 
 /**
@@ -463,16 +468,21 @@ function scanContainer(lines, start, file) {
  * `compileBody`/`handleIf` recursively. A whole `:if/:else if/:else` chain
  * therefore compiles to nested `data-wd-if` regions the runtime already drives —
  * identical behavior for static, reactive, and loop-row conditionals.
+ *
+ * `falsyStart` is the index within `lines` the falsy body starts at — the line
+ * after a bare `:else`, or the `:else if` line itself (its synthesized `:if`
+ * stands in for it) — so nested errors in that branch report the true file line.
  * @param {string[]} lines
  * @param {number} start Index of the `:if` line.
- * @param {string} file Source path for errors.
- * @returns {{ truthy: string[], falsy: string[], end: number }}
+ * @param {Ctx} ctx Compile context, for `file:line` errors.
+ * @returns {{ truthy: string[], falsy: string[], end: number, falsyStart: number }}
  */
-function scanConditional(lines, start, file) {
+function scanConditional(lines, start, ctx) {
   /** @type {string[]} */
   const truthy = [];
   /** @type {string[]} */
   const falsy = [];
+  let falsyStart = start + 1;
   let current = truthy;
   // "truthy": collecting the :if body. "else": a bare :else closed the chain —
   // no further branches allowed. "elseif": the first :else if was desugared into
@@ -499,7 +509,7 @@ function scanConditional(lines, start, file) {
     if (line.trim() === ":endif") {
       if (depth === 0) {
         if (mode === "elseif") falsy.push(":endif"); // close the synthesized nested :if
-        return { truthy, falsy, end: i };
+        return { truthy, falsy, end: i, falsyStart };
       }
       depth--;
     }
@@ -509,9 +519,10 @@ function scanConditional(lines, start, file) {
       if (elseIf) {
         if (mode === "else")
           throw new Error(
-            `":else if" after ":else" in ${file}. ":else" must be the last branch — order the "else if" conditions before the bare ":else".`
+            `":else if" after ":else" in ${ctx.file}. ":else" must be the last branch — order the "else if" conditions before the bare ":else".`
           );
         falsy.push(`:if ${elseIf[1]}`); // desugar the chain tail into a nested :if
+        falsyStart = i;
         current = falsy;
         mode = "elseif";
         continue;
@@ -519,8 +530,9 @@ function scanConditional(lines, start, file) {
       if (t === ":else") {
         if (mode === "else")
           throw new Error(
-            `Duplicate ":else" in ${file}. A conditional may have only one bare ":else".`
+            `Duplicate ":else" in ${ctx.file}. A conditional may have only one bare ":else".`
           );
+        falsyStart = i + 1;
         current = falsy;
         mode = "else";
         continue;
@@ -528,5 +540,5 @@ function scanConditional(lines, start, file) {
     }
     current.push(line);
   }
-  throw new Error(`Missing :endif for "${lines[start]}" in ${at(file, start)}`);
+  throw new Error(`Missing :endif for "${lines[start]}" in ${at(ctx, start)}`);
 }

package/src/compiler/context.js

@@ -58,14 +58,25 @@
  * @property {Assets} assets
  * @property {Map<string, unknown>} state Declared state keys → initial values.
  * @property {Set<string>} stores Page-global store names (a subset of state keys).
+ * @property {Set<string>} fetchKeys Base state keys declared by `:fetch`, so
+ *   bare `:if <key>_loading` / `:if <key>_error` regions get compile-time
+ *   `role`/`aria-live` announcements.
  * @property {string[]} warnings Non-fatal authoring hints.
  * @property {number} sectionCounter Counter for auto-generated section ids.
+ * @property {Map<string, number>} headingSlugs Heading-slug occurrence counts,
+ *   shared across prose chunks and includes so anchor ids dedupe document-wide.
  * @property {Map<string, import("./collections.js").CollectionRow[]>} collections
  *   Collection name → entry rows, built from the router's routes and threaded in
  *   so a bare-name `@loop blog into post` resolves to its entries at build time.
  * @property {import("./context.js").Pagination | null} pagination The pagination
  *   intent a `@loop … paginate N` recorded this compile, or null. The builder
  *   reads it to multiply routes; one paginated loop per page is supported.
+ * @property {Set<string>} deps Absolute paths of every source file this compile
+ *   read: the page itself, every `@include` target, and every `@loop` JSON data
+ *   file. The dev builder unions these (plus colocated assets) into the per-route
+ *   dependency map that drives incremental rebuilds.
+ * @property {Set<string>} collectionsUsed Names of the collections this compile
+ *   looped, so a change to any entry of a collection rebuilds its consumers.
  */
 
 /**
@@ -79,6 +90,11 @@
  * Per-file compile context threaded through the directive handlers.
  * @typedef {object} Ctx
  * @property {string} file Absolute path to the file being compiled.
+ * @property {number} [bodyLine] 0-based file line the compiled body starts on
+ *   (the frontmatter offset), so `at` reports true file line numbers.
+ * @property {number} [lineOffset] 0-based body line the current `compileBody`
+ *   slice starts on. Block handlers recurse with {@link nestedCtx}, so a line
+ *   index inside a nested block body still maps to the true file line.
  * @property {Paths} context Resolved project paths.
  * @property {string[]} stack Include stack (real paths) for cycle detection.
  * @property {Scope} scope Static value scope chain.
@@ -88,6 +104,13 @@
  * @property {string} [loopKey] State key of the list being looped, if any.
  * @property {boolean} [loopMeta] Inside a loop body, so `$index`/`$first`/… are valid.
  * @property {import("markdown-it").default} [md] Markdown-it instance selected for this file.
+ * @property {(lines: string[], ctx: Ctx) => string} compileBody The body
+ *   dispatcher, threaded through the context so block handlers (`:if`, `:::`,
+ *   `:form`, `@loop`, …) recurse into nested bodies without importing the
+ *   dispatcher back — the module graph stays an import-cycle-free DAG.
+ * @property {(file: string, context: Paths, stack: string[], scope: Scope, comp: Compilation, sections: string[], loopItem: string | null) => { meta: Meta, html: string }} compileFile
+ *   The per-file compile, threaded for the same reason so `@include` can
+ *   compile its target file.
  */
 
 /**
@@ -99,6 +122,8 @@
  * @property {string[]} warnings
  * @property {Pagination | null} pagination The pagination intent a paginated
  *   `@loop` recorded, or null. The builder reads it to multiply routes.
+ * @property {Set<string>} deps Absolute source-file dependencies of this compile.
+ * @property {Set<string>} collectionsUsed Collection names this compile looped.
  */
 
 /**
@@ -110,6 +135,8 @@
  * @property {string[]} warnings
  * @property {Pagination | null} pagination The pagination intent a paginated
  *   `@loop` recorded, or null. The builder reads it to multiply routes.
+ * @property {Set<string>} deps Absolute source-file dependencies of this compile.
+ * @property {Set<string>} collectionsUsed Collection names this compile looped.
  */
 
 /**
@@ -133,6 +160,8 @@
  * @property {NumArg | null} offset
  * @property {NumArg | null} limit
  * @property {string[] | null} empty Empty-branch body lines, if any.
+ * @property {number} [emptyStart] 0-based index the empty branch starts at
+ *   within the loop body, so its nested errors report the true file line.
  * @property {boolean} clauseRefsState Whether offset/limit reference state.
  * @property {boolean} sortable Drag-to-reorder the underlying :state/:store list
  *   (the `sortable` clause). Only valid on a plain reactive state-key loop.
@@ -178,10 +207,14 @@ export function createCompilation() {
     },
     state: new Map(),
     stores: new Set(),
+    fetchKeys: new Set(),
     warnings: [],
     sectionCounter: 0,
+    headingSlugs: new Map(),
     collections: new Map(),
-    pagination: null
+    pagination: null,
+    deps: new Set(),
+    collectionsUsed: new Set()
   };
 }
 
@@ -197,11 +230,28 @@ export function createScope(parent, vars = {}) {
 /**
  * Format a source location as `file:line` (1-based) for compile errors. Keeps the
  * file path intact so existing message matchers still pass, while pointing at the
- * directive's (or unclosed opener's) line.
- * @param {string} file
- * @param {number} index 0-based line index.
+ * directive's (or unclosed opener's) line. `index` is 0-based into the current
+ * `compileBody` slice; `ctx.lineOffset` (where that slice starts in the body,
+ * accumulated by {@link nestedCtx} as block handlers recurse) and `ctx.bodyLine`
+ * (the frontmatter offset) shift it back to the true file line.
+ * @param {Pick<Ctx, "file" | "bodyLine" | "lineOffset">} ctx
+ * @param {number} index 0-based line index into the current body slice.
  * @returns {string}
  */
-export function at(file, index) {
-  return `${file}:${index + 1}`;
+export function at(ctx, index) {
+  return `${ctx.file}:${index + 1 + (ctx.bodyLine ?? 0) + (ctx.lineOffset ?? 0)}`;
+}
+
+/**
+ * The compile context for a nested block body that starts `start` lines into the
+ * current slice. The offset accumulates, so errors inside arbitrarily nested
+ * blocks (`::: container`, `:form`, `@loop`, `:if`, `:carousel`) still report
+ * the true file line through {@link at}.
+ * @template {Pick<Ctx, "lineOffset">} T
+ * @param {T} ctx
+ * @param {number} start 0-based index the nested body starts at in the current slice.
+ * @returns {T}
+ */
+export function nestedCtx(ctx, start) {
+  return { ...ctx, lineOffset: (ctx.lineOffset ?? 0) + start };
 }