@bicharts/chart-host 0.6.76 → 0.6.78

package/dist/chunk-MGAO2DR7.mjs

@@ -0,0 +1,543 @@
+/*! @bicharts/chart-host — Apache-2.0. Bundled reference data: GeoNames (https://www.geonames.org/) CC BY 4.0; Natural Earth and US Census/TIGER (public domain). Full text: NOTICE in this package. */
+import {
+  AXIS_FILTER_CLASS,
+  CONTROL_CLASS,
+  LEGEND_MARK_CLASS,
+  MARK_CLASS,
+  MARK_KEY_ATTR,
+  MARK_SELECTED_CLASS,
+  ROW_IDX_ATTR,
+  SELECTION_RULE_ATTR,
+  SELECTION_RULE_CLICKED_MARKS
+} from "./chunk-7JWL6LYE.mjs";
+
+// src/selection.ts
+function rowIdxsFromMark(el) {
+  if (!el) return [];
+  const raw = el.getAttribute("data-row-idx");
+  if (!raw) return [];
+  const out = [];
+  for (const tok of raw.split(",")) {
+    const n = parseInt(tok.trim(), 10);
+    if (!isNaN(n) && n >= 0) out.push(n);
+  }
+  return out;
+}
+function nextSelection(current, rowIdxs, mods = {}) {
+  const cur = Array.from(current ?? []);
+  if (mods.ctrl || mods.shift) {
+    const next = new Set(cur);
+    for (const r of rowIdxs) {
+      if (next.has(r)) next.delete(r);
+      else next.add(r);
+    }
+    return Array.from(next);
+  }
+  const same = cur.length === rowIdxs.length && rowIdxs.every((r) => cur.includes(r));
+  return same ? [] : rowIdxs.slice();
+}
+function selectionRuleOf(container) {
+  try {
+    const el = container?.querySelector?.(`[${SELECTION_RULE_ATTR}]`);
+    return el?.getAttribute(SELECTION_RULE_ATTR) === SELECTION_RULE_CLICKED_MARKS ? "clicked-marks" : "any-row";
+  } catch {
+    return "any-row";
+  }
+}
+function markKeyOf(el) {
+  if (!el) return "";
+  const k = el.getAttribute(MARK_KEY_ATTR);
+  if (k != null && k !== "") return k;
+  return "rows:" + (el.getAttribute(ROW_IDX_ATTR) || "").replace(/\s+/g, "");
+}
+var toSet = (s) => new Set(Array.from(s ?? []));
+function sameRowSet(a, b) {
+  const A = toSet(a), B = toSet(b);
+  if (A.size !== B.size) return false;
+  for (const r of A) if (!B.has(r)) return false;
+  return true;
+}
+function planSelectionPaint(marks, selection, rule, clicked) {
+  const sel = toSet(selection);
+  if (sel.size === 0) return { on: marks.map(() => false), mode: "none", keys: [] };
+  const anyRow = () => marks.map((m) => m.rows.some((r) => sel.has(r)));
+  if (rule !== "clicked-marks") return { on: anyRow(), mode: "any-row", keys: [] };
+  if (clicked && clicked.keys.length && sameRowSet(clicked.selection, sel)) {
+    const want = new Set(clicked.keys);
+    const on = marks.map((m) => m.rows.length > 0 && want.has(m.key));
+    if (on.some(Boolean)) return { on, mode: "clicked", keys: marks.filter((_, i) => on[i]).map((m) => m.key) };
+  }
+  const exact = marks.map((m) => m.rows.length > 0 && sameRowSet(m.rows, sel));
+  if (exact.some(Boolean)) return { on: exact, mode: "exact", keys: marks.filter((_, i) => exact[i]).map((m) => m.key) };
+  return { on: anyRow(), mode: "fallback-any-row", keys: [] };
+}
+function nextClickedMarks(prev, current, key, next, mods = {}) {
+  if (!next.length) return null;
+  if (!(mods.ctrl || mods.shift)) return { keys: [key], selection: next.slice() };
+  const held = prev && sameRowSet(prev.selection, current) ? prev.keys : [];
+  const keys = held.includes(key) ? held.filter((k) => k !== key) : [...held, key];
+  return { keys, selection: next.slice() };
+}
+function isInsideControl(target, container) {
+  let el = target;
+  if (el && el.nodeType !== 1) el = el.parentElement ?? el.parentNode ?? null;
+  while (el && el !== container) {
+    if (el.nodeType === 1 && el.classList?.contains?.(CONTROL_CLASS)) return true;
+    el = el.parentElement ?? el.parentNode ?? null;
+  }
+  return false;
+}
+function createMarkResolver(env) {
+  const { root, doc, log } = env;
+  const isElement = (t) => {
+    const E = doc?.defaultView?.Element ?? globalThis.Element;
+    if (E && t instanceof E) return true;
+    return !!t && typeof t.closest === "function" && typeof t.getAttribute === "function";
+  };
+  const viewStyle = (n) => {
+    try {
+      const gcs = doc?.defaultView?.getComputedStyle ?? (typeof getComputedStyle === "function" ? getComputedStyle : null);
+      return gcs ? gcs(n).pointerEvents : "";
+    } catch {
+      return "";
+    }
+  };
+  const isInvisibleStrokePath = (el) => {
+    if (el.tagName.toLowerCase() !== "path") return false;
+    const f = el.getAttribute("fill");
+    if (f !== null && f !== "" && f !== "none" && f !== "transparent") return false;
+    const s = (el.getAttribute("stroke") || "").trim().toLowerCase();
+    const so = parseFloat(el.getAttribute("stroke-opacity") || "1");
+    return s === "transparent" || s === "none" || so <= 0.01;
+  };
+  const distToPathCenterline = (el, x, y) => {
+    const L = el.getTotalLength();
+    if (!(L > 0)) return Number.MAX_VALUE;
+    const m = el.getScreenCTM();
+    if (!m) return Number.MAX_VALUE;
+    let best = Number.MAX_VALUE;
+    const N = 64;
+    for (let i = 0; i <= N; i++) {
+      const pt = el.getPointAtLength(L * i / N);
+      const dx = m.a * pt.x + m.c * pt.y + m.e - x;
+      const dy = m.b * pt.x + m.d * pt.y + m.f - y;
+      const d = dx * dx + dy * dy;
+      if (d < best) best = d;
+    }
+    return Math.sqrt(best);
+  };
+  const refineHitCorridor = (mark, x, y, sel) => {
+    try {
+      if (!mark || !isInvisibleStrokePath(mark) || !mark.getAttribute("data-row-idx")) return mark;
+      const stack = doc.elementsFromPoint(x, y);
+      const candidates = [];
+      for (const el of stack) {
+        if (!root.contains(el)) continue;
+        if (!el.matches || !el.matches(sel)) continue;
+        if (!el.getAttribute("data-row-idx")) continue;
+        if (!isInvisibleStrokePath(el)) continue;
+        candidates.push(el);
+      }
+      if (candidates.indexOf(mark) < 0) candidates.push(mark);
+      if (candidates.length < 2) return mark;
+      let best = mark;
+      let bestD = Number.MAX_VALUE;
+      for (const el of candidates) {
+        const d = distToPathCenterline(el, x, y);
+        if (d < bestD) {
+          bestD = d;
+          best = el;
+        }
+      }
+      if (best !== mark) {
+        log("d3-hit-corridor-refined", {
+          candidates: candidates.length,
+          distPx: Math.round(bestD),
+          fromRows: (mark.getAttribute("data-row-idx") || "").slice(0, 24),
+          toRows: (best.getAttribute("data-row-idx") || "").slice(0, 24)
+        });
+      }
+      return best;
+    } catch {
+      return mark;
+    }
+  };
+  const findMark = (target, sel = ".d3-mark", ev) => {
+    if (!isElement(target)) return null;
+    const el = target;
+    const m = el.closest(sel);
+    if (m && ev) return refineHitCorridor(m, ev.clientX, ev.clientY, sel);
+    return m;
+  };
+  const penetrateOverlayAt = (x, y, sel) => {
+    try {
+      const stack = doc.elementsFromPoint(x, y);
+      for (const el of stack) {
+        if (!root.contains(el) || !isElement(el)) continue;
+        const cand = el.matches(sel) ? el : el.closest(sel);
+        if (!cand || !root.contains(cand) || !cand.getAttribute("data-row-idx")) continue;
+        log("d3_click-overlay-penetrated", { tag: el.tagName, cls: el.getAttribute("class"), via: el === cand ? "self" : "closest" });
+        return cand;
+      }
+    } catch {
+    }
+    return null;
+  };
+  const resolveByGeometry = (x, y, sel) => {
+    try {
+      const cands = root.querySelectorAll(sel);
+      let best = null, bestArea = Number.MAX_VALUE;
+      if (cands.length <= 600) {
+        for (const el of Array.from(cands)) {
+          if (!el.getAttribute("data-row-idx")) continue;
+          const r = el.getBoundingClientRect ? el.getBoundingClientRect() : null;
+          if (!r || r.width <= 0 || r.height <= 0) continue;
+          if (x < r.left || x > r.right || y < r.top || y > r.bottom) continue;
+          const area = r.width * r.height;
+          if (area < bestArea) {
+            bestArea = area;
+            best = el;
+          }
+        }
+      }
+      const hasHittableShape = (node) => {
+        const SHAPE = /^(rect|circle|ellipse|path|line|polygon|polyline|text|image|use)$/;
+        const all = [node, ...Array.from(node.querySelectorAll("*"))];
+        for (const n of all) {
+          const tag = (n.tagName || "").toLowerCase();
+          if (!SHAPE.test(tag)) continue;
+          const pe = viewStyle(n);
+          if (pe && pe !== "none") return true;
+        }
+        return false;
+      };
+      if (best && !hasHittableShape(best)) {
+        log("d3_click-geom-resolved", { rows: (best.getAttribute("data-row-idx") || "").slice(0, 24) });
+        return best;
+      } else if (best) {
+        log("d3_click-geom-skip-hittable", {});
+      }
+    } catch {
+    }
+    return null;
+  };
+  return { isInvisibleStrokePath, distToPathCenterline, refineHitCorridor, findMark, rowIdxsFromMark, penetrateOverlayAt, resolveByGeometry };
+}
+function collectD3GlyphCenters(container, baseRect, out) {
+  const Point = container.ownerDocument?.defaultView?.DOMPoint ?? globalThis.DOMPoint;
+  const marks = container.querySelectorAll(`.${MARK_CLASS}.${MARK_SELECTED_CLASS}`);
+  const rects = [];
+  for (let i = 0; i < marks.length; i++) {
+    const r = marks[i].getBoundingClientRect();
+    rects.push(r);
+  }
+  const CONTAINMENT_CAP = 300;
+  const EPS = 1;
+  const filterContainers = marks.length <= CONTAINMENT_CAP;
+  const enclosesAnother = (ci) => {
+    const c = rects[ci];
+    const cArea = c.width * c.height;
+    if (cArea <= 0) return false;
+    for (let mj = 0; mj < rects.length; mj++) {
+      if (mj === ci) continue;
+      const m = rects[mj];
+      const mArea = m.width * m.height;
+      if (mArea <= 0 || mArea >= cArea) continue;
+      if (m.left >= c.left - EPS && m.right <= c.right + EPS && m.top >= c.top - EPS && m.bottom <= c.bottom + EPS) return true;
+    }
+    return false;
+  };
+  for (let i = 0; i < marks.length; i++) {
+    const el = marks[i];
+    const r = rects[i];
+    if (r.width === 0 && r.height === 0) continue;
+    if (filterContainers && enclosesAnother(i)) continue;
+    const tag = el.tagName.toLowerCase();
+    let sx;
+    let sy;
+    const cxA = el.getAttribute("data-cx"), cyA = el.getAttribute("data-cy");
+    if (cxA != null && cyA != null && typeof el.getScreenCTM === "function") {
+      const ctm = el.getScreenCTM();
+      const cxN = parseFloat(cxA), cyN = parseFloat(cyA);
+      if (ctm && isFinite(cxN) && isFinite(cyN)) {
+        const p = new Point(cxN, cyN).matrixTransform(ctm);
+        sx = p.x;
+        sy = p.y;
+      }
+    }
+    if (sx === void 0 && tag === "path" && typeof el.getPointAtLength === "function") {
+      try {
+        const len = el.getTotalLength();
+        const ctm = el.getScreenCTM();
+        if (len > 0 && ctm) {
+          const dAttr = el.getAttribute("d") || "";
+          const isArcSector = /[Aa]/.test(dAttr) && !/[CcSsQqTt]/.test(dAttr);
+          let local;
+          if (isArcSector) {
+            const N = 24;
+            let ax = 0, ay = 0;
+            for (let k = 0; k < N; k++) {
+              const sp = el.getPointAtLength(len * k / N);
+              ax += sp.x;
+              ay += sp.y;
+            }
+            const cand = new Point(ax / N, ay / N);
+            let inside = true;
+            try {
+              if (typeof el.isPointInFill === "function") {
+                inside = el.isPointInFill(cand);
+              }
+            } catch {
+              inside = true;
+            }
+            if (inside) local = cand;
+          }
+          if (!local) local = el.getPointAtLength(len / 2);
+          const p = local.matrixTransform(ctm);
+          sx = p.x;
+          sy = p.y;
+        }
+      } catch {
+      }
+    }
+    if (sx === void 0 || sy === void 0) {
+      const isRect = tag === "rect";
+      sx = isRect ? r.left + r.width * 0.8 : r.left + r.width / 2;
+      sy = isRect ? r.top + r.height * 0.2 : r.top + r.height / 2;
+    }
+    out.push({ x: sx - baseRect.left, y: sy - baseRect.top });
+  }
+}
+var SELECTION_GLYPH_CLASS = "lch-sel-glyph";
+function clearSelectionGlyphs(overlay) {
+  if (overlay) {
+    while (overlay.firstChild) overlay.removeChild(overlay.firstChild);
+  }
+}
+function paintSelectionGlyphs(overlay, centers, style) {
+  const doc = overlay.ownerDocument;
+  const frag = doc.createDocumentFragment();
+  const count = Math.min(centers.length, style.max ?? 600);
+  for (let i = 0; i < count; i++) {
+    const c = centers[i];
+    const g = doc.createElement("span");
+    g.className = SELECTION_GLYPH_CLASS;
+    g.textContent = style.symbol;
+    g.style.position = "absolute";
+    g.style.left = c.x + "px";
+    g.style.top = c.y + "px";
+    g.style.transform = "translate(-50%, -50%)";
+    g.style.font = "700 11px/1 system-ui, -apple-system, Segoe UI, sans-serif";
+    g.style.color = style.color;
+    const halo = style.halo;
+    g.style.textShadow = `-1px -1px 1px ${halo}, 1px -1px 1px ${halo}, -1px 1px 1px ${halo}, 1px 1px 1px ${halo}, 0 0 2px ${halo}`;
+    g.style.pointerEvents = "none";
+    frag.appendChild(g);
+  }
+  overlay.appendChild(frag);
+  return count;
+}
+
+// src/hitTargets.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var HIT_ATTR = "data-lch-hit";
+var ELEMENT_CAP = 5e3;
+var mapsPresentationAttributes = /* @__PURE__ */ new WeakMap();
+function engineMapsPresentationAttributes(ownerDoc, view) {
+  if (!ownerDoc || typeof ownerDoc !== "object") return false;
+  const known = mapsPresentationAttributes.get(ownerDoc);
+  if (known !== void 0) return known;
+  let maps = false;
+  try {
+    const host = ownerDoc.documentElement;
+    const probe = ownerDoc.createElementNS(SVG_NS, "svg");
+    const shape = ownerDoc.createElementNS(SVG_NS, "rect");
+    shape.setAttribute("fill", "none");
+    probe.appendChild(shape);
+    host.appendChild(probe);
+    try {
+      maps = String(view.getComputedStyle(shape).fill ?? "").trim().toLowerCase() === "none";
+    } finally {
+      host.removeChild(probe);
+    }
+  } catch {
+    maps = false;
+  }
+  mapsPresentationAttributes.set(ownerDoc, maps);
+  return maps;
+}
+function ensureCrossfilterHitTargets(container, doc) {
+  const report = { tagged: 0, hitRects: 0, peFlips: 0, peStrokeOnly: 0 };
+  try {
+    if (!container || typeof container.querySelectorAll !== "function") return report;
+    const els = container.querySelectorAll(
+      `.${MARK_CLASS}, .${LEGEND_MARK_CLASS}, .${AXIS_FILTER_CLASS}`
+    );
+    report.tagged = els.length;
+    if (els.length === 0 || els.length > ELEMENT_CAP) return report;
+    const ownerDoc = doc ?? container.ownerDocument;
+    const view = ownerDoc?.defaultView;
+    const computed = (el) => {
+      try {
+        return view?.getComputedStyle ? view.getComputedStyle(el) : null;
+      } catch {
+        return null;
+      }
+    };
+    for (const el of Array.from(els)) {
+      const tag = String(el.tagName || "").toLowerCase();
+      if (tag === "g") {
+        if (!el.hasAttribute?.(ROW_IDX_ATTR)) continue;
+        if (el.querySelector?.(`rect[${HIT_ATTR}="1"]`)) continue;
+        const cls = el.getAttribute?.("class") || "";
+        const isFurniture = cls.indexOf(LEGEND_MARK_CLASS) >= 0 || cls.indexOf(AXIS_FILTER_CLASS) >= 0;
+        if (!isFurniture) {
+          let hasHittableChild = false;
+          const kids = el.querySelectorAll?.("*") ?? [];
+          for (const kid of Array.from(kids)) {
+            const ktag = String(kid.tagName || "").toLowerCase();
+            if (ktag === "g" || ktag === "tspan" || ktag === "title" || ktag === "defs") continue;
+            const cs = computed(kid);
+            if (!cs || cs.pointerEvents !== "none") {
+              hasHittableChild = true;
+              break;
+            }
+          }
+          if (hasHittableChild) continue;
+        }
+        let bb = null;
+        try {
+          bb = el.getBBox?.();
+        } catch {
+          bb = null;
+        }
+        if (!bb || !(bb.width > 0) || !(bb.height > 0)) continue;
+        const rect = ownerDoc.createElementNS(SVG_NS, "rect");
+        rect.setAttribute("x", String(bb.x));
+        rect.setAttribute("y", String(bb.y));
+        rect.setAttribute("width", String(bb.width));
+        rect.setAttribute("height", String(bb.height));
+        rect.setAttribute("fill", "transparent");
+        rect.setAttribute(HIT_ATTR, "1");
+        if (rect.style) {
+          rect.style.pointerEvents = "all";
+          rect.style.cursor = "pointer";
+        }
+        el.insertBefore(rect, el.firstChild);
+        report.hitRects++;
+      } else {
+        const cs = computed(el);
+        if (cs && cs.pointerEvents === "none") {
+          const fill = String((engineMapsPresentationAttributes(ownerDoc, view) ? cs.fill : el.getAttribute?.("fill") ?? cs.fill) ?? "").trim().toLowerCase();
+          const unfilled = fill === "none" || fill === "transparent" || fill === "rgba(0, 0, 0, 0)";
+          if (el.style) el.style.pointerEvents = unfilled ? "stroke" : "all";
+          report.peFlips++;
+          if (unfilled) report.peStrokeOnly++;
+        }
+      }
+    }
+  } catch {
+  }
+  return report;
+}
+
+// src/hitBands.ts
+var MIN_HIT_BAND_PX = 8;
+var ELEMENT_CAP2 = 5e3;
+var EMPTY = {
+  openStrokes: 0,
+  interactive: 0,
+  hairline: 0,
+  uncovered: 0,
+  widestPx: 0
+};
+var OPEN_TAGS = /* @__PURE__ */ new Set(["path", "line", "polyline"]);
+function styleOf(el, doc) {
+  try {
+    const view = doc?.defaultView;
+    return view?.getComputedStyle ? view.getComputedStyle(el) : null;
+  } catch {
+    return null;
+  }
+}
+function attrOrComputed(el, name, cs) {
+  const a = el.getAttribute?.(name);
+  if (a !== null && a !== void 0 && String(a).trim() !== "") return String(a).trim();
+  const c = cs?.[name === "stroke-width" ? "strokeWidth" : name];
+  return c === null || c === void 0 ? "" : String(c).trim();
+}
+function isUnfilled(fill) {
+  const f = fill.toLowerCase();
+  return f === "none" || f === "transparent" || f === "rgba(0, 0, 0, 0)" || f === "rgba(0,0,0,0)";
+}
+function widthPx(raw) {
+  const m = /^(-?\d+(?:\.\d+)?)\s*(px)?$/i.exec(raw);
+  if (!m) return NaN;
+  const n = parseFloat(m[1]);
+  return isFinite(n) ? n : NaN;
+}
+function censusHitBands(container, doc) {
+  if (!container || typeof container.querySelectorAll !== "function") return EMPTY;
+  try {
+    const els = Array.from(
+      container.querySelectorAll(`.${MARK_CLASS}, [${ROW_IDX_ATTR}]`)
+    );
+    if (els.length === 0 || els.length > ELEMENT_CAP2) return EMPTY;
+    const ownerDoc = doc ?? container.ownerDocument;
+    const widestByGeom = /* @__PURE__ */ new Map();
+    const rows = [];
+    for (const el of els) {
+      const tag = String(el.tagName || "").toLowerCase();
+      if (!OPEN_TAGS.has(tag)) continue;
+      const cs = styleOf(el, ownerDoc);
+      const open = isUnfilled(attrOrComputed(el, "fill", cs));
+      const w = widthPx(attrOrComputed(el, "stroke-width", cs) || "1");
+      const geom = String(el.getAttribute?.("d") ?? "") || `${tag}#${String(el.getAttribute?.(ROW_IDX_ATTR) ?? "")}`;
+      const inert = String(cs?.pointerEvents ?? el.style?.pointerEvents ?? "") === "none";
+      rows.push({ el, geom, w, open, inert });
+      if (isFinite(w)) {
+        const prev = widestByGeom.get(geom);
+        if (prev === void 0 || w > prev) widestByGeom.set(geom, w);
+      }
+    }
+    const out = { ...EMPTY };
+    for (const r of rows) {
+      if (!r.open) continue;
+      out.openStrokes++;
+      if (r.inert) continue;
+      out.interactive++;
+      if (isFinite(r.w) && r.w > out.widestPx) out.widestPx = Math.round(r.w);
+      if (!(r.w < MIN_HIT_BAND_PX)) continue;
+      out.hairline++;
+      const best = widestByGeom.get(r.geom);
+      if (best === void 0 || best < MIN_HIT_BAND_PX) out.uncovered++;
+    }
+    return out;
+  } catch {
+    return EMPTY;
+  }
+}
+function hitBandFlag(c) {
+  if (c.interactive === 0) return "";
+  return c.uncovered > 0 ? "hitband:d3:thin" : "hitband:d3:ok";
+}
+
+export {
+  rowIdxsFromMark,
+  nextSelection,
+  selectionRuleOf,
+  markKeyOf,
+  sameRowSet,
+  planSelectionPaint,
+  nextClickedMarks,
+  isInsideControl,
+  createMarkResolver,
+  collectD3GlyphCenters,
+  SELECTION_GLYPH_CLASS,
+  clearSelectionGlyphs,
+  paintSelectionGlyphs,
+  ensureCrossfilterHitTargets,
+  MIN_HIT_BAND_PX,
+  censusHitBands,
+  hitBandFlag
+};