@diagrammo/dgmo 0.49.0 → 0.50.1

package/dist/{chunk-26RVGM44.js → chunk-YIA4LEX4.js}

@@ -1,6 +1,6 @@
 import {
   encodeDiagramUrl
-} from "./chunk-SVDWQGX2.js";
+} from "./chunk-ZAD4HV2G.js";
 import {
   FONT_FAMILY
 } from "./chunk-6KFWC4CO.js";
@@ -290,16 +290,24 @@ function computeBBox(svg) {
     const x = attr(tag, "x");
     const y = attr(tag, "y");
     if (x !== null && y !== null) {
-      const w = text.length * 7;
+      const fontSize = attr(tag, "font-size") ?? (() => {
+        const s = tag.match(/font-size:\s*([\d.]+)/);
+        return s ? parseFloat(s[1]) : 14;
+      })();
+      const w = text.length * fontSize * 0.5;
       const anchor = tag.match(/\btext-anchor="([^"]*)"/)?.[1] ?? "start";
       const left = anchor === "middle" ? x - w / 2 : anchor === "end" ? x - w : x;
       const right = anchor === "middle" ? x + w / 2 : anchor === "end" ? x : x + w;
-      push(left, y - 14);
-      push(right, y + 4);
+      push(left, y - fontSize * 0.9);
+      push(right, y + fontSize * 0.25);
     }
   }
-  for (const m of svg.matchAll(/<path\b[^>]*?\bd="([^"]+)"/g)) {
-    const d = m[1];
+  for (const m of svg.matchAll(/<path\b[^>]*?>/g)) {
+    const tag = m[0];
+    if (tag.includes("data-embed-ignore-bbox")) continue;
+    const dm = tag.match(/\bd="([^"]+)"/);
+    if (!dm) continue;
+    const d = dm[1];
     const nums = d.match(/-?\d+(?:\.\d+)?/g);
     if (!nums) continue;
     for (let i = 0; i + 1 < nums.length; i += 2) {
@@ -328,4 +336,4 @@ export {
   normalizeSvgForEmbed,
   getEmbedSvgViewBox
 };
-//# sourceMappingURL=chunk-26RVGM44.js.map
+//# sourceMappingURL=chunk-YIA4LEX4.js.map

package/dist/chunk-YNRDWYZP.js

@@ -0,0 +1,295 @@
+// src/countdown/resolve.ts
+var DAY_MS = 864e5;
+var WEEK_MS = 7 * DAY_MS;
+function monthIndex(token) {
+  const t = token.trim().toLowerCase().slice(0, 3);
+  const i = [
+    "jan",
+    "feb",
+    "mar",
+    "apr",
+    "may",
+    "jun",
+    "jul",
+    "aug",
+    "sep",
+    "oct",
+    "nov",
+    "dec"
+  ].indexOf(t);
+  return i < 0 ? null : i;
+}
+function weekdayIndex(token) {
+  const t = token.trim().toLowerCase().slice(0, 3);
+  const i = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"].indexOf(t);
+  return i < 0 ? null : i;
+}
+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) {
+  const d = new Date(ms);
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+}
+function nthWeekdayOfMonth(year, month, weekday, nth, hour, minute) {
+  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 new Date(year, month, d, hour, minute).getTime();
+      }
+    }
+    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 new Date(year, month, day, hour, minute).getTime();
+}
+function resolveNext(rule, now) {
+  const nowD = new Date(now);
+  const { hour, minute } = rule;
+  const passes = rule.allDay ? (t) => dayStart(t) >= dayStart(now) : (t) => t > now;
+  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 = nowD.getFullYear(); ; y++) {
+        if (!dayExists(y, month, day)) continue;
+        const t = new Date(y, month, day, hour, minute).getTime();
+        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 = nowD.getFullYear();
+      let m = nowD.getMonth();
+      for (let i = 0; i < 24; i++) {
+        const t = nthWeekdayOfMonth(y, m, weekday, nth, hour, minute);
+        if (t !== null && passes(t)) return t;
+        m++;
+        if (m > 11) {
+          m = 0;
+          y++;
+        }
+      }
+      return now + WEEK_MS;
+    }
+    case "weekly": {
+      const weekday = rule.weekday;
+      for (let i = 0; i < 8; i++) {
+        const d = new Date(
+          nowD.getFullYear(),
+          nowD.getMonth(),
+          nowD.getDate() + i,
+          hour,
+          minute
+        );
+        if (d.getDay() === weekday && passes(d.getTime())) return d.getTime();
+      }
+      return now + WEEK_MS;
+    }
+    case "interval": {
+      const n = rule.intervalN ?? 1;
+      const anchor = rule.anchorMs ?? now;
+      if (rule.intervalUnit === "month") {
+        const a = new Date(anchor);
+        const day = a.getDate();
+        for (let k = 0; ; k++) {
+          const y = a.getFullYear();
+          const m = a.getMonth() + k * n;
+          const yy = y + Math.floor(m / 12);
+          const mm = (m % 12 + 12) % 12;
+          if (!dayExists(yy, mm, day)) continue;
+          const t2 = new Date(yy, mm, day, hour, minute).getTime();
+          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((now - anchor) / step));
+        t = anchor + k * step;
+        while (!passes(t)) t += step;
+      }
+      return t;
+    }
+  }
+}
+function ordinalFor(resolvedMs, since) {
+  return new Date(resolvedMs).getFullYear() - since;
+}
+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 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) {
+  const n = new Date(nowMs);
+  const t = new Date(targetMs);
+  let y = t.getFullYear() - n.getFullYear();
+  let mo = t.getMonth() - n.getMonth();
+  let d = t.getDate() - n.getDate();
+  let h = t.getHours() - n.getHours();
+  let mi = t.getMinutes() - n.getMinutes();
+  let s = t.getSeconds() - n.getSeconds();
+  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.getFullYear(), t.getMonth(), 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) {
+  const b = breakdown(nowMs, targetMs);
+  return [
+    [b.years, "year"],
+    [b.months, "month"],
+    [b.days, "day"],
+    [b.hours, "hour"],
+    [b.minutes, "minute"]
+  ];
+}
+function formatHuman(nowMs, targetMs) {
+  const units = humanUnits(nowMs, targetMs);
+  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) {
+  const all = humanUnits(nowMs, targetMs);
+  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) {
+  const d = new Date(ms);
+  return `${WEEKDAY_ABBR[d.getDay()]} ${MONTH_ABBR[d.getMonth()]} ${d.getDate()} ${d.getFullYear()}`;
+}
+function formatDateShort(ms) {
+  const d = new Date(ms);
+  return `${MONTH_ABBR[d.getMonth()]} ${d.getDate()} ${d.getFullYear()}`;
+}
+function formatFooter(resolvedMs, hasTime) {
+  const parts = [formatDate(resolvedMs)];
+  if (hasTime) {
+    const d = new Date(resolvedMs);
+    parts.push(`${pad2(d.getHours())}:${pad2(d.getMinutes())}`);
+  }
+  return parts.join(" \xB7 ");
+}
+
+export {
+  DAY_MS,
+  monthIndex,
+  weekdayIndex,
+  applyOrdinalTemplate,
+  resolveNext,
+  ordinalFor,
+  formatCount,
+  formatWordsDetail,
+  formatHuman,
+  formatCompound,
+  formatDateShort,
+  formatFooter
+};
+//# sourceMappingURL=chunk-YNRDWYZP.js.map

package/dist/{chunk-SGHSY3LU.js → chunk-Z6XJQ6KO.js}

@@ -12,7 +12,10 @@ var SKETCH_GEOMETRY = {
   cellPx: 26,
   /** universal footprint width, in grid cells */
   footprintCellsW: 8,
-  /** mandatory gap between footprints, in cells */
+  /**
+   * Legacy — the gap is now a derived half-unit (footprint/2 per axis), not
+   * these cell counts. Kept only so the shape of SKETCH_GEOMETRY is stable.
+   */
   gapCellsX: 4,
   gapCellsY: 4,
   /** box reserved top band, px (spec decision 12) */
@@ -23,10 +26,12 @@ var SKETCH_GEOMETRY = {
   ringFrac: 0.22
 };
 var SKETCH_FOOT_W = SKETCH_GEOMETRY.footprintCellsW * SKETCH_GEOMETRY.cellPx;
-var SKETCH_FOOT_H = Math.round(SKETCH_FOOT_W / SKETCH_PHI);
-var SKETCH_HALF_SLOT_X = (SKETCH_FOOT_W + SKETCH_GEOMETRY.gapCellsX * SKETCH_GEOMETRY.cellPx) / 2;
-var SKETCH_HALF_SLOT_Y = (SKETCH_FOOT_H + SKETCH_GEOMETRY.gapCellsY * SKETCH_GEOMETRY.cellPx) / 2;
-var SKETCH_SEP = 2;
+var SKETCH_FOOT_H = 2 * Math.round(SKETCH_FOOT_W / SKETCH_PHI / 2);
+var SKETCH_HALF_SLOT_X = SKETCH_FOOT_W / 2;
+var SKETCH_HALF_SLOT_Y = SKETCH_FOOT_H / 2;
+var SKETCH_SEP = 3;
+var SKETCH_SLOT_X = SKETCH_HALF_SLOT_X * SKETCH_SEP;
+var SKETCH_SLOT_Y = SKETCH_HALF_SLOT_Y * SKETCH_SEP;
 function sketchSlotToPx(c, r) {
   return { x: c * SKETCH_HALF_SLOT_X, y: r * SKETCH_HALF_SLOT_Y };
 }
@@ -343,6 +348,74 @@ function layoutSketch(parsed, options = {}) {
       });
     }
   }
+  {
+    const centerOf = (id) => {
+      const n = nodes.find((nd) => nd.id === id);
+      if (n) return { x: n.x + n.w / 2, y: n.y + n.h / 2 };
+      const b = boxes.find((bx) => bx.id === id);
+      if (b) return { x: b.x + b.w / 2, y: b.y + b.h / 2 };
+      return null;
+    };
+    const segHitsRect = (ax, ay, bx, by, rx0, ry0, rx1, ry1) => {
+      let t0 = 0;
+      let t1 = 1;
+      const p = [-(bx - ax), bx - ax, -(by - ay), by - ay];
+      const q = [ax - rx0, rx1 - ax, ay - ry0, ry1 - ay];
+      for (let i = 0; i < 4; i++) {
+        if (p[i] === 0) {
+          if (q[i] < 0) return false;
+        } else {
+          const t = q[i] / p[i];
+          if (p[i] < 0) {
+            if (t > t1) return false;
+            if (t > t0) t0 = t;
+          } else {
+            if (t < t0) return false;
+            if (t < t1) t1 = t;
+          }
+        }
+      }
+      return t0 <= t1;
+    };
+    const warned = /* @__PURE__ */ new Set();
+    for (let pass = 0; pass < 4; pass++) {
+      let moved = false;
+      for (const n of nodes) {
+        if (n.boxLabel) continue;
+        for (const e of collapsed.edges) {
+          if (e.sourceId === n.id || e.targetId === n.id) continue;
+          const a = centerOf(e.sourceId);
+          const b = centerOf(e.targetId);
+          if (!a || !b) continue;
+          if (!segHitsRect(a.x, a.y, b.x, b.y, n.x, n.y, n.x + n.w, n.y + n.h))
+            continue;
+          const ncx = n.x + n.w / 2;
+          const ncy = n.y + n.h / 2;
+          const m = n;
+          if (Math.abs(b.x - a.x) >= Math.abs(b.y - a.y)) {
+            const lineY = a.y + (b.y - a.y) * (ncx - a.x) / (b.x - a.x || 1);
+            let dir = ncy >= lineY ? 1 : -1;
+            if (n.slot.r + dir * SKETCH_SEP < 0) dir = 1;
+            m.y += dir * SKETCH_SLOT_Y;
+            m.slot = { c: n.slot.c, r: n.slot.r + dir * SKETCH_SEP };
+          } else {
+            const lineX = a.x + (b.x - a.x) * (ncy - a.y) / (b.y - a.y || 1);
+            let dir = ncx >= lineX ? 1 : -1;
+            if (n.slot.c + dir * SKETCH_SEP < 0) dir = 1;
+            m.x += dir * SKETCH_SLOT_X;
+            m.slot = { c: n.slot.c + dir * SKETCH_SEP, r: n.slot.r };
+          }
+          if (!warned.has(n.id)) {
+            overlapWarn(n.lineNumber, n.label);
+            warned.add(n.id);
+          }
+          moved = true;
+          break;
+        }
+      }
+      if (!moved) break;
+    }
+  }
   let width = 0;
   let height = 0;
   for (const n of nodes) {
@@ -370,8 +443,10 @@ export {
   SKETCH_HALF_SLOT_X,
   SKETCH_HALF_SLOT_Y,
   SKETCH_SEP,
+  SKETCH_SLOT_X,
+  SKETCH_SLOT_Y,
   sketchSlotToPx,
   collapseSketch,
   layoutSketch
 };
-//# sourceMappingURL=chunk-SGHSY3LU.js.map
+//# sourceMappingURL=chunk-Z6XJQ6KO.js.map