@bicharts/chart-host 0.6.82 → 0.6.84

package/dist/types/qualifyGroups.d.ts

@@ -44,15 +44,66 @@ export interface QualifyRefusalRow {
     reason?: string | null;
     /** True = a required channel is ABSENT. Absent/false = a threshold we are willing to waive. */
     isVeto?: boolean | null;
+    /**
+     * WHICH GATE wrote `reason`, as the server's stable code. Absent from a server that predates
+     * the code, which reads as "not known to be about the tile": the row keeps the grouping the
+     * list always had.
+     */
+    reasonCode?: string | null;
 }
 /** Which heading to write BEFORE a refused row, if any. */
-export type QualifyRefusalHeading = "poorFit" | "cannotDraw";
+export type QualifyRefusalHeading = "poorFit" | "tooSmall" | "cannotDraw";
 /** Carried across the refusal loop. One per render. */
 export interface QualifyRefusalGroupState {
     poorFit: boolean;
+    tooSmall: boolean;
     cannotDraw: boolean;
 }
 export declare function newQualifyRefusalGroupState(): QualifyRefusalGroupState;
+/**
+ * THE REFUSAL CODES THAT MEAN "THE TILE", NOT "THE FIELDS".
+ *
+ * Each refusal carries the code of the gate that wrote its sentence. These gates compare what a
+ * chart type needs with the size and shape of the tile and nothing else:
+ *  - TILE_TOO_NARROW, TILE_TOO_SHORT, TILE_NOT_SQUARE, TILE_NOT_TALL: too narrow, too short, not
+ *    square enough, not tall enough.
+ *  - TILE_TOO_SMALL: a type that does not hold up on a small tile, turned down because the tile is
+ *    under the size the full catalogue needs, whatever the data is.
+ *  - EMBED_NOTHING_FITS_TILE: a headline-plus-small-drawing type whose drawing has no form that
+ *    fits the tile; the headline alone is still drawable on a plain card.
+ *  - EMBED_BEESWARM_TILE_TOO_SMALL: a beeswarm turned down because the tile is under the size it
+ *    needs.
+ * The data can be exactly right and the type is still turned down, and the one thing that changes
+ * the answer is a bigger tile.
+ *
+ * Without this split those rows sat under "Can't be drawn from the fields as bound" or "Poor fit
+ * for these fields" - headings that send the reader to rebind data that is fine.
+ *
+ * ONLY GATES THAT LOOK AT THE TILE ALONE ARE LISTED. A gate that weighs the tile against the data
+ * (ROWS_CRAMPED, a row-per-category floor; TOO_MANY_PANELS, a panel budget; CATEGORIES_TOO_WIDE)
+ * can be answered by either, so naming it a tile problem would be the same false instruction
+ * turned around. A code is added here when the server starts sending one that is purely about the
+ * tile; an unknown code keeps the grouping it had.
+ */
+export declare const QUALIFY_TILE_REFUSAL_CODES: readonly string[];
+/**
+ * THE HEADING OVER THE TILE BLOCK, in the one place every host reads it from, so the wording
+ * cannot drift between them and a test pins it once.
+ *
+ * It says what the reader can do about it, not what category the row is in, and it says nothing
+ * about the fields: the rows under it are exactly the ones the fields are not the problem for.
+ * English source text - a host that localizes looks it up like its other headings.
+ */
+export declare const QUALIFY_TOO_SMALL_HEADING = "Needs a bigger tile";
+/**
+ * IS THIS REFUSAL ABOUT THE TILE'S SIZE OR SHAPE? Decided from the server's code, never from the
+ * sentence: a host that matched the English would go blind the day the sentences are translated,
+ * and would re-derive a verdict it was already handed.
+ *
+ * A row with no code (an older server) is NOT tile-bound. That is the safe direction: it keeps
+ * the two-heading grouping the list had before the code existed.
+ */
+export declare function refusalIsTileBound(row: QualifyRefusalRow | null | undefined): boolean;
 /**
  * MAY THE READER PICK THIS ONE? The single place that answers it, in either host.
  *
@@ -63,15 +114,22 @@ export declare function newQualifyRefusalGroupState(): QualifyRefusalGroupState;
  */
 export declare function refusalIsSelectable(row: QualifyRefusalRow | null | undefined): boolean;
 /**
- * The refused rows in RENDER ORDER: everything pickable first, then the vetoes.
+ * The refused rows in RENDER ORDER: the pickable ones first, then the ones the tile alone turned
+ * down, then the vetoes the fields cause.
  *
  * A STABLE PARTITION, not a sort — within each block the server's alphabetical order survives, so
  * two answers over the same shape stay diffable. Rows without a name are dropped: a control
  * labelled with nothing cannot be chosen and a reason with no subject cannot be read.
  *
- * The two blocks are ordered pickable-first because the reader opened this section to DO something.
+ * The blocks are ordered pickable-first because the reader opened this section to DO something.
  * Putting the inert half above the actionable half makes them scroll past every chart they cannot
  * have to reach the ones they can.
+ *
+ * THE TILE BLOCK SITS BETWEEN THE TWO, and its own rows are pickable-first too. A tile refusal is
+ * a veto or a waivable one like any other (the reader may still pick the waivable ones), but what
+ * it asks of the reader is different: resize, not rebind. Every row the code marks as about the
+ * tile goes there whichever way its veto flag points, so none is left under a heading that names
+ * the fields.
  */
 export declare function orderRefusalsForDisplay<T extends QualifyRefusalRow>(rows: readonly T[] | null | undefined): T[];
 /**

package/dist/types/selection.d.ts

@@ -3,6 +3,20 @@
  * numbers. A token that is not one names no row and is skipped; no attribute, no rows.
  */
 export declare function rowIdxsFromMark(el: Element | null): number[];
+/** The most rows one published set may name: the largest window any host hands a chart. A set past it
+ *  is cut there rather than refused, because the cap bounds the work an event can ask for and a table
+ *  never holds a row beyond it. */
+export declare const ROW_SET_MAX = 250000;
+/** The rows a published set names: whole non-negative numbers only, each once, in the order given, at
+ *  most ROW_SET_MAX. Anything else in the array is dropped, and a value that is not an array names none. */
+export declare function validRowSet(rows: unknown): number[];
+/**
+ * Publish a selection as a row set: fires the cross-filter event on `container`, carrying `rows` (valid
+ * ones only) and the `source` the host passes on to its subscribers. An empty set is a clear. For a
+ * chart that computes its own selection; a chart that selects by marks needs nothing, the host reads
+ * data-row-idx itself.
+ */
+export declare function dispatchRowSet(container: Element, rows: readonly number[], source?: string): void;
 /** The keys held during a click. Cmd counts as Ctrl. */
 export interface SelectionModifiers {
     ctrl?: boolean;
@@ -89,6 +103,43 @@ export declare function nextClickedMarks(prev: ClickedMarks | null | undefined,
  * its parent. A click inside a control is neither a selection nor a click on empty canvas.
  */
 export declare function isInsideControl(target: EventTarget | Node | null | undefined, container: Element): boolean;
+/** Movement between press and release, in px on either axis, at which a gesture is a drag. */
+export declare const DRAG_NOT_CLICK_PX = 5;
+/** A pointer position in client px. */
+export interface PressPoint {
+    x: number;
+    y: number;
+}
+/** True when the pointer travelled far enough between press and release to be a drag. */
+export declare function gestureWasDrag(down: PressPoint | null | undefined, up: PressPoint, thresholdPx?: number): boolean;
+/** Where the press is parked: on the CONTAINER, so every reader (the host's click handler, a renderer
+ *  adapter, the visual's bridge) reads the one record. */
+export declare const CONTAINER_SLOT_PRESS_AT = "__lchPressAt";
+/** The recorded press on `container`, or null when there is none. */
+export declare function pressOf(container: Element | null | undefined): PressPoint | null;
+/** Forget the recorded press: the click it led to has been read. */
+export declare function clearPress(container: Element | null | undefined): void;
+/**
+ * Record where the pointer goes down on `container`, in the CAPTURE phase so a renderer that stops
+ * propagation on its own handlers still leaves its origin, and whether it then travels 5px or more
+ * before it comes up. The travel is what makes a drag that ends where it began (a lasso closed on its
+ * own start, a brush returned to its origin) still a drag: the click it leaves has moved nowhere.
+ * Returns the function that stops all of it.
+ */
+export declare function trackPress(container: HTMLElement): () => void;
+/**
+ * True when `click` ended a press whose pointer travelled DRAG_NOT_CLICK_PX or more, on the way or by where
+ * the click landed. Reads the press, never writes it.
+ *
+ * A click a pointer made carries detail >= 1. A keyboard or scripted click carries detail 0 and no
+ * pointer position, so it is compared with nothing: the press on record may be one that never produced a
+ * click (released outside the chart), and a stale press must not turn a later keyboard click into a drag.
+ */
+export declare function clickWasDrag(container: Element | null | undefined, click: {
+    clientX?: number;
+    clientY?: number;
+    detail?: number;
+} | null | undefined): boolean;
 export interface MarkResolverEnv {
     root: HTMLElement;
     doc: Document;

package/package.json

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