@slotted/angular 0.0.0-stage → 0.1.0-beta.1

package/types/slotted-angular-filter-bar.d.ts

@@ -0,0 +1,573 @@
+import * as _slotted_core_date from '@slotted/core/date';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef } from '@angular/core';
+import { FilterKind, FilterDescriptor, FilterGroup, FilterOperator, FilterPath, FilterCondition, removeNodeAt, FilterNode, FilterRule } from '@slotted/core/filter';
+import { FamilyTranslator, FilterBarMessages, PartialMessages } from '@slotted/core/i18n';
+import { ChangeRequest } from '@slotted/core/state';
+
+type FilterBarApply = 'live' | 'manual';
+type FilterBarSize = 'sm' | 'md' | 'lg';
+type FilterBarValueReason = 'pointer' | 'keyboard' | 'clear' | 'remove' | 'select' | 'submit' | 'programmatic';
+type FilterBarQueryReason = 'keyboard' | 'clear' | 'submit' | 'programmatic';
+type FilterBarPresetReason = 'select' | 'clear' | 'programmatic';
+type FilterBarOpenReason = 'pointer' | 'keyboard' | 'escape' | 'outsidePress' | 'dismiss' | 'submit' | 'programmatic';
+type FilterBarRevealedReason = 'pointer' | 'keyboard' | 'programmatic';
+/** A value of a set field, with the word a reader sees for it. */
+interface FilterBarOption {
+    value: string;
+    label: string;
+}
+/**
+ * One field a listing can be filtered by. `key` is what a rule names and what
+ * `read(row, field)` receives; `kind` decides the operators and the operand
+ * control, which is the same decision `table`'s typed filters make.
+ */
+interface FilterBarField {
+    key: string;
+    label: string;
+    kind: FilterKind;
+    /**
+     * Drawn before the field's name on its chip and in the add menu: a glyph
+     * name from `@slotted/core/glyph`, or a template of the consumer's.
+     */
+    icon?: string | TemplateRef<unknown>;
+    /** Narrows the operators the kind offers. */
+    operators?: readonly string[];
+    /** The operator a new rule starts with. Defaults to the kind's. */
+    defaultOperator?: string;
+    /**
+     * Always in sight: a dashed pill while it holds no condition, a chip in the
+     * same place once it does.
+     */
+    pinned?: boolean;
+    /**
+     * A field that always holds a rule: Clear returns it to `defaultValue`
+     * rather than to nothing, and a rule without an operand refuses to be
+     * applied or removed. A required field is pinned whether or not it says so.
+     */
+    required?: boolean;
+    defaultValue?: FilterDescriptor | null;
+    /** A heading the add menu groups the field under. */
+    section?: string;
+    /** Whether the global query searches this field. */
+    searchable?: boolean;
+    /** The values a `set` field offers. */
+    options?: readonly FilterBarOption[];
+    min?: number | string;
+    max?: number | string;
+    step?: number;
+}
+/** A saved view: a name and the tree it restores. */
+interface FilterBarPreset {
+    key: string;
+    label: string;
+    value: FilterGroup | null;
+}
+declare const FILTER_BAR_DEFAULT_APPLY: FilterBarApply;
+declare const FILTER_BAR_DEFAULT_SIZE: FilterBarSize;
+declare const FILTER_BAR_DEFAULT_QUERY_DELAY = 320;
+declare const FILTER_BAR_DEFAULT_CHIP_LIMIT = 6;
+interface FilterBarDefaults {
+    apply?: FilterBarApply;
+    chipLimit?: number;
+    queryDelay?: number;
+    shortcut?: string | null;
+    size?: FilterBarSize;
+}
+declare const FILTER_BAR_DEFAULTS_TOKEN: InjectionToken<FilterBarDefaults>;
+/**
+ * An application decides once how its bars apply, how long the query waits,
+ * how many chips show, and which key reaches the search. A bar that states any
+ * of those itself still wins. Its words come from the language in force
+ * (`provideSlotted`).
+ */
+declare function provideFilterBarDefaults(defaults: FilterBarDefaults): {
+    provide: InjectionToken<FilterBarDefaults>;
+    useValue: FilterBarDefaults;
+};
+declare function injectFilterBarDefaults(): FilterBarDefaults;
+
+type Condition = FilterCondition<string, unknown>;
+/** The family's words in the language in force, with the bar's `messages` laid over them. */
+type FilterBarTranslator = FamilyTranslator<FilterBarMessages>;
+/** What a `slFilterBarOperand` template is handed for one operand. */
+interface FilterBarOperandContext {
+    $implicit: FilterBarField;
+    field: FilterBarField;
+    operator: FilterOperator;
+    index: 0 | 1;
+    value: unknown;
+    set: (value: unknown) => void;
+    apply: () => void;
+    label: string;
+    size: FilterBarSize;
+}
+/**
+ * Replaces the operand control of a field's rules. `slFilterBarOperand` names
+ * the field, or `*` for every field. The template is rendered per rule and
+ * never built for a closed surface.
+ */
+declare class SlFilterBarOperand {
+    readonly field: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<FilterBarOperandContext>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFilterBarOperand, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlFilterBarOperand, "ng-template[slFilterBarOperand]", never, { "field": { "alias": "slFilterBarOperand"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Writes this family's part name on a control another family's directive
+ * owns. `slButton`, `slIconButton` and `slMenuTriggerFor` each write
+ * `data-part` from their host metadata, which erases the one the template
+ * wrote — the rule the briefing records for `toolbar`'s overflow control — so
+ * the part is written back after the first render, where nothing writes over
+ * it again.
+ */
+declare class SlFilterBarPart {
+    readonly part: _angular_core.InputSignal<string>;
+    private readonly host;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFilterBarPart, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlFilterBarPart, "[slFilterBarPart]", never, { "part": { "alias": "slFilterBarPart"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** The consumer's own controls, drawn in the `end` slot. */
+declare class SlFilterBarEnd {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFilterBarEnd, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlFilterBarEnd, "[slFilterBarEnd]", never, {}, {}, never, never, true, never>;
+}
+/** What every editor in the family reads from the bar. */
+interface FilterBarEnvironment {
+    fields: () => readonly FilterBarField[];
+    t: FilterBarTranslator;
+    size: () => FilterBarSize;
+    operandTemplates: () => readonly SlFilterBarOperand[];
+}
+/**
+ * One condition — the operator and its operands — with the operand control the
+ * kind draws, the same choice `table`'s typed filters make, or the consumer's
+ * own template.
+ */
+declare class SlFilterBarCondition {
+    readonly field: _angular_core.InputSignal<FilterBarField>;
+    readonly condition: _angular_core.InputSignal<Condition>;
+    /** The bar's words, which the condition speaks in. */
+    readonly translator: _angular_core.InputSignal<FilterBarTranslator>;
+    readonly size: _angular_core.InputSignal<FilterBarSize>;
+    readonly operandTemplates: _angular_core.InputSignal<readonly SlFilterBarOperand[]>;
+    /** Draws the operator control. A chip's value popover leaves it to the chip's operator segment. */
+    readonly withOperator: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The rule is invalid: the operator select says so itself, edge and ring. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Ids for the two parts, which a rule card's sentence names in `aria-controls`. */
+    readonly ids: _angular_core.InputSignal<{
+        operator: string;
+        operand: string;
+    } | undefined>;
+    readonly applyRequest: _angular_core.OutputEmitterRef<void>;
+    readonly conditionChange: _angular_core.OutputEmitterRef<Condition>;
+    protected readonly truths: {
+        label: string;
+        value: string;
+    }[];
+    protected readonly operators: _angular_core.Signal<readonly string[]>;
+    protected readonly operatorItems: _angular_core.Signal<{
+        label: string;
+        value: string;
+    }[]>;
+    protected readonly slots: _angular_core.Signal<readonly (0 | 1)[]>;
+    protected readonly customTemplate: _angular_core.Signal<SlFilterBarOperand | undefined>;
+    protected readonly t: FilterBarTranslator;
+    operatorName(operator: string): string;
+    protected operandLabel(slot: 0 | 1): string;
+    protected operand(slot: 0 | 1): unknown;
+    protected numberBound(value: number | string | undefined): number | null;
+    protected day: (value: unknown) => _slotted_core_date.PlainDate | null;
+    protected time: (value: unknown) => _slotted_core_date.PlainTime | null;
+    protected dateTime: (value: unknown) => _slotted_core_date.PlainDateTime | null;
+    protected isoDay: (value: unknown) => string | null;
+    protected isoTime: (value: unknown) => string | null;
+    protected isoDateTime: (value: unknown) => string | null;
+    protected setOperator(operator: string): void;
+    protected setOperand(slot: 0 | 1, value: unknown): void;
+    protected apply(): void;
+    protected context(slot: 0 | 1): FilterBarOperandContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFilterBarCondition, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlFilterBarCondition, "[slFilterBarCondition]", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "condition": { "alias": "condition"; "required": true; "isSignal": true; }; "translator": { "alias": "translator"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": true; "isSignal": true; }; "operandTemplates": { "alias": "operandTemplates"; "required": false; "isSignal": true; }; "withOperator": { "alias": "withOperator"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "ids": { "alias": "ids"; "required": false; "isSignal": true; }; }, { "applyRequest": "applyRequest"; "conditionChange": "conditionChange"; }, never, never, true, never>;
+}
+/**
+ * One rule row in the builder: its sentence, field, operator, operand, remove.
+ * The sentence heads the card the stylesheet draws while the builder is
+ * narrow, and pressing it expands the card.
+ */
+declare class SlFilterBarRule {
+    readonly rule: _angular_core.InputSignal<FilterRule>;
+    readonly fields: _angular_core.InputSignal<readonly FilterBarField[]>;
+    /** The bar's words, which the rule speaks in. */
+    readonly translator: _angular_core.InputSignal<FilterBarTranslator>;
+    readonly size: _angular_core.InputSignal<FilterBarSize>;
+    readonly operandTemplates: _angular_core.InputSignal<readonly SlFilterBarOperand[]>;
+    readonly removable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The rule's path inside the root, which names its card. */
+    readonly path: _angular_core.InputSignal<FilterPath>;
+    /** The one card open in the builder, by its path joined with dots. */
+    readonly expanded: _angular_core.InputSignal<string | null>;
+    readonly ruleChange: _angular_core.OutputEmitterRef<FilterRule>;
+    readonly removeRequest: _angular_core.OutputEmitterRef<void>;
+    readonly applyRequest: _angular_core.OutputEmitterRef<void>;
+    readonly expandedChange: _angular_core.OutputEmitterRef<string | null>;
+    protected readonly id: string;
+    protected readonly t: FilterBarTranslator;
+    protected readonly key: _angular_core.Signal<string>;
+    protected readonly isExpanded: _angular_core.Signal<boolean>;
+    protected readonly field: _angular_core.Signal<FilterBarField | undefined>;
+    protected readonly condition: _angular_core.Signal<Condition>;
+    protected readonly operands: _angular_core.Signal<0 | 2 | 1>;
+    protected readonly fieldItems: _angular_core.Signal<{
+        label: string;
+        value: string;
+    }[]>;
+    protected readonly words: _angular_core.Signal<{
+        operator: string;
+        value: string;
+        full: string;
+        operands: number;
+    }>;
+    protected readonly label: _angular_core.Signal<string>;
+    protected changeField(key: string): void;
+    protected changeCondition(condition: Condition): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFilterBarRule, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlFilterBarRule, "[slFilterBarRule]", never, { "rule": { "alias": "rule"; "required": true; "isSignal": true; }; "fields": { "alias": "fields"; "required": true; "isSignal": true; }; "translator": { "alias": "translator"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": true; "isSignal": true; }; "operandTemplates": { "alias": "operandTemplates"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "path": { "alias": "path"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "ruleChange": "ruleChange"; "removeRequest": "removeRequest"; "applyRequest": "applyRequest"; "expandedChange": "expandedChange"; }, never, never, true, never>;
+}
+/**
+ * A group: its join, its rules and groups in order, and the controls that grow
+ * it. Recursive, so a group holds a group; the depth is on the element for the
+ * rail the stylesheet draws.
+ */
+declare class SlFilterBarGroup {
+    readonly group: _angular_core.InputSignal<FilterGroup>;
+    readonly path: _angular_core.InputSignal<FilterPath>;
+    readonly root: _angular_core.InputSignal<FilterGroup>;
+    readonly fields: _angular_core.InputSignal<readonly FilterBarField[]>;
+    /** The bar's words, which the group speaks in. */
+    readonly translator: _angular_core.InputSignal<FilterBarTranslator>;
+    readonly size: _angular_core.InputSignal<FilterBarSize>;
+    readonly operandTemplates: _angular_core.InputSignal<readonly SlFilterBarOperand[]>;
+    /** The one rule card open in the builder, by its path joined with dots. */
+    readonly expanded: _angular_core.InputSignal<string | null>;
+    readonly rootChange: _angular_core.OutputEmitterRef<FilterGroup>;
+    readonly applyRequest: _angular_core.OutputEmitterRef<void>;
+    readonly expandedChange: _angular_core.OutputEmitterRef<string | null>;
+    protected readonly t: FilterBarTranslator;
+    protected readonly joinWord: _angular_core.Signal<string>;
+    /** The words of `matches` before and after the join chooser, which stands in its `{join}`. */
+    protected readonly aroundJoin: _angular_core.Signal<[string, string]>;
+    protected readonly removeNodeAt: typeof removeNodeAt;
+    protected readonly firstField: _angular_core.Signal<FilterBarField | undefined>;
+    protected readonly buttonSize: _angular_core.Signal<"sm" | "md">;
+    protected isGroup(node: FilterNode): node is FilterGroup;
+    protected isRequired(rule: FilterRule): boolean;
+    protected childPath(index: number): FilterPath;
+    protected setJoin(join: string): void;
+    protected replace(index: number, rule: FilterRule): void;
+    protected remove(index: number): void;
+    protected addRule(): void;
+    protected addGroup(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFilterBarGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlFilterBarGroup, "fieldset[slFilterBarGroup]", never, { "group": { "alias": "group"; "required": true; "isSignal": true; }; "path": { "alias": "path"; "required": false; "isSignal": true; }; "root": { "alias": "root"; "required": true; "isSignal": true; }; "fields": { "alias": "fields"; "required": true; "isSignal": true; }; "translator": { "alias": "translator"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": true; "isSignal": true; }; "operandTemplates": { "alias": "operandTemplates"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "rootChange": "rootChange"; "applyRequest": "applyRequest"; "expandedChange": "expandedChange"; }, never, ["*"], true, never>;
+}
+/**
+ * One rule in a popover. Under `live` every change is requested at once — a
+ * text or number operand after `queryDelay`, so a query does not fire per
+ * keystroke — and Done closes; under `manual` the change goes to the draft the
+ * same way. Clear removes the rule, which a required field refuses.
+ */
+declare class SlFilterBarRuleEditor {
+    readonly field: _angular_core.InputSignal<FilterBarField>;
+    readonly current: _angular_core.InputSignal<FilterDescriptor | undefined>;
+    /** The bar's words, which the editor speaks in. */
+    readonly translator: _angular_core.InputSignal<FilterBarTranslator>;
+    readonly size: _angular_core.InputSignal<FilterBarSize>;
+    readonly operandTemplates: _angular_core.InputSignal<readonly SlFilterBarOperand[]>;
+    readonly queryDelay: _angular_core.InputSignal<number>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Draws the operator control: a chip's value popover leaves it to the chip. */
+    readonly withOperator: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ruleChange: _angular_core.OutputEmitterRef<FilterDescriptor | null>;
+    readonly doneRequest: _angular_core.OutputEmitterRef<void>;
+    protected readonly t: FilterBarTranslator;
+    private readonly destroyRef;
+    private readonly local;
+    private timer;
+    protected readonly draft: _angular_core.Signal<FilterDescriptor>;
+    protected readonly condition: _angular_core.Signal<Condition>;
+    constructor();
+    protected change(condition: Condition): void;
+    protected done(): void;
+    protected clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFilterBarRuleEditor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlFilterBarRuleEditor, "[slFilterBarRuleEditor]", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "current": { "alias": "current"; "required": false; "isSignal": true; }; "translator": { "alias": "translator"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": true; "isSignal": true; }; "operandTemplates": { "alias": "operandTemplates"; "required": false; "isSignal": true; }; "queryDelay": { "alias": "queryDelay"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "withOperator": { "alias": "withOperator"; "required": false; "isSignal": true; }; }, { "ruleChange": "ruleChange"; "doneRequest": "doneRequest"; }, never, never, true, never>;
+}
+/** One field's condition in the bar, as its chip draws it. */
+interface BarChip {
+    readonly kind: 'chip';
+    readonly id: string;
+    readonly key: string;
+    readonly field: FilterBarField | undefined;
+    readonly filter: FilterDescriptor;
+    readonly label: string;
+    /** The group's name: the field and its sentence, and whether it is incomplete. */
+    readonly name: string;
+    /** The operator as the sentence reads it. */
+    readonly operator: string;
+    /** The condition's own operator, which the operator menu checks. */
+    readonly condition: string;
+    readonly operators: readonly string[];
+    readonly operands: number;
+    readonly value: string;
+    readonly valueName: string;
+    readonly valueTitle: string | null;
+    readonly hasValue: boolean;
+    readonly pinned: boolean;
+    readonly incomplete: boolean;
+    readonly folded: boolean;
+    readonly unknown: boolean;
+    readonly removable: boolean;
+}
+/** A pinned field without a condition. */
+interface BarPill {
+    readonly kind: 'pill';
+    readonly id: string;
+    readonly field: FilterBarField;
+}
+/** A group at the first level, written as one sentence that opens the builder. */
+interface BarGroup {
+    readonly kind: 'group';
+    readonly id: string;
+    readonly path: FilterPath;
+    readonly words: string;
+    readonly folded: boolean;
+}
+type BarMember = BarChip | BarPill | BarGroup;
+/**
+ * A condition the reader started — from `add` or from a pinned field's pill —
+ * and whose operand is not there yet. It is the bar's own and not the value's:
+ * the engine would drop it as inactive anyway, so it is drawn as an incomplete
+ * chip and enters the value the moment it is complete.
+ */
+interface PendingRule {
+    key: string;
+    filter: FilterDescriptor;
+    /** Where an applied rule stood before it lost its operand, so its chip keeps its place. */
+    at?: number;
+}
+/**
+ * A bar above a listing that edits one value: a tree of conditions over the
+ * listing's fields, whose leaves are the descriptor `table` edits in a column
+ * header. The bar draws the first level — a search field, a pill per pinned
+ * field without a condition, a chip of segments per condition — and opens a
+ * drawer on the whole tree.
+ *
+ * The family applies nothing. It reports the tree and the query, and
+ * `createFilterGroupPredicate` and `createSearchPredicate` in
+ * `@slotted/core/filter` are what a consumer applies to its own rows.
+ */
+declare class SlFilterBar {
+    /** The fields the listing can be filtered by, in the order the add menu lists them. */
+    readonly fields: _angular_core.InputSignal<readonly FilterBarField[]>;
+    /** The tree. Present is controlled, for the life of the bar. */
+    readonly value: _angular_core.ModelSignal<FilterGroup | null | undefined>;
+    /** Where an uncontrolled tree starts, read once. */
+    readonly defaultValue: _angular_core.InputSignal<FilterGroup | null>;
+    /** The global query. */
+    readonly query: _angular_core.ModelSignal<string | undefined>;
+    readonly defaultQuery: _angular_core.InputSignal<string>;
+    readonly presets: _angular_core.InputSignal<readonly FilterBarPreset[] | undefined>;
+    readonly preset: _angular_core.ModelSignal<string | null | undefined>;
+    readonly defaultPreset: _angular_core.InputSignal<string | null>;
+    /** Whether the builder is open. */
+    readonly open: _angular_core.ModelSignal<boolean | undefined>;
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the chips past `chipLimit` are shown. */
+    readonly revealed: _angular_core.ModelSignal<boolean | undefined>;
+    readonly defaultRevealed: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The five effective values: the model when it is set, the default otherwise. */
+    readonly currentValue: _angular_core.Signal<FilterGroup | null>;
+    readonly currentQuery: _angular_core.Signal<string>;
+    readonly currentPreset: _angular_core.Signal<string | null>;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    readonly isRevealed: _angular_core.Signal<boolean>;
+    readonly apply: _angular_core.InputSignal<FilterBarApply | undefined>;
+    readonly sticky: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** A parent for the builder's drawer alone, instead of the shared portal root. */
+    readonly container: _angular_core.InputSignal<Element | null | undefined>;
+    readonly size: _angular_core.InputSignal<FilterBarSize | undefined>;
+    readonly queryDelay: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly chipLimit: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly shortcut: _angular_core.InputSignal<string | null | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The conditions can be read and reached, and nothing changes them. */
+    readonly readOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The number of rows the filter kept, and the number there are. Written by
+     * the `count` message, or `countOnly` without a total, in the digits of the
+     * language in force.
+     */
+    readonly count: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly total: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * landmark's name (`bar`), the controls, the chips' names, the count and the
+     * announcements.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<FilterBarMessages> | undefined>;
+    /** The requests behind every committed change, each with the reason it carries. */
+    readonly valueChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<FilterGroup | null>>;
+    readonly queryChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<string>>;
+    readonly presetChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<string | null>>;
+    readonly openChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    readonly revealedChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    /** Draws the save-as-view control in the builder. */
+    readonly savePresetEnabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Asks the application to save the tree as a view. */
+    readonly savePreset: _angular_core.OutputEmitterRef<FilterGroup | null>;
+    private readonly defaults;
+    private readonly host;
+    private readonly injector;
+    private readonly destroyRef;
+    protected readonly ariaLabel: string | null;
+    private readonly searchInput;
+    private readonly barElement;
+    protected readonly operandTemplates: _angular_core.Signal<readonly SlFilterBarOperand[]>;
+    protected readonly endSlot: _angular_core.Signal<SlFilterBarEnd | undefined>;
+    readonly id: string;
+    protected readonly empty: FilterGroup;
+    /** The family's words in the language in force, with this bar's `messages` laid over them. */
+    readonly t: FilterBarTranslator;
+    protected readonly applyValue: _angular_core.Signal<FilterBarApply>;
+    protected readonly sizeValue: _angular_core.Signal<FilterBarSize>;
+    protected readonly queryDelayValue: _angular_core.Signal<number>;
+    protected readonly chipLimitValue: _angular_core.Signal<number>;
+    protected readonly shortcutValue: _angular_core.Signal<string | null>;
+    private readonly locked;
+    private readonly draft;
+    protected readonly invalid: _angular_core.WritableSignal<string | null>;
+    protected readonly pending: _angular_core.WritableSignal<PendingRule | null>;
+    /** Which chip's value popover is open, by its field key. */
+    protected readonly valueOpen: _angular_core.WritableSignal<string | null>;
+    /** The one rule card open in the builder's card form, by its path. */
+    protected readonly expanded: _angular_core.WritableSignal<string | null>;
+    protected readonly drawerDraft: _angular_core.WritableSignal<FilterGroup | null>;
+    /** Whether the bar is under its narrow breakpoint: an edit then goes to the builder. */
+    protected readonly narrow: _angular_core.WritableSignal<boolean>;
+    /** Whether the viewport is under the sheet breakpoint: the builder then comes up from the bottom. */
+    protected readonly sheet: _angular_core.WritableSignal<boolean>;
+    private readonly typed;
+    /** A tree the builder opens on instead of the shown one: a rule the reader just started. */
+    private seed;
+    private timer;
+    protected readonly shown: _angular_core.Signal<FilterGroup | null>;
+    protected readonly shownQuery: _angular_core.Signal<string>;
+    protected readonly dirty: _angular_core.Signal<boolean>;
+    protected readonly presetDirty: _angular_core.Signal<boolean>;
+    private readonly format;
+    protected readonly required: _angular_core.Signal<FilterBarField[]>;
+    protected readonly pinned: _angular_core.Signal<FilterBarField[]>;
+    private readonly pinnedKeys;
+    protected readonly activeCount: _angular_core.Signal<number>;
+    protected readonly draftActive: _angular_core.Signal<number>;
+    protected readonly unfiltered: _angular_core.Signal<FilterBarField[]>;
+    protected readonly sections: _angular_core.Signal<{
+        fields: FilterBarField[];
+        name: string | undefined;
+    }[]>;
+    protected readonly presetItems: _angular_core.Signal<{
+        label: string;
+        value: string;
+    }[]>;
+    /**
+     * The bar's members in order: pinned fields as declared — a chip, or a pill
+     * while they hold no condition — then the other first-level conditions, then
+     * the one pending, which keeps the place an applied rule had when it lost its
+     * operand.
+     */
+    protected readonly members: _angular_core.Signal<readonly BarMember[]>;
+    protected readonly chipCount: _angular_core.Signal<number>;
+    protected readonly folded: _angular_core.Signal<number>;
+    protected readonly countText: _angular_core.Signal<string | null>;
+    constructor();
+    protected pillOf(member: BarMember): BarPill | null;
+    protected chipOf(member: BarMember): BarChip | null;
+    protected groupOf(member: BarMember): BarGroup | null;
+    protected isTemplate(icon: unknown): icon is TemplateRef<unknown>;
+    protected operatorWords(operator: string): string;
+    protected normalized(group: FilterGroup | null): FilterGroup | null;
+    /** One field's condition as its chip draws it. */
+    private describeChip;
+    private sentenceOf;
+    private announce;
+    requestValue(next: FilterGroup | null, reason: FilterBarValueReason, source?: unknown): void;
+    requestQuery(next: string, reason: FilterBarQueryReason, source?: unknown): void;
+    requestPreset(next: string | null, reason: FilterBarPresetReason, source?: unknown): void;
+    requestOpen(next: boolean, reason: FilterBarOpenReason, source?: unknown): void;
+    requestRevealed(next: boolean, reason: FilterBarRevealedReason, source?: unknown): void;
+    /**
+     * Every edit of the tree goes through here: under `live` it is requested at
+     * once, under `manual` it goes to the draft and Apply requests it.
+     */
+    private edit;
+    /** The tree with every required field at its default, which is what Clear returns to. */
+    protected baseline(): FilterGroup | null;
+    private missing;
+    /** A required field refuses: data-invalid on its chip or pill, its message said, and focus on it when asked. */
+    private refuse;
+    /** A field chosen from `add` or pressed as a pill: its chip, incomplete, with the value popover open. */
+    protected start(key: string, source?: unknown): void;
+    /** Every change to one field's rule from a chip: pending until active, then the value's. */
+    protected changeRule(key: string, next: FilterDescriptor | null, reason: FilterBarValueReason): void;
+    protected setOperator(key: string, filter: FilterDescriptor, operator: string): void;
+    protected toggleValue(key: string, open: boolean): void;
+    /** Done in a chip's value popover: the condition is said, and the popover closes. */
+    protected finishValue(key: string): void;
+    /** The value segment drawn without its popover: under the narrow breakpoint it opens the builder. */
+    protected onValueSegment(chip: BarChip, event: Event): void;
+    protected removeField(key: string, source?: unknown): void;
+    protected removeNode(path: FilterPath, source?: unknown): void;
+    /**
+     * `Delete` and `Backspace` on a segment remove the condition. The keyboard
+     * goes to the segment of the same role on the chip that followed, else on
+     * the one before, else to `add` — chosen before the removal, while both
+     * neighbours are still in the DOM, and focused after the render.
+     */
+    protected onChipKeyDown(event: KeyboardEvent, key: string): void;
+    protected onGroupKeyDown(event: KeyboardEvent, path: FilterPath): void;
+    private focusAfterRender;
+    protected clearAll(source?: unknown): void;
+    protected submit(source?: unknown): void;
+    protected reset(): void;
+    protected choosePreset(key: string | null, source?: unknown): void;
+    /** Opens the builder, with the card at `at.path` expanded, on `at.tree` when given. */
+    protected openBuilderAt(reason: FilterBarOpenReason, source?: unknown, at?: {
+        tree?: FilterGroup | null;
+        path: FilterPath;
+    }): void;
+    /** The builder open on one field's rule: the applied one, the pending one, or a fresh one. */
+    private openBuilderOn;
+    protected commitDrawer(): void;
+    protected onDrawerRequest(request: ChangeRequest<boolean>): void;
+    protected typeQuery(request: ChangeRequest<string>): void;
+    protected onSearchKeyDown(event: KeyboardEvent): void;
+    /** Puts focus in the search field. */
+    focusSearch(): void;
+    /**
+     * Opens the builder. With a path, the rule at that path opens as the
+     * expanded card. `open` is the model's name here, so the handle's `open(path)`
+     * is `openBuilder(path)`.
+     */
+    openBuilder(path?: FilterPath): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFilterBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlFilterBar, "[slFilterBar]", ["slFilterBar"], { "fields": { "alias": "fields"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "query": { "alias": "query"; "required": false; "isSignal": true; }; "defaultQuery": { "alias": "defaultQuery"; "required": false; "isSignal": true; }; "presets": { "alias": "presets"; "required": false; "isSignal": true; }; "preset": { "alias": "preset"; "required": false; "isSignal": true; }; "defaultPreset": { "alias": "defaultPreset"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "revealed": { "alias": "revealed"; "required": false; "isSignal": true; }; "defaultRevealed": { "alias": "defaultRevealed"; "required": false; "isSignal": true; }; "apply": { "alias": "apply"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "container": { "alias": "container"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "queryDelay": { "alias": "queryDelay"; "required": false; "isSignal": true; }; "chipLimit": { "alias": "chipLimit"; "required": false; "isSignal": true; }; "shortcut": { "alias": "shortcut"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "savePresetEnabled": { "alias": "savePresetEnabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "query": "queryChange"; "preset": "presetChange"; "open": "openChange"; "revealed": "revealedChange"; "valueChangeRequest": "valueChangeRequest"; "queryChangeRequest": "queryChangeRequest"; "presetChangeRequest": "presetChangeRequest"; "openChangeRequest": "openChangeRequest"; "revealedChangeRequest": "revealedChangeRequest"; "savePreset": "savePreset"; }, ["operandTemplates", "endSlot"], ["[slFilterBarEnd]"], true, never>;
+}
+
+export { FILTER_BAR_DEFAULTS_TOKEN, FILTER_BAR_DEFAULT_APPLY, FILTER_BAR_DEFAULT_CHIP_LIMIT, FILTER_BAR_DEFAULT_QUERY_DELAY, FILTER_BAR_DEFAULT_SIZE, SlFilterBar, SlFilterBarCondition, SlFilterBarEnd, SlFilterBarGroup, SlFilterBarOperand, SlFilterBarPart, SlFilterBarRule, SlFilterBarRuleEditor, injectFilterBarDefaults, provideFilterBarDefaults };
+export type { FilterBarApply, FilterBarDefaults, FilterBarEnvironment, FilterBarField, FilterBarOpenReason, FilterBarOperandContext, FilterBarOption, FilterBarPreset, FilterBarPresetReason, FilterBarQueryReason, FilterBarRevealedReason, FilterBarSize, FilterBarTranslator, FilterBarValueReason };
+//# sourceMappingURL=slotted-angular-filter-bar.d.ts.map

package/types/slotted-angular-filter-bar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-filter-bar.d.ts","sources":["../../filter-bar/src/filter-bar.constants.ts","../../filter-bar/src/filter-bar.ts"],"mappings":"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","names":[]}