@mathstack/ui 0.0.1-beta.1 → 0.0.1-beta.2

package/package.json

@@ -2,10 +2,10 @@
   "name": "@mathstack/ui",
   "license": "MIT",
   "peerDependencies": {
-    "@angular/cdk": ">=19.0.0 <21.0.0",
-    "@angular/common": ">=19.0.0 <21.0.0",
-    "@angular/core": ">=19.0.0 <21.0.0",
-    "@angular/material": ">=19.0.0 <21.0.0",
+    "@angular/cdk": ">=19.0.0 <22.0.0",
+    "@angular/common": ">=19.0.0 <22.0.0",
+    "@angular/core": ">=19.0.0 <22.0.0",
+    "@angular/material": ">=19.0.0 <22.0.0",
     "@mathstack/app-kit": "^1.0.0",
     "d3": "^7.8.5",
     "lodash-es": "^4.17.21",
@@ -21,15 +21,15 @@
     "directory": "libs/ui"
   },
   "module": "fesm2022/mathstack-ui.mjs",
-  "typings": "index.d.ts",
+  "typings": "types/mathstack-ui.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
     },
     ".": {
-      "types": "./index.d.ts",
+      "types": "./types/mathstack-ui.d.ts",
       "default": "./fesm2022/mathstack-ui.mjs"
     }
   },
-  "version": "0.0.1-beta.1"
+  "version": "0.0.1-beta.2"
 }

package/types/mathstack-ui.d.ts

@@ -0,0 +1,618 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, ElementRef, OnChanges, SimpleChanges, AfterContentInit, QueryList, AfterViewInit, OnInit, OnDestroy, DestroyRef, EventEmitter, NgZone, InjectionToken } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { Platform } from '@angular/cdk/platform';
+import { FormControl } from '@angular/forms';
+import * as i3 from '@angular/common';
+import * as i4 from '@angular/cdk/table';
+import * as i5 from '@angular/material/icon';
+import { MatTabContent } from '@angular/material/tabs';
+
+declare class ListboxLabelComponent {
+    labelContent: TemplateRef<unknown>;
+    label: ElementRef<HTMLParagraphElement>;
+    id: string;
+    private service;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListboxLabelComponent, "hsi-ui-listbox-label", never, {}, {}, never, ["*"], true, never>;
+}
+
+interface ListboxOptionPropertyChange {
+    property: 'selected' | 'disabled';
+    value: boolean;
+    comboboxId: string;
+    id: number;
+    optionValue: string | number | boolean;
+}
+declare class ListboxOptionComponent implements OnChanges {
+    label: ElementRef<HTMLDivElement>;
+    template: TemplateRef<unknown>;
+    boxDisplayLabel: string;
+    value: any;
+    /** Whether the option is selected.
+     * If this property is changed during this component's lifecycle, no new value will be emitted from the listbox.
+     * Box label and select all button will respond to changes.
+     * @default false
+     */
+    selected: boolean;
+    /** Whether the option is selected.
+     * If this property is changed during this component's lifecycle, no new value will be emitted from the listbox.
+     * Box label and select all button will respond to changes.
+     * @default false
+     */
+    disabled: boolean;
+    ariaLabel: string;
+    id: number;
+    protected _selected: BehaviorSubject<boolean>;
+    selected$: rxjs.Observable<boolean>;
+    private _disabled;
+    disabled$: rxjs.Observable<boolean>;
+    private externalPropertyChanges;
+    externalPropertyChanges$: rxjs.Observable<ListboxOptionPropertyChange>;
+    protected service: ComboboxService;
+    get valueToEmit(): any | string;
+    ngOnChanges(changes: SimpleChanges): void;
+    isFirstChangeAndValueIsFalse(change: SimpleChanges, property: 'selected' | 'disabled'): boolean;
+    getPropertyChange(property: 'selected' | 'disabled'): ListboxOptionPropertyChange;
+    protected updateSelected(selected: boolean): void;
+    private updateDisabled;
+    select(): void;
+    deselect(): void;
+    toggleSelected(): void;
+    isSelected(): boolean;
+    isDisabled(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListboxOptionComponent, "hsi-ui-listbox-option", never, { "boxDisplayLabel": { "alias": "boxDisplayLabel"; "required": false; }; "value": { "alias": "value"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, ["*", "[selectedIcon]", "[unselectedIcon]"], true, never>;
+}
+
+declare class ListboxGroupComponent implements AfterContentInit {
+    label: ListboxLabelComponent;
+    options: QueryList<ListboxOptionComponent>;
+    options$: Observable<ListboxOptionComponent[]>;
+    service: ComboboxService;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListboxGroupComponent, "hsi-ui-listbox-group", never, {}, {}, ["label", "options"], ["*"], true, never>;
+}
+
+declare class SelectAllListboxOptionComponent extends ListboxOptionComponent implements OnChanges {
+    boxDisplayLabel: string;
+    controlledOptions$: Observable<ListboxOptionComponent[]>;
+    controlledOptions: ListboxOptionComponent[];
+    service: ComboboxService;
+    private listboxComponent;
+    private destroyRef;
+    constructor();
+    ngOnChanges(): void;
+    protected updateSelected(selected: boolean): void;
+    setControlledOptions(): void;
+    getControlledOptionsFromGroups(groups: ListboxGroupComponent[]): ListboxOptionComponent[];
+    listenForOptionSelections(): void;
+    updateSelectAllSelected(controlledOptions: ListboxOptionComponent[]): void;
+    toggleSelected(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectAllListboxOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectAllListboxOptionComponent, "hsi-ui-select-all-listbox-option", never, { "boxDisplayLabel": { "alias": "boxDisplayLabel"; "required": false; }; }, {}, never, ["*", "[selectedIcon]", "[unselectedIcon]"], true, never>;
+}
+
+declare enum FocusTextbox {
+    default = "default",
+    includeMobile = "includeMobile"
+}
+interface KeyboardEventWithAutocomplete {
+    event: KeyboardEvent;
+    autoComplete: AutoComplete;
+    inputHasText: boolean;
+}
+declare enum Key {
+    ArrowDown = "ArrowDown",
+    ArrowUp = "ArrowUp",
+    End = "End",
+    Enter = "Enter",
+    Escape = "Escape",
+    Home = "Home",
+    LeftArrow = "ArrowLeft",
+    PageDown = "PageDown",
+    PageUp = "PageUp",
+    RightArrow = "ArrowRight",
+    Space = " ",
+    Tab = "Tab"
+}
+declare enum OptionAction {
+    first = "first",
+    last = "last",
+    next = "next",
+    nullActiveIndex = "nullActiveIndex",
+    pageDown = "pageDown",
+    pageUp = "pageUp",
+    previous = "previous",
+    select = "select",
+    zeroActiveIndex = "zeroActiveIndex"
+}
+declare enum ListboxAction {
+    close = "close",
+    open = "open",
+    closeSelect = "closeSelect"
+}
+declare enum TextboxAction {
+    focus = "focus",
+    setTextToValue = "setTextToValue",
+    cursorRight = "cursorRight",
+    cursorLeft = "cursorLeft",
+    cursorFirst = "cursorFirst",
+    cursorLast = "cursorLast",
+    addChar = "addChar",
+    type = "type"
+}
+declare enum AutoComplete {
+    none = "none",
+    list = "list",
+    both = "both",
+    inline = "inline"
+}
+type ComboboxAction = OptionAction | ListboxAction | TextboxAction;
+declare class ComboboxService {
+    id: string;
+    scrollContainerId: string;
+    comboboxLabelId: string;
+    autoComplete: AutoComplete;
+    hasEditableTextbox: boolean;
+    ignoreBlur: boolean;
+    isMultiSelect: boolean;
+    nullActiveIdOnClose: boolean;
+    scrollWhenOpened: boolean;
+    shouldAutoSelectOnListboxClose: boolean;
+    activeDescendant$: Observable<string>;
+    allOptions: ListboxOptionComponent[];
+    allOptions$: Observable<ListboxOptionComponent[]>;
+    destroy$: Subject<void>;
+    groups$: Observable<ListboxGroupComponent[]>;
+    optionPropertyChanges$: Observable<ListboxOptionPropertyChange>;
+    private focusTextbox;
+    focusTextbox$: Observable<FocusTextbox>;
+    private isKeyboardEvent;
+    isKeyboardEvent$: Observable<boolean>;
+    private _isOpen;
+    isOpen$: Observable<boolean>;
+    private label;
+    label$: Observable<ComboboxLabelComponent>;
+    private optionAction;
+    optionAction$: Observable<string>;
+    private projectedContentIsInDOM;
+    projectedContentIsInDOM$: Observable<boolean>;
+    private selectedOptionsToEmit;
+    selectedOptionsToEmit$: Observable<ListboxOptionComponent[]>;
+    private textboxBlur;
+    textboxBlur$: Observable<void>;
+    private touched;
+    touched$: Observable<boolean>;
+    private platform;
+    get isOpen(): boolean;
+    initActiveDescendant(source$?: Observable<string>): void;
+    setLabel(label: ComboboxLabelComponent): void;
+    openListbox(): void;
+    closeListbox(): void;
+    toggleListbox(): void;
+    setProjectedContentIsInDOM(): void;
+    emitTextboxBlur(): void;
+    setTouched(): void;
+    emitTextboxFocus(focus?: FocusTextbox): void;
+    emitOptionAction(action: OptionAction | string): void;
+    isMobile(): boolean;
+    setProjectedContent(groups: QueryList<ListboxGroupComponent>, options: QueryList<ListboxOptionComponent>): void;
+    setGroups(groups: QueryList<ListboxGroupComponent>): void;
+    setAllOptions(groups: QueryList<ListboxGroupComponent>, options: QueryList<ListboxOptionComponent>): void;
+    setSelectedOptionsToEmit(selected: ListboxOptionComponent[]): void;
+    getSelectedOptions(options: ListboxOptionComponent[]): ListboxOptionComponent[];
+    isSelectAllListboxOption(option: ListboxOptionComponent): option is SelectAllListboxOptionComponent;
+    setIsKeyboardEvent(isKeyboardEvent: boolean): void;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComboboxService>;
+}
+
+declare class ComboboxLabelComponent implements AfterViewInit {
+    labelContent: TemplateRef<unknown>;
+    service: ComboboxService;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ComboboxLabelComponent, "hsi-ui-combobox-label", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ComboboxComponent implements OnInit, OnDestroy {
+    labelComponent: ComboboxLabelComponent;
+    service: ComboboxService;
+    platform: Platform;
+    private zone;
+    private document;
+    private elRef;
+    private destroyRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    handleOutsideClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ComboboxComponent, "hsi-ui-combobox", never, {}, {}, ["labelComponent"], ["*"], true, never>;
+}
+
+declare class ActiveIndexService {
+    private activeIndex;
+    activeIndex$: Observable<number>;
+    scrollContentRef: ElementRef<HTMLDivElement>;
+    private service;
+    private filtering;
+    private scrolling;
+    init(allOptions$: Observable<ListboxOptionComponent[]>, destroyRef: DestroyRef): void;
+    setScrollContentRef(scrollContentRef: ElementRef): void;
+    initActiveId(): void;
+    listenToActions(allOptions$: Observable<ListboxOptionComponent[]>, destroyRef: DestroyRef): void;
+    private setNextActiveIndex;
+    private setPrevActiveIndex;
+    setActiveIndex(index: number | null, actionIfDisabled: OptionAction.next | OptionAction.previous | null, options: ListboxOptionComponent[], scrollToIndex?: boolean): void;
+    handleActiveIndexWhenCannotBeSet(): void;
+    private handleScrollingForNewIndex;
+    private getIndexForAction;
+    actionIsTypingChar(action: OptionAction | string): boolean;
+    updateActiveIndexFromKeyChar(char: string, options: ListboxOptionComponent[]): void;
+    private setActiveDescendant;
+    setActiveIndexToFirstSelectedOrDefault(options: ListboxOptionComponent[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActiveIndexService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActiveIndexService>;
+}
+
+declare class ListboxFilteringService {
+    searchTimeout: ReturnType<typeof setTimeout>;
+    searchString: string;
+    updateSearchString(char: string): void;
+    resetSearch(): void;
+    getIndexByLetter(options: ListboxOptionComponent[], searchString: string, startIndex: number): number;
+    filterOptionsBySearchString(options: ListboxOptionComponent[], searchString: string, exclude?: ListboxOptionComponent[]): ListboxOptionComponent[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxFilteringService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ListboxFilteringService>;
+}
+
+declare class ListboxScrollService {
+    private document;
+    isElementInView(element: HTMLElement): boolean;
+    isScrollable(element: HTMLElement): boolean;
+    maintainElementVisibility(activeElement: HTMLElement, scrollParent: HTMLElement): void;
+    scrollToTop(scrollParent: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxScrollService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ListboxScrollService>;
+}
+
+type SelectedCountLabel = {
+    singular: string;
+    plural: string;
+};
+declare class ListboxComponent implements OnChanges, AfterContentInit, AfterViewInit {
+    ngFormControl: FormControl<any | any[]>;
+    findsOptionOnTyping: boolean;
+    isMultiSelect: boolean;
+    maxHeight: number;
+    valueChanges: EventEmitter<any>;
+    scrollableContentRef: ElementRef<HTMLDivElement>;
+    label: ListboxLabelComponent;
+    options: QueryList<ListboxOptionComponent>;
+    groups: QueryList<ListboxGroupComponent>;
+    service: ComboboxService;
+    activeIndex: ActiveIndexService;
+    protected filtering: ListboxFilteringService;
+    protected scrolling: ListboxScrollService;
+    protected destroyRef: DestroyRef;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    setOnOptionChanges(): void;
+    setSelectedEmitting(): void;
+    emitValue(selections: any[]): void;
+    setOnBlurEvent(): void;
+    shouldAutoSelectOptionOnBlur(activeIndex: number, options: ListboxOptionComponent[]): boolean;
+    setOptionAction(): void;
+    actionIsTypingChar(action: OptionAction | string): boolean;
+    setResetOnClose(): void;
+    resetScroll(): void;
+    getListboxLabelAsBoxPlaceholder(): string;
+    selectOptionFromIndex(index: number, options: ListboxOptionComponent[]): void;
+    handleOptionClick(event: MouseEvent, optionIndex: number, groupIndex?: number): void;
+    handleOptionSelect(optionIndex: number, options: ListboxOptionComponent[], groupIndex?: number): void;
+    toggleOptionSelected(option: ListboxOptionComponent, options: ListboxOptionComponent[]): void;
+    updateSelectedOptionsToEmit(options: ListboxOptionComponent[]): void;
+    selectSingleSelectOption(option: ListboxOptionComponent, options: ListboxOptionComponent[]): void;
+    isSelectAllListboxOption(option: ListboxOptionComponent): option is SelectAllListboxOptionComponent;
+    getOptionIndexFromGroups(groupIndex: number, optionIndex: number): number;
+    getSelectedOptions(options: ListboxOptionComponent[]): ListboxOptionComponent[];
+    updateActiveIndexOnExternalChanges(): void;
+    handleOptionMousedown(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListboxComponent, "hsi-ui-listbox", never, { "ngFormControl": { "alias": "ngFormControl"; "required": false; }; "findsOptionOnTyping": { "alias": "findsOptionOnTyping"; "required": false; }; "isMultiSelect": { "alias": "isMultiSelect"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; }, { "valueChanges": "valueChanges"; }, ["label", "options", "groups"], never, true, never>;
+}
+
+declare class TextboxComponent implements OnInit, AfterViewInit {
+    ariaLabel: string;
+    selectedCountLabel?: SelectedCountLabel;
+    customLabel: (selectedOptions: ListboxOptionComponent[]) => string;
+    dynamicLabel: boolean;
+    findsOptionOnTyping: boolean;
+    box: ElementRef<HTMLDivElement>;
+    boxIcon: ElementRef<HTMLDivElement>;
+    openKeys: string[];
+    label: BehaviorSubject<string>;
+    label$: rxjs.Observable<string>;
+    protected destroyRef: DestroyRef;
+    service: ComboboxService;
+    private platform;
+    protected zone: NgZone;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    setFocusListener(): void;
+    focusBox(): void;
+    handleBlur(event: FocusEvent): void;
+    isHtmlElement(target: EventTarget): target is HTMLElement;
+    isMobile(): boolean;
+    handleClick(): void;
+    handleKeydown(event: KeyboardEvent): void;
+    onEscape(): void;
+    getActionFromKeydownEvent(event: KeyboardEvent): ComboboxAction;
+    isTypingCharacter(event: KeyboardEvent): boolean;
+    getActionFromKeyEventWhenOpen(event: KeyboardEvent): ComboboxAction;
+    handleKeyboardAction(action: ComboboxAction, event: KeyboardEvent): void;
+    setLabel(): void;
+    getComputedLabel(touched: boolean, options: ListboxOptionComponent[]): string;
+    getDefaultLabel(selectedOptions: ListboxOptionComponent[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextboxComponent, "hsi-ui-textbox", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "selectedCountLabel": { "alias": "selectedCountLabel"; "required": false; }; "customLabel": { "alias": "customLabel"; "required": false; }; "dynamicLabel": { "alias": "dynamicLabel"; "required": false; }; "findsOptionOnTyping": { "alias": "findsOptionOnTyping"; "required": false; }; }, {}, never, ["[boxLabel]", "[boxIcon]"], true, never>;
+}
+
+declare class EditableTextboxComponent extends TextboxComponent implements OnInit, AfterViewInit {
+    inputElRef: ElementRef<HTMLInputElement>;
+    autoSelect: boolean;
+    autoSelectTrigger: 'any' | 'character';
+    displaySelected: boolean;
+    initialValue: string;
+    inputType: 'text' | 'search';
+    ngFormControl: FormControl<string>;
+    placeholder: string;
+    clearOnClick: boolean;
+    valueChanges: EventEmitter<string>;
+    moveFocusToTextboxKeys: string[];
+    value: BehaviorSubject<string>;
+    value$: rxjs.Observable<string>;
+    openKeys: string[];
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    setLabel(): void;
+    onSelectionChange(selectedOptions: ListboxOptionComponent[]): void;
+    onInputChange(value: string): void;
+    setAndEmitValue(value: string): void;
+    setValue(value: string): void;
+    emitValue(value: string): void;
+    handleClick(): void;
+    protected setAutoSelectWhenInputIsEmpty(): void;
+    onEscape(): void;
+    getActionFromKeydownEvent(event: KeyboardEvent): ComboboxAction;
+    getActionFromKeydownEventWhenOpen(event: KeyboardEvent): ComboboxAction;
+    handleKeyboardAction(action: string, event: KeyboardEvent): void;
+    isPrintableCharacter(str: string): RegExpMatchArray;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditableTextboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditableTextboxComponent, "hsi-ui-editable-textbox", never, { "autoSelect": { "alias": "autoSelect"; "required": false; }; "autoSelectTrigger": { "alias": "autoSelectTrigger"; "required": false; }; "displaySelected": { "alias": "displaySelected"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; "inputType": { "alias": "inputType"; "required": false; }; "ngFormControl": { "alias": "ngFormControl"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "clearOnClick": { "alias": "clearOnClick"; "required": false; }; }, { "valueChanges": "valueChanges"; }, never, ["[boxIcon]"], true, never>;
+}
+
+declare class HsiUiComboboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HsiUiComboboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HsiUiComboboxModule, never, [typeof ComboboxComponent, typeof ComboboxLabelComponent, typeof TextboxComponent, typeof ListboxComponent, typeof ListboxGroupComponent, typeof ListboxOptionComponent, typeof ListboxLabelComponent, typeof EditableTextboxComponent, typeof SelectAllListboxOptionComponent], [typeof ComboboxComponent, typeof ComboboxLabelComponent, typeof TextboxComponent, typeof ListboxComponent, typeof ListboxGroupComponent, typeof ListboxLabelComponent, typeof ListboxOptionComponent, typeof EditableTextboxComponent, typeof SelectAllListboxOptionComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HsiUiComboboxModule>;
+}
+
+interface HsiUiDirectoryItem {
+    name: string;
+    value?: string;
+    children?: HsiUiDirectoryItem[];
+}
+interface HsiUiDirectorySelection {
+    activePath: string;
+    selectedItem: string;
+}
+declare class HsiUiDirectoryComponent implements OnChanges {
+    items: HsiUiDirectoryItem[];
+    level: number;
+    path: string;
+    terminalItemsAreSelectable: boolean;
+    selectionElementRole: string;
+    /**
+     * Sets the activePath and selectedItem.
+     */
+    selection: HsiUiDirectorySelection;
+    /**
+     * Emits the activePath and selectedItem when a leaf item is selected.
+     *
+     * Constructed from the `value` of each item if provided, otherwise uses `name`.
+     */
+    selectionChanges: EventEmitter<HsiUiDirectorySelection>;
+    /**
+     * @internal
+     *
+     * Internal, will have no effect if provided at root level.
+     */
+    stateChanges: EventEmitter<HsiUiDirectorySelection>;
+    state: BehaviorSubject<HsiUiDirectorySelection>;
+    state$: rxjs.Observable<HsiUiDirectorySelection>;
+    open: {};
+    ngOnChanges(changes: SimpleChanges): void;
+    toggleOpen(key: string): void;
+    selectItem(item: HsiUiDirectoryItem): void;
+    setState(state: HsiUiDirectorySelection): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HsiUiDirectoryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HsiUiDirectoryComponent, "hsi-ui-directory", never, { "items": { "alias": "items"; "required": false; }; "level": { "alias": "level"; "required": false; }; "path": { "alias": "path"; "required": false; }; "terminalItemsAreSelectable": { "alias": "terminalItemsAreSelectable"; "required": false; }; "selectionElementRole": { "alias": "selectionElementRole"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; }, { "selectionChanges": "selectionChanges"; "stateChanges": "stateChanges"; }, never, never, true, never>;
+}
+
+declare enum SortDirection {
+    asc = "asc",
+    desc = "desc"
+}
+type SortDirectionType = keyof typeof SortDirection;
+type TableValue = string | number | boolean | Date;
+type TableCellAlignment = 'left' | 'center' | 'right';
+declare class TableColumn<Datum> {
+    /**
+     * The label of the column. Used in the table header.
+     * */
+    label: string;
+    /**
+     * Function to extract the value to be sorted on from the datum.
+     * If not provided, the formatted value will be used for sorting.
+     */
+    getSortValue: (x: Datum) => TableValue;
+    /**
+     * Function to format the value for display in the table.
+     */
+    getFormattedValue: (x: Datum) => string;
+    /**
+     * Function to determine the alignment of the cell content.
+     */
+    getAlignment: (x: Datum) => TableCellAlignment;
+    /**
+     * Width of the column. Can be a percentage or pixel value.
+     */
+    width: string;
+    /**
+     * Function to determine the sort order of the column.
+     * If not provided, sort with use d3.ascending on the getSortValue or getFormattedValue.
+     */
+    ascendingSortFunction: (a: Datum, b: Datum) => number;
+    sortDirection: SortDirectionType;
+    /**
+     * Whether the column is sortable.
+     */
+    sortable: boolean;
+    activelySorted: boolean;
+    /**
+     * The sort order of the column. Used to determine the order of sorting when multiple columns are sorted.
+     * Sorting tiebreaks are determined by increasing sortOrder number.
+     **/
+    sortOrder: number;
+    /**
+     * Whether the column is a row header.
+     */
+    isRowHeader: boolean;
+    readonly initialSortDirection: SortDirectionType;
+    constructor(init?: Partial<TableColumn<Datum>>);
+    defaultSort(a: Datum, b: Datum): number;
+}
+
+declare class HsiUiTableConfig<Datum> {
+    data: Datum[];
+    columns: TableColumn<Datum>[];
+}
+
+declare class TableComponent<Datum> implements OnInit {
+    config$: Observable<HsiUiTableConfig<Datum>>;
+    sortIcon: string;
+    data$: Observable<Datum[]>;
+    columns$: Observable<TableColumn<Datum>[]>;
+    tableHeaders$: Observable<string[]>;
+    sort: BehaviorSubject<TableColumn<Datum>>;
+    sort$: Observable<TableColumn<Datum>>;
+    private destroyRef;
+    ngOnInit(): void;
+    setTableData(): void;
+    getMinSortOrderColumn(columns: TableColumn<Datum>[]): TableColumn<Datum>;
+    getColumnsWithNewSortApplied(activeSortColumn: TableColumn<Datum>, columns: TableColumn<Datum>[], toggleSortDirection?: boolean): TableColumn<Datum>[];
+    setTableHeaders(): void;
+    validateRowHeaders(): void;
+    sortTableByColumn(column: TableColumn<Datum>): void;
+    sortData(data: Datum[], primaryColumnSort: TableColumn<Datum>, columns: TableColumn<Datum>[]): Datum[];
+    columnTrackingFunction(_: number, column: TableColumn<Datum>): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "hsi-ui-table", never, { "config$": { "alias": "config$"; "required": false; }; "sortIcon": { "alias": "sortIcon"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class SingleSortHeaderComponent<Datum> {
+    column: TableColumn<Datum>;
+    sortIcon: string;
+    getColumnSortClasses(): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SingleSortHeaderComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SingleSortHeaderComponent<any>, "[hsi-ui-single-sort-header]", never, { "column": { "alias": "column"; "required": false; }; "sortIcon": { "alias": "sortIcon"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class TableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TableModule, [typeof TableComponent, typeof SingleSortHeaderComponent], [typeof i3.CommonModule, typeof i4.CdkTableModule, typeof i5.MatIconModule], [typeof TableComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TableModule>;
+}
+
+declare class TabBodyComponent {
+    bodyContent: TemplateRef<HTMLElement>;
+    lazyLoadedContent: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabBodyComponent, "hsi-ui-tab-body", never, {}, {}, ["lazyLoadedContent"], ["*"], true, never>;
+}
+
+declare const HSI_UI_TAB_CONTENT: InjectionToken<MatTabContent>;
+/**
+ * Allows a tab to be lazy-loaded when it is activated when used as a directive on an ng-template. It is recommended that this be used when the content of the tab requires calculations.
+ *
+ * Has the same functionality as https://material.angular.io/components/tabs/overview#lazy-loading
+ */
+declare class TabContentDirective {
+    /** Content for the tab. */
+    template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabContentDirective, "[hsiUiTabContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class TabLabelComponent {
+    value: string;
+    labelElement: ElementRef<HTMLDivElement>;
+    labelContent: TemplateRef<unknown>;
+    id: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabLabelComponent, "hsi-ui-tab-label", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class TabItemComponent<T> implements OnChanges {
+    isActive: boolean;
+    value: T;
+    bodyComponent: TabBodyComponent;
+    labelComponent: TabLabelComponent;
+    private service;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabItemComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabItemComponent<any>, "hsi-ui-tab-item", never, { "isActive": { "alias": "isActive"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, ["bodyComponent", "labelComponent"], ["*"], true, never>;
+}
+
+declare class TabsService<T> {
+    activeTab: BehaviorSubject<TabItemComponent<T> | null>;
+    activeTab$: rxjs.Observable<TabItemComponent<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TabsService<any>>;
+}
+
+declare class TabsComponent<T> implements AfterContentInit {
+    tabs: QueryList<TabItemComponent<T>>;
+    tabChange: EventEmitter<string | T>;
+    tabItems$: Observable<TabItemComponent<T>[]>;
+    tabChanges$: Observable<boolean[]>;
+    readonly service: TabsService<T>;
+    private destroyRef;
+    constructor();
+    ngAfterContentInit(): void;
+    initializeActiveTab(): void;
+    selectTab(tabItem: TabItemComponent<T>): void;
+    emitNewActiveTab(tabItem: TabItemComponent<T>): void;
+    handleKeydown(event: KeyboardEvent, tabItem: TabItemComponent<T>): void;
+    focusTab(tabItem: TabItemComponent<T>): void;
+    focusNextTab(tabIndex: number): void;
+    focusPreviousTab(tabIndex: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabsComponent<any>, "hsi-ui-tabs", never, {}, { "tabChange": "tabChange"; }, ["tabs"], never, true, never>;
+}
+
+declare class TabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TabsModule, never, [typeof TabsComponent, typeof TabLabelComponent, typeof TabItemComponent, typeof TabBodyComponent, typeof TabContentDirective], [typeof TabsComponent, typeof TabLabelComponent, typeof TabItemComponent, typeof TabBodyComponent, typeof TabContentDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TabsModule>;
+}
+
+export { AutoComplete, ComboboxComponent, ComboboxLabelComponent, ComboboxService, EditableTextboxComponent, FocusTextbox, HSI_UI_TAB_CONTENT, HsiUiComboboxModule, HsiUiDirectoryComponent, HsiUiTableConfig, Key, ListboxAction, ListboxComponent, ListboxGroupComponent, ListboxLabelComponent, ListboxOptionComponent, OptionAction, SelectAllListboxOptionComponent, SortDirection, TabBodyComponent, TabContentDirective, TabItemComponent, TabLabelComponent, TableColumn, TableComponent, TableModule, TabsComponent, TabsModule, TextboxAction, TextboxComponent };
+export type { ComboboxAction, HsiUiDirectoryItem, HsiUiDirectorySelection, KeyboardEventWithAutocomplete, ListboxOptionPropertyChange, SelectedCountLabel, SortDirectionType, TableCellAlignment, TableValue };

package/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@mathstack/ui" />
-export * from './public-api';

package/lib/combobox/combobox-label/combobox-label.component.d.ts

@@ -1,11 +0,0 @@
-import { AfterViewInit, TemplateRef } from '@angular/core';
-import { ComboboxService } from '../combobox.service';
-import * as i0 from "@angular/core";
-export declare class ComboboxLabelComponent implements AfterViewInit {
-    service: ComboboxService;
-    labelContent: TemplateRef<unknown>;
-    constructor(service: ComboboxService);
-    ngAfterViewInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxLabelComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ComboboxLabelComponent, "hsi-ui-combobox-label", never, {}, {}, never, ["*"], true, never>;
-}