@aurelia-ui-toolkits/headless 1.0.0

package/dist/types/combobox/ui-combobox.d.ts

@@ -0,0 +1,79 @@
+import { IError, IValidatedElement } from '../base/i-validated-element';
+import { UiMenu } from '../menu/ui-menu';
+type ComboboxOptions = unknown[] | ((filter: string | undefined, value: unknown) => unknown[] | Promise<unknown[]>);
+export declare class UiCombobox {
+    constructor();
+    readonly element: HTMLElement;
+    readonly slotHost: this;
+    errors: Map<IError, boolean>;
+    focus: boolean;
+    active: boolean;
+    controlEl: HTMLElement;
+    inputEl: HTMLInputElement;
+    menu: UiMenu;
+    value: unknown;
+    valueChanged(): Promise<void>;
+    text: string | undefined;
+    textChanged(): void;
+    items: ComboboxOptions;
+    itemsChanged(): Promise<void>;
+    filteredItems: unknown[];
+    selectedOption: unknown;
+    filterField: string | undefined;
+    filterFieldChanged(): void;
+    open: boolean;
+    label: string | undefined;
+    inset: boolean;
+    helperText: string | undefined;
+    id: string;
+    name: string | undefined;
+    placeholder: string | undefined;
+    autocomplete: AutoFill | undefined;
+    valueField: string | undefined;
+    labelField: string | undefined;
+    disabled: boolean;
+    readonly: boolean;
+    required: boolean;
+    invalid: boolean;
+    helperNodes: readonly Node[];
+    leadingNodes: readonly Node[];
+    trailingNodes: readonly Node[];
+    private initialText;
+    private getOptions;
+    private optionsRequest;
+    private suppressValueChanged;
+    private suppressFocusOpen;
+    get textValue(): string | undefined;
+    set textValue(value: string | undefined);
+    get labelId(): string;
+    get helperId(): string;
+    get errorsId(): string;
+    get hasValue(): boolean;
+    get placeholderText(): string | undefined;
+    attached(): Promise<void>;
+    addError(error: IError): void;
+    removeError(error: IError): void;
+    onInput(): Promise<void>;
+    onKeyDown(event: KeyboardEvent): Promise<void>;
+    onMenuSelect(event: CustomEvent): void;
+    onMenuTabAway(): void;
+    onFocusIn(): Promise<void>;
+    onFocusOut(event: FocusEvent): void;
+    onPointerDown(): void;
+    onPointerUp(): void;
+    onPointerLeave(): void;
+    private getItemValue;
+    private getItemLabel;
+    private setValue;
+    private setGetOptions;
+    private getOptionsDefault;
+    private loadOptions;
+    private updateFilterBasedOnValue;
+    private getItemFilterText;
+    private dispatchValueEvent;
+    private findError;
+}
+export interface IUiComboboxElement extends IValidatedElement {
+    value: unknown;
+}
+export {};

package/dist/types/disclosure/ui-disclosure.d.ts

@@ -0,0 +1,18 @@
+export declare class UiDisclosure {
+    open: boolean;
+    panelId: string;
+    hover: boolean;
+    focus: boolean;
+    active: boolean;
+    onClick(event: MouseEvent): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onKeyUp(event: KeyboardEvent): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onFocusIn(): void;
+    onFocusOut(): void;
+    onPointerDown(): void;
+    onPointerUp(): void;
+    onPointerLeave(): void;
+    private toggle;
+}

package/dist/types/drawer/ui-drawer.d.ts

@@ -0,0 +1,38 @@
+type DrawerSide = 'left' | 'right' | 'top' | 'bottom';
+export declare class UiDrawer implements EventListenerObject {
+    private readonly host;
+    open: boolean;
+    openChanged(newValue: boolean): void;
+    side: DrawerSide;
+    persistent: boolean;
+    modal: boolean;
+    closeOnOutside: boolean;
+    closeOnEscape: boolean;
+    focusOnOpen: boolean;
+    restoreFocus: boolean;
+    trigger: HTMLElement | undefined;
+    label: string | undefined;
+    labelledBy: string | undefined;
+    describedBy: string | undefined;
+    portalTarget: string | Element | null | undefined;
+    portalPosition: InsertPosition;
+    panelElement: HTMLElement | undefined;
+    private listening;
+    private previousFocus;
+    attaching(): void;
+    detaching(): void;
+    handleEvent(event: Event): void;
+    private startOpenState;
+    private stopOpenState;
+    private onWindowPointerDown;
+    private onWindowKeyDown;
+    private requestClose;
+    private setListeners;
+    private isPortalledPopup;
+    private focusPanel;
+    private restorePreviousFocus;
+    private trapFocus;
+    private getFocusableElements;
+    private isFocusable;
+}
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,91 @@
+import { IContainer } from 'aurelia';
+import { AlertConfiguration } from './alert-service/alert-configuration';
+import { AlertModal } from './alert-service/alert-modal/alert-modal';
+import { AlertService } from './alert-service/alert-service';
+import { ExceptionsTracker } from './alert-service/exceptions-tracker';
+import { PromptDialog } from './alert-service/prompt-dialog/prompt-dialog';
+import { UiAlert } from './alert/ui-alert';
+import { UiBadge } from './badge/ui-badge';
+import { UiBreadcrumbs } from './breadcrumbs/ui-breadcrumbs';
+import { UiButton } from './button/ui-button';
+import { UiIconButton } from './button/ui-icon-button';
+import { UiCheckbox } from './checkbox/ui-checkbox';
+import { UiChip } from './chip/ui-chip';
+import { UiCombobox } from './combobox/ui-combobox';
+import { UiDisclosure } from './disclosure/ui-disclosure';
+import { UiDrawer } from './drawer/ui-drawer';
+import { IError, UiInput } from './input/ui-input';
+import { UiMenu } from './menu/ui-menu';
+import { UiList } from './list/ui-list';
+import { UiListItem } from './list/ui-list-item';
+import { UiPopup } from './popup/ui-popup';
+import { UiProgress } from './progress/ui-progress';
+import { UiRadio } from './radio/ui-radio';
+import { UiRadioGroup } from './radio/ui-radio-group';
+import { UiSegment } from './segmented-control/ui-segment';
+import { UiSegmentedControl } from './segmented-control/ui-segmented-control';
+import { UiSelect } from './select/ui-select';
+import { UiSlider } from './slider/ui-slider';
+import { UiSplitter } from './splitter/ui-splitter';
+import { UiSwitch } from './switch/ui-switch';
+import { UiTab } from './tabs/ui-tab';
+import { UiTabs } from './tabs/ui-tabs';
+import { UiTable } from './table/ui-table';
+import { UiTableColumn } from './table/ui-table-column';
+import { UiToastRegion } from './toast/ui-toast-region';
+import { UiToastService } from './toast/ui-toast-service';
+import { UiTooltip } from './tooltip/ui-tooltip';
+import { UiTooltipService } from './tooltip/ui-tooltip-service';
+import { UiTopAppBar } from './top-app-bar/ui-top-app-bar';
+import { UiTree } from './tree/ui-tree';
+import { UiValidationControllerFactory } from './validation/ui-validation-controller-factory';
+export { UiButton };
+export { AlertConfiguration };
+export { AlertModal };
+export { AlertService };
+export { UiAlert };
+export { UiBadge };
+export { UiBreadcrumbs };
+export { UiIconButton };
+export { UiCheckbox };
+export { UiChip };
+export { UiCombobox };
+export { UiDisclosure };
+export { UiDrawer };
+export { UiInput };
+export { UiMenu };
+export { UiValidationControllerFactory };
+export type { IError };
+export { UiList };
+export { UiListItem };
+export { UiPopup };
+export { UiProgress };
+export { UiRadio };
+export { UiRadioGroup };
+export { UiSegment };
+export { UiSegmentedControl };
+export { UiSelect };
+export { UiSlider };
+export { UiSplitter };
+export { UiSwitch };
+export { UiTab };
+export { UiTabs };
+export { UiTable };
+export { UiTableColumn };
+export { UiToastRegion };
+export { UiToastService };
+export { UiTooltip };
+export { UiTooltipService };
+export { UiTopAppBar };
+export { UiTree };
+export { ExceptionsTracker };
+export { PromptDialog };
+export { confirmAction } from './alert-service/decorators/confirm-action';
+export { usingProgress } from './alert-service/decorators/using-progress';
+export type { IWithAlertService } from './alert-service/decorators/using-progress';
+export type { IAlertModalPayload } from './alert-service/alert-modal/i-alert-modal-payload';
+export type { IPromptDialogData } from './alert-service/prompt-dialog/prompt-dialog';
+export type { UiBreadcrumbItem } from './breadcrumbs/ui-breadcrumbs';
+export declare const AureliaHeadlessConfiguration: {
+    register(container: IContainer): IContainer;
+};

package/dist/types/input/enhance-ui-input.d.ts

@@ -0,0 +1,3 @@
+export declare class EnhanceUiInput {
+    compiling(template: HTMLElement | HTMLTemplateElement): void;
+}

package/dist/types/input/ui-input.d.ts

@@ -0,0 +1,44 @@
+import { IValidatedElement } from '../base/i-validated-element';
+export interface IError {
+    message: string | undefined;
+}
+export declare class UiInput {
+    constructor();
+    errors: Map<IError, boolean>;
+    focus: boolean;
+    active: boolean;
+    inputEl: HTMLInputElement;
+    label: string | undefined;
+    inset: boolean;
+    helperText: string | undefined;
+    id: string;
+    type: string | undefined;
+    name: string | undefined;
+    placeholder: string | undefined;
+    autocomplete: AutoFill | undefined;
+    disabled: boolean;
+    readonly: boolean;
+    required: boolean;
+    invalid: boolean;
+    helperNodes: readonly Node[];
+    leadingNodes: readonly Node[];
+    trailingNodes: readonly Node[];
+    private initialValue;
+    get value(): string | undefined;
+    set value(value: string);
+    get labelId(): string;
+    get helperId(): string;
+    get errorsId(): string;
+    attached(): void;
+    addError(error: IError): void;
+    removeError(error: IError): void;
+    onFocusIn(): void;
+    onFocusOut(): void;
+    onPointerDown(): void;
+    onPointerUp(): void;
+    onPointerLeave(): void;
+    private findError;
+}
+export interface IUiInputElement extends IValidatedElement {
+    value: string;
+}

package/dist/types/list/ui-list-item.d.ts

@@ -0,0 +1,10 @@
+import { UiList } from './ui-list';
+export declare class UiListItem {
+    readonly element: HTMLElement;
+    readonly parentList: UiList;
+    leadingNodes: readonly Node[];
+    secondaryNodes: readonly Node[];
+    trailingNodes: readonly Node[];
+    value: object;
+    disabled: boolean;
+}

package/dist/types/list/ui-list.d.ts

@@ -0,0 +1,45 @@
+import { UiListItem } from './ui-list-item';
+type ListOrientation = 'vertical' | 'horizontal';
+export declare class UiList {
+    private readonly host;
+    items: any[];
+    loop: boolean;
+    orientation: ListOrientation;
+    typeaheadField: string | undefined;
+    disabledField: string | ((item: unknown) => boolean);
+    selected: unknown;
+    listItems: UiListItem[];
+    listItemsChanged(): void;
+    private listItemsChangedCallback;
+    activeItem: unknown;
+    private typeaheadBuffer;
+    private typeaheadTimer;
+    detaching(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    isItemDisabled(item: unknown): boolean;
+    onClick(event: MouseEvent): void;
+    private suppressMouseOver;
+    onMouseMove(): void;
+    onMouseOver(event: MouseEvent): void;
+    focusFirst(): void;
+    focusLast(): void;
+    private getEffectiveItems;
+    private isNextKey;
+    private isPreviousKey;
+    private move;
+    private getNonDisabled;
+    private setFirstActive;
+    private setLastActive;
+    private activateItem;
+    private selectActive;
+    private selectItem;
+    private emitActivate;
+    private emitSelection;
+    private resolveItemFromEvent;
+    private isTypeaheadKey;
+    private handleTypeahead;
+    private getItemText;
+    private clearTypeahead;
+    private scrollItemIntoView;
+}
+export {};

package/dist/types/menu/ui-menu.d.ts

@@ -0,0 +1,29 @@
+import { Keys } from '../base/keys';
+import { UiPopup } from '../popup/ui-popup';
+type MenuPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
+export declare class UiMenu {
+    readonly element: HTMLElement;
+    readonly slotHost: this;
+    popup: UiPopup;
+    open: boolean;
+    openChanged(newValue: boolean): void;
+    anchor: Element | undefined;
+    tabReference: HTMLElement | undefined;
+    placement: MenuPlacement;
+    offset: number;
+    portalTarget: string | Element | null | undefined;
+    portalPosition: InsertPosition;
+    exposedHost: unknown;
+    closeOnOutside: boolean;
+    closeOnEscape: boolean;
+    matchAnchorWidth: boolean;
+    focusOnOpen: boolean;
+    restoreFocus: boolean;
+    closeOnSelect: boolean;
+    get effectiveSlotHost(): unknown;
+    onListSelect(event: Event): void;
+    onPopupTabAway(event: CustomEvent): void;
+    focus(key?: Keys.Home | Keys.End): void;
+    contains(target: Node): boolean;
+}
+export {};

package/dist/types/popup/ui-popup.d.ts

@@ -0,0 +1,61 @@
+type PopupPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
+export declare class UiPopup {
+    readonly element: HTMLElement;
+    readonly slotHost: this;
+    private readonly hiddenPanelStyle;
+    open: boolean;
+    openChanged(newValue: boolean): void;
+    closeOnOutside: boolean;
+    closeOnEscape: boolean;
+    matchAnchorWidth: boolean;
+    matchAnchorWidthChanged(): void;
+    focusOnOpen: boolean;
+    restoreFocus: boolean;
+    anchor: Element | undefined;
+    anchorChanged(newValue: Element | undefined, oldValue: Element | undefined): void;
+    tabReference: HTMLElement | undefined;
+    placement: PopupPlacement;
+    placementChanged(): void;
+    offset: number;
+    offsetChanged(): void;
+    portalTarget: string | Element | null | undefined;
+    portalPosition: InsertPosition;
+    exposedHost: unknown;
+    panelRole: string;
+    panelId: string | undefined;
+    panelStyle: string;
+    panelElement: HTMLElement | undefined;
+    get effectiveSlotHost(): unknown;
+    attaching(): void;
+    detaching(): void;
+    private listening;
+    private anchorRectSnapshot;
+    private previousFocus;
+    private resizeObserver;
+    private observedPanelHeight;
+    private observedPanelScrollHeight;
+    private mutationObserver;
+    private currentPlaceTop;
+    private preservePlacementUpdate;
+    private readonly onAnchorPointerDownCapture;
+    private readonly onWindowPointerDown;
+    private readonly onWindowKeyDown;
+    private readonly onWindowLayoutChange;
+    private startOpenState;
+    private stopOpenState;
+    private requestClose;
+    onListSelect(event: Event): void;
+    focus(): void;
+    contains(target: Node): boolean;
+    private focusPanel;
+    private restorePreviousFocus;
+    private focusNextFromTabReference;
+    private getFocusableElements;
+    private isFocusable;
+    private setListeners;
+    private observePanelSize;
+    private handlePanelContentChange;
+    private queuePositionUpdate;
+    private updatePosition;
+}
+export {};

package/dist/types/progress/ui-progress.d.ts

@@ -0,0 +1,15 @@
+export declare class UiProgress {
+    value: number | undefined;
+    valueChanged(): void;
+    max: number;
+    maxChanged(): void;
+    label: string | undefined;
+    circular: boolean;
+    indeterminate: boolean;
+    normalizedMax: number;
+    normalizedValue: number;
+    barStyle: string | undefined;
+    circleStyle: string | undefined;
+    binding(): void;
+    private updateState;
+}

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

@@ -0,0 +1,37 @@
+import { IError, IValidatedElement } from '../base/i-validated-element';
+import { UiRadio } from './ui-radio';
+export declare class UiRadioGroup {
+    constructor();
+    readonly element: HTMLElement;
+    errors: Map<IError, boolean>;
+    focus: boolean;
+    value: unknown;
+    label: string | undefined;
+    helperText: string | undefined;
+    id: string;
+    disabled: boolean;
+    readonly: boolean;
+    required: boolean;
+    invalid: boolean;
+    helperNodes: readonly Node[];
+    radioElements: readonly HTMLElement[];
+    get radios(): UiRadio[];
+    get labelId(): string;
+    get helperId(): string;
+    get errorsId(): string;
+    select(value: unknown): void;
+    isSelected(radio: UiRadio): boolean;
+    addError(error: IError): void;
+    removeError(error: IError): void;
+    onRadioKeyDown(radio: UiRadio, event: KeyboardEvent): void;
+    onFocusIn(): void;
+    onFocusOut(): void;
+    get enabledRadios(): UiRadio[];
+    private focusRadio;
+    private getNavigationDirection;
+    private dispatchValueEvent;
+    private findError;
+}
+export interface IUiRadioGroupElement extends IValidatedElement {
+    value: unknown;
+}

package/dist/types/radio/ui-radio.d.ts

@@ -0,0 +1,11 @@
+import { UiRadioGroup } from './ui-radio-group';
+export declare class UiRadio {
+    readonly element: HTMLElement;
+    readonly parentGroup: UiRadioGroup;
+    private readonly onHostKeyDown;
+    value: unknown;
+    disabled: boolean;
+    onClick(): void;
+    attaching(): void;
+    detaching(): void;
+}

package/dist/types/segmented-control/ui-segment.d.ts

@@ -0,0 +1,8 @@
+import { UiSegmentedControl } from './ui-segmented-control';
+export declare class UiSegment {
+    readonly element: HTMLElement;
+    readonly parentControl: UiSegmentedControl;
+    value: unknown;
+    disabled: boolean;
+    onClick(): void;
+}

package/dist/types/segmented-control/ui-segmented-control.d.ts

@@ -0,0 +1,17 @@
+import { UiSegment } from './ui-segment';
+export declare class UiSegmentedControl {
+    private readonly host;
+    value: unknown;
+    label: string | undefined;
+    disabled: boolean;
+    readonly: boolean;
+    segments: UiSegment[];
+    segmentsChanged(): void;
+    attached(): void;
+    select(segment: UiSegment): void;
+    onKeyDown(event: KeyboardEvent): void;
+    get enabledSegments(): UiSegment[];
+    private selectInitialSegment;
+    private getNavigationDirection;
+    private dispatchValueEvent;
+}

package/dist/types/select/enhance-ui-select.d.ts

@@ -0,0 +1,3 @@
+export declare class EnhanceUiSelect {
+    compiling(template: HTMLElement | HTMLTemplateElement): void;
+}

package/dist/types/select/ui-select.d.ts

@@ -0,0 +1,50 @@
+import { IError, IValidatedElement } from '../base/i-validated-element';
+export declare class UiSelect {
+    constructor();
+    readonly element: HTMLElement;
+    errors: Map<IError, boolean>;
+    focus: boolean;
+    active: boolean;
+    open: boolean;
+    controlEl: HTMLElement;
+    value: unknown;
+    selectedItem: unknown;
+    label: string | undefined;
+    inset: boolean;
+    helperText: string | undefined;
+    id: string;
+    placeholder: string | undefined;
+    valueField: string | undefined;
+    labelField: string | undefined;
+    disabled: boolean;
+    readonly: boolean;
+    required: boolean;
+    invalid: boolean;
+    helperNodes: readonly Node[];
+    leadingNodes: readonly Node[];
+    trailingNodes: readonly Node[];
+    get labelId(): string;
+    get helperId(): string;
+    get errorsId(): string;
+    get displayText(): string | undefined;
+    get placeholderText(): string | undefined;
+    get hasValue(): boolean;
+    addError(error: IError): void;
+    removeError(error: IError): void;
+    onClick(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onMenuSelect(event: CustomEvent): void;
+    onMenuTabAway(): void;
+    onFocusIn(): void;
+    onFocusOut(event: FocusEvent): void;
+    onPointerDown(): void;
+    onPointerUp(): void;
+    onPointerLeave(): void;
+    private getItemValue;
+    private getItemLabel;
+    private dispatchValueEvent;
+    private findError;
+}
+export interface IUiSelectElement extends IValidatedElement {
+    value: unknown;
+}

package/dist/types/slider/ui-slider.d.ts

@@ -0,0 +1,58 @@
+import { IError, IValidatedElement } from '../base/i-validated-element';
+export declare class UiSlider {
+    constructor();
+    readonly element: HTMLElement;
+    errors: Map<IError, boolean>;
+    focus: boolean;
+    active: boolean;
+    inputEl: HTMLInputElement;
+    endInputEl: HTMLInputElement;
+    fillStyle: string;
+    normalizedValue: number;
+    normalizedEndValue: number;
+    labelId: string;
+    helperId: string;
+    errorsId: string;
+    endId: string;
+    value: number;
+    valueChanged(): void;
+    endValue: number;
+    endValueChanged(): void;
+    min: number;
+    minChanged(): void;
+    max: number;
+    maxChanged(): void;
+    step: number;
+    range: boolean;
+    rangeChanged(): void;
+    label: string | undefined;
+    helperText: string | undefined;
+    id: string;
+    idChanged(): void;
+    name: string | undefined;
+    disabled: boolean;
+    readonly: boolean;
+    required: boolean;
+    invalid: boolean;
+    helperNodes: readonly Node[];
+    binding(): void;
+    addError(error: IError): void;
+    removeError(error: IError): void;
+    onInput(event: Event): void;
+    onChange(event: Event): void;
+    onFocusIn(): void;
+    onFocusOut(): void;
+    onPointerDown(event: PointerEvent): void;
+    onPointerUp(): void;
+    onPointerLeave(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    private normalizeValues;
+    private updateFillStyle;
+    private updateIds;
+    private dispatchValueEvent;
+    private findError;
+}
+export interface IUiSliderElement extends IValidatedElement {
+    value: number;
+    endValue: number;
+}

package/dist/types/splitter/ui-splitter.d.ts

@@ -0,0 +1,39 @@
+type SplitterDirection = 'horizontal' | 'vertical';
+export declare class UiSplitter implements EventListenerObject {
+    private readonly host;
+    private targetElement;
+    private startPosition;
+    private startSize;
+    private dragging;
+    private pointerMoved;
+    private expandedSize;
+    private targetDisplay;
+    private targetOverflow;
+    size: number;
+    sizeChanged(): void;
+    direction: SplitterDirection;
+    directionChanged(): void;
+    min: number;
+    max: number;
+    disabled: boolean;
+    storageKey: string | undefined;
+    valueNow: number;
+    attaching(): void;
+    detaching(): void;
+    handleEvent(event: Event): void;
+    onPointerDown(event: PointerEvent): void;
+    onKeyDown(event: KeyboardEvent): void;
+    private onPointerMove;
+    private onPointerUp;
+    private stopDragging;
+    private setSize;
+    private toggleCollapsed;
+    private applySize;
+    private updateValueNow;
+    private loadSize;
+    private persistSize;
+    private get minSize();
+    private get maxSize();
+    private get storageId();
+}
+export {};