optikos 0.0.0-stage → 0.1.0

package/dist/types/components/fields/pickerfield/pickerfield.d.ts

@@ -0,0 +1,77 @@
+import { TextField, type TextFieldConfig } from '../textfield/textfield.js';
+import { Dropdown } from '../../overlays/dropdown/dropdown.js';
+import { ListBox, type ListItem } from '../listbox/listbox.js';
+import type { Store } from '../../../data/store.js';
+export type { ListItem };
+export type Option = string | number | Record<string, any>;
+export interface PickerConfig<V = unknown> extends TextFieldConfig<V> {
+    options?: Option[];
+    store?: Store<any>;
+    valueField?: string;
+    displayField?: string;
+    /** Text that does not match an item is discarded on blur. Default true. */
+    forceSelection?: boolean;
+    emptyText?: string;
+    openOnFocus?: boolean;
+    maxHeight?: number | string;
+    /** Show the record's value (its id) as a badge inside the field and as a hint in every list row. Default false. */
+    showValue?: boolean;
+}
+/**
+ * Shared base of Select, ComboBox and SuggestField: an input that owns a Dropdown with a ListBox,
+ * the ARIA combobox wiring and the keyboard model. Subclasses decide what typing does (`onType`)
+ * and whether the input is editable.
+ */
+export declare abstract class PickerField<V = unknown, C extends PickerConfig<V> = PickerConfig<V>> extends TextField<V, C> {
+    protected baseCls: string;
+    protected items: ListItem[];
+    protected selection?: ListItem;
+    /** The user typed since the last selection/blur; the input text is a search term, not the value's label. */
+    protected typed: boolean;
+    protected list: ListBox;
+    protected dd: Dropdown;
+    private triggerEl?;
+    private idEl?;
+    private wrapEl?;
+    private buffer;
+    private bufferTimer?;
+    protected editable(): boolean;
+    protected hasTrigger(): boolean;
+    /** Called when the user types in an editable picker. */
+    protected onType(_text: string): void;
+    protected toItem(o: Option): ListItem;
+    protected loadItems(): void;
+    setOptions(options: Option[]): void;
+    setStore(store: Store<any>): void;
+    private offStore?;
+    private bindStore;
+    protected findItem(value: unknown): ListItem | undefined;
+    getSelection(): ListItem | undefined;
+    /** Selects an item object directly (needed when the list does not contain it, e.g. a remote value). */
+    setSelection(item: ListItem | undefined, silent?: boolean): void;
+    /** The items to display for the current search state. Default: all. */
+    protected visibleItems(): ListItem[];
+    protected refreshList(): void;
+    private syncActive;
+    protected createControl(): HTMLDivElement;
+    protected onRender(): void;
+    protected onReadonly(readonly: boolean): void;
+    protected onDisabled(disabled: boolean): void;
+    protected applyValue(v: V): void;
+    /** The id badge (`showValue`): visible while a record is selected, and the input makes room for it. */
+    protected paintId(): void;
+    getDisplayText(): string;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    expand(): void;
+    collapse(): void;
+    protected pick(item: ListItem): void;
+    /** Called on blur: commits free text or reverts to the selected label. */
+    protected settle(): void;
+    protected onInput(): void;
+    protected onKey(e: KeyboardEvent): void;
+    /** Select-style type-ahead: letters jump to the next label that starts with them. */
+    private typeahead;
+    setEmptyText(text: string): void;
+}

package/dist/types/components/fields/radiogroup/radiogroup.d.ts

@@ -0,0 +1,26 @@
+import { Field, type FieldConfig } from '../../../core/field.js';
+export type RadioOption = string | {
+    value: string | number;
+    label: string;
+    disabled?: boolean;
+};
+export interface RadioGroupConfig extends FieldConfig<string | number | null> {
+    options?: RadioOption[];
+    direction?: 'vertical' | 'horizontal';
+}
+export declare class RadioGroup extends Field<string | number | null, RadioGroupConfig> {
+    protected baseCls: string;
+    private group;
+    private inputs;
+    protected emptyValue(): null;
+    protected createControl(): HTMLElement;
+    private opts;
+    private buildOptions;
+    protected onRender(): void;
+    protected applyValue(v: string | number | null): void;
+    /** The `is-checked` class (what the styled dot reads) mirrors the native `checked` of each option. */
+    private paintChecked;
+    getDisplayText(): string;
+    protected onDisabled(disabled: boolean): void;
+    setOptions(options: RadioOption[]): void;
+}

package/dist/types/components/fields/secretfield/secretfield.d.ts

@@ -0,0 +1,52 @@
+import { TextField, type TextFieldConfig } from '../textfield/textfield.js';
+export interface SecretFieldConfig extends TextFieldConfig<string | null> {
+    /** A secret is already saved. It can never be shown; it can only be replaced. `form.load({ key: true })` sets it too. */
+    stored?: boolean;
+    /** Ask before replacing a saved secret. Default true. */
+    confirmReplace?: boolean;
+    replaceTitle?: string;
+    replaceText?: string;
+    /** The eye hides the value again when the field loses focus. Default true. */
+    autoHide?: boolean;
+}
+/**
+ * A field for secrets. While you type you can peek at what you typed (the eye); once a secret is saved it is shown only as a
+ * mask and can never be read back: to change it you replace it, after a warning. `getValue()` is `null` while untouched
+ * (keep what is saved), the new text once typed, `''` when replaced and left empty.
+ */
+export declare class SecretField extends TextField<string | null, SecretFieldConfig> {
+    protected baseCls: string;
+    private stored;
+    private initialStored;
+    private replacing;
+    private revealed;
+    private eyeBtn;
+    private replaceBtn;
+    private keepBtn;
+    private hint;
+    constructor(config?: SecretFieldConfig);
+    protected emptyValue(): string | null;
+    /** A saved secret that was not touched counts as filled in (so `required` is satisfied). */
+    protected isEmpty(v: string | null): boolean;
+    protected createControl(): HTMLDivElement;
+    protected onRender(): void;
+    isStored(): boolean;
+    /** The user chose to replace a saved secret and has not finished. */
+    isReplacing(): boolean;
+    isRevealed(): boolean;
+    /** Says whether a secret is saved (a saved secret is never given to the field, only the fact that it exists). */
+    setStored(stored: boolean): void;
+    /** `true` (what `form.load` passes for "a secret exists") means saved; a string is a new value typed or set by code. */
+    setValue(v: string | boolean | null, silent?: boolean): void;
+    markClean(): void;
+    /** Back to what was loaded: the saved secret, untouched. */
+    reset(): void;
+    /** Warns, then turns a saved secret into an empty field to type the new value in. Resolves to whether it was replaced. */
+    replace(): Promise<boolean>;
+    /** Gives up replacing: the saved secret stays as it was. */
+    keep(): void;
+    setRevealed(on: boolean): void;
+    /** Never reveals: a mask when there is something, nothing otherwise. */
+    getDisplayText(): string;
+    private paint;
+}

package/dist/types/components/fields/select/select.d.ts

@@ -0,0 +1,10 @@
+import { PickerField, type PickerConfig } from '../pickerfield/pickerfield.js';
+export interface SelectConfig<V = unknown> extends PickerConfig<V> {
+}
+/** Pick one option from a closed list. The input is read-only; letters jump to matching labels. */
+export declare class Select<V = unknown> extends PickerField<V, SelectConfig<V>> {
+    protected baseCls: string;
+    protected editable(): boolean;
+    protected emptyValue(): V;
+    protected isEmpty(v: V): boolean;
+}

package/dist/types/components/fields/slider/slider.d.ts

@@ -0,0 +1,62 @@
+import { Field, type FieldConfig } from '../../../core/field.js';
+export interface SliderMark {
+    value: number;
+    label?: string;
+}
+export interface SliderConfig extends FieldConfig<number | [number, number]> {
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Two knobs: the value is `[low, high]`. */
+    range?: boolean;
+    marks?: boolean | SliderMark[];
+    /** When the bubble with the value shows. Default `drag` (while dragging or focused). */
+    showValue?: 'drag' | 'always' | 'never';
+    format?: (v: number) => string;
+    showScale?: boolean;
+}
+type V = number | [number, number];
+/** A bar with a ball to drag: a number, or a range with two balls. */
+export declare class Slider extends Field<V, SliderConfig> {
+    protected baseCls: string;
+    private track;
+    private fill;
+    private knobs;
+    private bubbles;
+    private marksEl;
+    private get min();
+    private get max();
+    private get step();
+    private get isRange();
+    protected emptyValue(): V;
+    protected isEmpty(): boolean;
+    private fmt;
+    private vals;
+    /** Snaps to a multiple of `step` inside [min, max] (without float noise). */
+    private snap;
+    protected createControl(): HTMLDivElement;
+    private buildKnobs;
+    protected onRender(): void;
+    private pct;
+    protected applyValue(v: V): void;
+    private paintMarks;
+    private valueAt;
+    private nearest;
+    private onTrackDown;
+    private onKnobDown;
+    /** The user moved knob `i` to `v`: update the value (knobs of a range never cross) and tell everyone. */
+    private setAt;
+    private onKey;
+    /** Where the (first) knob is, 0–100. */
+    getPercent(): number;
+    private refresh;
+    setMin(min: number): void;
+    setMax(max: number): void;
+    setStep(step: number): void;
+    private clampAll;
+    /** Switches between one knob and two; the value is converted. */
+    setRange(range: boolean): void;
+    protected onDisabled(disabled: boolean): void;
+    protected onReadonly(readonly: boolean): void;
+}
+export {};

package/dist/types/components/fields/suggestfield/suggestfield.d.ts

@@ -0,0 +1,34 @@
+import { PickerField, type PickerConfig, type ListItem, type Option } from '../pickerfield/pickerfield.js';
+export interface SuggestConfig<V = unknown> extends PickerConfig<V> {
+    /** Async search. Receives the text and an AbortSignal that fires when a newer search starts. */
+    query?: (text: string, ctx: {
+        signal: AbortSignal;
+    }) => Promise<Option[]> | Option[];
+    minChars?: number;
+    /** Debounce in ms. */
+    delay?: number;
+    highlight?: boolean;
+    /** Leading icon name; `false` hides it. Default: the magnifier (`search`). */
+    icon?: string | false;
+}
+/** Search-as-you-type field: results come from `query` (or a Store with a proxy), not from a fixed list. */
+export declare class SuggestField<V = unknown> extends PickerField<V, SuggestConfig<V>> {
+    protected baseCls: string;
+    private seq;
+    private abort?;
+    private cancelWait?;
+    private live;
+    protected hasTrigger(): boolean;
+    protected emptyValue(): V;
+    protected isEmpty(v: V): boolean;
+    protected createControl(): HTMLDivElement;
+    protected onRender(): void;
+    protected onType(text: string): void;
+    /** Runs a search now (skips the debounce). */
+    search(text: string): Promise<void>;
+    private showResults;
+    private setSearching;
+    setQuery(query: NonNullable<SuggestConfig['query']>): void;
+    clearSuggestions(): void;
+    protected pick(item: ListItem): void;
+}

package/dist/types/components/fields/textarea/textarea.d.ts

@@ -0,0 +1,16 @@
+import { TextField, type TextFieldConfig } from '../textfield/textfield.js';
+export interface TextAreaConfig extends TextFieldConfig {
+    rows?: number;
+    autoGrow?: boolean;
+    maxRows?: number;
+}
+export declare class TextArea extends TextField<string, TextAreaConfig> {
+    protected baseCls: string;
+    protected createInput(): HTMLTextAreaElement;
+    protected onKey(e: KeyboardEvent): void;
+    protected onInput(): void;
+    protected applyValue(v: string): void;
+    notifyMount(): void;
+    private grow;
+    setRows(rows: number): void;
+}

package/dist/types/components/fields/textfield/textfield.d.ts

@@ -0,0 +1,38 @@
+import { Field, type FieldConfig } from '../../../core/field.js';
+export interface TextFieldConfig<V = string> extends FieldConfig<V> {
+    inputType?: 'text' | 'email' | 'tel' | 'url' | 'search' | 'password';
+    placeholder?: string;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    autocomplete?: string;
+    selectOnFocus?: boolean;
+    clearable?: boolean;
+}
+type Input = HTMLInputElement | HTMLTextAreaElement;
+export declare class TextField<V = string, C extends TextFieldConfig<V> = TextFieldConfig<V>> extends Field<V, C> {
+    protected baseCls: string;
+    protected clearBtn?: HTMLButtonElement;
+    /** Subclasses (TextArea, ...) replace the native control. */
+    protected createInput(): Input;
+    protected get input(): Input;
+    protected createControl(): HTMLDivElement;
+    /** The text the user typed becomes the value on every edit. */
+    protected onInput(): void;
+    /** Text → value. Subclasses with non-string values (NumberField) override. */
+    protected parse(text: string): V;
+    /** Value → text shown in the input. */
+    protected display(v: V): string;
+    protected onKey(e: KeyboardEvent): void;
+    getDisplayText(): string;
+    protected applyValue(v: V): void;
+    protected onReadonly(readonly: boolean): void;
+    protected onDisabled(disabled: boolean): void;
+    protected check(): string;
+    setPlaceholder(text: string): void;
+    setMaxLength(n: number): void;
+    setInputType(type: NonNullable<TextFieldConfig['inputType']>): void;
+    select(): void;
+    getInput(): Input;
+}
+export {};

package/dist/types/components/fieldset.d.ts

@@ -0,0 +1 @@
+export * from '../components/layout/fieldset/fieldset.js';

package/dist/types/components/filterbuilder.d.ts

@@ -0,0 +1 @@
+export * from '../components/data/filterbuilder/filterbuilder.js';

package/dist/types/components/form/form/form.d.ts

@@ -0,0 +1,51 @@
+import { Container, type ContainerConfig } from '../../../core/container.js';
+import { Field } from '../../../core/field.js';
+import type { Model } from '../../../data/model.js';
+import type { Component } from '../../../core/component.js';
+import type { LayoutSpec } from '../../../layout/layout.js';
+export interface FormTab {
+    title: string;
+    icon?: string;
+    items: ContainerConfig['items'];
+    /** Default: two columns (one on a phone). */
+    layout?: LayoutSpec;
+}
+export interface FormConfig extends ContainerConfig {
+    /** Shortcut: the fields in tabs, still one form (one `getValues`, one `validate`, one dirty). */
+    tabs?: FormTab[];
+    /** Default `labelPos` for fields that do not set their own. */
+    labelPos?: 'top' | 'left';
+    readonly?: boolean;
+}
+export declare class Form extends Container<FormConfig> {
+    protected baseCls: string;
+    protected tag: 'form';
+    constructor(config?: FormConfig);
+    protected build(): HTMLElement;
+    protected onRender(): void;
+    getFields(): Field<any>[];
+    getField(name: string): Field<any> | undefined;
+    /** Nested object built from field names (`address.city` → `{ address: { city } }`). */
+    getValues(opts?: {
+        dirtyOnly?: boolean;
+    }): Record<string, any>;
+    /** Sets the fields present in `values` (silently). */
+    setValues(values: Record<string, any>): void;
+    /** Fills the form from a plain object or a Model, and makes it the "clean" state. */
+    load(record: Record<string, any> | Model): void;
+    /** Brings a field into view: asks every ancestor that shows one child at a time (Tabs, a card layout) to show the branch. */
+    protected reveal(field: Component): void;
+    /** Error counts and "changed" dots on the headers of every Tabs inside the form. */
+    protected syncTabs(): void;
+    /** Writes the changed fields back into a Model. */
+    updateRecord(model: Model): void;
+    markClean(): void;
+    reset(): void;
+    isDirty(): boolean;
+    isValid(): boolean;
+    clearErrors(): void;
+    /** Validates every field (marks errors) and focuses the first invalid one. */
+    validate(): boolean;
+    submit(): boolean;
+    setReadonly(readonly: boolean): void;
+}

package/dist/types/components/form/stepform/stepform.d.ts

@@ -0,0 +1,62 @@
+import { Form, type FormConfig } from '../form/form.js';
+import { type ContainerConfig } from '../../../core/container.js';
+import type { LayoutSpec } from '../../../layout/layout.js';
+import { Stepper } from '../../navigation/stepper/stepper.js';
+import '../../layout/container/container.js';
+export interface FormStep {
+    title: string;
+    description?: string;
+    icon?: string;
+    /** May be left alone: the stepper says "optional" (its fields are still validated if filled wrongly). */
+    optional?: boolean;
+    items: ContainerConfig['items'];
+    /** Default: two columns (one on a phone). */
+    layout?: LayoutSpec;
+}
+export interface StepFormConfig extends FormConfig {
+    steps: FormStep[];
+    /** Moving forward validates the steps on the way. `false` lets the user click any step. Default true. */
+    linear?: boolean;
+    /** Adds a last "Review" step with a summary of the values; a function renders the summary yourself. */
+    review?: boolean | ((values: Record<string, any>, form: StepForm) => string | Node);
+    reviewTitle?: string;
+    backText?: string;
+    nextText?: string;
+    finishText?: string;
+    /** Shows a Cancel button (fires `cancel`). */
+    cancelText?: string;
+}
+/** One form, several steps: a Stepper on top, one step at a time, Back / Next / Finish, validation per step and an optional review. */
+export declare class StepForm extends Form {
+    protected baseCls: string;
+    private stepper;
+    private body;
+    private pane?;
+    private backBtn;
+    private nextBtn;
+    private finishBtn;
+    private index;
+    constructor(config: StepFormConfig);
+    private cfg;
+    private count;
+    private real;
+    getStep(): number;
+    getStepCount(): number;
+    getStepper(): Stepper;
+    private stepFields;
+    /** Validates one step's fields (marks the errors, sets its state on the stepper). */
+    validateStep(i: number): boolean;
+    /** Moves to a step. Forward with `linear` validates the steps on the way and stops at the first invalid one. Returns whether it got there. */
+    goTo(j: number): boolean;
+    next(): boolean;
+    back(): boolean;
+    /** The card layout changed the visible step (by `goTo`, or because `validate` brought an invalid field into view). */
+    private onActivate;
+    private refreshReview;
+    /** What the user sees for a field (its display text; ticks for booleans, dots for passwords). */
+    private show_;
+    /** Enter and the Finish button: Next on every step but the last; on the last, validate everything and `finish`. */
+    submit(): boolean;
+    /** Clears the values and goes back to the first step. */
+    reset(): void;
+}

package/dist/types/components/form.d.ts

@@ -0,0 +1 @@
+export * from '../components/form/form/form.js';

package/dist/types/components/grid.d.ts

@@ -0,0 +1 @@
+export * from '../components/data/grid/grid.js';

package/dist/types/components/icon.d.ts

@@ -0,0 +1 @@
+export * from '../components/base/icon/icon.js';

package/dist/types/components/label.d.ts

@@ -0,0 +1 @@
+export * from '../components/base/label/label.js';

package/dist/types/components/layout/container/container.d.ts

@@ -0,0 +1 @@
+export { Container, type ContainerConfig } from '../../../core/container.js';

package/dist/types/components/layout/fieldset/fieldset.d.ts

@@ -0,0 +1,21 @@
+import { Container, type ContainerConfig } from '../../../core/container.js';
+export interface FieldSetConfig extends ContainerConfig {
+    title?: string;
+    collapsible?: boolean;
+    collapsed?: boolean;
+}
+export declare class FieldSet extends Container<FieldSetConfig> {
+    protected baseCls: string;
+    protected tag: 'fieldset';
+    private legend;
+    private bodyEl;
+    private toggleBtn?;
+    getBody(): HTMLElement;
+    protected build(): HTMLElement;
+    protected onRender(): void;
+    setTitle(title: string): void;
+    setCollapsed(collapsed: boolean): void;
+    collapse(): void;
+    expand(): void;
+    toggle(): void;
+}

package/dist/types/components/layout/panel/panel.d.ts

@@ -0,0 +1,47 @@
+import { Container, type ContainerConfig } from '../../../core/container.js';
+import { type ToolbarConfig } from '../toolbar/toolbar.js';
+import type { ButtonConfig } from '../../base/button/button.js';
+export interface PanelTool {
+    icon: string;
+    label: string;
+    handler?: (panel: Panel, ev: MouseEvent) => void;
+}
+export interface PanelConfig extends ContainerConfig {
+    title?: string;
+    icon?: string;
+    collapsible?: boolean;
+    collapsed?: boolean;
+    closable?: boolean;
+    closeAction?: 'destroy' | 'hide';
+    tools?: PanelTool[];
+    tbar?: ToolbarConfig['items'];
+    bbar?: ToolbarConfig['items'];
+    buttons?: ButtonConfig[];
+    bodyCls?: string;
+}
+export declare class Panel<C extends PanelConfig = PanelConfig> extends Container<C> {
+    protected baseCls: string;
+    protected headerEl: HTMLElement;
+    protected titleEl: HTMLElement;
+    protected bodyEl: HTMLElement;
+    private toolsEl;
+    private iconHost;
+    private toggleBtn?;
+    private bars;
+    private bodyId;
+    private titleId;
+    getBody(): HTMLElement;
+    protected build(): HTMLDivElement;
+    protected onRender(): void;
+    private addTool;
+    private updateHeader;
+    setTitle(title: string): void;
+    setIcon(name: string): void;
+    /** Collapses/expands without events. Use `collapse()`/`expand()` for the full behavior. */
+    setCollapsed(collapsed: boolean): void;
+    collapse(): void;
+    expand(): void;
+    toggle(): void;
+    close(): void;
+    protected onDestroy(): void;
+}

package/dist/types/components/layout/spacer/spacer.d.ts

@@ -0,0 +1,12 @@
+import { Component, type ComponentConfig } from '../../../core/component.js';
+export interface SpacerConfig extends ComponentConfig {
+    /** Renders a vertical separator line. */
+    line?: boolean;
+}
+/** Without `width`/`flex` it takes the free space (`flex: 1`), pushing the next items away. */
+export declare class Spacer extends Component<SpacerConfig> {
+    protected baseCls: string;
+    protected tag: 'span';
+    protected onRender(): void;
+    setLine(line: boolean): void;
+}

package/dist/types/components/layout/toolbar/toolbar.d.ts

@@ -0,0 +1,15 @@
+import { Container, type ContainerConfig } from '../../../core/container.js';
+import { type AnyConfig } from '../../../core/registry.js';
+import '../spacer/spacer.js';
+export interface ToolbarConfig extends ContainerConfig {
+    vertical?: boolean;
+}
+/** Items may be `'->'` (fill space), `'-'` (separator) or `' '` (small gap). */
+export declare class Toolbar extends Container<ToolbarConfig> {
+    protected baseCls: string;
+    private rover?;
+    protected shorthand(s: string): AnyConfig;
+    protected build(): HTMLElement;
+    protected onRender(): void;
+    notifyMount(): void;
+}

package/dist/types/components/layout/viewport/viewport.d.ts

@@ -0,0 +1,7 @@
+import { Container, type ContainerConfig } from '../../../core/container.js';
+/** Root container that fills the window. Only one can exist at a time. */
+export declare class Viewport extends Container<ContainerConfig> {
+    protected baseCls: string;
+    constructor(config?: ContainerConfig);
+    protected onRender(): void;
+}

package/dist/types/components/listbox.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/listbox/listbox.js';

package/dist/types/components/lookupfield.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/lookupfield/lookupfield.js';

package/dist/types/components/menu.d.ts

@@ -0,0 +1 @@
+export * from '../components/overlays/menu/menu.js';

package/dist/types/components/messagebox.d.ts

@@ -0,0 +1 @@
+export * from '../components/overlays/messagebox/messagebox.js';

package/dist/types/components/navigation/breadcrumb/breadcrumb.d.ts

@@ -0,0 +1,32 @@
+import { Component, type ComponentConfig } from '../../../core/component.js';
+export interface BreadcrumbItem {
+    text: string;
+    icon?: string;
+    /** Renders a real link (native navigation, middle-click, copy link). */
+    href?: string;
+    handler?: (item: BreadcrumbItem) => void;
+}
+export interface BreadcrumbConfig extends ComponentConfig {
+    items?: BreadcrumbItem[];
+    /** More items than this collapse the middle into a "…" menu. Minimum 3, default 4. */
+    maxItems?: number;
+    separator?: string;
+}
+export declare class Breadcrumb extends Component<BreadcrumbConfig> {
+    protected baseCls: string;
+    protected tag: 'nav';
+    private list;
+    private menu?;
+    protected onRender(): void;
+    private items;
+    /** Indexes hidden behind the "…" button (empty when everything fits). */
+    private collapsed;
+    private paint;
+    /** Runs `before-navigate` / handler / `navigate`. Returns false when cancelled. */
+    private go;
+    private showHidden;
+    setItems(items: BreadcrumbItem[]): void;
+    setMaxItems(max: number): void;
+    /** Any text, e.g. `'/'` or `'›'`. */
+    setSeparator(separator: string): void;
+}