@diagrammo/dgmo 0.92.1 → 0.93.0

package/dist/chunk-UCHZJJIT.js

@@ -0,0 +1,421 @@
+// src/countdown/resolve.ts
+var DAY_MS = 864e5;
+var WEEK_MS = 7 * DAY_MS;
+var ZONE_WD = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+function zoneFields(ms, tz) {
+  const d = new Date(ms);
+  if (!tz) {
+    return {
+      year: d.getFullYear(),
+      month: d.getMonth(),
+      day: d.getDate(),
+      hour: d.getHours(),
+      minute: d.getMinutes(),
+      second: d.getSeconds(),
+      weekday: d.getDay()
+    };
+  }
+  try {
+    const o = {};
+    new Intl.DateTimeFormat("en-US", {
+      timeZone: tz,
+      hour12: false,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      weekday: "short"
+    }).formatToParts(d).forEach((x) => {
+      o[x.type] = x.value;
+    });
+    return {
+      year: Number(o["year"]),
+      month: Number(o["month"]) - 1,
+      day: Number(o["day"]),
+      hour: Number(o["hour"]) % 24,
+      minute: Number(o["minute"]),
+      second: Number(o["second"]),
+      weekday: Math.max(0, ZONE_WD.indexOf(o["weekday"] ?? "Sun"))
+    };
+  } catch {
+    return {
+      year: d.getUTCFullYear(),
+      month: d.getUTCMonth(),
+      day: d.getUTCDate(),
+      hour: d.getUTCHours(),
+      minute: d.getUTCMinutes(),
+      second: d.getUTCSeconds(),
+      weekday: d.getUTCDay()
+    };
+  }
+}
+function zoneOffsetMs(tz, ms) {
+  const f = zoneFields(ms, tz);
+  const asUTC = Date.UTC(f.year, f.month, f.day, f.hour, f.minute, f.second);
+  return asUTC - Math.floor(ms / 1e3) * 1e3;
+}
+function wallToMs(y, mo, d, h, mi, tz) {
+  if (!tz) return new Date(y, mo, d, h, mi).getTime();
+  const guess = Date.UTC(y, mo, d, h, mi);
+  const off1 = zoneOffsetMs(tz, guess);
+  const ms = guess - off1;
+  const off2 = zoneOffsetMs(tz, ms);
+  return off2 === off1 ? ms : guess - off2;
+}
+function zoneOffsetLabel(ms, tz) {
+  if (!tz) return "";
+  try {
+    const off = new Intl.DateTimeFormat("en-US", {
+      timeZone: tz,
+      timeZoneName: "shortOffset"
+    }).formatToParts(new Date(ms)).find((x) => x.type === "timeZoneName");
+    return off ? off.value.replace("GMT", "UTC") : "";
+  } catch {
+    return "";
+  }
+}
+var DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+var LOCAL_DT_RE = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?$/;
+function targetToMs(target, tz = null) {
+  const s = target.trim();
+  if (DATE_ONLY_RE.test(s)) {
+    const [y, m, d] = s.split("-").map(Number);
+    return wallToMs(y, m - 1, d, 0, 0, tz);
+  }
+  const dt = LOCAL_DT_RE.exec(s);
+  if (dt) {
+    return wallToMs(
+      Number(dt[1]),
+      Number(dt[2]) - 1,
+      Number(dt[3]),
+      Number(dt[4]),
+      Number(dt[5]),
+      tz
+    );
+  }
+  return new Date(s).getTime();
+}
+function ordinalWord(n) {
+  const abs = Math.abs(n);
+  const tens = abs % 100;
+  let suffix = "th";
+  if (tens < 11 || tens > 13) {
+    const ones = abs % 10;
+    suffix = ones === 1 ? "st" : ones === 2 ? "nd" : ones === 3 ? "rd" : "th";
+  }
+  return `${n}${suffix}`;
+}
+function applyOrdinalTemplate(template, n) {
+  return template.replace(/\bNth\b/g, ordinalWord(n)).replace(/\bN\b/g, String(n));
+}
+function dayStart(ms, tz = null) {
+  const f = zoneFields(ms, tz);
+  return wallToMs(f.year, f.month, f.day, 0, 0, tz);
+}
+function dayDelta(a, b, tz = null) {
+  return Math.round((dayStart(b, tz) - dayStart(a, tz)) / DAY_MS);
+}
+function dayKey(ms, tz = null) {
+  const f = zoneFields(ms, tz);
+  return `${f.year}-${f.month + 1}-${f.day}`;
+}
+function sameDay(a, b, tz = null) {
+  const x = zoneFields(a, tz);
+  const y = zoneFields(b, tz);
+  return x.year === y.year && x.month === y.month && x.day === y.day;
+}
+function nthWeekdayOfMonth(year, month, weekday, nth, hour, minute, tz) {
+  if (nth < 0) {
+    const last = new Date(year, month + 1, 0).getDate();
+    for (let d = last; d >= 1; d--) {
+      if (new Date(year, month, d).getDay() === weekday) {
+        return wallToMs(year, month, d, hour, minute, tz);
+      }
+    }
+    return null;
+  }
+  const firstDow = new Date(year, month, 1).getDay();
+  const offset = (weekday - firstDow + 7) % 7;
+  const day = 1 + offset + (nth - 1) * 7;
+  if (day > new Date(year, month + 1, 0).getDate()) return null;
+  return wallToMs(year, month, day, hour, minute, tz);
+}
+function resolveNext(rule, now2) {
+  const tz = rule.tz ?? null;
+  const nowF = zoneFields(now2, tz);
+  const { hour, minute } = rule;
+  const passes = rule.allDay ? (t) => dayStart(t, tz) >= dayStart(now2, tz) : (t) => t > now2;
+  const dayExists = (y, m, d) => new Date(y, m, d).getMonth() === m;
+  switch (rule.kind) {
+    case "month-day": {
+      const month = rule.month;
+      const day = rule.day;
+      for (let y = nowF.year; ; y++) {
+        if (!dayExists(y, month, day)) continue;
+        const t = wallToMs(y, month, day, hour, minute, tz);
+        if (passes(t)) return t;
+      }
+    }
+    case "nth-weekday":
+    case "last-weekday": {
+      const weekday = rule.weekday;
+      const nth = rule.kind === "last-weekday" ? -1 : rule.nth;
+      let y = nowF.year;
+      let m = nowF.month;
+      for (let i = 0; i < 24; i++) {
+        const t = nthWeekdayOfMonth(y, m, weekday, nth, hour, minute, tz);
+        if (t !== null && passes(t)) return t;
+        m++;
+        if (m > 11) {
+          m = 0;
+          y++;
+        }
+      }
+      return now2 + WEEK_MS;
+    }
+    case "weekly": {
+      const weekday = rule.weekday;
+      for (let i = 0; i < 8; i++) {
+        const cal = new Date(nowF.year, nowF.month, nowF.day + i);
+        if (cal.getDay() !== weekday) continue;
+        const t = wallToMs(
+          cal.getFullYear(),
+          cal.getMonth(),
+          cal.getDate(),
+          hour,
+          minute,
+          tz
+        );
+        if (passes(t)) return t;
+      }
+      return now2 + WEEK_MS;
+    }
+    case "interval": {
+      const n = rule.intervalN ?? 1;
+      const anchor = rule.anchorMs ?? now2;
+      if (rule.intervalUnit === "month") {
+        const a = zoneFields(anchor, tz);
+        const day = a.day;
+        for (let k = 0; ; k++) {
+          const y = a.year;
+          const m = a.month + k * n;
+          const yy = y + Math.floor(m / 12);
+          const mm = (m % 12 + 12) % 12;
+          if (!dayExists(yy, mm, day)) continue;
+          const t2 = wallToMs(yy, mm, day, hour, minute, tz);
+          if (passes(t2)) return t2;
+        }
+      }
+      const step = (rule.intervalUnit === "week" ? WEEK_MS : DAY_MS) * n;
+      let t = anchor;
+      if (!passes(t)) {
+        const k = Math.max(0, Math.floor((now2 - anchor) / step));
+        t = anchor + k * step;
+        while (!passes(t)) t += step;
+      }
+      return t;
+    }
+  }
+}
+function ordinalFor(resolvedMs, rule) {
+  const anchor = rule.anchorMs;
+  if (anchor === void 0) return 0;
+  const tz = rule.tz ?? null;
+  const a = zoneFields(anchor, tz);
+  const r = zoneFields(resolvedMs, tz);
+  const months = (r.year - a.year) * 12 + (r.month - a.month);
+  const spanDays = (dayStart(resolvedMs, tz) - dayStart(anchor, tz)) / DAY_MS;
+  switch (rule.kind) {
+    case "month-day":
+      return r.year - a.year;
+    case "nth-weekday":
+    case "last-weekday":
+      return months;
+    case "weekly":
+      return Math.round(spanDays / 7);
+    case "interval": {
+      const n = rule.intervalN ?? 1;
+      if (rule.intervalUnit === "month") return Math.floor(months / n);
+      const perStep = rule.intervalUnit === "week" ? 7 : 1;
+      return Math.round(spanDays / perStep / n);
+    }
+  }
+}
+function roundBy(value, mode) {
+  return mode === "down" ? Math.floor(value) : mode === "nearest" ? Math.round(value) : Math.ceil(value);
+}
+function pad2(n) {
+  return n < 10 ? "0" + n : String(n);
+}
+function plural(n, unit) {
+  return `${n} ${unit}${n === 1 ? "" : "s"}`;
+}
+function formatCount(remainingMs, opts) {
+  const { units, round, fields } = opts;
+  if (units === "days")
+    return plural(roundBy(remainingMs / DAY_MS, round), "day");
+  if (units === "weeks")
+    return plural(roundBy(remainingMs / WEEK_MS, round), "week");
+  const totalSec = Math.floor(remainingMs / 1e3);
+  if (units === "clock") {
+    const h2 = Math.floor(totalSec / 3600);
+    const m2 = Math.floor(totalSec % 3600 / 60);
+    const s2 = totalSec % 60;
+    return `${pad2(h2)}:${pad2(m2)}:${pad2(s2)}`;
+  }
+  if (units === "words") {
+    const days2 = Math.ceil(remainingMs / DAY_MS);
+    if (days2 <= 0) return "now";
+    if (days2 === 1) return "tomorrow";
+    if (days2 < 14) return `${days2} days`;
+    if (days2 < 60) return `${Math.round(days2 / 7)} weeks`;
+    return `${Math.round(days2 / 30)} months`;
+  }
+  const days = Math.floor(totalSec / 86400);
+  const h = Math.floor(totalSec % 86400 / 3600);
+  const m = Math.floor(totalSec % 3600 / 60);
+  const s = totalSec % 60;
+  const has = (f) => fields.includes(f);
+  const clockParts = [];
+  if (has("h")) clockParts.push(pad2(h));
+  if (has("m")) clockParts.push(pad2(m));
+  if (has("s")) clockParts.push(pad2(s));
+  const clock = clockParts.join(":");
+  const dayPrefix = has("d") && days > 0 ? `${days}d${clock ? " " : ""}` : "";
+  return dayPrefix + clock || plural(days, "day");
+}
+function splitClockSeconds(s) {
+  const m = /^(.+:\d{2}):(\d{2})$/.exec(s);
+  return m ? { lead: m[1], sec: ":" + m[2] } : { lead: s, sec: null };
+}
+function formatWordsDetail(remainingMs) {
+  const totalMin = Math.floor(Math.max(0, remainingMs) / 6e4);
+  const d = Math.floor(totalMin / 1440);
+  const h = Math.floor(totalMin % 1440 / 60);
+  const m = totalMin % 60;
+  const parts = [];
+  if (d > 0) parts.push(`${d} day${d === 1 ? "" : "s"}`);
+  if (d > 0 || h > 0) parts.push(`${h} hour${h === 1 ? "" : "s"}`);
+  parts.push(`${m} minute${m === 1 ? "" : "s"}`);
+  return parts.join(" ");
+}
+function breakdown(nowMs, targetMs, tz = null) {
+  const n = zoneFields(nowMs, tz);
+  const t = zoneFields(targetMs, tz);
+  let y = t.year - n.year;
+  let mo = t.month - n.month;
+  let d = t.day - n.day;
+  let h = t.hour - n.hour;
+  let mi = t.minute - n.minute;
+  let s = t.second - n.second;
+  if (s < 0) {
+    s += 60;
+    mi--;
+  }
+  if (mi < 0) {
+    mi += 60;
+    h--;
+  }
+  if (h < 0) {
+    h += 24;
+    d--;
+  }
+  if (d < 0) {
+    d += new Date(t.year, t.month, 0).getDate();
+    mo--;
+  }
+  if (mo < 0) {
+    mo += 12;
+    y--;
+  }
+  return { years: y, months: mo, days: d, hours: h, minutes: mi, seconds: s };
+}
+function humanUnits(nowMs, targetMs, tz = null) {
+  const b = breakdown(nowMs, targetMs, tz);
+  return [
+    [b.years, "year"],
+    [b.months, "month"],
+    [b.days, "day"],
+    [b.hours, "hour"],
+    [b.minutes, "minute"]
+  ];
+}
+function formatHuman(nowMs, targetMs, tz = null) {
+  const units = humanUnits(nowMs, targetMs, tz);
+  let i = 0;
+  while (i < units.length - 1 && units[i][0] === 0) i++;
+  const rest = units.slice(i);
+  const say = (arr) => arr.map(([n, u]) => `${n} ${u}${n === 1 ? "" : "s"}`).join(", ");
+  const primary = rest.slice(0, 2).filter((p, idx) => p[0] > 0 || idx === 0);
+  const secondary = rest.slice(2).filter((p) => p[0] > 0);
+  return { big: say(primary) || "now", sub: say(secondary) };
+}
+function formatCompound(nowMs, targetMs, maxUnits = 2, tz = null) {
+  const all = humanUnits(nowMs, targetMs, tz);
+  let i = 0;
+  while (i < all.length - 1 && all[i][0] === 0) i++;
+  const chosen = all.slice(i, i + maxUnits).filter((p, idx) => p[0] > 0 || idx === 0);
+  if (!chosen.length) return "now";
+  return chosen.map(([n, u]) => `${n} ${u}${n === 1 ? "" : "s"}`).join(", ");
+}
+var WEEKDAY_ABBR = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var MONTH_ABBR = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+function formatDate(ms, tz = null) {
+  const f = zoneFields(ms, tz);
+  return `${WEEKDAY_ABBR[f.weekday]} ${MONTH_ABBR[f.month]} ${f.day} ${f.year}`;
+}
+function formatDateShort(ms, tz = null) {
+  const f = zoneFields(ms, tz);
+  return `${MONTH_ABBR[f.month]} ${f.day} ${f.year}`;
+}
+function formatFooter(resolvedMs, hasTime, tz = null) {
+  const parts = [formatDate(resolvedMs, tz)];
+  if (hasTime) {
+    const f = zoneFields(resolvedMs, tz);
+    parts.push(`${pad2(f.hour)}:${pad2(f.minute)}`);
+    const label = zoneOffsetLabel(resolvedMs, tz);
+    if (label) parts.push(label);
+  }
+  return parts.join(" \xB7 ");
+}
+
+// src/utils/now.ts
+var pinnedMs = null;
+function now() {
+  return pinnedMs ?? Date.now();
+}
+
+export {
+  DAY_MS,
+  targetToMs,
+  applyOrdinalTemplate,
+  dayStart,
+  dayDelta,
+  dayKey,
+  sameDay,
+  resolveNext,
+  ordinalFor,
+  formatCount,
+  splitClockSeconds,
+  formatWordsDetail,
+  formatHuman,
+  formatCompound,
+  formatDateShort,
+  formatFooter,
+  now
+};

package/dist/{chunk-FSJ3ZA6N.js → chunk-UG7AQQNR.js}

@@ -1,24 +1,24 @@
-import {
-  wrapDescriptionLines
-} from "./chunk-NPWVOFB3.js";
-import {
-  renderInlineText
-} from "./chunk-S7W75MIM.js";
 import {
   ScaleContext
 } from "./chunk-24YPR5EH.js";
 import {
-  renderIntegratedLegend
-} from "./chunk-NMS5XSLX.js";
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT,
+  TITLE_Y
+} from "./chunk-VLC6WNRD.js";
 import {
   ARROWHEAD_HEIGHT,
   ARROWHEAD_WIDTH
 } from "./chunk-XCKNFFKM.js";
 import {
-  TITLE_FONT_SIZE,
-  TITLE_FONT_WEIGHT,
-  TITLE_Y
-} from "./chunk-VLC6WNRD.js";
+  renderIntegratedLegend
+} from "./chunk-NMS5XSLX.js";
+import {
+  wrapDescriptionLines
+} from "./chunk-MB2SQF7N.js";
+import {
+  renderInlineText
+} from "./chunk-65GPEV5V.js";
 import {
   FONT_FAMILY
 } from "./chunk-ICLB27PZ.js";

package/dist/{chunk-WFA6IULY.js → chunk-URRAWU5D.js}

@@ -172,6 +172,10 @@ function dayStart(ms, tz = null) {
 function dayDelta(a, b, tz = null) {
   return Math.round((dayStart(b, tz) - dayStart(a, tz)) / DAY_MS);
 }
+function dayKey(ms, tz = null) {
+  const f = zoneFields(ms, tz);
+  return `${f.year}-${f.month + 1}-${f.day}`;
+}
 function sameDay(a, b, tz = null) {
   const x = zoneFields(a, tz);
   const y = zoneFields(b, tz);
@@ -454,6 +458,7 @@ export {
   applyOrdinalTemplate,
   dayStart,
   dayDelta,
+  dayKey,
   sameDay,
   resolveNext,
   ordinalFor,

package/dist/{chunk-VOR32OHN.js → chunk-USAGHYRD.js}

@@ -5,20 +5,14 @@ import {
   scoreToCurveY
 } from "./chunk-EBIDNRSR.js";
 import {
-  wrapNoteBody
-} from "./chunk-RJNZHFNG.js";
-import {
-  NOTE_BULLET_INDENT
-} from "./chunk-5DH3KYFH.js";
+  parseJourneyMap
+} from "./chunk-PGSGJLUR.js";
 import {
-  renderInlineText
-} from "./chunk-S7W75MIM.js";
+  serializeSvg
+} from "./chunk-CYRB2JTN.js";
 import {
   ScaleContext
 } from "./chunk-24YPR5EH.js";
-import {
-  renderIntegratedLegend
-} from "./chunk-NMS5XSLX.js";
 import {
   CARD_RADIUS,
   CONTAINER_RADIUS,
@@ -26,14 +20,18 @@ import {
   NODE_STROKE_WIDTH
 } from "./chunk-XCKNFFKM.js";
 import {
-  serializeSvg
-} from "./chunk-CYRB2JTN.js";
+  renderIntegratedLegend
+} from "./chunk-NMS5XSLX.js";
+import {
+  NOTE_BULLET_INDENT,
+  wrapNoteBody
+} from "./chunk-D6PVMUCX.js";
+import {
+  renderInlineText
+} from "./chunk-65GPEV5V.js";
 import {
   FONT_FAMILY
 } from "./chunk-ICLB27PZ.js";
-import {
-  parseJourneyMap
-} from "./chunk-A4PNWAUW.js";
 import {
   resolveActiveTagGroup,
   tagAttrKey

package/dist/{chunk-QUGC7GWB.js → chunk-UVX3IYXF.js}

@@ -1,30 +1,30 @@
-import {
-  looksLikePert
-} from "./chunk-CDM6XMOT.js";
 import {
   isLiveLinkLine
 } from "./chunk-KBDMEOLI.js";
 import {
   looksLikeSequence
-} from "./chunk-B5PEKSRH.js";
+} from "./chunk-VSAKEMDD.js";
+import {
+  looksLikeOrg
+} from "./chunk-5OTA2PUH.js";
+import {
+  looksLikeSitemap
+} from "./chunk-ZECJ7Q6C.js";
+import {
+  looksLikePert
+} from "./chunk-CDM6XMOT.js";
 import {
   looksLikeFlowchart
-} from "./chunk-26BBJUBW.js";
+} from "./chunk-M6ZQAFPD.js";
 import {
   looksLikeState
-} from "./chunk-2YAFDND3.js";
-import {
-  looksLikeClassDiagram
-} from "./chunk-Q6ZQX2HX.js";
+} from "./chunk-M4NV5PPU.js";
 import {
   looksLikeERDiagram
-} from "./chunk-DRFGIOZ6.js";
-import {
-  looksLikeOrg
-} from "./chunk-5OTA2PUH.js";
+} from "./chunk-Q7Y6JQ3R.js";
 import {
-  looksLikeSitemap
-} from "./chunk-ZECJ7Q6C.js";
+  looksLikeClassDiagram
+} from "./chunk-KCMGIYPO.js";
 import {
   parseFirstLine
 } from "./chunk-TIIZIAGS.js";

package/dist/{chunk-B5PEKSRH.js → chunk-VSAKEMDD.js}

@@ -1,3 +1,6 @@
+import {
+  extractPaletteDirective
+} from "./chunk-CYTFO2LF.js";
 import {
   inferParticipantType
 } from "./chunk-C3Z4DX3V.js";
@@ -247,7 +250,9 @@ function parseSequenceDgmo(content, palette) {
   if (!content?.trim()) {
     return fail(0, "Empty content");
   }
-  const lines = content.split("\n");
+  const directive = extractPaletteDirective(content);
+  result.diagnostics.push(...directive.diagnostics);
+  const lines = directive.content.split("\n");
   let hasExplicitChart = false;
   let contentStarted = false;
   let activeTagOptionLine = 0;

package/dist/{chunk-5SSTVFPX.js → chunk-WK5QEYFA.js}

@@ -1,16 +1,14 @@
 import {
   searchPlacement
-} from "./chunk-HXULJZA2.js";
+} from "./chunk-LDDDKWL6.js";
 import {
   noteCanvasShift,
-  placeNotes
-} from "./chunk-FTUMRSGT.js";
+  placeNotes,
+  resolveNotes
+} from "./chunk-NJJCTEBM.js";
 import {
   noteBoxSize
-} from "./chunk-RJNZHFNG.js";
-import {
-  resolveNotes
-} from "./chunk-O753JUEZ.js";
+} from "./chunk-D6PVMUCX.js";
 
 // src/graph/layout.ts
 import dagre from "@dagrejs/dagre";