@diagrammo/dgmo 0.46.0 → 0.48.0

package/{src/utils/time-ticks.ts → dist/chunk-YRYKTYMQ.js}

@@ -1,32 +1,25 @@
-// ============================================================
-// Time axis tick computation — shared by d3.ts and gantt/renderer.ts
-// ============================================================
-
-import type * as d3Scale from 'd3-scale';
-
-export const MONTH_ABBR = [
-  'Jan',
-  'Feb',
-  'Mar',
-  'Apr',
-  'May',
-  'Jun',
-  'Jul',
-  'Aug',
-  'Sep',
-  'Oct',
-  'Nov',
-  'Dec',
+// src/utils/time-ticks.ts
+var MONTH_ABBR = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
 ];
-
-function fractionalYearToDate(frac: number): Date {
+function fractionalYearToDate(frac) {
   const year = Math.floor(frac);
   const remainder = frac - year;
-  // Inverse of: (month-1)/12 + (day-1)/365 + hour/8760 + minute/525600 + second/31536000
   const monthFrac = remainder * 12;
-  const month = Math.floor(monthFrac); // 0-based
+  const month = Math.floor(monthFrac);
   const monthRemainder = remainder - month / 12;
-  const dayFrac = monthRemainder * 365; // fractional day-of-year offset
+  const dayFrac = monthRemainder * 365;
   const day = Math.floor(dayFrac) + 1;
   const dayRemainder = dayFrac - Math.floor(dayFrac);
   const hourFrac = dayRemainder * 24;
@@ -36,55 +29,20 @@ function fractionalYearToDate(frac: number): Date {
   const second = Math.round((minuteFrac - minute) * 60);
   return new Date(year, month, day, hour, minute, second);
 }
-
-/** Convert a Date to a fractional year number. */
-function dateToFractionalYear(d: Date): number {
-  return (
-    d.getFullYear() +
-    d.getMonth() / 12 +
-    (d.getDate() - 1) / 365 +
-    d.getHours() / 8760 +
-    d.getMinutes() / 525600 +
-    d.getSeconds() / 31536000
-  );
+function dateToFractionalYear(d) {
+  return d.getFullYear() + d.getMonth() / 12 + (d.getDate() - 1) / 365 + d.getHours() / 8760 + d.getMinutes() / 525600 + d.getSeconds() / 31536e3;
 }
-
-/** Year axis label: negative years render as `N BCE`. */
-function formatYearTick(y: number): string {
+function formatYearTick(y) {
   return y < 0 ? `${-y} BCE` : String(y);
 }
-
-/**
- * Generates adaptive tick marks along a time axis.
- * Picks the right granularity (years, months, weeks, days, hours, minutes)
- * based on the domain span.
- *
- * Optional boundary parameters add ticks at exact data start/end:
- * - boundaryStart/boundaryEnd: numeric date values
- * - boundaryStartLabel/boundaryEndLabel: formatted labels for those dates
- */
-export function computeTimeTicks(
-  domainMin: number,
-  domainMax: number,
-  scale: d3Scale.ScaleLinear<number, number>,
-  boundaryStart?: number,
-  boundaryEnd?: number,
-  boundaryStartLabel?: string,
-  boundaryEndLabel?: string
-): { pos: number; label: string }[] {
+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: { pos: number; label: string }[] = [];
-
-  // Year ticks for multi-year spans (need at least 2 boundaries)
+  let ticks = [];
   const firstYear = Math.ceil(domainMin);
   const lastYear = Math.floor(domainMax);
   if (lastYear >= firstYear + 1) {
-    // Decimate ticks for long spans so labels don't overlap. The ladder runs
-    // up to century/bicentury steps so millennium-scale spans (and BCE labels,
-    // which are ~2× wider) stay legible.
     const yearSpan = lastYear - firstYear;
     let step = 1;
     if (yearSpan > 800) step = 200;
@@ -94,111 +52,89 @@ export function computeTimeTicks(
     else if (yearSpan > 40) step = 10;
     else if (yearSpan > 20) step = 5;
     else if (yearSpan > 10) step = 2;
-
-    // Align to step boundary so ticks land on round years (1700, 1710, …)
     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) {
-    // Month ticks for spans > ~3 months
     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) {
-          // m is 1..12, so MONTH_ABBR[m-1] is always defined.
-          const abbr = MONTH_ABBR[m - 1]!;
+          const abbr = MONTH_ABBR[m - 1];
           ticks.push({
             pos: scale(val),
-            label: crossesYear ? `${abbr} '${String(y).slice(-2)}` : abbr,
+            label: crossesYear ? `${abbr} '${String(y).slice(-2)}` : abbr
           });
         }
       }
     }
-  } else if (span <= 0.0000114) {
-    // Second ticks for spans ≤ ~6 minutes
-    // Adaptive step: >3min → 30s, >1min → 15s, >30s → 10s, else 5s
+  } else if (span <= 114e-7) {
     let stepSec = 5;
-    const spanSec = span * 31536000;
+    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);
-    // Round down to nearest step boundary
     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');
+        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 <= 0.000685) {
-    // Minute ticks for spans ≤ ~6 hours
-    // Adaptive step: >3h → 30min, >1h → 15min, >30min → 10min, else 5min
+  } 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;
-
-    // Iterate from the start hour boundary
     const startDate = fractionalYearToDate(domainMin);
-    // Round down to nearest step boundary
     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');
+        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 <= 0.00822) {
-    // Hour ticks for spans ≤ ~3 days
-    // Adaptive step: >2d → 6h, >1d → 3h, >12h → 2h, else 1h
+  } 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;
-
-    // For single-day spans, just show HH:MM without the date prefix
     const singleDay = spanHours <= 24;
-
     const startDate = fractionalYearToDate(domainMin);
-    // Round down to nearest step boundary
     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');
+        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 {
@@ -210,7 +146,6 @@ export function computeTimeTicks(
       startDate.setHours(startDate.getHours() + stepHour);
     }
   } else {
-    // Week ticks for spans ≤ ~3 months (1st, 8th, 15th, 22nd of each month)
     for (let y = minYear; y <= maxYear + 1; y++) {
       for (let m = 1; m <= 12; m++) {
         for (const d of [1, 8, 15, 22]) {
@@ -219,35 +154,33 @@ export function computeTimeTicks(
           if (val >= domainMin) {
             ticks.push({
               pos: scale(val),
-              label: `${MONTH_ABBR[m - 1]} ${d}`,
+              label: `${MONTH_ABBR[m - 1]} ${d}`
             });
           }
         }
       }
     }
   }
-
-  // Add boundary ticks at exact data start/end if provided
-  // When a boundary tick collides with a standard tick, replace the standard tick
-  const collisionThreshold = 40; // pixels
-
-  if (boundaryStart !== undefined && boundaryStartLabel) {
+  const collisionThreshold = 40;
+  if (boundaryStart !== void 0 && boundaryStartLabel) {
     const boundaryPos = scale(boundaryStart);
-    // Remove any standard ticks that would collide with the start boundary
     ticks = ticks.filter(
       (t) => Math.abs(t.pos - boundaryPos) >= collisionThreshold
     );
     ticks.unshift({ pos: boundaryPos, label: boundaryStartLabel });
   }
-
-  if (boundaryEnd !== undefined && boundaryEndLabel) {
+  if (boundaryEnd !== void 0 && boundaryEndLabel) {
     const boundaryPos = scale(boundaryEnd);
-    // Remove any standard ticks that would collide with the end boundary
     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