@bicharts/chart-host 0.5.58 → 0.5.59

package/dist/{chunk-UUH6S5Q5.mjs → chunk-WG4NTR5H.mjs}

@@ -1227,6 +1227,87 @@ function blankRenderFlag(lang, cause) {
   return `blankrender:${clean(lang)}:${clean(cause)}`;
 }
 
+// src/hitBands.ts
+var MIN_HIT_BAND_PX = 8;
+var ELEMENT_CAP2 = 5e3;
+var EMPTY2 = {
+  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 a2 = el.getAttribute?.(name);
+  if (a2 !== null && a2 !== void 0 && String(a2).trim() !== "") return String(a2).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 m2 = /^(-?\d+(?:\.\d+)?)\s*(px)?$/i.exec(raw);
+  if (!m2) return NaN;
+  const n = parseFloat(m2[1]);
+  return isFinite(n) ? n : NaN;
+}
+function censusHitBands(container, doc) {
+  if (!container || typeof container.querySelectorAll !== "function") return EMPTY2;
+  try {
+    const els = Array.from(
+      container.querySelectorAll(`.${MARK_CLASS}, [${ROW_IDX_ATTR}]`)
+    );
+    if (els.length === 0 || els.length > ELEMENT_CAP2) return EMPTY2;
+    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 = { ...EMPTY2 };
+    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 EMPTY2;
+  }
+}
+function hitBandFlag(c) {
+  if (c.interactive === 0) return "";
+  return c.uncovered > 0 ? "hitband:d3:thin" : "hitband:d3:ok";
+}
+
 // src/host.ts
 function sessionViewStateProvider(container) {
   const holder = container;
@@ -1550,6 +1631,12 @@ function createChartHost(container, config) {
         }
       } catch {
       }
+      if (config.onHitBandCensus) {
+        try {
+          config.onHitBandCensus(censusHitBands(container, doc));
+        } catch {
+        }
+      }
     },
     setOptions(partial) {
       raw = { ...raw, ...partial };
@@ -1655,6 +1742,9 @@ export {
   censusMarks,
   isBlankRender,
   blankRenderFlag,
+  MIN_HIT_BAND_PX,
+  censusHitBands,
+  hitBandFlag,
   sessionViewStateProvider,
   noopViewStateProvider,
   requiredD3Plugins,

package/dist/index.mjs

@@ -31,12 +31,14 @@ import {
   LIFT_SELECTED_CLASS,
   MARK_CLASS,
   MARK_SELECTED_CLASS,
+  MIN_HIT_BAND_PX,
   ROW_IDX_ATTR,
   SELECTION_ACTIVE_CLASS,
   VALUE_AXIS_BASELINE_DEFAULT,
   XFILTER_REFRESH_EVENT,
   blankRenderFlag,
   buildRenderPayload,
+  censusHitBands,
   censusMarks,
   chartOwnsTimeline,
   clearGeoCache,
@@ -47,6 +49,7 @@ import {
   explainRenderFailure,
   geoAssetFor,
   geoFromCache,
+  hitBandFlag,
   isBlankRender,
   loadGeo,
   ne,
@@ -59,7 +62,7 @@ import {
   sessionViewStateProvider,
   stripEsmExports,
   te
-} from "./chunk-UUH6S5Q5.mjs";
+} from "./chunk-WG4NTR5H.mjs";
 import "./chunk-A2GMXZP7.mjs";
 
 // src/trivial.ts
@@ -898,6 +901,7 @@ export {
   LIFT_SELECTED_CLASS,
   MARK_CLASS,
   MARK_SELECTED_CLASS,
+  MIN_HIT_BAND_PX,
   ROW_IDX_ATTR,
   SELECTION_ACTIVE_CLASS,
   VALUE_AXIS_BASELINE_DEFAULT,
@@ -910,6 +914,7 @@ export {
   buildReviewWire,
   canConfirmLaunch,
   captureSvgSnapshot,
+  censusHitBands,
   censusMarks,
   chartOwnsTimeline,
   chooserFitsViewport,
@@ -925,6 +930,7 @@ export {
   geoAssetFor,
   geoFromCache,
   hasRefusalsToShow,
+  hitBandFlag,
   isBlankRender,
   launchFavorStyle,
   launchGenerates,

package/dist/react.mjs

@@ -4,7 +4,7 @@ import {
   createChartHost,
   geoFromCache,
   loadGeo
-} from "./chunk-UUH6S5Q5.mjs";
+} from "./chunk-WG4NTR5H.mjs";
 import "./chunk-A2GMXZP7.mjs";
 
 // src/react.tsx

package/dist/types/hitBands.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Narrowest stroke, in CSS pixels, that counts as a real click target.
+ *
+ * The generated-code recipe asks for 10-14px. Eight is the floor rather than the target: it is
+ * generous enough that a chart which made a deliberate effort is not counted as a defect, and it
+ * is the same number the server-side rule uses, so the two halves cannot drift into disagreeing
+ * about which strokes are thin.
+ */
+export declare const MIN_HIT_BAND_PX = 8;
+export interface HitBandCensus {
+    /** Tagged marks that are OPEN strokes (`fill` none/transparent with a painted stroke). */
+    openStrokes: number;
+    /** Of those, the ones the chart has not opted out of with `pointer-events:none`. */
+    interactive: number;
+    /** Of the interactive ones, those whose own band is under `MIN_HIT_BAND_PX`. */
+    hairline: number;
+    /** Of the hairlines, those with no wider companion sharing their geometry. THE DEFECT. */
+    uncovered: number;
+    /** Widest band, rounded, seen on any interactive open stroke — for tuning the floor. */
+    widestPx: number;
+}
+/**
+ * Count the declared marks that are open strokes, and how many of them are too thin to hit.
+ *
+ * A companion is any OTHER tagged element sharing this one's geometry (the same `d`, or the same
+ * row index when there is no `d`) whose band clears the floor. That is exactly the recipe's
+ * shape, and it means a chart which drew its hit band correctly reports `uncovered: 0` however it
+ * spelled the transparency — the width is what makes a band a band.
+ *
+ * A mark whose own visible stroke is already wide is its OWN hit band and is never counted as a
+ * hairline. A Sankey link is the case that matters: its thickness is its value, routinely 10-40px,
+ * and asking it for a companion would be asking for a second hit area on top of a good one.
+ *
+ * Never throws — telemetry must not be the reason a delivered render fails. An unreadable width
+ * counts as WIDE (`NaN` fails the `< MIN_HIT_BAND_PX` test), because a census that guesses
+ * "defect" when it cannot measure would report the environment rather than the chart.
+ */
+export declare function censusHitBands(container: any, doc?: any): HitBandCensus;
+/**
+ * The always-on behaviour tag for this census, or "" when there is nothing to say.
+ *
+ * One tag per render in the `hitband:` namespace, so the rate is a `LIKE` away and the three
+ * states sum to every render that drew an open stroke — a rate needs a denominator, and
+ * `hitband:d3:ok` is it. Charts with no open-stroke marks at all emit nothing rather than a
+ * third value nobody will remember to exclude.
+ */
+export declare function hitBandFlag(c: HitBandCensus): string;

package/dist/types/host.d.ts

@@ -1,6 +1,7 @@
 import { type RenderOptions, type ViewStateProvider } from "./contract";
 import { type ResolveOptionsInput } from "./defaults";
 import { type MarkCensus } from "./blankRender";
+import { type HitBandCensus } from "./hitBands";
 export type RenderFn = (container: HTMLElement, data: any, options: RenderOptions) => void;
 /**
  * THE SESSION PROVIDER — what every host got hard-coded before contract 1.6.0, now named.
@@ -77,6 +78,18 @@ export interface ChartHostConfig {
         census: MarkCensus;
         rows: number;
     }) => void;
+    /**
+     * Called after every render with the hit-band census — how many of this chart's marks are
+     * thin open strokes, and how many of those have no wider companion to catch a click
+     * (2026-09-03). Counts only; the host decides what, if anything, to record. It fires even
+     * when everything is fine, because a rate needs a denominator and `interactive` is it: a
+     * chart with no open-stroke marks reports zeroes and should be excluded, not counted as good.
+     *
+     * This is the half a server-side code check structurally cannot do. A regex reads
+     * `.attr('stroke-width', 2)` and nothing else; `.attr('stroke-width', d => scale(d.v))` is a
+     * number only the browser knows, and this reads the COMPUTED width off the rendered element.
+     */
+    onHitBandCensus?: (census: HitBandCensus) => void;
     /** This chart declares time keyframes: frame one is allowed to be empty, so no blank verdict
      *  is issued for it. */
     animated?: boolean;

package/dist/types/index.d.ts

@@ -16,3 +16,4 @@ export { qualifyPick, qualifyAuto, qualifyCancel, launchGenerates, launchFavorSt
 export { computeSelectionCard, normaliseAggregation, type SelectionCardModel, type SelectionCardLine, type SelectionCardOptions, } from "./selectionCard";
 export { ensureCrossfilterHitTargets, type HitTargetReport } from "./hitTargets";
 export { censusMarks, isBlankRender, blankRenderFlag, type MarkCensus, type BlankVerdictInput } from "./blankRender";
+export { censusHitBands, hitBandFlag, MIN_HIT_BAND_PX, type HitBandCensus } from "./hitBands";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bicharts/chart-host",
-  "version": "0.5.58",
+  "version": "0.5.59",
   "description": "Run a BIC-generated D3 chart in any web host: compiles the generated render() function, applies the shared option defaults, resolves mark clicks (through tooltip overlays), owns the selection affordance, and translates row indices between cross-filtered charts. The same contract the BIC Power BI visual implements, minus Power BI. React bindings at @bicharts/chart-host/react.",
   "license": "Apache-2.0",
   "type": "module",