@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-P6T66CCZ.js

@@ -0,0 +1,226 @@
+import {
+  CATEGORICAL_COLOR_ORDER
+} from "./chunk-TLVIHFRO.js";
+
+// src/palettes/color-utils.ts
+function hexToHSL(hex) {
+  const raw = hex.replace("#", "");
+  const full = raw.length === 3 ? [...raw].map((c) => c + c).join("") : raw;
+  const r = parseInt(full.substring(0, 2), 16) / 255;
+  const g = parseInt(full.substring(2, 4), 16) / 255;
+  const b = parseInt(full.substring(4, 6), 16) / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  if (max === min) {
+    return { h: 0, s: 0, l: Math.round(l * 100) };
+  }
+  const d = max - min;
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  let h;
+  if (max === r) {
+    h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+  } else if (max === g) {
+    h = ((b - r) / d + 2) / 6;
+  } else {
+    h = ((r - g) / d + 4) / 6;
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function hslToHex(h, s, l) {
+  const sNorm = s / 100;
+  const lNorm = l / 100;
+  if (sNorm === 0) {
+    const v = Math.round(lNorm * 255);
+    return `#${v.toString(16).padStart(2, "0")}${v.toString(16).padStart(2, "0")}${v.toString(16).padStart(2, "0")}`;
+  }
+  const hue2rgb = (p2, q2, t) => {
+    let tNorm = t;
+    if (tNorm < 0) tNorm += 1;
+    if (tNorm > 1) tNorm -= 1;
+    if (tNorm < 1 / 6) return p2 + (q2 - p2) * 6 * tNorm;
+    if (tNorm < 1 / 2) return q2;
+    if (tNorm < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - tNorm) * 6;
+    return p2;
+  };
+  const q = lNorm < 0.5 ? lNorm * (1 + sNorm) : lNorm + sNorm - lNorm * sNorm;
+  const p = 2 * lNorm - q;
+  const hNorm = h / 360;
+  const r = Math.round(hue2rgb(p, q, hNorm + 1 / 3) * 255);
+  const g = Math.round(hue2rgb(p, q, hNorm) * 255);
+  const b = Math.round(hue2rgb(p, q, hNorm - 1 / 3) * 255);
+  return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+}
+function hexToHSLString(hex) {
+  const { h, s, l } = hexToHSL(hex);
+  return `${h} ${s}% ${l}%`;
+}
+function tint(hex, amount) {
+  const raw = hex.replace("#", "");
+  const full = raw.length === 3 ? [...raw].map((c) => c + c).join("") : raw;
+  const r = parseInt(full.substring(0, 2), 16);
+  const g = parseInt(full.substring(2, 4), 16);
+  const b = parseInt(full.substring(4, 6), 16);
+  const tr = Math.round(r + (255 - r) * amount);
+  const tg = Math.round(g + (255 - g) * amount);
+  const tb = Math.round(b + (255 - b) * amount);
+  return `#${tr.toString(16).padStart(2, "0")}${tg.toString(16).padStart(2, "0")}${tb.toString(16).padStart(2, "0")}`;
+}
+function shade(hex, base, amount) {
+  const parse = (h) => {
+    const raw = h.replace("#", "");
+    const full = raw.length === 3 ? [...raw].map((c) => c + c).join("") : raw;
+    return [
+      parseInt(full.substring(0, 2), 16),
+      parseInt(full.substring(2, 4), 16),
+      parseInt(full.substring(4, 6), 16)
+    ];
+  };
+  const [r, g, b] = parse(hex);
+  const [br, bg, bb] = parse(base);
+  const sr = Math.round(r + (br - r) * amount);
+  const sg = Math.round(g + (bg - g) * amount);
+  const sb = Math.round(b + (bb - b) * amount);
+  return `#${sr.toString(16).padStart(2, "0")}${sg.toString(16).padStart(2, "0")}${sb.toString(16).padStart(2, "0")}`;
+}
+function mix(a, b, pct) {
+  const parse = (h) => {
+    const r = h.replace("#", "");
+    const f = r.length === 3 ? [...r].map((c2) => c2 + c2).join("") : r;
+    return [
+      parseInt(f.substring(0, 2), 16),
+      parseInt(f.substring(2, 4), 16),
+      parseInt(f.substring(4, 6), 16)
+    ];
+  };
+  const [ar, ag, ab] = parse(a), [br, bg, bb] = parse(b), t = pct / 100;
+  const c = (x, y) => Math.round(x * t + y * (1 - t)).toString(16).padStart(2, "0");
+  return `#${c(ar, br)}${c(ag, bg)}${c(ab, bb)}`;
+}
+function valueRampColor(low, high, t, _opts) {
+  const tc = Math.max(0, Math.min(1, t));
+  return mix(high, low, tc * 100);
+}
+function valueRampStops(low, high, _opts) {
+  return [
+    { offset: 0, color: low },
+    { offset: 1, color: high }
+  ];
+}
+function relativeLuminance(hex) {
+  const raw = hex.replace("#", "");
+  const full = raw.length === 3 ? [...raw].map((c) => c + c).join("") : raw;
+  const [r, g, b] = [
+    parseInt(full.substring(0, 2), 16) / 255,
+    parseInt(full.substring(2, 4), 16) / 255,
+    parseInt(full.substring(4, 6), 16) / 255
+  ].map((c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4);
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function contrastRatio(a, b) {
+  const la = relativeLuminance(a);
+  const lb = relativeLuminance(b);
+  const lighter = Math.max(la, lb);
+  const darker = Math.min(la, lb);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function contrastText(bg, lightText, darkText) {
+  const L = relativeLuminance(bg);
+  if (L > 0.55) return darkText;
+  const raw = bg.replace("#", "");
+  const full = raw.length === 3 ? [...raw].map((c) => c + c).join("") : raw;
+  const r = parseInt(full.substring(0, 2), 16);
+  const g = parseInt(full.substring(2, 4), 16);
+  const b = parseInt(full.substring(4, 6), 16);
+  const minRgb = Math.min(r, g, b);
+  if (minRgb >= 100) {
+    return contrastRatio(bg, darkText) > contrastRatio(bg, lightText) ? darkText : lightText;
+  }
+  return lightText;
+}
+function themeBaseBg(palette, isDark) {
+  return isDark ? palette.surface : palette.bg;
+}
+function shapeFill(palette, intent, isDark, opts) {
+  if (opts?.solid) return intent;
+  return mix(intent, themeBaseBg(palette, isDark), 25);
+}
+function getSeriesColors(palette) {
+  const c = palette.colors;
+  return CATEGORICAL_COLOR_ORDER.map((name) => c[name]);
+}
+function getSegmentColors(palette, count) {
+  if (count <= 0) return [];
+  const base = [...new Set(getSeriesColors(palette))];
+  if (count <= base.length) return base.slice(0, count);
+  const { bg, text } = palette;
+  const variants = [
+    (c) => mix(c, bg, 55),
+    // lighter
+    (c) => mix(c, text, 55),
+    // darker
+    (c) => mix(c, bg, 35),
+    (c) => mix(c, text, 35)
+  ];
+  const out = [...base];
+  for (let w = 0; out.length < count; w++) {
+    const variant = variants[w % variants.length];
+    for (const c of base) {
+      if (out.length >= count) break;
+      out.push(variant(c));
+    }
+  }
+  return out.slice(0, count);
+}
+var POLITICAL_TINT_BANDS = {
+  light: [32, 48, 64, 80],
+  dark: [44, 58, 72, 86]
+};
+function politicalTints(palette, count, isDark) {
+  if (count <= 0) return [];
+  const base = themeBaseBg(palette, isDark);
+  const c = palette.colors;
+  const swatches = [
+    .../* @__PURE__ */ new Set([
+      c.green,
+      c.yellow,
+      c.orange,
+      c.purple,
+      c.red,
+      c.teal,
+      c.cyan,
+      c.blue
+    ])
+  ];
+  const bands = isDark ? POLITICAL_TINT_BANDS.dark : POLITICAL_TINT_BANDS.light;
+  const out = [];
+  for (const pct of bands) {
+    if (out.length >= count) break;
+    for (const s of swatches) out.push(mix(s, base, pct));
+  }
+  return out.slice(0, count);
+}
+
+export {
+  hexToHSL,
+  hslToHex,
+  hexToHSLString,
+  tint,
+  shade,
+  mix,
+  valueRampColor,
+  valueRampStops,
+  relativeLuminance,
+  contrastRatio,
+  contrastText,
+  themeBaseBg,
+  shapeFill,
+  getSeriesColors,
+  getSegmentColors,
+  politicalTints
+};
+//# sourceMappingURL=chunk-P6T66CCZ.js.map

package/dist/chunk-PBAHEPLQ.js

@@ -0,0 +1,223 @@
+import {
+  measureText
+} from "./chunk-WCT3NYCV.js";
+
+// src/label-layout.ts
+function rectsOverlap(a, b) {
+  return a.x < b.x + b.w && a.x + a.w > b.x && a.y < b.y + b.h && a.y + a.h > b.y;
+}
+function rectCircleOverlap(rect, circle) {
+  const nearestX = Math.max(rect.x, Math.min(circle.cx, rect.x + rect.w));
+  const nearestY = Math.max(rect.y, Math.min(circle.cy, rect.y + rect.h));
+  const dx = nearestX - circle.cx;
+  const dy = nearestY - circle.cy;
+  return dx * dx + dy * dy < circle.r * circle.r;
+}
+function segmentRectOverlap(x0, y0, x1, y1, rect) {
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  let t0 = 0;
+  let t1 = 1;
+  const edges = [
+    [-dx, x0 - rect.x],
+    [dx, rect.x + rect.w - x0],
+    [-dy, y0 - rect.y],
+    [dy, rect.y + rect.h - y0]
+  ];
+  for (const [p, q] of edges) {
+    if (p === 0) {
+      if (q < 0) return false;
+    } else {
+      const t = q / p;
+      if (p < 0) {
+        if (t > t1) return false;
+        if (t > t0) t0 = t;
+      } else {
+        if (t < t0) return false;
+        if (t < t1) t1 = t;
+      }
+    }
+  }
+  return true;
+}
+function segmentsCross(ax, ay, bx, by, cx, cy, dx, dy) {
+  const o = (px, py, qx, qy, rx, ry) => Math.sign((qx - px) * (ry - py) - (qy - py) * (rx - px));
+  const o1 = o(ax, ay, bx, by, cx, cy);
+  const o2 = o(ax, ay, bx, by, dx, dy);
+  const o3 = o(cx, cy, dx, dy, ax, ay);
+  const o4 = o(cx, cy, dx, dy, bx, by);
+  if (o1 !== o2 && o3 !== o4) return true;
+  const onSeg = (px, py, qx, qy, rx, ry) => Math.min(px, qx) <= rx && rx <= Math.max(px, qx) && Math.min(py, qy) <= ry && ry <= Math.max(py, qy);
+  if (o1 === 0 && onSeg(ax, ay, bx, by, cx, cy)) return true;
+  if (o2 === 0 && onSeg(ax, ay, bx, by, dx, dy)) return true;
+  if (o3 === 0 && onSeg(cx, cy, dx, dy, ax, ay)) return true;
+  if (o4 === 0 && onSeg(cx, cy, dx, dy, bx, by)) return true;
+  return false;
+}
+function computeQuadrantPointLabels(points, chartBounds, obstacles, pointRadius, fontSize) {
+  const labelHeight = fontSize + 4;
+  const stepSize = labelHeight + 2;
+  const minGap = pointRadius + 4;
+  const pointCircles = points.map((p) => ({
+    cx: p.cx,
+    cy: p.cy,
+    r: pointRadius
+  }));
+  const placedLabels = [];
+  const results = [];
+  for (let i = 0; i < points.length; i++) {
+    const pt = points[i];
+    const labelWidth = measureText(pt.label, fontSize) + 8;
+    let best = null;
+    const directions = [
+      {
+        // Above
+        gen: (offset) => {
+          const lx = pt.cx - labelWidth / 2;
+          const ly = pt.cy - offset - labelHeight;
+          if (ly < chartBounds.top || lx < chartBounds.left || lx + labelWidth > chartBounds.right)
+            return null;
+          return {
+            rect: { x: lx, y: ly, w: labelWidth, h: labelHeight },
+            textX: pt.cx,
+            textY: ly + labelHeight / 2,
+            anchor: "middle"
+          };
+        }
+      },
+      {
+        // Below
+        gen: (offset) => {
+          const lx = pt.cx - labelWidth / 2;
+          const ly = pt.cy + offset;
+          if (ly + labelHeight > chartBounds.bottom || lx < chartBounds.left || lx + labelWidth > chartBounds.right)
+            return null;
+          return {
+            rect: { x: lx, y: ly, w: labelWidth, h: labelHeight },
+            textX: pt.cx,
+            textY: ly + labelHeight / 2,
+            anchor: "middle"
+          };
+        }
+      },
+      {
+        // Right
+        gen: (offset) => {
+          const lx = pt.cx + offset;
+          const ly = pt.cy - labelHeight / 2;
+          if (lx + labelWidth > chartBounds.right || ly < chartBounds.top || ly + labelHeight > chartBounds.bottom)
+            return null;
+          return {
+            rect: { x: lx, y: ly, w: labelWidth, h: labelHeight },
+            textX: lx,
+            textY: pt.cy,
+            anchor: "start"
+          };
+        }
+      },
+      {
+        // Left
+        gen: (offset) => {
+          const lx = pt.cx - offset - labelWidth;
+          const ly = pt.cy - labelHeight / 2;
+          if (lx < chartBounds.left || ly < chartBounds.top || ly + labelHeight > chartBounds.bottom)
+            return null;
+          return {
+            rect: { x: lx, y: ly, w: labelWidth, h: labelHeight },
+            textX: lx + labelWidth,
+            textY: pt.cy,
+            anchor: "end"
+          };
+        }
+      }
+    ];
+    for (const { gen } of directions) {
+      for (let offset = minGap; ; offset += stepSize) {
+        const cand = gen(offset);
+        if (!cand) break;
+        let collision = false;
+        for (const pl of placedLabels) {
+          if (rectsOverlap(cand.rect, pl)) {
+            collision = true;
+            break;
+          }
+        }
+        if (!collision) {
+          for (const circle of pointCircles) {
+            if (rectCircleOverlap(cand.rect, circle)) {
+              collision = true;
+              break;
+            }
+          }
+        }
+        if (!collision) {
+          for (const obs of obstacles) {
+            if (rectsOverlap(cand.rect, obs)) {
+              collision = true;
+              break;
+            }
+          }
+        }
+        if (!collision) {
+          const dist = offset;
+          if (!best || dist < best.dist) {
+            best = {
+              rect: cand.rect,
+              textX: cand.textX,
+              textY: cand.textY,
+              anchor: cand.anchor,
+              dist
+            };
+          }
+          break;
+        }
+      }
+    }
+    if (!best) {
+      const lx = pt.cx - labelWidth / 2;
+      const ly = pt.cy - minGap - labelHeight;
+      best = {
+        rect: { x: lx, y: ly, w: labelWidth, h: labelHeight },
+        textX: pt.cx,
+        textY: ly + labelHeight / 2,
+        anchor: "middle",
+        dist: minGap
+      };
+    }
+    placedLabels.push(best.rect);
+    let connectorLine;
+    if (best.dist > minGap + stepSize) {
+      const dx = best.textX - pt.cx;
+      const dy = best.textY - pt.cy;
+      const angle = Math.atan2(dy, dx);
+      const x1 = pt.cx + Math.cos(angle) * pointRadius;
+      const y1 = pt.cy + Math.sin(angle) * pointRadius;
+      const x2 = Math.max(
+        best.rect.x,
+        Math.min(pt.cx, best.rect.x + best.rect.w)
+      );
+      const y2 = Math.max(
+        best.rect.y,
+        Math.min(pt.cy, best.rect.y + best.rect.h)
+      );
+      connectorLine = { x1, y1, x2, y2 };
+    }
+    results.push({
+      label: pt.label,
+      x: best.textX,
+      y: best.textY,
+      anchor: best.anchor,
+      ...connectorLine !== void 0 && { connectorLine }
+    });
+  }
+  return results;
+}
+
+export {
+  rectsOverlap,
+  rectCircleOverlap,
+  segmentRectOverlap,
+  segmentsCross,
+  computeQuadrantPointLabels
+};
+//# sourceMappingURL=chunk-PBAHEPLQ.js.map