@fusion.dev/helix-headless 0.146.0 → 0.148.0

package/dist/qr-code/export.js

@@ -1,3 +1,17 @@
+export const boxIn = (rect, area, box) => {
+    const scale = box / area.width;
+    return [
+        (rect.left - area.left) * scale,
+        (rect.top - area.top) * scale,
+        rect.width * scale,
+        rect.height * scale,
+    ];
+};
+export const logoBox = (rect, area, box) => {
+    const frame = boxIn(rect, area, box);
+    const [x, y, width, height] = frame;
+    return x < 0 || y < 0 || x + width > box || y + height > box ? undefined : frame;
+};
 const attribute = (value) => value.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;');
 const unit = (value) => String(Math.round(value * 100) / 100);
 const placed = ([x, y, width, height]) => `x="${unit(x)}" y="${unit(y)}" width="${unit(width)}" height="${unit(height)}"`;

package/dist/qr-code/name.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The name a code is read by: its `label`, or with none, the word for a code,
+ * followed by the value where the value is a web address.
+ *
+ * **A value that is no web address is never read out.** A code that sets up
+ * an authenticator (`otpauth://…?secret=…`) or joins a network
+ * (`WIFI:…;P:…;;`) carries a secret in its value, and the value as the name
+ * read that secret aloud to anyone in earshot. A web address is what a
+ * sighted reader gets by scanning, so it is said after the word.
+ */
+export declare const qrName: (label: string, value: string, word: string) => string;

package/dist/qr-code/name.js

@@ -0,0 +1,7 @@
+export const qrName = (label, value, word) => {
+    if (label.trim() !== '') {
+        return label;
+    }
+    const address = value.trim();
+    return /^https?:\/\/\S+$/iu.test(address) ? `${word}, ${address}` : word;
+};

package/dist/qr-code/root/qr-code-root.d.ts

@@ -13,9 +13,12 @@ export type QrStyle = 'dots' | 'rounded' | 'square';
  * thousand modules, and an element for each would be a thousand nodes for one
  * image.
  *
- * The element has `role="img"` and an accessible name. Set the name to what the
- * code is for. When you pass no name, the value is the name. Most codes hold a
- * URL, and a URL read aloud gives the destination.
+ * The element has `role="img"` and an accessible name. Set `label` to what
+ * the code is for, such as "Open the menu". With no `label`, a code is named
+ * by `code-label`, "QR code", followed by its value where the value is a web
+ * address, which a URL read aloud makes a destination. Any other value is
+ * never read out: a code that sets up an authenticator or joins a network
+ * carries a secret in it.
  *
  * The quiet zone of four modules is required by the specification, and a
  * scanner rejects a code cropped to its edge. It is drawn inside the `viewBox`,
@@ -24,7 +27,8 @@ export type QrStyle = 'dots' | 'rounded' | 'square';
  * `correction` sets how much of the code can be lost. At `H` a code can lose
  * thirty percent and still scan, so a mark in the center slot is safe. At `L`
  * the same mark makes the code unscannable. The default is `M`, and `H` when the
- * `logo` slot is filled.
+ * `logo` slot is filled. A code that holds a logo at a `correction` below `H`
+ * warns once with the kind `unscannable-logo`.
  *
  * A higher level holds fewer characters, so a value that fits at `M` can be too
  * long once a logo raises the level to `H`. A value too long for the level
@@ -34,7 +38,8 @@ export type QrStyle = 'dots' | 'rounded' | 'square';
  * `toSvg()`, `toPng()` and `download()` give the drawn code as a file of its
  * own, in the colors it is drawn in, with a slotted image or SVG logo where
  * it sits, for a page that offers it to save or print, as Zag's download
- * trigger does.
+ * trigger does. `download()` saves an SVG for a name ending in `.svg`, and a
+ * PNG for any other.
  *
  * @since 0.1.0
  * @status stable
@@ -56,6 +61,11 @@ export type QrStyle = 'dots' | 'rounded' | 'square';
  * @cssstate overflow - The value is too long for a code at the correction level, so the fallback shows.
  */
 export declare class HelixHeadlessQrCode extends HelixElement {
+    /**
+     * The words a code with no `label` is named by, followed by its value where
+     * the value is a web address.
+     */
+    codeLabel: string;
     /**
      * The error correction level, which sets how much of the code can be lost
      * and still scan.
@@ -68,10 +78,13 @@ export declare class HelixHeadlessQrCode extends HelixElement {
      */
     correction?: QrCorrection;
     /**
-     * The image's accessible name.
+     * The image's accessible name: what the code is for, such as "Open the
+     * menu".
      *
-     * Falling back to the value is deliberate: a code almost always holds a URL,
-     * and a URL is a better name than "QR code" for a reader who cannot see it.
+     * Absent names it by `code-label` and, for a web address, the address,
+     * which is what a reader who cannot scan it needs. Any other value is left
+     * out of the name, since it may hold a secret, such as an authenticator's
+     * key or a network's password.
      */
     label: string;
     /**
@@ -100,6 +113,14 @@ export declare class HelixHeadlessQrCode extends HelixElement {
     protected firstUpdated(changed: PropertyValues): void;
     /** The level actually used, which the slot can raise. */
     private get level();
+    /** Whether this code has warned that its logo may keep it from scanning. */
+    private toldLogo;
+    /**
+     * Warns once when a logo covers a code whose level was set below `H`, where
+     * the cover can take more than the level can lose. A level the code chose
+     * itself is `H` already.
+     */
+    private auditLogo;
     /** The value and level that did not fit, so `error` fires once for each. */
     private overflowed;
     /**
@@ -137,7 +158,8 @@ export declare class HelixHeadlessQrCode extends HelixElement {
      */
     toPng(size?: number): Promise<Blob | null>;
     /**
-     * Saves the code as a PNG named `filename`, `size` pixels square.
+     * Saves the code as a file named `filename`, `size` pixels square: an SVG
+     * where the name ends in `.svg`, and a PNG otherwise.
      *
      * Call it from a press, since a browser lets a page start a download only
      * in answer to one. Does nothing where no code is drawn.

package/dist/qr-code/root/qr-code-root.js

@@ -4,11 +4,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { customElement, HelixElement, rgbOf } from '@fusion.dev/helix-core';
+import { customElement, HelixElement, reportRuntime, rgbOf, slotFilled, } from '@fusion.dev/helix-core';
 import { html, nothing, svg, } from 'lit';
 import { property } from 'lit/decorators.js';
 import { encode } from 'uqr';
-import { qrSvg } from '../export.js';
+import { boxIn, logoBox, qrSvg } from '../export.js';
+import { qrName } from '../name.js';
 const QUIET = 4;
 const pixelsOf = (image) => {
     try {
@@ -76,9 +77,11 @@ const pathFor = (matrix, style, only = 'all') => {
 let HelixHeadlessQrCode = class HelixHeadlessQrCode extends HelixElement {
     constructor() {
         super(...arguments);
+        this.codeLabel = 'QR code';
         this.label = '';
         this.value = '';
         this.logo = false;
+        this.toldLogo = false;
         this.overflowed = '';
     }
     willUpdate(changed) {
@@ -94,6 +97,17 @@ let HelixHeadlessQrCode = class HelixHeadlessQrCode extends HelixElement {
     get level() {
         return this.correction ?? (this.logo ? 'H' : 'M');
     }
+    auditLogo() {
+        if (this.toldLogo || !this.logo || (this.correction ?? 'H') === 'H') {
+            return;
+        }
+        this.toldLogo = true;
+        reportRuntime({
+            kind: 'unscannable-logo',
+            message: `<${this.localName}> holds a logo at correction "${this.correction}", which may keep it from scanning. Set \`correction\` to "H", or leave it unset.`,
+            tag: this.localName,
+        });
+    }
     encoded() {
         try {
             return encode(this.value, { border: 0, ecc: this.level });
@@ -107,6 +121,7 @@ let HelixHeadlessQrCode = class HelixHeadlessQrCode extends HelixElement {
     }
     updated(changed) {
         super.updated(changed);
+        this.auditLogo();
         const key = `${this.level}:${this.value}`;
         const overflow = this.value !== '' && this.encoded() === undefined;
         this.toggleState('overflow', overflow);
@@ -150,15 +165,8 @@ let HelixHeadlessQrCode = class HelixHeadlessQrCode extends HelixElement {
         if (!holder || holder.hidden || !mark || area.width === 0) {
             return undefined;
         }
-        const scale = box / area.width;
-        const at = (rect) => [
-            (rect.left - area.left) * scale,
-            (rect.top - area.top) * scale,
-            rect.width * scale,
-            rect.height * scale,
-        ];
-        const frame = at(holder.getBoundingClientRect());
-        if (frame[0] < 0 || frame[1] < 0 || frame[0] + frame[2] > box || frame[1] + frame[3] > box) {
+        const frame = logoBox(holder.getBoundingClientRect(), area, box);
+        if (!frame) {
             return undefined;
         }
         const fill = getComputedStyle(holder).backgroundColor;
@@ -166,7 +174,7 @@ let HelixHeadlessQrCode = class HelixHeadlessQrCode extends HelixElement {
         const logo = {
             frame,
             ground: ground ? background : rgbOf(fill),
-            mark: at(mark.getBoundingClientRect()),
+            mark: boxIn(mark.getBoundingClientRect(), area, box),
         };
         if (mark instanceof HTMLImageElement) {
             return { ...logo, href: pixelsOf(mark) };
@@ -191,11 +199,12 @@ let HelixHeadlessQrCode = class HelixHeadlessQrCode extends HelixElement {
         return new Promise((resolve) => canvas.toBlob(resolve, 'image/png'));
     }
     async download(filename = 'qr-code.png', size = 512) {
-        const png = await this.toPng(size);
-        if (!png) {
+        const svg = /\.svg$/i.test(filename) ? this.toSvg(size) : '';
+        const file = svg ? new Blob([svg], { type: 'image/svg+xml' }) : await this.toPng(size);
+        if (!file) {
             return;
         }
-        const url = URL.createObjectURL(png);
+        const url = URL.createObjectURL(file);
         const link = document.createElement('a');
         link.href = url;
         link.download = filename;
@@ -215,7 +224,7 @@ let HelixHeadlessQrCode = class HelixHeadlessQrCode extends HelixElement {
       viewBox="0 0 ${box} ${box}"
       xmlns="http://www.w3.org/2000/svg"
       role="img"
-      aria-label=${this.label || this.value}
+      aria-label=${qrName(this.label, this.value, this.codeLabel)}
       shape-rendering="crispEdges"
     >
       <path
@@ -240,7 +249,7 @@ let HelixHeadlessQrCode = class HelixHeadlessQrCode extends HelixElement {
       <slot
         name="logo"
         @slotchange=${(event) => {
-            const next = event.target.assignedNodes().length > 0;
+            const next = slotFilled(event.target);
             if (next !== this.logo) {
                 this.logo = next;
                 this.requestUpdate();
@@ -250,6 +259,9 @@ let HelixHeadlessQrCode = class HelixHeadlessQrCode extends HelixElement {
     </span>`;
     }
 };
+__decorate([
+    property({ attribute: 'code-label' })
+], HelixHeadlessQrCode.prototype, "codeLabel", void 0);
 __decorate([
     property({ attribute: 'correction' })
 ], HelixHeadlessQrCode.prototype, "correction", void 0);

package/dist/radio/group/radio-group.d.ts

@@ -30,6 +30,21 @@ declare const HelixHeadlessRadioGroup_base: (new (...args: any[]) => import("@fu
  * `helix-select`. A native radio sends `input` and `change` in the same task as
  * the click.
  *
+ * **Keyboard.** The group is one tab stop: the chosen radio, or the first that
+ * can be chosen.
+ *
+ * | Key | What it does |
+ * |---|---|
+ * | Right, Down | Chooses the next radio, from the last back to the first. |
+ * | Left, Up | Chooses the radio before, from the first round to the last. |
+ * | Home, End | Chooses the first or the last radio. |
+ * | Space, Enter | Chooses the focused radio. |
+ *
+ * Left and Right swap on a right-to-left page, and a disabled radio is passed
+ * over. Under `readonly` the arrows move focus and choose nothing. The group
+ * is a `radiogroup` named by `label`, and each radio is a `role="radio"`
+ * button with `aria-checked`.
+ *
  * @since 0.1.0
  * @status stable
  * @aliases RadioButtons, Choice group

package/dist/radio/root/radio-root.js

@@ -4,7 +4,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { customElement, HelixElement, HostClickController, MixinSelectableItem, } from '@fusion.dev/helix-core';
+import { customElement, HelixElement, HostClickController, MixinSelectableItem, slotFilled, } from '@fusion.dev/helix-core';
 import { html } from 'lit';
 import { property } from 'lit/decorators.js';
 let HelixHeadlessRadio = class HelixHeadlessRadio extends MixinSelectableItem(HelixElement) {
@@ -35,7 +35,7 @@ let HelixHeadlessRadio = class HelixHeadlessRadio extends MixinSelectableItem(He
       <span part="box" aria-hidden="true"
         ><slot
           name="indicator"
-          @slotchange=${(event) => this.toggleState('has-indicator', event.target.assignedNodes().length > 0)}
+          @slotchange=${(event) => this.toggleState('has-indicator', slotFilled(event.target))}
         ></slot
       ></span>
       <slot name="icon"></slot>

package/dist/rating/root/rating-root.d.ts

@@ -18,6 +18,20 @@ declare const HelixHeadlessRating_base: (new (...args: any[]) => import("@fusion
  * With `clearable`, pressing the chosen score again, or Backspace or Delete on
  * the marks, takes the rating back to unrated and sends `helix-clear`.
  *
+ * **Keyboard.** The marks are one tab stop, on the chosen score or the first.
+ *
+ * | Key | What it does |
+ * |---|---|
+ * | Right, Down | Chooses the next score up, and stops at the highest. |
+ * | Left, Up | Chooses the next score down, and stops at the lowest. |
+ * | Home, End | Chooses the lowest or the highest score. |
+ * | Space, Enter | Chooses the focused score, or clears it under `clearable` when it is already chosen. |
+ * | Backspace, Delete | Clears the rating, under `clearable`. |
+ *
+ * Left and Right swap on a right-to-left page. The marks are a `radiogroup`
+ * named by `label`, and each score is a `radio` named by `option-label`, such
+ * as "3 out of 5". A read-only rating is one `img` named by its score.
+ *
  * @since 0.1.0
  * @status stable
  * @category forms
@@ -172,8 +186,8 @@ export declare class HelixHeadlessRating extends HelixHeadlessRating_base {
      * each of its own options. Anything past the first slotted element is
      * ignored.
      */
-    private markSource;
-    /** Whether `markSource` has had its first answer from the children. */
+    private readonly mark;
+    /** Whether `mark` has had its first answer from the children. */
     private markRead;
     /**
      * What the pointer is over, which is shown instead of the score while it is.
@@ -215,18 +229,17 @@ export declare class HelixHeadlessRating extends HelixHeadlessRating_base {
     /** The pointer drawing a score, while one is. */
     private dragging;
     /**
-     * One clone per place a mark goes, kept so a render does not remake them.
+     * The shape for one place, or nothing when the stylesheet is drawing it.
      *
-     * A drag renders on every pointer move, and handing Lit a fresh node each
-     * time would swap every mark in the row on every frame of a gesture whose
-     * whole point is that only the fill moves.
+     * One copy per place, kept so a render does not remake them: a drag renders
+     * on every pointer move, and handing Lit a fresh node each time would swap
+     * every mark in the row on every frame of a gesture whose whole point is
+     * that only the fill moves.
      */
-    private readonly clones;
-    /** The shape for one place, or nothing when the stylesheet is drawing it. */
     private markFor;
     private readonly handleMarkSlot;
     /** The element slotted into `empty-mark`, which the track copies. */
-    private emptySource;
+    private readonly empty;
     /**
      * The step under a point on the row, or the nearest one to it.
      *

package/dist/rating/root/rating-root.js

@@ -4,10 +4,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { AriaForwardController, valueAsNumber as asNumber, customElement, fillTemplate, numberAsValue as fromNumber, HelixClearEvent, HelixFormElement, HelixPreviewEvent, KeyboardNavigationController, MixinControllerValue, MixinField, reportRuntime, } from '@fusion.dev/helix-core';
+import { AriaForwardController, valueAsNumber as asNumber, customElement, fillTemplate, numberAsValue as fromNumber, HelixClearEvent, HelixFormElement, HelixPreviewEvent, KeyboardNavigationController, MixinControllerValue, MixinField, nearest, reportRuntime, SlottedGlyph, } from '@fusion.dev/helix-core';
 import { html, nothing } from 'lit';
 import { property, state } from 'lit/decorators.js';
-import { nearestStep } from '../steps.js';
 let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue(MixinField(HelixFormElement)) {
     constructor() {
         super(...arguments);
@@ -23,7 +22,7 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
         this.aria = new AriaForwardController(this, {
             target: () => this.partNamed('marks'),
         });
-        this.markSource = undefined;
+        this.mark = new SlottedGlyph();
         this.markRead = false;
         this.previewing = undefined;
         this.keys = new KeyboardNavigationController(this, {
@@ -32,19 +31,12 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
             wrap: false,
         });
         this.dragging = undefined;
-        this.clones = new Map();
         this.handleMarkSlot = (event) => {
             const slot = event.target;
-            const source = slot.assignedElements({ flatten: true })[0];
-            this.clones.clear();
-            if (slot.name === 'empty-mark') {
-                this.emptySource = source;
-            }
-            else {
-                this.markSource = source;
-            }
+            (slot.name === 'empty-mark' ? this.empty : this.mark).read(slot);
+            this.requestUpdate();
         };
-        this.emptySource = undefined;
+        this.empty = new SlottedGlyph();
         this.handleDragStart = (event) => {
             if (this.isDisabled || this.readOnly || event.button !== 0) {
                 return;
@@ -167,21 +159,11 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
         }));
     }
     markFor(layer, index) {
-        const source = layer === 'track' ? (this.emptySource ?? this.markSource) : this.markSource;
-        if (!source) {
-            return undefined;
-        }
-        const key = `${layer}:${index}`;
-        const held = this.clones.get(key);
-        if (held) {
-            return held;
-        }
-        const clone = source.cloneNode(true);
-        this.clones.set(key, clone);
-        return clone;
+        const glyph = layer === 'track' && this.empty.slotted ? this.empty : this.mark;
+        return glyph.copyFor(`${layer}:${index}`);
     }
     scoreAt(clientX) {
-        let nearest;
+        let closest;
         let best = Number.POSITIVE_INFINITY;
         for (const option of this.renderRoot?.querySelectorAll('[part="option"]') ?? []) {
             const box = option.getBoundingClientRect();
@@ -191,10 +173,10 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
             const away = clientX < box.left ? box.left - clientX : clientX - box.right;
             if (away < best) {
                 best = away;
-                nearest = option.dataset.score;
+                closest = option.dataset.score;
             }
         }
-        return nearest;
+        return closest;
     }
     clearsAt(score) {
         return this.clearable && this.value !== '' && Number(score) === Number(this.value);
@@ -239,8 +221,8 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
         super.willUpdate(changed);
         if (!this.markRead && this.childrenKnown) {
             this.markRead = true;
-            this.markSource = this.knownChildren.find((child) => child.slot === 'mark');
-            this.emptySource = this.knownChildren.find((child) => child.slot === 'empty-mark');
+            this.mark.take(this.knownChildren.find((child) => child.slot === 'mark'));
+            this.empty.take(this.knownChildren.find((child) => child.slot === 'empty-mark'));
         }
     }
     firstUpdated(changed) {
@@ -255,7 +237,7 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
         if (!answered) {
             return first;
         }
-        return nearestStep(this.steps, this.score) ?? first;
+        return nearest(this.steps, this.score) ?? first;
     }
     render() {
         const showing = this.previewing ?? this.score;
@@ -276,7 +258,7 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
       aria-describedby=${this.describedBy ?? nothing}
       aria-invalid=${this.invalidity ?? nothing}
       aria-required=${this.required && !this.readOnly ? 'true' : nothing}
-      data-slotted=${this.markSource ? '' : nothing}
+      data-slotted=${this.mark.slotted ? '' : nothing}
       style=${`--rating-full: ${Math.floor(showing)}; --rating-part: ${showing - Math.floor(showing)}; --rating-steps: ${this.positions.length}`}
       @pointercancel=${this.handleDragCancel}
       @keydown=${this.handleClearKey}
@@ -299,7 +281,7 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
       <span
         part="track"
         aria-hidden="true"
-        data-slotted=${this.emptySource ? '' : nothing}
+        data-slotted=${this.empty.slotted ? '' : nothing}
         >${marksIn('track')}</span
       >
       <span
@@ -367,15 +349,9 @@ __decorate([
 __decorate([
     property({ attribute: 'value-text' })
 ], HelixHeadlessRating.prototype, "valueText", void 0);
-__decorate([
-    state()
-], HelixHeadlessRating.prototype, "markSource", void 0);
 __decorate([
     state()
 ], HelixHeadlessRating.prototype, "previewing", void 0);
-__decorate([
-    state()
-], HelixHeadlessRating.prototype, "emptySource", void 0);
 HelixHeadlessRating = __decorate([
     customElement('helix-headless-rating')
 ], HelixHeadlessRating);

package/dist/scatter-chart/measures.d.ts

@@ -0,0 +1,22 @@
+/** The numeric columns by what they measure. */
+export interface Measures {
+    /** The column across, the first one that is not the size. */
+    across: number | undefined;
+    /** The column `size-by` names, which sizes the points. */
+    size: number | undefined;
+    /** Every other column, each a series up. */
+    ups: number[];
+}
+/**
+ * The numeric columns by what they measure: the column whose heading
+ * `sizeBy` names as the size, by its series key, then the first of the rest
+ * across and every other one up.
+ */
+export declare const measuresOf: (columns: readonly number[], name: (column: number) => string, sizeBy: string) => Measures;
+/**
+ * Each row's point size from its reading in the size column, by area, so a
+ * point twice the measure is twice the ink: the square root of its share of
+ * the largest. A size below zero is none, and a row with no size, or a column
+ * whose largest is not above zero, has no weight.
+ */
+export declare const bubbleWeights: (sizes: readonly (number | undefined)[]) => (number | undefined)[];

package/dist/scatter-chart/measures.js

@@ -0,0 +1,11 @@
+import { seriesKey } from '@fusion.dev/helix-core';
+export const measuresOf = (columns, name, sizeBy) => {
+    const key = seriesKey(sizeBy);
+    const size = key === '' ? undefined : columns.find((column) => seriesKey(name(column)) === key);
+    const [across, ...ups] = columns.filter((column) => column !== size);
+    return { across, size, ups };
+};
+export const bubbleWeights = (sizes) => {
+    const largest = Math.max(0, ...sizes.map((one) => one ?? 0));
+    return sizes.map((one) => one === undefined || largest <= 0 ? undefined : Math.sqrt(Math.max(0, one) / largest));
+};

package/dist/scatter-chart/root/scatter-chart-root.d.ts

@@ -1,10 +1,16 @@
 import { HelixElement } from '@fusion.dev/helix-core';
 import { nothing, type TemplateResult } from 'lit';
 import '../../tooltip/index.js';
+import { type Measures } from '../measures.js';
 /** One row drawn as a point: which row, which series, and where, in percent of the plot. */
 export interface ScatterPoint {
     depth: number;
     row: number;
+    /**
+     * How large the point is drawn under `size-by`, from 0 to 1: the square root
+     * of its share of the largest size, so its area follows the measure.
+     */
+    weight?: number | undefined;
     x: number;
     y: number;
 }
@@ -35,6 +41,11 @@ declare const HelixHeadlessScatterChart_base: typeof HelixElement & (new (...arg
  * `trend` draws each series' line of best fit, by least squares, across the
  * plot in the series' color.
  *
+ * **`size-by` names a third measure, drawn as each point's size**, as a bubble
+ * chart does: `size-by="Population"` takes that column out of the series and
+ * gives each point an area in proportion to its row's number there. The
+ * tooltip and the table still say the number.
+ *
  * The summary gives each series' correlation coefficient and its number of
  * points. The table has every number, and the drawing is hidden from screen
  * readers.
@@ -94,6 +105,7 @@ declare const HelixHeadlessScatterChart_base: typeof HelixElement & (new (...arg
  * @csspart y-name - The name of the vertical measure.
  * @csspart y-tick - One labeled value on the vertical axis.
  *
+ * @cssproperty --chart-point-weight - How large a point is drawn under `size-by`, from 0 to 1, by area. The component writes it, and the stylesheet that sizes the point reads it.
  * @cssproperty --chart-point-x - A point's horizontal position, as a percentage. The component writes it.
  * @cssproperty --chart-point-y - A point's vertical position, as a percentage from the top. The component writes it.
  * @cssproperty --chart-tick - A tick's position along its axis, as a percentage. The component writes it.
@@ -116,6 +128,15 @@ export declare class HelixHeadlessScatterChart extends HelixHeadlessScatterChart
      * The word the summary uses for a row when it counts them.
      */
     pointsLabel: string;
+    /**
+     * The heading of a column whose numbers size the points, such as
+     * `Population`, which makes the chart a bubble chart.
+     *
+     * That column is then a measure and no series: it draws no points of its
+     * own, and each point's area follows its row's number in it. Absent, every
+     * point is one size.
+     */
+    sizeBy: string;
     /**
      * Draws each series' line of best fit across the plot, by least squares, in
      * the series' color: the regression line a reader would otherwise draw by
@@ -148,6 +169,11 @@ export declare class HelixHeadlessScatterChart extends HelixHeadlessScatterChart
      * which is where a reader is told what it is.
      */
     seriesOf(cell: number): number | undefined;
+    /**
+     * The numeric columns by what they measure: the first across, the column
+     * `size-by` names as the size, and every other one up, as a series.
+     */
+    protected get measures(): Measures;
     /** Whether the levels across are ruled. */
     protected get rulesX(): boolean;
     /** Whether the levels up are ruled. */