@bicharts/chart-host 0.5.60 → 0.5.62

package/dist/index.mjs

@@ -688,8 +688,12 @@ function filterQualifyRows(rows, term, read) {
   if (byDesc.length > 0) return { rows: byDesc, tier: "desc", term: t };
   return { rows: [], tier: "none", term: t };
 }
-var readQualifyChartRow = (r) => ({ name: r.name, description: r.description });
-var readQualifyRefusalRow = (r) => ({ name: r.name, description: r.reason });
+function readQualifyChartRow(r) {
+  return { name: r.name, description: r.description };
+}
+function readQualifyRefusalRow(r) {
+  return { name: r.name, description: r.reason };
+}
 var FILTER_ROW_PX = 32;
 var FILTER_MIN_WIDTH_PX = 420;
 var FILTER_MIN_HEIGHT_PX = 300;
@@ -705,6 +709,57 @@ function qualifyFilterGate(i) {
   if (!listNeedsFilter(i.scrollHeight, i.clientHeight)) return { show: false, why: "no-overflow" };
   return { show: true, why: "shown" };
 }
+function computeQualifyFilterView(groups, term) {
+  const g = Array.isArray(groups) ? groups : [];
+  const read = (r) => ({ name: r.name, description: r.description });
+  const collect = (section) => {
+    const out = [];
+    for (const grp of g) if (grp.section === section) for (const r of grp.rows) out.push(r);
+    return out;
+  };
+  const fitRows = collect("fits");
+  const fit = filterQualifyRows(fitRows, term, read);
+  const ref = filterQualifyRows(collect("refused"), term, read);
+  const visible = /* @__PURE__ */ new Set();
+  for (const r of fit.rows) visible.add(r.el);
+  for (const r of ref.rows) visible.add(r.el);
+  const show = [], hide = [], showHeadings = [], hideHeadings = [];
+  for (const grp of g) {
+    let any = false;
+    for (const r of grp.rows) {
+      if (visible.has(r.el)) {
+        show.push(r.el);
+        any = true;
+      } else {
+        hide.push(r.el);
+      }
+    }
+    if (grp.heading !== null) (any ? showHeadings : hideHeadings).push(grp.heading);
+  }
+  const filtering = fit.tier !== "all";
+  const openRefusals = filtering && fit.rows.length === 0 && ref.rows.length > 0;
+  let note = "none";
+  if (filtering) {
+    if (fit.tier === "desc") note = "descFallback";
+    else if (fit.tier === "none") note = openRefusals ? "onlyRefusals" : "noMatch";
+  }
+  return {
+    show,
+    hide,
+    showHeadings,
+    hideHeadings,
+    tier: fit.tier,
+    matched: fit.rows.length,
+    total: fitRows.length,
+    refusalMatched: ref.rows.length,
+    openRefusals,
+    note,
+    term: fit.term
+  };
+}
+function qualifyFilterCountText(view) {
+  return view.tier === "all" ? String(view.total) : `${view.matched} of ${view.total}`;
+}
 function inlineFilterGate(rowCount) {
   return rowCount >= INLINE_FILTER_MIN_ROWS ? { show: true, why: "shown" } : { show: false, why: "no-overflow" };
 }
@@ -985,6 +1040,7 @@ export {
   clearGeoCache,
   compileRenderFn,
   compileTrivialSource,
+  computeQualifyFilterView,
   computeSelectionCard,
   confirmLaunch,
   createChartHost,
@@ -1014,6 +1070,7 @@ export {
   qualifyAuto,
   qualifyCancel,
   qualifyFailureFallsOpen,
+  qualifyFilterCountText,
   qualifyFilterGate,
   qualifyGroupHeadingFor,
   qualifyPick,

package/dist/types/index.d.ts

@@ -13,7 +13,7 @@ export { shouldReview, buildReviewWire, bareBase64, actionFor, type ReviewGate,
 export { askApplyImprovements, type ReviewDialogOptions, type ReviewDialogText } from "./reviewDialog";
 export { qualifyGroupHeadingFor, newQualifyGroupState, type QualifyGroupRow, type QualifyGroupState, type QualifyGroupHeading, orderRefusalsForDisplay, refusalIsSelectable, hasRefusalsToShow, qualifyRefusalHeadingFor, newQualifyRefusalGroupState, type QualifyRefusalRow, type QualifyRefusalGroupState, type QualifyRefusalHeading, } from "./qualifyGroups";
 export { qualifyPick, qualifyAuto, qualifyCancel, launchGenerates, launchFavorStyle, chooserFitsViewport, shouldOpenChooserOnGenerate, shouldOpenInlineChooserOnGenerate, canConfirmLaunch, confirmLaunch, qualifyFailureFallsOpen, CHOOSER_MIN_WIDTH_PX, CHOOSER_MIN_HEIGHT_PX, type QualifyLaunchOutcome, type ChooserGateInput, } from "./qualifyLaunch";
-export { normalizeFilterTerm, filterQualifyRows, readQualifyChartRow, readQualifyRefusalRow, filterFitsChooser, listNeedsFilter, qualifyFilterGate, inlineFilterGate, FILTER_MIN_TERM_CHARS, FILTER_ROW_PX, FILTER_MIN_WIDTH_PX, FILTER_MIN_HEIGHT_PX, INLINE_FILTER_MIN_ROWS, type QualifyFilterTier, type QualifyFilterResult, type QualifyFilterRead, type QualifyFilterGateReason, type QualifyFilterGateInput, } from "./qualifyFilter";
+export { normalizeFilterTerm, filterQualifyRows, readQualifyChartRow, readQualifyRefusalRow, filterFitsChooser, listNeedsFilter, qualifyFilterGate, inlineFilterGate, FILTER_MIN_TERM_CHARS, FILTER_ROW_PX, FILTER_MIN_WIDTH_PX, FILTER_MIN_HEIGHT_PX, INLINE_FILTER_MIN_ROWS, computeQualifyFilterView, qualifyFilterCountText, type QualifyFilterTier, type QualifyFilterResult, type QualifyFilterRead, type QualifyFilterGateReason, type QualifyFilterGateInput, type QualifyFilterRow, type QualifyFilterGroup, type QualifyFilterView, type QualifyFilterNoteKind, } from "./qualifyFilter";
 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";

package/dist/types/qualifyFilter.d.ts

@@ -67,21 +67,33 @@ export type QualifyFilterRead<T> = (row: T) => {
  * and the hosts already drop it at render time.
  */
 export declare function filterQualifyRows<T>(rows: readonly T[] | null | undefined, term: string | null | undefined, read: QualifyFilterRead<T>): QualifyFilterResult<T>;
-/** Reads a fitting row (`charts[]`): `name` / `description`. */
-export declare const readQualifyChartRow: QualifyFilterRead<{
+/** Reads a fitting row (`charts[]`): `name` / `description`.
+ *
+ *  GENERIC, and it has to be. Written as a `const` with an explicit `QualifyFilterRead<{...}>`
+ *  annotation it PINS the row type, and `filterQualifyRows` then infers T from the reader instead
+ *  of from the rows - so a caller passing its own richer row type gets back an array typed as the
+ *  reader's minimal shape and fails to assign it home. Caught by the MCP tool, which passes
+ *  `EligibleChart[]` and got `{name?, description?}[]` back. */
+export declare function readQualifyChartRow<T extends {
+    name?: string | null;
+    description?: string | null;
+}>(r: T): {
     name?: string | null;
     description?: string | null;
-}>;
+};
 /**
  * Reads a REFUSED row (`refused[]`). Its second field is the gate's SENTENCE rather than a
  * description, and searching it is right for the same reason the tier exists: the sentence names
  * the reader's own columns, so "region" finding every type refused over Region is a useful
  * answer to "why isn't my chart here" - which is the only question that section is open to ask.
  */
-export declare const readQualifyRefusalRow: QualifyFilterRead<{
+export declare function readQualifyRefusalRow<T extends {
     name?: string | null;
     reason?: string | null;
-}>;
+}>(r: T): {
+    name?: string | null;
+    description?: string | null;
+};
 /**
  * THE HEIGHT THE FILTER ROW COSTS THE LIST - the row plus its 6px bottom margin.
  *
@@ -165,6 +177,83 @@ export declare function qualifyFilterGate(i: QualifyFilterGateInput): {
     show: boolean;
     why: QualifyFilterGateReason;
 };
+/** One row, as the hosts record it while BUILDING the list - the element handle plus the text it
+ *  is matched on, carried beside the element rather than scraped back out of it later. */
+export interface QualifyFilterRow<E> {
+    el: E;
+    name: string;
+    description: string;
+}
+/** A heading and the rows it introduces, in render order. `section` separates the fitting list
+ *  from the refusal block behind "Show all chart types" - two independently visible surfaces
+ *  answering two different questions, and only one of them can be auto-opened. */
+export interface QualifyFilterGroup<E> {
+    heading: E | null;
+    section: "fits" | "refused";
+    rows: QualifyFilterRow<E>[];
+}
+/** WHICH SENTENCE THE HOST HAS TO SHOW. The host owns the words (it localizes); this owns the
+ *  decision, which is the half that can differ between two hosts without anyone noticing.
+ *
+ *  "none"         - a name tier answered, or nothing is being filtered. Say nothing: the reader's
+ *                   own word was found where they expected it and needs no explanation.
+ *  "descFallback" - no name matched; these matched on description. MUST be said - a silent
+ *                   fall-through is indistinguishable from bad matching.
+ *  "onlyRefusals" - nothing that FITS matches, but something in the refusal block does. Say where
+ *                   it went; that block is now open.
+ *  "noMatch"      - nothing anywhere. NEVER phrase this like "nothing fits your data": one is a
+ *                   statement about a typed string and is fixed with backspace, the other is a
+ *                   statement about the data and is not.
+ */
+export type QualifyFilterNoteKind = "none" | "descFallback" | "onlyRefusals" | "noMatch";
+export interface QualifyFilterView<E> {
+    /** Rows to show, and rows to hide. Two lists rather than one predicate so a host can write
+     *  them in one pass without asking a Set per element. */
+    show: E[];
+    hide: E[];
+    /** Headings to show, and headings that now introduce nothing. A heading with nothing under it
+     *  is a label for an empty category, and the rule it draws reads as a divider between two
+     *  things that are not there. */
+    showHeadings: E[];
+    hideHeadings: E[];
+    tier: QualifyFilterTier;
+    /** Matches and totals for the FITTING list - what the "12 of 137" counter is made of. */
+    matched: number;
+    total: number;
+    refusalMatched: number;
+    /**
+     * Does the refusal block need to be OPEN for this term?
+     *
+     * True only when the term matches nothing that fits and something that does not. "Why isn't
+     * my chart here" is the only question that section is open to ask, and the reader has just
+     * asked it by name - the server's own sentence about why it cannot be drawn is already
+     * rendered, one collapsed checkbox away.
+     *
+     * THE HOST MUST TREAT THIS AS AN OVERRIDE, NOT A SETTING: remember what the reader's own
+     * checkbox said before the first override, and put it back the moment this goes false. An
+     * auto-expansion that sticks leaves the reader with a section they never opened.
+     */
+    openRefusals: boolean;
+    note: QualifyFilterNoteKind;
+    /** The normalized term, for the host to interpolate into whichever sentence it shows. */
+    term: string;
+}
+/**
+ * The filtered view of a whole dialog: fitting rows, refusal rows, headings and the note.
+ *
+ * ORDER IS UNTOUCHED, as everywhere else here - `show` and `hide` come out in the order the
+ * groups were built, so a host writing them in sequence cannot reorder anything by accident.
+ */
+export declare function computeQualifyFilterView<E>(groups: readonly QualifyFilterGroup<E>[], term: string | null | undefined): QualifyFilterView<E>;
+/** The counter beside the box: "12 of 137" while filtering, the plain total otherwise.
+ *
+ *  Digits only, assembled here so both hosts show the same shape of number - the words around it
+ *  (there are none today) would be the host's business, the arithmetic is not. */
+export declare function qualifyFilterCountText(view: {
+    tier: QualifyFilterTier;
+    matched: number;
+    total: number;
+}): string;
 /**
  * The same question for a host whose chooser is an INLINE, SCROLLING PANEL - and it has no size
  * clause, for the reason `shouldOpenInlineChooserOnGenerate` already sets out at length.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bicharts/chart-host",
-  "version": "0.5.60",
+  "version": "0.5.62",
   "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",