@fusion.dev/helix-core 0.206.0 → 0.207.1

package/dist/mixins/mixin-chart-source/mixin-chart-source.js

@@ -1,16 +1,17 @@
 import { __decorate } from "tslib";
 import { html, nothing } from 'lit';
-import { property } from 'lit/decorators.js';
+import { property, state } from 'lit/decorators.js';
 import { ChartPointerController } from '../../controllers/chart-pointer-controller/chart-pointer-controller.js';
 import { SourceController } from '../../controllers/source-controller/source-controller.js';
 import { seriesKey } from '../../utils/read-series/read-series.js';
 import { writtenList } from '../../utils/written-list/written-list.js';
-import { words } from '../../words/words.js';
+import { formatWords, words } from '../../words/words.js';
 export const PALETTE = 24;
 export const seriesIndex = (depth) => (depth % PALETTE) + 1;
 export const PLOT_WIDTH = 100;
 export const PLOT_HEIGHT = 100;
 export const seriesNames = (list) => writtenList(list).map(seriesKey);
+export const READINGS_PAGE = 200;
 export const POSITION_LABEL = '{position} of {count}';
 export const MixinChartSource = (Base) => {
     class ChartSourceElement extends Base {
@@ -22,7 +23,11 @@ export const MixinChartSource = (Base) => {
             this.for = '';
             this.label = '';
             this.locale = '';
+            this.nextReadingsLabel = 'Next readings';
             this.positionLabel = '{position} of {count}';
+            this.previousReadingsLabel = 'Previous readings';
+            this.readingsLabel = 'Readings {first} to {last} of {count}';
+            this.tablePage = 0;
         }
         static { this.words = ''; }
         static get observedAttributes() {
@@ -60,8 +65,16 @@ export const MixinChartSource = (Base) => {
         }
         get plottedColumns() {
             const rows = this.sourceRows;
-            const width = Math.max(0, ...rows.map((row) => row.cells.length));
-            return Array.from({ length: width }, (_, column) => column).filter((column) => rows.some((row) => row.cells[column]?.value !== undefined));
+            if (this.plotted?.rows === rows) {
+                return this.plotted.columns;
+            }
+            let width = 0;
+            for (const row of rows) {
+                width = Math.max(width, row.cells.length);
+            }
+            const columns = Array.from({ length: width }, (_, column) => column).filter((column) => rows.some((row) => row.cells[column]?.value !== undefined));
+            this.plotted = { columns, rows };
+            return columns;
         }
         seriesOf(cell) {
             const depth = this.plottedColumns.indexOf(cell);
@@ -85,13 +98,52 @@ export const MixinChartSource = (Base) => {
             if (this.source.element || rows.length === 0) {
                 return nothing;
             }
-            const width = Math.max(...rows.map((row) => row.cells.length));
+            let width = 0;
+            for (const row of rows) {
+                width = Math.max(width, row.cells.length);
+            }
             const columns = Array.from({ length: width }, (_, cell) => this.columnName(cell));
-            return html `<table part="table">
+            const pages = Math.ceil(rows.length / READINGS_PAGE);
+            const page = Math.min(this.tablePage, pages - 1);
+            const first = page * READINGS_PAGE;
+            const shown = rows.slice(first, first + READINGS_PAGE);
+            const paged = pages > 1;
+            return html `<table
+        aria-describedby=${paged ? 'helix-chart-readings' : nothing}
+        aria-rowcount=${paged ? rows.length + 1 : nothing}
+        part="table"
+      >
         ${this.named ? html `<caption>${this.named}</caption>` : nothing}
-        <thead><tr><th scope="col">${this.data?.columns[0] ?? ''}</th>${columns.map((name) => html `<th scope="col">${name}</th>`)}</tr></thead>
-        <tbody>${rows.map((row) => html `<tr><th scope="row">${row.label}</th>${columns.map((_, cell) => html `<td>${row.cells[cell]?.text ?? ''}</td>`)}</tr>`)}</tbody>
-      </table>`;
+        <thead><tr aria-rowindex=${paged ? 1 : nothing}><th scope="col">${this.data?.columns[0] ?? ''}</th>${columns.map((name) => html `<th scope="col">${name}</th>`)}</tr></thead>
+        <tbody>${shown.map((row, place) => html `<tr aria-rowindex=${paged ? first + place + 2 : nothing}><th scope="row">${row.label}</th>${columns.map((_, cell) => html `<td>${row.cells[cell]?.text ?? ''}</td>`)}</tr>`)}</tbody>
+      </table>${paged ? this.renderTablePages(page, pages, first, shown.length, rows.length) : nothing}`;
+        }
+        renderTablePages(page, pages, first, shown, count) {
+            const turn = (by) => () => {
+                const next = Math.min(Math.max(page + by, 0), pages - 1);
+                if (next !== page) {
+                    this.tablePage = next;
+                }
+            };
+            return html `<div part="table-pages">
+        <span id="helix-chart-readings" role="status">${formatWords(this, 'readingsLabel', {
+                count,
+                first: first + 1,
+                last: first + shown,
+            })}</span>
+        <button
+          aria-disabled=${page === 0 ? 'true' : 'false'}
+          tabindex="-1"
+          type="button"
+          @click=${turn(-1)}
+        >${this.previousReadingsLabel}</button>
+        <button
+          aria-disabled=${page === pages - 1 ? 'true' : 'false'}
+          tabindex="-1"
+          type="button"
+          @click=${turn(1)}
+        >${this.nextReadingsLabel}</button>
+      </div>`;
         }
     }
     __decorate([
@@ -106,9 +158,24 @@ export const MixinChartSource = (Base) => {
     __decorate([
         property()
     ], ChartSourceElement.prototype, "locale", void 0);
+    __decorate([
+        words,
+        property({ attribute: 'next-readings-label' })
+    ], ChartSourceElement.prototype, "nextReadingsLabel", void 0);
     __decorate([
         words,
         property({ attribute: 'position-label' })
     ], ChartSourceElement.prototype, "positionLabel", void 0);
+    __decorate([
+        words,
+        property({ attribute: 'previous-readings-label' })
+    ], ChartSourceElement.prototype, "previousReadingsLabel", void 0);
+    __decorate([
+        words,
+        property({ attribute: 'readings-label' })
+    ], ChartSourceElement.prototype, "readingsLabel", void 0);
+    __decorate([
+        state()
+    ], ChartSourceElement.prototype, "tablePage", void 0);
     return ChartSourceElement;
 };

package/dist/mixins/mixin-field/mixin-field.js

@@ -197,5 +197,7 @@ export const MixinField = (Base) => {
     __decorate([
         state()
     ], FieldElement.prototype, "touched", void 0);
+    ;
+    FieldElement.disableWarning?.('change-in-update');
     return FieldElement;
 };

package/dist/mixins/mixin-tokens/mixin-tokens.js

@@ -4,6 +4,7 @@ import { html, nothing } from 'lit';
 import { property, state } from 'lit/decorators.js';
 import { drawIcon } from '../../utils/draw-icon/draw-icon.js';
 import { inlineStep } from '../../utils/inline-step/inline-step.js';
+import { numberConverter } from '../../utils/number-converter/number-converter.js';
 import { formatWords, words } from '../../words/words.js';
 export const MixinTokens = (Base) => {
     class TokensElement extends Base {
@@ -148,7 +149,7 @@ export const MixinTokens = (Base) => {
         property({ attribute: 'expand-label' })
     ], TokensElement.prototype, "expandLabel", void 0);
     __decorate([
-        property({ attribute: 'max-tags', type: Number })
+        property({ attribute: 'max-tags', converter: numberConverter('max-tags', 0) })
     ], TokensElement.prototype, "maxTags", void 0);
     __decorate([
         words,

package/dist/mixins/mixin-viewport/mixin-viewport.js

@@ -5,6 +5,7 @@ import { FullscreenController } from '../../controllers/fullscreen-controller/fu
 import { IdleController } from '../../controllers/idle-controller/idle-controller.js';
 import { inlineStep } from '../../utils/inline-step/inline-step.js';
 import { isRtl } from '../../utils/is-rtl/is-rtl.js';
+import { numberConverter, timeConverter } from '../../utils/number-converter/number-converter.js';
 import { formatWords, words } from '../../words/words.js';
 const HINT_SHOWS = 1600;
 export const MixinViewport = (Base) => {
@@ -323,7 +324,7 @@ export const MixinViewport = (Base) => {
         property()
     ], Viewport.prototype, "gestures", void 0);
     __decorate([
-        property({ attribute: 'idle-delay', type: Number })
+        property({ attribute: 'idle-delay', converter: timeConverter('idle-delay', 0) })
     ], Viewport.prototype, "idleDelay", void 0);
     __decorate([
         words,
@@ -338,7 +339,7 @@ export const MixinViewport = (Base) => {
         property({ attribute: 'pan-right-label' })
     ], Viewport.prototype, "panRightLabel", void 0);
     __decorate([
-        property({ attribute: 'pan-step', type: Number })
+        property({ attribute: 'pan-step', converter: numberConverter('pan-step', 0.25) })
     ], Viewport.prototype, "panStep", void 0);
     __decorate([
         words,

package/dist/utils/audit-children/audit-children.d.ts

@@ -20,6 +20,7 @@
  *
  * `part` is the child's tag after the tier, such as `option`, and `entry` its
  * family's entry, such as `option`; the host's `tier` gives the rest of both.
+ * On a tier of your own the report names the tag to define.
  * `consequence` says what the missing child costs, after "so". `drawn` is for
  * children the host draws from data, such as the options of Listbox's `items`:
  * the page wrote none, so an undefined tag is reported without one in the

package/dist/utils/audit-children/audit-children.js

@@ -1,3 +1,4 @@
+import { howToRegister } from '../how-to-register/how-to-register.js';
 import { reportRuntime } from '../report-runtime/report-runtime.js';
 const reported = new Set();
 const afterPaint = (check) => {
@@ -29,10 +30,9 @@ export const auditChildren = (host, part, entry, consequence, drawn = false) =>
             return;
         }
         reported.add(key);
-        const pkg = tier === 'helix-' ? '@fusion.dev/helix' : '@fusion.dev/helix-headless';
         reportRuntime({
             kind: 'unregistered-part',
-            message: `<${tag}> in <${host.localName}> is not registered, so ${consequence}. Import '${pkg}/${entry}'.`,
+            message: `<${tag}> in <${host.localName}> is not registered, so ${consequence}. ${howToRegister({ entry, host: host.localName, tag, tier })}`,
             tag: host.localName,
         });
     };

package/dist/utils/audit-name/audit-name.js

@@ -1,3 +1,4 @@
+import { labelsOf } from '../labels-of/labels-of.js';
 import { nameText } from '../name-text/name-text.js';
 import { reportRuntime } from '../report-runtime/report-runtime.js';
 const namesWithWords = (ids, from, shown) => {
@@ -36,8 +37,7 @@ export const hasName = (element, shown) => {
     if ((referenced ?? []).some((one) => nameText(one, shown).trim() !== '')) {
         return true;
     }
-    const labels = element.labels;
-    if ([...(labels ?? [])].some((label) => nameText(label).trim() !== '')) {
+    if (labelsOf(element).some((label) => nameText(label).trim() !== '')) {
         return true;
     }
     const role = element.getAttribute('role') ?? implicitRole(element);

package/dist/utils/audit-number/audit-number-off.d.ts

@@ -0,0 +1,12 @@
+import type { auditNumber as audit, auditTime as time } from './audit-number.js';
+/**
+ * The not-a-number warning in a production build: nothing.
+ *
+ * `#audit-number` resolves here unless the bundler or runtime asks for the
+ * `development` condition, so a production build carries none of the audit's
+ * code. The signature is the audit's, so a call site reads the same in both
+ * builds. See `audit-number.ts`.
+ */
+export declare const auditNumber: typeof audit;
+/** The not-a-time warning in a production build: nothing. */
+export declare const auditTime: typeof time;

package/dist/utils/audit-number/audit-number-off.js

@@ -0,0 +1,2 @@
+export const auditNumber = () => { };
+export const auditTime = () => { };

package/dist/utils/audit-number/audit-number.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Reports a numeric attribute that holds something other than a number, such
+ * as `page-size="1O"`, which `numberConverter` reads as the property's
+ * default.
+ *
+ * **Once for each attribute, value and default**, since a converter is not
+ * handed the element: twenty tables written with `page-size="1O"` are one
+ * mistake, and the sentence names what to search the markup for.
+ *
+ * **In a development build only**, as `missing-name` is: every numeric
+ * attribute would pay for a sentence meant for the person writing the page.
+ * Core imports it as `#audit-number`, which `package.json` resolves here under
+ * the `development` condition and to `audit-number-off.ts`, which does
+ * nothing, everywhere else.
+ */
+export declare const auditNumber: (attribute: string, value: string, fallback: number | undefined, unit?: string) => void;
+/**
+ * Reports an attribute in milliseconds that holds something other than a
+ * time, such as `duration="soon"` or `delay="-1s"`, which `timeConverter`
+ * reads as the property's default. Once for each, in a development build
+ * only, as `auditNumber` is.
+ */
+export declare const auditTime: (attribute: string, value: string, fallback: number | undefined) => void;

package/dist/utils/audit-number/audit-number.js

@@ -0,0 +1,21 @@
+import { reportRuntime } from '../report-runtime/report-runtime.js';
+const reported = new Set();
+const report = (message) => {
+    if (reported.has(message)) {
+        return;
+    }
+    reported.add(message);
+    reportRuntime({ kind: 'not-a-number', message });
+};
+const kept = (attribute, fallback) => fallback === undefined
+    ? `\`${attribute}\` stays unset`
+    : `\`${attribute}\` keeps its default of ${fallback}`;
+export const auditNumber = (attribute, value, fallback, unit) => {
+    const takes = unit === undefined ? 'a number' : `a number of ${unit}, with no unit after it`;
+    report(`${attribute}="${value}" is not a number, so ${kept(attribute, fallback)}. ` +
+        `Write \`${attribute}\` as ${takes}.`);
+};
+export const auditTime = (attribute, value, fallback) => {
+    report(`${attribute}="${value}" is not a time of zero or more, so ${kept(attribute, fallback)}. ` +
+        `Write \`${attribute}\` in milliseconds, such as 300, or as a CSS time, such as 300ms or 0.3s.`);
+};

package/dist/utils/category-labels/category-labels.d.ts

@@ -0,0 +1,74 @@
+/** One reading on a category axis: its name, and the instant it stands for, where it has one. */
+export interface Category {
+    /**
+     * The reading's own name, which is what is drawn under it.
+     */
+    label: string;
+    /**
+     * The machine-readable instant, from a `<time>` in the row's header.
+     */
+    when?: string;
+}
+/** One reading's name drawn along a category axis, and the room it is given. */
+export interface PlacedLabel {
+    /**
+     * The reading's place among the readings, counting from zero.
+     */
+    at: number;
+    /**
+     * How much of the axis the name's room takes, as a percentage.
+     */
+    size: number;
+    /**
+     * Where the name's room starts, as a percentage of the axis from its start.
+     */
+    start: number;
+}
+/** How long a category axis is and how long each name on it is, in pixels. */
+export interface AxisLengths {
+    /**
+     * The least room left between two names.
+     */
+    gap: number;
+    /**
+     * The axis' own length.
+     */
+    length: number;
+    /**
+     * How long the name of the reading at this place is, along the axis.
+     */
+    name: (at: number) => number;
+}
+/**
+ * How many names are drawn while the axis is not measured: before its first
+ * layout, and where there is no layout at all, as on a server or in a DOM
+ * without boxes. Every name up to this many, which is more than any axis
+ * holds at a readable size, and a share of them past it.
+ */
+export declare const UNMEASURED_LABELS = 100;
+/**
+ * Which readings a category axis names, and where each name sits.
+ *
+ * **Every name where every name fits, and a regular share of them where they
+ * do not.** One name per reading in a grid of equal columns truncated each name
+ * to its column and, past a few hundred readings, laid them over one another:
+ * 10,000 readings across 900 pixels gave each name under a tenth of a pixel and
+ * built ten thousand elements to draw nothing legible. So the names that fit
+ * are drawn and the rest are left out, with the first and the last always kept.
+ *
+ * **Which share depends on what the names are.** Instants, from a `<time>` in
+ * every row, are named where they cross into a new period: the first of each
+ * month, the first of each year. Numbers in order, such as years, are named
+ * where they cross a round number. Anything else is named every so many
+ * readings, counted from the first. Every share is the finest of a ladder of
+ * round steps, 1, 2 and 5 at each power of ten, that leaves `gap` between every
+ * two names at `length`.
+ *
+ * Without `lengths` the axis has not been measured, and every name is drawn up
+ * to `UNMEASURED_LABELS`, which is what a page with no layout sees.
+ *
+ * A pure function, so the drawing and its specs share one answer. The names
+ * are read for the reading's own words only: a reading's tooltip and its
+ * spoken readout say its own name, whether or not the axis draws it.
+ */
+export declare const placeLabels: (categories: readonly Category[], lengths?: AxisLengths) => PlacedLabel[];

package/dist/utils/category-labels/category-labels.js

@@ -0,0 +1,230 @@
+export const UNMEASURED_LABELS = 100;
+const roundStep = (rung) => [1, 2, 5][rung % 3] * 10 ** Math.floor(rung / 3);
+const plainRungs = function* (count) {
+    for (let rung = 0;; rung += 1) {
+        const step = roundStep(rung);
+        yield { bucket: (at) => Math.floor(at / step), estimate: count / step };
+        if (step >= count) {
+            return;
+        }
+    }
+};
+const numericRungs = function* (values) {
+    let finest = Number.POSITIVE_INFINITY;
+    for (let at = 1; at < values.length; at += 1) {
+        finest = Math.min(finest, Math.abs(values[at] - values[at - 1]));
+    }
+    const span = Math.abs(values.at(-1) - values[0]);
+    const base = 10 ** Math.floor(Math.log10(finest));
+    for (let rung = 0;; rung += 1) {
+        const step = base * roundStep(rung);
+        yield {
+            bucket: (at) => Math.floor(values[at] / step + 1e-9),
+            estimate: span / step,
+        };
+        if (step > span) {
+            return;
+        }
+    }
+};
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+const CLOCK = [
+    SECOND,
+    5 * SECOND,
+    15 * SECOND,
+    30 * SECOND,
+    MINUTE,
+    5 * MINUTE,
+    15 * MINUTE,
+    30 * MINUTE,
+    HOUR,
+    3 * HOUR,
+    6 * HOUR,
+    12 * HOUR,
+    DAY,
+    2 * DAY,
+];
+const timeRungs = function* (walls) {
+    const span = Math.abs(walls.at(-1) - walls[0]);
+    for (const step of CLOCK) {
+        yield { bucket: (at) => Math.floor(walls[at] / step), estimate: span / step };
+    }
+    yield {
+        bucket: (at) => Math.floor((Math.floor(walls[at] / DAY) + 3) / 7),
+        estimate: span / (7 * DAY),
+    };
+    const months = (at) => {
+        const date = new Date(walls[at]);
+        return date.getUTCFullYear() * 12 + date.getUTCMonth();
+    };
+    for (const step of [1, 3, 6]) {
+        yield { bucket: (at) => Math.floor(months(at) / step), estimate: span / (step * 30 * DAY) };
+    }
+    for (let rung = 0;; rung += 1) {
+        const step = roundStep(rung);
+        yield {
+            bucket: (at) => Math.floor(Math.floor(months(at) / 12) / step),
+            estimate: span / (step * 365 * DAY),
+        };
+        if (step * 365 * DAY > span) {
+            return;
+        }
+    }
+};
+const ordered = (values, strict) => {
+    let rising = true;
+    let falling = true;
+    for (let at = 1; at < values.length; at += 1) {
+        const step = values[at] - values[at - 1];
+        rising &&= strict ? step > 0 : step >= 0;
+        falling &&= strict ? step < 0 : step <= 0;
+    }
+    return rising || falling;
+};
+const DATE_ONLY = /^\d{4}(-\d{2}(-\d{2})?)?$/;
+const rungsOf = (categories) => {
+    const count = categories.length;
+    if (count > 1 && categories.every((one) => one.when !== undefined)) {
+        const walls = categories.map((one) => {
+            const when = one.when.trim();
+            const instant = Date.parse(when);
+            return DATE_ONLY.test(when)
+                ? instant
+                : instant - new Date(instant).getTimezoneOffset() * MINUTE;
+        });
+        if (walls.every(Number.isFinite) && ordered(walls, false)) {
+            return timeRungs(walls);
+        }
+    }
+    if (count > 1) {
+        const values = categories.map((one) => one.label.trim() === '' ? Number.NaN : Number(one.label.trim()));
+        if (values.every(Number.isFinite) && ordered(values, true)) {
+            return numericRungs(values);
+        }
+    }
+    return plainRungs(count);
+};
+const changes = (rung, count) => {
+    const found = [0];
+    let previous = rung.bucket(0);
+    for (let at = 1; at < count; at += 1) {
+        const bucket = rung.bucket(at);
+        if (bucket !== previous) {
+            found.push(at);
+            previous = bucket;
+        }
+    }
+    return found;
+};
+const extentOf = (count, lengths) => (at) => {
+    const long = lengths.name(at);
+    const center = ((at + 0.5) / count) * lengths.length;
+    const inset = lengths.gap / 2;
+    const low = Math.max(inset, Math.min(center - long / 2, lengths.length - inset - long));
+    return [low, low + long];
+};
+const keep = (candidates, count, lengths) => {
+    const last = count - 1;
+    const extent = extentOf(count, lengths);
+    const kept = [0];
+    let end = extent(0)[1];
+    const tail = last > 0 ? extent(last)[0] : Number.POSITIVE_INFINITY;
+    for (const at of candidates) {
+        if (at === 0 || at === last) {
+            continue;
+        }
+        const [low, high] = extent(at);
+        if (high + lengths.gap > tail) {
+            break;
+        }
+        if (low < end + lengths.gap) {
+            if (kept.length === 1) {
+                continue;
+            }
+            return undefined;
+        }
+        kept.push(at);
+        end = high;
+    }
+    if (last > 0) {
+        kept.push(last);
+    }
+    return kept;
+};
+const short = (value) => Math.round(value * 10_000) / 10_000;
+const percent = (at, low, high, length) => ({
+    at,
+    size: short(((high - low) / length) * 100),
+    start: short((low / length) * 100),
+});
+const rooms = (kept, count, lengths) => {
+    const last = kept.length - 1;
+    if (last === 0) {
+        return [{ at: kept[0], size: 100, start: 0 }];
+    }
+    if (!lengths) {
+        const center = (at) => at + 0.5;
+        return kept.map((at, place) => {
+            const before = place > 0 ? center(at) - center(kept[place - 1]) : 2 * center(at);
+            const after = place < last ? center(kept[place + 1]) - center(at) : 2 * (count - center(at));
+            const half = Math.min(before, after) / 2;
+            return percent(at, center(at) - half, center(at) + half, count);
+        });
+    }
+    const length = lengths.length;
+    const extent = extentOf(count, lengths);
+    const spans = kept.map(extent);
+    const [head, tail] = [spans[0], spans[last]];
+    if (last === 1 && head[1] + lengths.gap > tail[0]) {
+        return [
+            percent(kept[0], 0, length / 2, length),
+            percent(kept[1], length / 2, length, length),
+        ];
+    }
+    return kept.map((at, place) => {
+        const [low, high] = spans[place];
+        const before = place > 0 ? (low - spans[place - 1][1]) / 2 : low;
+        const after = place < last ? (spans[place + 1][0] - high) / 2 : length - high;
+        const pad = Math.max(0, Math.min(before, after));
+        return percent(at, low - pad, high + pad, length);
+    });
+};
+export const placeLabels = (categories, lengths) => {
+    const count = categories.length;
+    if (count === 0) {
+        return [];
+    }
+    if (!lengths || !(lengths.length > 0)) {
+        let step = 1;
+        for (let rung = 0; count / step > UNMEASURED_LABELS; rung += 1) {
+            step = roundStep(rung + 1);
+        }
+        const kept = Array.from({ length: Math.ceil(count / step) }, (_, place) => place * step);
+        return rooms(kept.at(-1) === count - 1 ? kept : [...kept, count - 1], count, undefined);
+    }
+    const most = (2 * lengths.length) / Math.max(lengths.gap, 1);
+    if (count <= most) {
+        const every = Array.from({ length: count }, (_, at) => at);
+        const all = keep(every, count, lengths);
+        if (all && all.length === count) {
+            return rooms(all, count, lengths);
+        }
+    }
+    for (const rung of rungsOf(categories)) {
+        if (rung.estimate > most) {
+            continue;
+        }
+        const candidates = changes(rung, count);
+        if (candidates.length === count) {
+            continue;
+        }
+        const kept = keep(candidates, count, lengths);
+        if (kept) {
+            return rooms(kept, count, lengths);
+        }
+    }
+    return rooms(count > 1 ? [0, count - 1] : [0], count, lengths);
+};

package/dist/utils/closest-name/closest-name.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The name in `names` closest to `wrong`, or `undefined` where none is close
+ * enough to be the one meant.
+ *
+ * **Close is the fewest letters added, taken out, changed, or swapped with
+ * the one beside them**, a swap counting once, so `chekc` finds `check`.
+ * **Up to a third of the name's length**, the ceiling diagnostics' `nearest`
+ * keeps, since a confident wrong suggestion costs more than none: `x` is a
+ * typo for nothing. The first of two names at the same distance wins.
+ */
+export declare const closestName: (wrong: string, names: Iterable<string>) => string | undefined;

package/dist/utils/closest-name/closest-name.js

@@ -0,0 +1,35 @@
+export const closestName = (wrong, names) => {
+    let found;
+    let least = Math.floor(wrong.length / 3) + 1;
+    for (const name of names) {
+        if (Math.abs(name.length - wrong.length) >= least) {
+            continue;
+        }
+        const distance = distanceOf(wrong, name);
+        if (distance < least) {
+            found = name;
+            least = distance;
+        }
+    }
+    return found;
+};
+const distanceOf = (from, to) => {
+    const rows = [Array.from({ length: to.length + 1 }, (_, column) => column)];
+    for (let row = 1; row <= from.length; row += 1) {
+        const above = rows[row - 1];
+        const current = [row];
+        for (let column = 1; column <= to.length; column += 1) {
+            const same = from[row - 1] === to[column - 1];
+            let cell = Math.min(above[column] + 1, current[column - 1] + 1, above[column - 1] + (same ? 0 : 1));
+            if (row > 1 &&
+                column > 1 &&
+                from[row - 1] === to[column - 2] &&
+                from[row - 2] === to[column - 1]) {
+                cell = Math.min(cell, rows[row - 2][column - 2] + 1);
+            }
+            current[column] = cell;
+        }
+        rows.push(current);
+    }
+    return rows[from.length][to.length];
+};