@diagrammo/dgmo 0.48.2 → 0.50.0

package/dist/chunk-BTUTZMPT.js

@@ -0,0 +1,482 @@
+import {
+  monthIndex,
+  resolveNext,
+  weekdayIndex
+} from "./chunk-YNRDWYZP.js";
+import {
+  extractColor,
+  measureIndent,
+  parseFirstLine
+} from "./chunk-OTAL43EH.js";
+import {
+  makeDgmoError,
+  makeFail
+} from "./chunk-CXK4DZH3.js";
+
+// src/countdown/parser.ts
+var DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+var TIME_24H_RE = /^(\d{1,2}):(\d{2})$/;
+var AMPM_RE = /^(\d{1,2})(?::(\d{2}))?\s*([ap]m)$/i;
+function targetToMs(target) {
+  const s = target.trim();
+  if (DATE_ONLY_RE.test(s)) {
+    const [y, m, d] = s.split("-").map(Number);
+    return new Date(y, m - 1, d).getTime();
+  }
+  const t = new Date(s).getTime();
+  return Number.isFinite(t) ? t : null;
+}
+function ordinalToken(tok) {
+  const t = tok.toLowerCase();
+  if (t === "last") return -1;
+  const m = t.match(/^(\d+)(?:st|nd|rd|th)?$/);
+  if (m) {
+    const n = Number(m[1]);
+    return n >= 1 && n <= 5 ? n : null;
+  }
+  return null;
+}
+function parse24h(tok) {
+  const m = tok.match(TIME_24H_RE);
+  if (!m) return null;
+  const hour = Number(m[1]);
+  const minute = Number(m[2]);
+  if (hour > 23 || minute > 59) return null;
+  return { hour, minute };
+}
+function parseAt(rest, lineNum, softError) {
+  const t = parse24h(rest.trim());
+  if (t) return t;
+  const fixed = ampmTo24h(rest.trim());
+  softError(
+    lineNum,
+    fixed ? `"at ${rest}": use 24h time (${fixed}).` : `"at" needs a 24h time like 18:00 (got "${rest}").`
+  );
+  return null;
+}
+function ampmTo24h(tok) {
+  const m = tok.match(AMPM_RE);
+  if (!m) return null;
+  let hour = Number(m[1]) % 12;
+  if (/pm/i.test(m[3])) hour += 12;
+  return `${String(hour).padStart(2, "0")}:${m[2] ?? "00"}`;
+}
+function parseCountdown(content, palette) {
+  const result = {
+    type: "countdown",
+    title: null,
+    titleLineNumber: null,
+    target: null,
+    targetMs: null,
+    rule: null,
+    resolvedMs: null,
+    hasTime: false,
+    since: null,
+    sinceLabel: null,
+    units: "human",
+    round: "up",
+    fields: ["d", "h", "m", "s"],
+    lang: "en",
+    onDay: null,
+    expired: null,
+    note: null,
+    noVisual: false,
+    diagnostics: [],
+    error: null
+  };
+  const fail = makeFail(result);
+  const warn = (line, message) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning"));
+  };
+  const softError = (line, message) => {
+    result.diagnostics.push(makeDgmoError(line, message, "error"));
+  };
+  if (!content?.trim()) return fail(0, "No content provided");
+  const lines = content.split("\n");
+  let headerParsed = false;
+  let cadence = null;
+  let intervalN = 1;
+  let intervalUnit = "day";
+  let onSpec = null;
+  let atTime = null;
+  let anchorMs = null;
+  let targetMs = null;
+  let hasTargetLine = false;
+  let hasEvery = false;
+  const noteBody = [];
+  let inNote = false;
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    if (!headerParsed) {
+      const first = parseFirstLine(trimmed);
+      if (first?.chartType !== "countdown") {
+        return fail(lineNum, 'Expected "countdown [Title]" as the first line.');
+      }
+      if (first.title) {
+        const { label, color } = extractColor(
+          first.title,
+          palette,
+          result.diagnostics,
+          lineNum
+        );
+        result.title = label || null;
+        if (color !== void 0) result.color = color;
+      }
+      result.titleLineNumber = lineNum;
+      headerParsed = true;
+      continue;
+    }
+    if (measureIndent(raw) > 0) {
+      if (inNote) noteBody.push(trimmed);
+      else
+        warn(
+          lineNum,
+          `Indented content "${trimmed}" ignored \u2014 countdown is a single value.`
+        );
+      continue;
+    }
+    const [keyword, ...restTokens] = trimmed.split(/\s+/);
+    const key = keyword.toLowerCase();
+    const rest = restTokens.join(" ").trim();
+    if (key !== "note") inNote = false;
+    switch (key) {
+      // ── One-shot target ──
+      case "target": {
+        hasTargetLine = true;
+        if (/^now$/i.test(rest)) {
+          targetMs = Date.now();
+          result.target = new Date(targetMs).toISOString();
+          result.hasTime = true;
+        } else {
+          const ms = targetToMs(rest);
+          if (ms === null) {
+            softError(
+              lineNum,
+              `"target" needs an ISO date/datetime or "now" (got "${rest}").`
+            );
+          } else {
+            result.target = rest;
+            targetMs = ms;
+            if (rest.includes("T")) result.hasTime = true;
+          }
+        }
+        break;
+      }
+      // ── Recurrence — the canonical single-line form:
+      //   every <cadence> [on <instant>] [at <time>] [from <date>]
+      // (each slot may also appear on its own line — handled below.)
+      case "every": {
+        hasEvery = true;
+        const seg = {
+          cadence: [],
+          on: [],
+          at: [],
+          from: []
+        };
+        let cur = "cadence";
+        for (const tok of rest.split(/\s+/).filter(Boolean)) {
+          const low = tok.toLowerCase();
+          if (low === "on" || low === "at" || low === "from") cur = low;
+          else seg[cur].push(tok);
+        }
+        const head = (seg.cadence[0] ?? "").toLowerCase();
+        const bareInterval = (head === "day" || head === "week" || head === "month") && seg.from.length > 0 && seg.on.length === 0;
+        if (bareInterval) {
+          cadence = "interval";
+          intervalN = 1;
+          intervalUnit = head;
+        } else if (head === "year" || head === "month" || head === "week") {
+          cadence = head;
+        } else if (head === "day") {
+          softError(
+            lineNum,
+            "`every day` needs `from <date>` (an interval anchor)."
+          );
+          break;
+        } else if (/^\d+$/.test(head) && seg.cadence[1]) {
+          const unit = seg.cadence[1].toLowerCase().replace(/s$/, "");
+          if (unit === "day" || unit === "week" || unit === "month") {
+            cadence = "interval";
+            intervalN = Number(head);
+            intervalUnit = unit;
+          } else {
+            softError(
+              lineNum,
+              `every ${head} <days|weeks|months> \u2014 unknown unit "${seg.cadence[1]}".`
+            );
+          }
+        } else {
+          emitFreeProseError(lineNum, rest, softError);
+          break;
+        }
+        if (seg.on.length)
+          onSpec = parseOn(seg.on.join(" "), lineNum, softError);
+        if (seg.at.length)
+          atTime = parseAt(seg.at.join(" "), lineNum, softError);
+        if (seg.from.length) {
+          const ms = targetToMs(seg.from.join(" "));
+          if (ms === null) {
+            softError(
+              lineNum,
+              `"from" needs an anchor date (got "${seg.from.join(" ")}").`
+            );
+          } else {
+            anchorMs = ms;
+          }
+        }
+        break;
+      }
+      // Standalone slot lines (lenient multi-line form).
+      case "on": {
+        onSpec = parseOn(rest, lineNum, softError);
+        break;
+      }
+      case "at": {
+        const t = parseAt(rest, lineNum, softError);
+        if (t) atTime = t;
+        break;
+      }
+      case "from": {
+        const ms = targetToMs(rest);
+        if (ms === null) {
+          softError(lineNum, `"from" needs an anchor date (got "${rest}").`);
+        } else {
+          anchorMs = ms;
+        }
+        break;
+      }
+      // ── Ordinal / since — numbers a yearly occurrence (resolvedYear − since) ──
+      case "since": {
+        const y = Number(rest);
+        if (Number.isInteger(y) && y > 0) result.since = y;
+        else softError(lineNum, `"since" needs a year (got "${rest}").`);
+        break;
+      }
+      // The eyebrow template: `Nth` → ordinal word, `N` → the number.
+      case "since-label":
+        result.sinceLabel = rest || null;
+        break;
+      // ── Display ──
+      case "units": {
+        const v = rest.toLowerCase();
+        if (v === "human" || v === "days" || v === "full" || v === "clock" || v === "weeks" || v === "words" || v === "compound") {
+          result.units = v;
+        } else {
+          warn(
+            lineNum,
+            `Unknown units "${rest}" \u2014 use human|days|full|clock|weeks|words.`
+          );
+        }
+        break;
+      }
+      case "round": {
+        const v = rest.toLowerCase();
+        if (v === "up" || v === "down" || v === "nearest") {
+          result.round = v;
+        } else {
+          warn(lineNum, `Unknown round "${rest}" \u2014 use up|down|nearest.`);
+        }
+        break;
+      }
+      case "fields": {
+        const set = rest.split(/[,\s]+/).map((f) => f.toLowerCase()).filter((f) => ["d", "h", "m", "s"].includes(f));
+        if (set.length) result.fields = set;
+        else
+          warn(lineNum, `"fields" needs a subset of d,h,m,s (got "${rest}").`);
+        break;
+      }
+      case "lang":
+        result.lang = rest.toLowerCase() || "en";
+        break;
+      case "on-day":
+        result.onDay = rest || null;
+        break;
+      case "expired":
+        result.expired = rest;
+        break;
+      // ── `no-visual` — suppress the default-on calendar band (§36.6). ──
+      case "no-visual":
+        result.noVisual = true;
+        break;
+      // ── `note` — markdown caption; inline value or indented body block. ──
+      case "note":
+        inNote = true;
+        if (rest) noteBody.push(rest);
+        break;
+      default:
+        warn(lineNum, `Unrecognized line "${trimmed}".`);
+    }
+  }
+  if (noteBody.length) result.note = noteBody.join("\n");
+  if (hasEvery && hasTargetLine) {
+    softError(
+      result.titleLineNumber ?? 1,
+      "A countdown has either `target` (one-shot) or `every` (recurring), not both."
+    );
+  }
+  if (result.expired !== null && hasEvery) {
+    warn(
+      result.titleLineNumber ?? 1,
+      "`expired` applies only to one-shot `target` blocks; recurring blocks roll forward."
+    );
+  }
+  if (hasEvery && cadence) {
+    const rule = assembleRule(
+      cadence,
+      { intervalN, intervalUnit, anchorMs },
+      onSpec,
+      atTime,
+      result.titleLineNumber ?? 1,
+      softError
+    );
+    if (rule) {
+      result.rule = rule;
+      result.resolvedMs = resolveNext(rule, Date.now());
+      if (atTime) result.hasTime = true;
+    }
+  } else if (targetMs !== null) {
+    result.targetMs = targetMs;
+    result.resolvedMs = targetMs;
+  }
+  if (result.resolvedMs === null && result.error === null) {
+    if (!hasEvery && !hasTargetLine) {
+      softError(
+        result.titleLineNumber ?? 1,
+        "Missing `target` or `every` \u2014 a countdown needs one."
+      );
+    }
+  }
+  return result;
+}
+function parseOn(rest, lineNum, softError) {
+  const toks = rest.split(/\s+/).filter(Boolean);
+  if (toks.length === 0) {
+    softError(
+      lineNum,
+      '"on" needs a target (e.g. "Aug 21", "3rd Tuesday", "Friday").'
+    );
+    return null;
+  }
+  const ord = ordinalToken(toks[0]);
+  if (ord !== null && toks[1]) {
+    const wd2 = weekdayIndex(toks[1]);
+    if (wd2 === null) {
+      softError(lineNum, `"${toks[1]}" is not a weekday.`);
+      return null;
+    }
+    return { nth: ord, weekday: wd2 };
+  }
+  const mo = monthIndex(toks[0]);
+  if (mo !== null && toks[1]) {
+    const day = Number(toks[1].replace(/(st|nd|rd|th)$/i, ""));
+    if (!Number.isInteger(day) || day < 1 || day > 31) {
+      softError(lineNum, `"${toks[1]}" is not a valid day of month.`);
+      return null;
+    }
+    return { month: mo, day };
+  }
+  const wd = weekdayIndex(toks[0]);
+  if (wd !== null) return { weekday: wd };
+  softError(
+    lineNum,
+    `"on ${rest}" \u2014 use "Aug 21", "3rd Tuesday", "last Friday", or a weekday.`
+  );
+  return null;
+}
+function assembleRule(cadence, interval, onSpec, atTime, lineNum, softError) {
+  const hour = atTime?.hour ?? 0;
+  const minute = atTime?.minute ?? 0;
+  const allDay = atTime === null;
+  if (cadence === "interval") {
+    return {
+      kind: "interval",
+      intervalN: interval.intervalN,
+      intervalUnit: interval.intervalUnit,
+      anchorMs: interval.anchorMs ?? void 0,
+      hour,
+      minute,
+      allDay
+    };
+  }
+  if (cadence === "year") {
+    if (onSpec?.month === void 0 || onSpec.day === void 0) {
+      softError(
+        lineNum,
+        "`every year` needs `on <Month> <Day>` (e.g. on Aug 21)."
+      );
+      return null;
+    }
+    return {
+      kind: "month-day",
+      month: onSpec.month,
+      day: onSpec.day,
+      hour,
+      minute,
+      allDay
+    };
+  }
+  if (cadence === "month") {
+    if (onSpec?.nth === void 0 || onSpec.weekday === void 0) {
+      softError(
+        lineNum,
+        "`every month` needs `on <nth> <weekday>`, `on last <weekday>`, or `from <date>`."
+      );
+      return null;
+    }
+    return onSpec.nth < 0 ? { kind: "last-weekday", weekday: onSpec.weekday, hour, minute, allDay } : {
+      kind: "nth-weekday",
+      nth: onSpec.nth,
+      weekday: onSpec.weekday,
+      hour,
+      minute,
+      allDay
+    };
+  }
+  if (onSpec?.weekday === void 0 || onSpec.nth !== void 0) {
+    softError(lineNum, "`every week` needs `on <weekday>` (e.g. on Friday).");
+    return null;
+  }
+  return { kind: "weekly", weekday: onSpec.weekday, hour, minute, allDay };
+}
+function emitFreeProseError(lineNum, rest, softError) {
+  const toks = rest.split(/\s+/).filter(Boolean);
+  const problems = [];
+  let onPart = "";
+  let atPart = "";
+  for (let i = 0; i < toks.length; i++) {
+    const tok = toks[i];
+    const fixed = ampmTo24h(tok);
+    if (fixed) {
+      problems.push(`"${tok}": use 24h time (${fixed})`);
+      atPart = ` at ${fixed}`;
+      continue;
+    }
+    const wd = weekdayIndex(tok);
+    if (wd !== null) onPart = `week on ${tok}`;
+    const mo = monthIndex(tok);
+    if (mo !== null && toks[i + 1] && /^\d/.test(toks[i + 1])) {
+      onPart = `year on ${tok} ${toks[i + 1]}`;
+    }
+  }
+  if (!onPart && !atPart) {
+    problems.push(
+      "bare cadence \u2014 use year | month | week | N days|weeks|months"
+    );
+  } else if (onPart.startsWith("week")) {
+    problems.push("bare weekday needs a cadence");
+  }
+  const suggestion = onPart ? `every ${onPart}${atPart}` : `every week \u2026${atPart}`;
+  softError(
+    lineNum,
+    `Free-form recurrence rejected. ${problems.join("; ")}. Try: ${suggestion}`
+  );
+}
+
+export {
+  targetToMs,
+  parseCountdown
+};
+//# sourceMappingURL=chunk-BTUTZMPT.js.map

package/dist/{chunk-YGJTDXVR.js → chunk-C4GQDB5L.js}

@@ -1,7 +1,7 @@
 import {
   NODE_HEIGHT,
   NODE_WIDTH
-} from "./chunk-IJZFN3HM.js";
+} from "./chunk-TWQUYVP3.js";
 
 // src/boxes-and-lines/layout-grouped.ts
 var NODESEP = 50;
@@ -689,4 +689,4 @@ export {
   acyclicOrient,
   groupedTierCandidates
 };
-//# sourceMappingURL=chunk-YGJTDXVR.js.map
+//# sourceMappingURL=chunk-C4GQDB5L.js.map

package/dist/{chunk-Y2ZE3MSG.js → chunk-C63UWAKM.js}

@@ -2,7 +2,7 @@ import {
   CHAR_WIDTH_RATIO,
   measureText,
   truncateText
-} from "./chunk-WCT3NYCV.js";
+} from "./chunk-5LWQH6QV.js";
 
 // src/infra/layout.ts
 import dagre from "@dagrejs/dagre";
@@ -587,4 +587,4 @@ export {
   fixEdgeWaypoints,
   layoutInfra
 };
-//# sourceMappingURL=chunk-Y2ZE3MSG.js.map
+//# sourceMappingURL=chunk-C63UWAKM.js.map

package/dist/{chunk-725LDASD.js → chunk-CLD2OKV7.js}

@@ -1,6 +1,6 @@
 import {
   acyclicOrient
-} from "./chunk-YGJTDXVR.js";
+} from "./chunk-C4GQDB5L.js";
 
 // src/swimlane/layout.ts
 var MARGIN = 30;
@@ -419,4 +419,4 @@ function layoutSwimlane(parsed) {
 export {
   layoutSwimlane
 };
-//# sourceMappingURL=chunk-725LDASD.js.map
+//# sourceMappingURL=chunk-CLD2OKV7.js.map

package/dist/{chunk-WBRZJOEC.js → chunk-CMCR5WBW.js}

@@ -1,12 +1,12 @@
 import {
   buildPlacedNotes
-} from "./chunk-JED6ZDEE.js";
+} from "./chunk-O7WP4ZD4.js";
 import {
   noteCanvasShift
 } from "./chunk-6EK55ART.js";
 import {
   measureText
-} from "./chunk-WCT3NYCV.js";
+} from "./chunk-5LWQH6QV.js";
 import {
   resolveNotes
 } from "./chunk-FMDSF3OV.js";
@@ -201,4 +201,4 @@ function layoutClassDiagram(parsed, options) {
 export {
   layoutClassDiagram
 };
-//# sourceMappingURL=chunk-WBRZJOEC.js.map
+//# sourceMappingURL=chunk-CMCR5WBW.js.map

package/dist/{chunk-IZMRON6C.js → chunk-CVV36CWI.js}

@@ -4,7 +4,7 @@ import {
 import {
   resolveTagColor,
   tagAttrKey
-} from "./chunk-QLCCJEJI.js";
+} from "./chunk-WCUHAQKB.js";
 import {
   resolveColor
 } from "./chunk-TLVIHFRO.js";
@@ -164,4 +164,4 @@ export {
   formatPct,
   buildLegend
 };
-//# sourceMappingURL=chunk-IZMRON6C.js.map
+//# sourceMappingURL=chunk-CVV36CWI.js.map