@fusion.dev/helix-headless 0.23.0 → 0.24.0

package/dist/element-events.generated.js

@@ -5,7 +5,7 @@ registerElementEvents({
     'helix-headless-app-header': ['helix-scrolled'],
     'helix-headless-avatar': ['error', 'load'],
     'helix-headless-carousel': ['helix-select'],
-    'helix-headless-chat': ['helix-before-pin'],
+    'helix-headless-chat': ['helix-before-pin', 'helix-history', 'helix-send'],
     'helix-headless-chat-composer': ['helix-send'],
     'helix-headless-chat-message': ['helix-send'],
     'helix-headless-checkbox': ['change', 'helix-before-toggle', 'input'],
@@ -38,7 +38,13 @@ registerElementEvents({
     ],
     'helix-headless-command': ['helix-before-close', 'helix-before-open', 'helix-select', 'toggle'],
     'helix-headless-copy-button': ['helix-copy'],
-    'helix-headless-data-table': ['helix-filter', 'helix-navigate', 'helix-sort'],
+    'helix-headless-data-table': [
+        'helix-filter',
+        'helix-navigate',
+        'helix-reorder',
+        'helix-select',
+        'helix-sort',
+    ],
     'helix-headless-date-input': [
         'change',
         'helix-before-change',
@@ -53,14 +59,19 @@ registerElementEvents({
     'helix-headless-drilldown': ['helix-select'],
     'helix-headless-drilldown-item': ['helix-select'],
     'helix-headless-file-input': ['change', 'helix-before-change', 'input'],
+    'helix-headless-filter-chip': ['helix-dismiss'],
     'helix-headless-filter-input': [
         'change',
         'helix-before-change',
         'helix-before-close',
         'helix-before-open',
+        'helix-dismiss',
+        'helix-facet',
+        'helix-select',
         'input',
         'toggle',
     ],
+    'helix-headless-filter-menu': ['helix-facet'],
     'helix-headless-heatmap': ['helix-resize'],
     'helix-headless-image': ['error', 'load'],
     'helix-headless-input': ['change', 'helix-before-change', 'input'],
@@ -70,8 +81,10 @@ registerElementEvents({
     'helix-headless-menu': ['helix-before-close', 'helix-before-open', 'helix-select', 'toggle'],
     'helix-headless-menu-item': ['helix-select'],
     'helix-headless-notification': ['helix-dismiss', 'helix-read'],
-    'helix-headless-notifications': ['helix-read'],
+    'helix-headless-notification-group': ['helix-before-close', 'helix-before-open'],
+    'helix-headless-notifications': ['helix-dismiss', 'helix-read'],
     'helix-headless-number-input': ['change', 'helix-before-change', 'input'],
+    'helix-headless-object-inspector': ['helix-copy'],
     'helix-headless-option': ['helix-select'],
     'helix-headless-outline': ['helix-before-activate'],
     'helix-headless-pagination': ['helix-navigate'],
@@ -79,7 +92,7 @@ registerElementEvents({
     'helix-headless-pin-input': ['change', 'helix-before-change', 'helix-complete', 'input'],
     'helix-headless-popover': ['helix-before-close', 'helix-before-open', 'toggle'],
     'helix-headless-radio': ['helix-select'],
-    'helix-headless-radio-group': ['change', 'helix-before-change', 'input'],
+    'helix-headless-radio-group': ['change', 'helix-before-change', 'helix-select', 'input'],
     'helix-headless-rating': ['change', 'helix-before-change', 'input'],
     'helix-headless-select': [
         'change',
@@ -90,13 +103,19 @@ registerElementEvents({
         'toggle',
     ],
     'helix-headless-slider': ['change', 'helix-before-change', 'input'],
-    'helix-headless-speed-dial': ['helix-before-close', 'helix-before-open', 'toggle'],
+    'helix-headless-speed-dial': [
+        'helix-before-close',
+        'helix-before-open',
+        'helix-select',
+        'toggle',
+    ],
     'helix-headless-speed-dial-item': ['helix-select'],
     'helix-headless-splitter': ['helix-before-collapse', 'helix-before-resize'],
     'helix-headless-step': ['helix-select'],
-    'helix-headless-steps': ['helix-activate', 'helix-before-activate'],
+    'helix-headless-steps': ['helix-activate', 'helix-before-activate', 'helix-select'],
     'helix-headless-switch': ['change', 'helix-before-toggle', 'input'],
     'helix-headless-tab': ['helix-select'],
+    'helix-headless-table-column': ['helix-before-resize'],
     'helix-headless-tabs': ['helix-activate', 'helix-before-activate', 'helix-select'],
     'helix-headless-tag': ['helix-dismiss'],
     'helix-headless-textarea': ['change', 'helix-before-change', 'input'],
@@ -109,6 +128,7 @@ registerElementEvents({
         'toggle',
     ],
     'helix-headless-time-picker': ['change', 'helix-before-change', 'input'],
+    'helix-headless-toast': ['helix-dismiss'],
     'helix-headless-toast-item': ['helix-dismiss'],
     'helix-headless-toggle': ['helix-select'],
     'helix-headless-toggle-group': ['change', 'helix-before-change', 'helix-select', 'input'],
@@ -117,6 +137,7 @@ registerElementEvents({
         'helix-before-activate',
         'helix-before-close',
         'helix-complete',
+        'helix-tour-ask',
         'toggle',
     ],
     'helix-headless-tour-stop': ['helix-tour-ask'],

package/dist/filter-input/chip/filter-chip.d.ts

@@ -0,0 +1,114 @@
+import { HelixElement } from '@fusion.dev/helix-core';
+import { type PropertyValues, type TemplateResult } from 'lit';
+declare const HelixHeadlessFilterChip_base: (new (...args: any[]) => import("@fusion.dev/helix-core").DismissibleElement) & typeof HelixElement;
+/**
+ * @summary One filter in force: a field, how it is compared, and to what.
+ *
+ * @description
+ * A chip is the readable form of the thing `FilterField` declares. It carries
+ * the three parts a filter has and a control that asks for it to go.
+ *
+ * **The operator is drawn only when it is worth drawing**, which is the whole
+ * reason the common case reads as plainly as it does:
+ *
+ * ```
+ * Disposition   refunded, chargeback         the field's usual comparison, unwritten
+ * Disposition   is not   refunded            a comparison somebody chose, so it shows
+ * Created       after    1 Aug               a scalar, which has no usual comparison
+ * ```
+ *
+ * A reader ticking two values in a menu gets the first, with no jargon on it. A
+ * reader who reaches for a comparison gets the third, which explains itself the
+ * first time they see one. The rule is one line: **omit `operator-label` for the
+ * field's default operator and pass it for every other.** Whoever builds the
+ * chip holds the field, and the field knows which its default is.
+ *
+ * **It shows a filter and never applies one.** Dismissing is a request, the way
+ * it is on `Tag` and `Announcement`: the chip is the consumer's element in a
+ * consumer's list, and taking it out from under them would put their model and
+ * the document out of step. `preventDefault()` on the `helix-dismiss` is a
+ * refusal, and that is also how a consumer takes control of the interaction for
+ * one press: `requestChange` documents the whole pattern, and its first line is
+ * that control is an action rather than a mode.
+ *
+ * **Changing the comparison belongs to whatever is slotted into `operator`.** A
+ * menu trigger there makes the segment a control; the text fallback makes it a
+ * label. This element does not learn either, for the reason `FilterOperator`
+ * gives: what the words mean is the domain's.
+ *
+ * @since 0.23.0
+ * @status experimental
+ * @category forms
+ * @aliases FilterToken, FacetChip
+ * @documentation https://helix.fusion.dev/components/filter-input
+ *
+ * @slot - What the field is compared to, which is usually text and may be
+ * anything a consumer wants read there.
+ * @slot field - Replaces the field's name, for a chip that wants a mark beside
+ * it or a shortened form.
+ * @slot operator - Replaces the comparison, and is where a control that changes
+ * it goes.
+ *
+ * @event {HelixDismissEvent} helix-dismiss - Fired when the reader asks to remove the filter. Cancelable: refusing it takes the decision and nothing moves.
+ *
+ * @csspart dismiss - The control that asks to remove the filter.
+ * @csspart dismiss-mark - The glyph on the dismiss control, where none is slotted.
+ * @csspart field - The name of what is being filtered.
+ * @csspart operator - How it is compared, drawn only where there is one to draw.
+ * @csspart values - What it is compared to.
+ */
+export declare class HelixHeadlessFilterChip extends HelixHeadlessFilterChip_base {
+    dismissLabel: string;
+    /**
+     * The field this filter is on, as a reader sees it.
+     *
+     * The slot's fallback rather than the slot's replacement: a consumer who wants
+     * a mark beside the name slots `field` and this goes unused.
+     */
+    label: string;
+    /**
+     * The field this filter is on, as the consumer's model calls it.
+     *
+     * Never shown. Reflected, because a consumer removing one filter from a list
+     * of them selects on this, and so undefaulted for the reason `operator` gives.
+     *
+     * **A chip built in script should be given the attribute, not the property**,
+     * if the next thing to happen might select on it. Reflection is written on
+     * this element's next update rather than during the assignment, so a second
+     * `helix-facet` for the same field arriving in the same frame selects nothing,
+     * builds a second chip, and leaves the row holding two of one filter. The
+     * lookup then finds whichever came first, so dismissing one chip takes the
+     * other away. `setAttribute('name', field)` is true immediately and costs
+     * nothing; the property is for markup and for frameworks that write both.
+     */
+    name?: string;
+    /**
+     * What the consumer's own model calls the comparison in force.
+     *
+     * Never shown, and it is what a consumer matches on when the chip comes back
+     * to them. `label` translates; this does not.
+     *
+     * Reflected and so undefaulted: a reflected property with a default writes an
+     * attribute on upgrade that the server never wrote, and the two markups differ
+     * before a reader has touched anything.
+     */
+    operator?: string;
+    /**
+     * The comparison, as a reader sees it, and empty for the field's usual one.
+     *
+     * **Empty is the whole design and not an oversight.** A chip drawn for the
+     * comparison a field is normally filtered by says the field and the values and
+     * nothing between them, because a word every chip carries is a word nobody
+     * reads. The moment somebody picks a different comparison it appears, which
+     * makes an unusual filter look unusual.
+     */
+    operatorLabel: string;
+    protected firstUpdated(changed: PropertyValues): void;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'helix-headless-filter-chip': HelixHeadlessFilterChip;
+    }
+}
+export {};

package/dist/filter-input/chip/filter-chip.js

@@ -0,0 +1,61 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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, MixinDismissible } from '@fusion.dev/helix-core';
+import { x } from '@fusion.dev/helix-icons';
+import { html, nothing } from 'lit';
+import { property } from 'lit/decorators.js';
+import { unsafeSVG } from 'lit/directives/unsafe-svg.js';
+let HelixHeadlessFilterChip = class HelixHeadlessFilterChip extends MixinDismissible(HelixElement) {
+    constructor() {
+        super(...arguments);
+        this.dismissLabel = 'Remove filter';
+        this.label = '';
+        this.operatorLabel = '';
+    }
+    firstUpdated(changed) {
+        super.firstUpdated(changed);
+        this.finishHydration();
+    }
+    render() {
+        const operator = this.operatorLabel !== '' || this.knownChildren.some((child) => child.slot === 'operator');
+        const values = !this.childrenKnown ||
+            [...this.childNodes].some((node) => node instanceof Element ? node.slot === '' : (node.textContent ?? '').trim() !== '');
+        return html `<span part="field"><slot name="field">${this.label}</slot></span>
+      ${operator
+            ? html `<span part="operator"><slot name="operator">${this.operatorLabel}</slot></span>`
+            : nothing}
+      ${values ? html `<span part="values"><slot></slot></span>` : nothing}
+      ${this.dismissible
+            ? html `<button
+              part="dismiss"
+              type="button"
+              aria-label=${this.dismissLabel}
+              @click=${() => this.dismiss()}
+            >
+              <svg part="dismiss-mark" fill="currentColor" viewBox=${x.viewBox} aria-hidden="true">
+                ${unsafeSVG(x.content)}
+              </svg>
+            </button>`
+            : nothing}`;
+    }
+};
+__decorate([
+    property()
+], HelixHeadlessFilterChip.prototype, "label", void 0);
+__decorate([
+    property({ reflect: true })
+], HelixHeadlessFilterChip.prototype, "name", void 0);
+__decorate([
+    property({ reflect: true })
+], HelixHeadlessFilterChip.prototype, "operator", void 0);
+__decorate([
+    property({ attribute: 'operator-label' })
+], HelixHeadlessFilterChip.prototype, "operatorLabel", void 0);
+HelixHeadlessFilterChip = __decorate([
+    customElement('helix-headless-filter-chip')
+], HelixHeadlessFilterChip);
+export { HelixHeadlessFilterChip };

package/dist/filter-input/field/filter-field.d.ts

@@ -0,0 +1,128 @@
+import { HelixElement } from '@fusion.dev/helix-core';
+import { nothing, type PropertyValues } from 'lit';
+import type { HelixHeadlessOption } from '../../option/index.js';
+import { type FilterGrammarField } from '../grammar.js';
+import type { HelixHeadlessFilterOperator } from '../operator/filter-operator.js';
+/**
+ * @summary One thing a set can be filtered by, and how.
+ *
+ * @description
+ * **A declaration, not a control.** It renders nothing and is never seen. A
+ * consumer writes one per field, with the comparisons that field supports and
+ * the values it supports them on, and the filter input reads them to build its
+ * menu:
+ *
+ * ```html
+ * <helix-headless-filter-field name="disposition" label="Disposition">
+ *   <helix-headless-filter-operator name="any" label="is any of" default>
+ *   </helix-headless-filter-operator>
+ *   <helix-headless-filter-operator name="none" label="is none of">
+ *   </helix-headless-filter-operator>
+ *   <helix-headless-option value="refunded">Refunded</helix-headless-option>
+ * </helix-headless-filter-field>
+ * ```
+ *
+ * **Operators are per field and never global.** `is after` belongs to a date and
+ * `has all of` to a set, and a field that supports one comparison shows no
+ * chooser at all. A global list would offer every field every word and leave the
+ * component deciding which of them made sense, which is the domain question it
+ * declines to answer.
+ *
+ * **A field that declares none gets two, and they are the ones the punctuation
+ * can say.** `is any of` and `is none of` are what `field:a,b` and `-field:a,b`
+ * mean, so declaring them was ceremony for the case every product has; the
+ * example above is what a consumer writes when the words matter, not the price
+ * of admission. Declaring one comparison replaces both rather than joining
+ * them — see `vocabulary`, which is where that is decided once for the menu and
+ * the grammar together.
+ *
+ * **Values are `Option`s, which is the element a consumer already has.** They
+ * carry a value, a label and a disabled state, and a picker built on `Menu` or
+ * `Listbox` can render them without this element inventing a second way to say
+ * the same thing. A field whose values cannot be enumerated declares none, and
+ * what fills a chip then is whatever the consumer types.
+ *
+ * @since 0.23.0
+ * @status experimental
+ * @category forms
+ * @aliases Facet, Dimension
+ * @documentation https://helix.fusion.dev/components/filter-input
+ *
+ * @slot - The comparisons this field supports, as `FilterOperator`s, and the
+ * values it supports them on, as `Option`s. Neither is rendered: they are read.
+ */
+export declare class HelixHeadlessFilterField extends HelixElement {
+    /**
+     * What a reader is shown, in the menu and on every chip built from this field.
+     */
+    label: string;
+    /**
+     * What the consumer's own model calls this field.
+     *
+     * Never shown, and what arrives in the filter this helps build.
+     *
+     * Reflected and so undefaulted: a reflected property with a default writes an
+     * attribute on upgrade that the server never wrote.
+     */
+    name?: string;
+    /**
+     * The comparisons declared under this field, in the order they were written.
+     *
+     * Read from the light DOM rather than from a slot, because there is no slot:
+     * this element renders nothing, so nothing is ever assigned. Order is the
+     * consumer's, which is the order a chooser should offer them in.
+     *
+     * **As declared, so empty where nothing was.** The defaults are applied by
+     * `vocabulary` and not here: this getter answers what the consumer wrote, and
+     * a caller that wants what the field *supports* wants the other one.
+     */
+    get operators(): HelixHeadlessFilterOperator[];
+    /**
+     * The comparison a chip leaves unwritten, or nothing where the consumer named
+     * none.
+     *
+     * **The first one marked, and a second is reported rather than resolved.** Two
+     * defaults on one field is a consumer saying two different things, and picking
+     * one of them quietly would show a chip whose operator is missing and whose
+     * meaning is not the one they wrote. A field with no default has none: every
+     * chip built from it then spells its operator out, which is correct for a
+     * field whose comparisons are all equally surprising.
+     */
+    get defaultOperator(): HelixHeadlessFilterOperator | null;
+    /**
+     * The values declared under this field, in the order they were written.
+     *
+     * Empty is meaningful rather than missing: a field whose values cannot be
+     * listed, a free text search or an open ended number, declares none and the
+     * picker offers typing instead of choosing.
+     */
+    get values(): HelixHeadlessOption[];
+    /**
+     * This field flattened into what the menu renders and the grammar reads.
+     *
+     * **The one place the defaults are applied.** A field that declares no
+     * comparisons supports `is any of` and `is none of`, which is what the typed
+     * grammar can say and so what the picker offers; declaring one replaces both,
+     * because a set half inherited and half written is one nobody can read off the
+     * markup. Two things need this answer and neither should be resolving it
+     * itself.
+     *
+     * Data rather than elements, so the grammar stays a module with no DOM in it
+     * and the menu renders rows from the same shape whether the consumer wrote the
+     * operators or not.
+     */
+    get vocabulary(): FilterGrammarField;
+    protected willUpdate(changed: PropertyValues): void;
+    /**
+     * Nothing, which is what makes this a declaration.
+     *
+     * No `<slot>`, so none of the children a consumer wrote is painted. See
+     * `FilterOperator`'s note, which records the mechanism.
+     */
+    protected render(): typeof nothing;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'helix-headless-filter-field': HelixHeadlessFilterField;
+    }
+}

package/dist/filter-input/field/filter-field.js

@@ -0,0 +1,70 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 } from '@fusion.dev/helix-core';
+import { nothing } from 'lit';
+import { property } from 'lit/decorators.js';
+import { DEFAULT_FILTER_OPERATORS } from '../grammar.js';
+let HelixHeadlessFilterField = class HelixHeadlessFilterField extends HelixElement {
+    constructor() {
+        super(...arguments);
+        this.label = '';
+    }
+    get operators() {
+        return [
+            ...this.querySelectorAll(':scope > helix-headless-filter-operator, :scope > helix-filter-operator'),
+        ];
+    }
+    get defaultOperator() {
+        const marked = this.operators.filter((operator) => operator.default);
+        if (marked.length > 1) {
+            console.warn(`\`${this.name || 'A filter field'}\` names ${marked.length} default operators, and a chip can only leave one unwritten. Mark one.`);
+        }
+        return marked[0] ?? null;
+    }
+    get values() {
+        return [
+            ...this.querySelectorAll(':scope > helix-headless-option, :scope > helix-option'),
+        ];
+    }
+    get vocabulary() {
+        const declared = this.operators;
+        const unwritten = this.defaultOperator;
+        return {
+            label: this.label,
+            name: this.name ?? '',
+            operators: declared.length > 0
+                ? declared.map((operator) => ({
+                    arity: operator.arity ?? 'many',
+                    default: operator === unwritten,
+                    label: operator.label,
+                    name: operator.name ?? '',
+                }))
+                : DEFAULT_FILTER_OPERATORS,
+            values: this.values.map((option) => ({
+                label: option.textContent?.trim() || option.value,
+                value: option.value,
+            })),
+        };
+    }
+    willUpdate(changed) {
+        super.willUpdate(changed);
+        this.internals.role = 'none';
+    }
+    render() {
+        return nothing;
+    }
+};
+__decorate([
+    property()
+], HelixHeadlessFilterField.prototype, "label", void 0);
+__decorate([
+    property({ reflect: true })
+], HelixHeadlessFilterField.prototype, "name", void 0);
+HelixHeadlessFilterField = __decorate([
+    customElement('helix-headless-filter-field')
+], HelixHeadlessFilterField);
+export { HelixHeadlessFilterField };

package/dist/filter-input/grammar.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Reading a typed filter against what a consumer declared.
+ *
+ * **Helix owns the punctuation, the consumer owns the words.** `field:a,b` is a
+ * filter in every product that has ever had one, and a library that made every
+ * consumer write that parse again was charging them for a decision nobody
+ * disagrees about. So the shape is here: a key, a colon, a comma separated list,
+ * and a leading `-` for the negation. What a key or a value *means* is still
+ * never asked, which is the line `FilterField` draws and this does not cross:
+ * nothing here compares anything, and what comes out is the same `helix-facet`
+ * the picker announces, for the consumer to answer however they answer it.
+ *
+ * **It reads only what was declared.** A key is a field's `name` or its `label`;
+ * a value is an `Option`'s `value` or its text. Anything else is left alone and
+ * comes back as text, which is what makes a search box that is also a filter
+ * possible: a reader types `refund tuesday disposition:settled` and two thirds
+ * of that is still a search.
+ *
+ * **Where the consumer's vocabulary starts, this stops.** The negation is bound
+ * to the operator named `none` and to nothing else, so a field that declares its
+ * own comparisons and no `none` has no negation to type: `-created:today` is
+ * text, and the picker is where that filter gets built. Guessing which of a
+ * consumer's operators a `-` meant is the domain question, and this is the one
+ * place it would be tempting to answer.
+ *
+ * Its own module rather than sitting in the element, because it is string
+ * handling with no DOM in it: this is the half worth testing directly.
+ */
+import type { FacetDetail } from '@fusion.dev/helix-core';
+/** One comparison a field supports, as the grammar needs it. */
+export interface FilterGrammarOperator {
+    /**
+     * How many values it takes: `none` is complete on its own, `one` is a scalar,
+     * `many` is a set. Undeclared reads as `many`, which `FilterOperator` records.
+     */
+    arity: 'many' | 'none' | 'one';
+    /** Whether this is the one a chip leaves unwritten. */
+    default: boolean;
+    /** What a reader is shown. */
+    label: string;
+    /** What the consumer's model calls it. */
+    name: string;
+}
+/** One value a field can be compared to, as the grammar needs it. */
+export interface FilterGrammarValue {
+    /** What a reader is shown, and one of the two spellings it can be typed as. */
+    label: string;
+    /** What the consumer's model calls it. */
+    value: string;
+}
+/** One field and everything declared under it, as the grammar needs it. */
+export interface FilterGrammarField {
+    /** What a reader is shown. */
+    label: string;
+    /** What the consumer's model calls it. */
+    name: string;
+    /** The comparisons it supports, the field's own or the defaults. */
+    operators: readonly FilterGrammarOperator[];
+    /** The values it can be compared to, or none where they cannot be listed. */
+    values: readonly FilterGrammarValue[];
+}
+/** One filter read out of the text. */
+export interface FilterGrammarTerm {
+    /** What the picker would have announced for this, unchanged. */
+    facet: FacetDetail;
+    /** The pieces of text it was read from, so a caller can take exactly them. */
+    written: readonly string[];
+}
+/** What a line of text turned out to say. */
+export interface FilterGrammarReading {
+    /** What it said, one per field. */
+    terms: readonly FilterGrammarTerm[];
+    /** What it did not, in the order it was written. */
+    text: string;
+}
+/**
+ * The comparisons a field has when it declares none.
+ *
+ * **Two, because two is what the punctuation can say.** `field:a,b` and
+ * `-field:a,b` are the whole default grammar, so a third default would be one
+ * the picker offered and nobody could type. A field wanting `is after` declares
+ * it, and declaring anything replaces these rather than joining them: a set half
+ * inherited from a library and half written by hand is one nobody can read off
+ * the markup.
+ */
+export declare const DEFAULT_FILTER_OPERATORS: readonly FilterGrammarOperator[];
+/**
+ * Reads a line of text as filters and whatever was not one.
+ *
+ * **One comparison per field, and a second is left as text.** `helix-facet`
+ * carries a field's whole set, so `disposition:a -disposition:b` has no event
+ * shape to arrive in and the picker cannot build it either. Announcing the
+ * second over the first would drop a filter the reader wrote and spelled
+ * correctly; leaving it in the box shows them it was not taken.
+ */
+export declare function readFilterText(text: string, fields: readonly FilterGrammarField[]): FilterGrammarReading;