@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-YRYKTYMQ.js

@@ -0,0 +1,186 @@
+// src/utils/time-ticks.ts
+var MONTH_ABBR = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+function fractionalYearToDate(frac) {
+  const year = Math.floor(frac);
+  const remainder = frac - year;
+  const monthFrac = remainder * 12;
+  const month = Math.floor(monthFrac);
+  const monthRemainder = remainder - month / 12;
+  const dayFrac = monthRemainder * 365;
+  const day = Math.floor(dayFrac) + 1;
+  const dayRemainder = dayFrac - Math.floor(dayFrac);
+  const hourFrac = dayRemainder * 24;
+  const hour = Math.floor(hourFrac);
+  const minuteFrac = (hourFrac - hour) * 60;
+  const minute = Math.floor(minuteFrac);
+  const second = Math.round((minuteFrac - minute) * 60);
+  return new Date(year, month, day, hour, minute, second);
+}
+function dateToFractionalYear(d) {
+  return d.getFullYear() + d.getMonth() / 12 + (d.getDate() - 1) / 365 + d.getHours() / 8760 + d.getMinutes() / 525600 + d.getSeconds() / 31536e3;
+}
+function formatYearTick(y) {
+  return y < 0 ? `${-y} BCE` : String(y);
+}
+function computeTimeTicks(domainMin, domainMax, scale, boundaryStart, boundaryEnd, boundaryStartLabel, boundaryEndLabel) {
+  const minYear = Math.floor(domainMin);
+  const maxYear = Math.floor(domainMax);
+  const span = domainMax - domainMin;
+  let ticks = [];
+  const firstYear = Math.ceil(domainMin);
+  const lastYear = Math.floor(domainMax);
+  if (lastYear >= firstYear + 1) {
+    const yearSpan = lastYear - firstYear;
+    let step = 1;
+    if (yearSpan > 800) step = 200;
+    else if (yearSpan > 400) step = 100;
+    else if (yearSpan > 160) step = 50;
+    else if (yearSpan > 80) step = 20;
+    else if (yearSpan > 40) step = 10;
+    else if (yearSpan > 20) step = 5;
+    else if (yearSpan > 10) step = 2;
+    const alignedFirst = Math.ceil(firstYear / step) * step;
+    for (let y = alignedFirst; y <= lastYear; y += step) {
+      ticks.push({ pos: scale(y), label: formatYearTick(y) });
+    }
+  } else if (span > 0.25) {
+    const crossesYear = maxYear > minYear;
+    for (let y = minYear; y <= maxYear + 1; y++) {
+      for (let m = 1; m <= 12; m++) {
+        const val = y + (m - 1) / 12;
+        if (val > domainMax) break;
+        if (val >= domainMin) {
+          const abbr = MONTH_ABBR[m - 1];
+          ticks.push({
+            pos: scale(val),
+            label: crossesYear ? `${abbr} '${String(y).slice(-2)}` : abbr
+          });
+        }
+      }
+    }
+  } else if (span <= 114e-7) {
+    let stepSec = 5;
+    const spanSec = span * 31536e3;
+    if (spanSec > 180) stepSec = 30;
+    else if (spanSec > 60) stepSec = 15;
+    else if (spanSec > 30) stepSec = 10;
+    const startDate = fractionalYearToDate(domainMin);
+    startDate.setSeconds(
+      Math.floor(startDate.getSeconds() / stepSec) * stepSec,
+      0
+    );
+    while (true) {
+      const val = dateToFractionalYear(startDate);
+      if (val > domainMax) break;
+      if (val >= domainMin) {
+        const hh = String(startDate.getHours()).padStart(2, "0");
+        const mm = String(startDate.getMinutes()).padStart(2, "0");
+        const ss = String(startDate.getSeconds()).padStart(2, "0");
+        ticks.push({ pos: scale(val), label: `${hh}:${mm}:${ss}` });
+      }
+      startDate.setSeconds(startDate.getSeconds() + stepSec);
+    }
+  } else if (span <= 685e-6) {
+    let stepMin = 5;
+    const spanHours = span * 8760;
+    if (spanHours > 3) stepMin = 30;
+    else if (spanHours > 1) stepMin = 15;
+    else if (spanHours > 0.5) stepMin = 10;
+    const startDate = fractionalYearToDate(domainMin);
+    startDate.setMinutes(
+      Math.floor(startDate.getMinutes() / stepMin) * stepMin,
+      0,
+      0
+    );
+    while (true) {
+      const val = dateToFractionalYear(startDate);
+      if (val > domainMax) break;
+      if (val >= domainMin) {
+        const hh = String(startDate.getHours()).padStart(2, "0");
+        const mm = String(startDate.getMinutes()).padStart(2, "0");
+        ticks.push({ pos: scale(val), label: `${hh}:${mm}` });
+      }
+      startDate.setMinutes(startDate.getMinutes() + stepMin);
+    }
+  } else if (span <= 822e-5) {
+    let stepHour = 1;
+    const spanHours = span * 8760;
+    if (spanHours > 48) stepHour = 6;
+    else if (spanHours > 24) stepHour = 3;
+    else if (spanHours > 12) stepHour = 2;
+    const singleDay = spanHours <= 24;
+    const startDate = fractionalYearToDate(domainMin);
+    startDate.setHours(
+      Math.floor(startDate.getHours() / stepHour) * stepHour,
+      0,
+      0,
+      0
+    );
+    while (true) {
+      const val = dateToFractionalYear(startDate);
+      if (val > domainMax) break;
+      if (val >= domainMin) {
+        const hh = String(startDate.getHours()).padStart(2, "0");
+        const mm = String(startDate.getMinutes()).padStart(2, "0");
+        if (singleDay) {
+          ticks.push({ pos: scale(val), label: `${hh}:${mm}` });
+        } else {
+          const mon = MONTH_ABBR[startDate.getMonth()];
+          const d = startDate.getDate();
+          ticks.push({ pos: scale(val), label: `${mon} ${d} ${hh}:${mm}` });
+        }
+      }
+      startDate.setHours(startDate.getHours() + stepHour);
+    }
+  } else {
+    for (let y = minYear; y <= maxYear + 1; y++) {
+      for (let m = 1; m <= 12; m++) {
+        for (const d of [1, 8, 15, 22]) {
+          const val = y + (m - 1) / 12 + (d - 1) / 365;
+          if (val > domainMax) break;
+          if (val >= domainMin) {
+            ticks.push({
+              pos: scale(val),
+              label: `${MONTH_ABBR[m - 1]} ${d}`
+            });
+          }
+        }
+      }
+    }
+  }
+  const collisionThreshold = 40;
+  if (boundaryStart !== void 0 && boundaryStartLabel) {
+    const boundaryPos = scale(boundaryStart);
+    ticks = ticks.filter(
+      (t) => Math.abs(t.pos - boundaryPos) >= collisionThreshold
+    );
+    ticks.unshift({ pos: boundaryPos, label: boundaryStartLabel });
+  }
+  if (boundaryEnd !== void 0 && boundaryEndLabel) {
+    const boundaryPos = scale(boundaryEnd);
+    ticks = ticks.filter(
+      (t) => Math.abs(t.pos - boundaryPos) >= collisionThreshold
+    );
+    ticks.push({ pos: boundaryPos, label: boundaryEndLabel });
+  }
+  return ticks;
+}
+
+export {
+  MONTH_ABBR,
+  computeTimeTicks
+};
+//# sourceMappingURL=chunk-YRYKTYMQ.js.map

package/dist/chunk-YYVTBZZC.js

@@ -0,0 +1,61 @@
+// src/utils/scaling.ts
+var DEFAULT_MIN_SCALE_FACTOR = 0.5;
+var TEXT_FLOOR = 9;
+var ScaleContext = class _ScaleContext {
+  factor;
+  isBelowFloor;
+  constructor(factor, minScaleFactor) {
+    this.factor = factor;
+    this.isBelowFloor = factor <= minScaleFactor;
+  }
+  static from(containerSize, idealSize, minScaleFactor = DEFAULT_MIN_SCALE_FACTOR) {
+    if (idealSize <= 0) return _ScaleContext.identity();
+    const raw = containerSize / idealSize;
+    const clamped = Math.max(Math.min(raw, 1), minScaleFactor);
+    return new _ScaleContext(clamped, minScaleFactor);
+  }
+  /**
+   * Fit content into a bounding box, scaling by whichever dimension is more
+   * constraining (the smaller of the width- and height-fit ratios) so the
+   * diagram never overflows the canvas in either axis. Like {@link from}, the
+   * factor is clamped to `[minScaleFactor, 1]` (content is never enlarged, and
+   * never shrunk past the readability floor).
+   */
+  static fromBox(containerWidth, idealWidth, containerHeight, idealHeight, minScaleFactor = DEFAULT_MIN_SCALE_FACTOR) {
+    const wRaw = idealWidth > 0 ? containerWidth / idealWidth : 1;
+    const hRaw = idealHeight > 0 ? containerHeight / idealHeight : 1;
+    const raw = Math.min(wRaw, hRaw);
+    const clamped = Math.max(Math.min(raw, 1), minScaleFactor);
+    return new _ScaleContext(clamped, minScaleFactor);
+  }
+  /**
+   * Build a context from an explicit raw factor (clamped to
+   * `[minScaleFactor, 1]`). Used to refine a fit iteratively: layout scaling is
+   * non-linear (gaps shrink faster than floored text), so the first-pass factor
+   * can still overflow — re-measure the laid-out result and tighten.
+   */
+  static fromFactor(rawFactor, minScaleFactor = DEFAULT_MIN_SCALE_FACTOR) {
+    const clamped = Math.max(Math.min(rawFactor, 1), minScaleFactor);
+    return new _ScaleContext(clamped, minScaleFactor);
+  }
+  static identity() {
+    return new _ScaleContext(1, DEFAULT_MIN_SCALE_FACTOR);
+  }
+  aesthetic(value) {
+    if (this.factor >= 1) return value;
+    return value * this.factor ** 1.5;
+  }
+  structural(value) {
+    if (this.factor >= 1) return value;
+    return value * this.factor;
+  }
+  text(fontSize, floor = TEXT_FLOOR) {
+    if (this.factor >= 1) return fontSize;
+    return Math.max(fontSize * this.factor, floor);
+  }
+};
+
+export {
+  ScaleContext
+};
+//# sourceMappingURL=chunk-YYVTBZZC.js.map