@area8975/ui 0.2.2-dev.48 → 0.2.2-dev.50

package/types/area8975-ui-table.d.ts

@@ -0,0 +1,371 @@
+import * as i0 from "@angular/core";
+import { OnDestroy, OnInit, TemplateRef, WritableSignal } from "@angular/core";
+import { SelectDataSource } from "@area8975/ui/select";
+import { Observable } from "rxjs";
+export type TableSortDirection = 'asc' | 'desc';
+export interface TableSortState {
+  columnId: string;
+  direction: TableSortDirection;
+}
+export type TableColumnDisplayType = 'text' | 'number' | 'currency' | 'date' | 'time' | 'icon';
+export type TableColumnPin = 'left' | 'right';
+export interface TableColumnFilterOption {
+  label: string;
+  value: unknown;
+}
+export interface TableColumn<Row> {
+  /** unique key, used for sorting/filtering/visibility/pinning/reordering */
+  id: string;
+  header: string;
+  /** the cell's value, used for sorting and filtering even when a `uiTableCell` template draws the cell */
+  accessor: (row: Row) => unknown;
+  /** how the cell value is formatted for display, defaults to plain text */
+  displayType?: TableColumnDisplayType;
+  /** ISO currency code, used when displayType is 'currency'. Defaults to the currency from `provideUiFormat`. */
+  currency?: string;
+  /**
+   * Masks the cell in privacy mode, e.g. a transaction's description. Currency cells are already masked, icon cells have no text.
+   * A `uiTableCell` template is replaced by the mask too.
+   */
+  sensitive?: boolean;
+  sortable?: boolean;
+  filterable?: boolean;
+  /** when set, the filter renders as a select instead of a free-text contains filter */
+  filterOptions?: TableColumnFilterOption[];
+  /** fix the column to one side of the scroll area, needs width to compute its offset */
+  pin?: TableColumnPin;
+  resizable?: boolean;
+  width?: number;
+  minWidth?: number;
+  /** false excludes the column from the drag-to-reorder behaviour */
+  reorderable?: boolean;
+  /** false excludes the column from the visibility toggle menu */
+  hideable?: boolean;
+}
+/** Context for a `uiTableCell` template. */
+export interface TableCellContext<Row> {
+  $implicit: Row;
+  /** what the column's accessor gives for the row */
+  value: unknown;
+}
+export interface TableRowAction<Row> {
+  id: string;
+  label: string;
+  icon: string;
+  onClick: (row: Row) => void;
+  disabled?: (row: Row) => boolean;
+}
+export interface TableDataSourceParameters {
+  page: number;
+  /** 0 or less means "no limit", used when the table isn't paginated */
+  size: number;
+  query: string;
+  sort: TableSortState | null;
+  filters: Record<string, unknown>;
+}
+export interface TableDataSourceContent<Row> {
+  items: Row[];
+  total: number;
+}
+export interface TableDataSource<Row> {
+  load(params: TableDataSourceParameters): Observable<TableDataSourceContent<Row>>;
+}
+export interface TableLocalDataSourceOptions<Row> {
+  search?: (item: Row, query: string) => boolean;
+  sortValue?: (item: Row, columnId: string) => unknown;
+  filter?: (item: Row, filters: Record<string, unknown>) => boolean;
+}
+export declare class TableLocalDataSource<Row> implements TableDataSource<Row> {
+  private readonly items;
+  private readonly options;
+  constructor(items: Row[], options?: TableLocalDataSourceOptions<Row>);
+  load(params: TableDataSourceParameters): Observable<TableDataSourceContent<Row>>;
+}
+export declare class TableRemoteDataSource<Row> implements TableDataSource<Row> {
+  private readonly fetch;
+  constructor(fetch: (params: TableDataSourceParameters) => Observable<TableDataSourceContent<Row>>);
+  load(params: TableDataSourceParameters): Observable<TableDataSourceContent<Row>>;
+}
+interface ColumnDragPreview {
+  label: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+export declare class UiTableComponent<Row = unknown> implements OnInit, OnDestroy {
+  readonly classes: import("@angular/core").InputSignal<string>;
+  /** Lets controls elsewhere on the page link to this table, e.g. `<ui-search [table]="'transactions'">`. */
+  readonly tableId: import("@angular/core").InputSignal<string | null>;
+  readonly columns: import("@angular/core").InputSignal<TableColumn<Row>[]>;
+  readonly dataSource: import("@angular/core").InputSignal<TableDataSource<Row>>;
+  readonly emptyMessage: import("@angular/core").InputSignal<string>;
+  readonly errorMessage: import("@angular/core").InputSignal<string>;
+  readonly rowId: import("@angular/core").InputSignal<(row: Row, index: number) => unknown>;
+  readonly selectable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly searchable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly searchPlaceholder: import("@angular/core").InputSignal<string>;
+  readonly paginated: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly pageSize: import("@angular/core").InputSignal<number>;
+  readonly toggleableColumns: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly reorderableColumns: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly reorderableRows: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly stickyHeader: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Leaves out the header row, for rows that read on their own. A `uiTableBar` can still select every row. */
+  readonly headerless: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  private readonly bar;
+  protected readonly hasBar: import("@angular/core").Signal<boolean>;
+  /** Starts each run of rows with a heading row, e.g. a date. A row gets one whenever its heading differs from the row before it. */
+  readonly groupHeading: import("@angular/core").InputSignal<((row: Row) => string) | null>;
+  readonly actions: import("@angular/core").InputSignal<TableRowAction<Row>[]>;
+  readonly sort: import("@angular/core").ModelSignal<TableSortState | null>;
+  readonly selectedRowIds: import("@angular/core").ModelSignal<Set<unknown>>;
+  readonly selectionChange: import("@angular/core").OutputEmitterRef<Row[]>;
+  readonly rowsReordered: import("@angular/core").OutputEmitterRef<Row[]>;
+  readonly rows: import("@angular/core").WritableSignal<Row[]>;
+  readonly total: import("@angular/core").WritableSignal<number>;
+  readonly loading: import("@angular/core").WritableSignal<boolean>;
+  readonly error: import("@angular/core").WritableSignal<boolean>;
+  readonly query: import("@angular/core").WritableSignal<string>;
+  readonly filters: import("@angular/core").WritableSignal<Record<string, unknown>>;
+  protected readonly currentPage: import("@angular/core").WritableSignal<number>;
+  protected readonly hiddenColumnIds: import("@angular/core").WritableSignal<Set<string>>;
+  protected readonly columnOrderIds: import("@angular/core").WritableSignal<string[] | null>;
+  protected readonly columnWidths: import("@angular/core").WritableSignal<Record<string, number>>;
+  protected readonly columnMenuOpen: import("@angular/core").WritableSignal<boolean>;
+  protected readonly filterMenuOpen: import("@angular/core").WritableSignal<boolean>;
+  protected readonly draggedColumnId: import("@angular/core").WritableSignal<string | null>;
+  protected readonly dragOverColumnId: import("@angular/core").WritableSignal<string | null>;
+  protected readonly dragPreview: import("@angular/core").WritableSignal<ColumnDragPreview | null>;
+  protected readonly draggedRowIndex: import("@angular/core").WritableSignal<number | null>;
+  private readonly cellDirectives;
+  protected readonly cellTemplates: import("@angular/core").Signal<Map<string, TemplateRef<TableCellContext<unknown>>>>;
+  readonly isEmpty: import("@angular/core").Signal<boolean>;
+  readonly generatedClasses: import("@angular/core").Signal<string>;
+  protected readonly orderedColumns: import("@angular/core").Signal<TableColumn<Row>[]>;
+  protected readonly hideableColumns: import("@angular/core").Signal<TableColumn<Row>[]>;
+  protected readonly visibleColumns: import("@angular/core").Signal<TableColumn<Row>[]>;
+  protected readonly renderColumns: import("@angular/core").Signal<TableColumn<Row>[]>;
+  protected readonly filterableColumns: import("@angular/core").Signal<TableColumn<Row>[]>;
+  protected readonly hasFilterableColumns: import("@angular/core").Signal<boolean>;
+  protected readonly activeFilterCount: import("@angular/core").Signal<number>;
+  protected readonly hasActions: import("@angular/core").Signal<boolean>;
+  protected readonly columnSpan: import("@angular/core").Signal<number>;
+  /** Each row's heading, or null when it continues the run above it. */
+  protected readonly groupHeadings: import("@angular/core").Signal<(string | null)[]>;
+  private readonly hasSensitiveColumns;
+  protected readonly fixedWidth: import("@angular/core").Signal<number | null>;
+  protected readonly actionsColumnWidth: import("@angular/core").Signal<number>;
+  protected readonly totalPages: import("@angular/core").Signal<number>;
+  protected readonly resultsLabel: import("@angular/core").Signal<string>;
+  readonly allSelected: import("@angular/core").Signal<boolean>;
+  readonly someSelected: import("@angular/core").Signal<boolean>;
+  private readonly leftOffsets;
+  private readonly rightOffsets;
+  private readonly load$;
+  private readonly destroyRef;
+  private readonly cdr;
+  private readonly registry;
+  protected readonly uiFormat: import("@area8975/ui/format").UiFormat;
+  private readonly privateText;
+  protected readonly privacy: import("@angular/core").Signal<"visible" | "discreet" | "hidden">;
+  private loadedQuery;
+  private loadedFilters;
+  private loadedSort;
+  private resizeState;
+  private columnDragState;
+  private readonly filterDataSources;
+  constructor();
+  ngOnInit(): void;
+  ngOnDestroy(): void;
+  reload(): void;
+  protected cellValue(column: TableColumn<Row>, row: Row): unknown;
+  protected cellIconValue(column: TableColumn<Row>, row: Row): string;
+  protected moneyCellValue(column: TableColumn<Row>, row: Row): number | null;
+  protected formattedCellValue(column: TableColumn<Row>, row: Row): string;
+  protected onQueryChange(value: string): void;
+  protected filterValue(columnId: string): string;
+  protected onFilterInput(columnId: string, value: string): void;
+  protected filterDataSource(column: TableColumn<Row>): SelectDataSource<TableColumnFilterOption>;
+  protected selectedFilterOption(column: TableColumn<Row>): TableColumnFilterOption | null;
+  protected filterOptionLabel(option: TableColumnFilterOption): string;
+  protected readonly sensitiveFilterOptionLabel: (option: TableColumnFilterOption) => string;
+  protected onFilterSelect(columnId: string, option: TableColumnFilterOption | null): void;
+  protected clearFilters(): void;
+  protected toggleSort(column: TableColumn<Row>): void;
+  protected sortDirection(column: TableColumn<Row>): TableSortDirection | null;
+  protected goToPage(page: number): void;
+  protected isColumnVisible(column: TableColumn<Row>): boolean;
+  protected toggleColumnVisibility(column: TableColumn<Row>): void;
+  protected isRowSelected(row: Row, index: number): boolean;
+  protected toggleRow(row: Row, index: number): void;
+  toggleSelectAll(): void;
+  protected columnWidth(column: TableColumn<Row>): number;
+  protected isPinned(column: TableColumn<Row>): boolean;
+  protected leftOffset(column: TableColumn<Row>): number | null;
+  protected rightOffset(column: TableColumn<Row>): number | null;
+  protected startResize(event: PointerEvent, column: TableColumn<Row>): void;
+  protected canReorderRows(): boolean;
+  protected onColumnDragStart(event: PointerEvent, column: TableColumn<Row>): void;
+  protected onRowDragStart(event: DragEvent, index: number): void;
+  protected onRowDragOver(event: DragEvent): void;
+  protected onRowDrop(event: DragEvent, index: number): void;
+  private readonly onResizeMove;
+  private readonly onResizeEnd;
+  private readonly onColumnDragMove;
+  private readonly onColumnDragEnd;
+  private setFilter;
+  private resetAndReload;
+  private emitSelectionChange;
+  private fetch;
+  private applyResult;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiTableComponent<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UiTableComponent<any>, "ui-table", never, {
+    "classes": {
+      "alias": "classes";
+      "required": false;
+      "isSignal": true;
+    };
+    "tableId": {
+      "alias": "tableId";
+      "required": false;
+      "isSignal": true;
+    };
+    "columns": {
+      "alias": "columns";
+      "required": true;
+      "isSignal": true;
+    };
+    "dataSource": {
+      "alias": "dataSource";
+      "required": true;
+      "isSignal": true;
+    };
+    "emptyMessage": {
+      "alias": "emptyMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMessage": {
+      "alias": "errorMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowId": {
+      "alias": "rowId";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectable": {
+      "alias": "selectable";
+      "required": false;
+      "isSignal": true;
+    };
+    "searchable": {
+      "alias": "searchable";
+      "required": false;
+      "isSignal": true;
+    };
+    "searchPlaceholder": {
+      "alias": "searchPlaceholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "paginated": {
+      "alias": "paginated";
+      "required": false;
+      "isSignal": true;
+    };
+    "pageSize": {
+      "alias": "pageSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "toggleableColumns": {
+      "alias": "toggleableColumns";
+      "required": false;
+      "isSignal": true;
+    };
+    "reorderableColumns": {
+      "alias": "reorderableColumns";
+      "required": false;
+      "isSignal": true;
+    };
+    "reorderableRows": {
+      "alias": "reorderableRows";
+      "required": false;
+      "isSignal": true;
+    };
+    "stickyHeader": {
+      "alias": "stickyHeader";
+      "required": false;
+      "isSignal": true;
+    };
+    "headerless": {
+      "alias": "headerless";
+      "required": false;
+      "isSignal": true;
+    };
+    "groupHeading": {
+      "alias": "groupHeading";
+      "required": false;
+      "isSignal": true;
+    };
+    "actions": {
+      "alias": "actions";
+      "required": false;
+      "isSignal": true;
+    };
+    "sort": {
+      "alias": "sort";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectedRowIds": {
+      "alias": "selectedRowIds";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "sort": "sortChange";
+    "selectedRowIds": "selectedRowIdsChange";
+    "selectionChange": "selectionChange";
+    "rowsReordered": "rowsReordered";
+  }, ["bar", "cellDirectives"], ["[uiTableBar]"], true, never>;
+}
+/**
+ * Draws a column's cells in place of its formatted value, matched by column id:
+ * `<ng-template uiTableCell="description" let-row>`. The accessor stays the cell's value.
+ */
+export declare class UiTableCellDirective {
+  readonly columnId: import("@angular/core").InputSignal<string>;
+  readonly template: TemplateRef<TableCellContext<unknown>>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiTableCellDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<UiTableCellDirective, "ng-template[uiTableCell]", never, {
+    "columnId": {
+      "alias": "uiTableCell";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Content for a bar along the top of the table, e.g. a count and a sort control above a
+ * `headerless` list: `<div uiTableBar>`. With `selectable`, the bar also selects every row.
+ */
+export declare class UiTableBarDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiTableBarDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<UiTableBarDirective, "[uiTableBar]", never, {}, {}, never, never, true, never>;
+}
+export interface UiLinkedTable {
+  readonly query: WritableSignal<string>;
+  readonly filters: WritableSignal<Record<string, unknown>>;
+}
+export declare class UiTableRegistry {
+  private readonly tables;
+  get(id: string): UiLinkedTable | null;
+  register(id: string, table: UiLinkedTable): void;
+  unregister(id: string, table: UiLinkedTable): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiTableRegistry, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}

package/types/area8975-ui-textarea.d.ts

@@ -0,0 +1,126 @@
+import * as i0 from "@angular/core";
+/** Native resize values for the textarea element. */
+export declare const TextareaResizeOptions: readonly ["none", "both", "horizontal", "vertical"];
+/** @see {@link TextareaResizeOptions} */
+export type TextareaResize = typeof TextareaResizeOptions[number];
+/** true is valid, false is invalid, null is not yet validated. */
+export type TextareaValidation = boolean | null;
+export declare class UiTextareaComponent {
+  readonly value: import("@angular/core").ModelSignal<string>;
+  readonly classes: import("@angular/core").InputSignal<string>;
+  readonly id: import("@angular/core").InputSignal<string>;
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly placeholder: import("@angular/core").InputSignal<string>;
+  readonly rows: import("@angular/core").InputSignal<number>;
+  readonly resize: import("@angular/core").InputSignal<"none" | "both" | "horizontal" | "vertical">;
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** true/false shows valid/invalid styling. null means not validated yet. */
+  readonly validationState: import("@angular/core").ModelSignal<TextareaValidation>;
+  readonly minlength: import("@angular/core").InputSignal<number | null>;
+  readonly maxlength: import("@angular/core").InputSignal<number | null>;
+  readonly autofocus: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly spellcheck: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  readonly describedBy: import("@angular/core").InputSignal<string>;
+  readonly focused: import("@angular/core").OutputEmitterRef<FocusEvent>;
+  readonly blurred: import("@angular/core").OutputEmitterRef<FocusEvent>;
+  readonly generatedClasses: import("@angular/core").Signal<string>;
+  protected handleInput(event: Event): void;
+  protected handleFocus(event: FocusEvent): void;
+  protected handleBlur(event: FocusEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiTextareaComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UiTextareaComponent, "ui-textarea", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "classes": {
+      "alias": "classes";
+      "required": false;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "rows": {
+      "alias": "rows";
+      "required": false;
+      "isSignal": true;
+    };
+    "resize": {
+      "alias": "resize";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+      "isSignal": true;
+    };
+    "validationState": {
+      "alias": "validationState";
+      "required": false;
+      "isSignal": true;
+    };
+    "minlength": {
+      "alias": "minlength";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxlength": {
+      "alias": "maxlength";
+      "required": false;
+      "isSignal": true;
+    };
+    "autofocus": {
+      "alias": "autofocus";
+      "required": false;
+      "isSignal": true;
+    };
+    "spellcheck": {
+      "alias": "spellcheck";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "describedBy": {
+      "alias": "describedBy";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "validationState": "validationStateChange";
+    "focused": "focused";
+    "blurred": "blurred";
+  }, never, never, true, never>;
+}

package/types/area8975-ui-theme.d.ts

@@ -0,0 +1,61 @@
+import * as i0 from "@angular/core";
+import { EnvironmentProviders, InjectionToken } from "@angular/core";
+import { SegmentedOption } from "@area8975/ui/segmented";
+export declare class UiDarkClass {
+  readonly isDark: import("@angular/core").WritableSignal<boolean>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiDarkClass, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** What the user picked, `system` follows the OS setting. */
+export type UiThemePreference = 'system' | 'light' | 'dark';
+export interface UiThemeConfig {
+  storageKey: string;
+}
+export declare const UI_THEME_CONFIG: InjectionToken<UiThemeConfig>;
+/**
+ * Add this to `index.html`'s `<head>` so the stored theme applies before boot:
+ *
+ * ```html
+ * <script>
+ *     try {
+ *         const preference = localStorage.getItem('ui-theme') ?? 'system';
+ *         const dark = preference === 'dark' ||
+ *             (preference === 'system' && matchMedia('(prefers-color-scheme: dark)').matches);
+ *         document.documentElement.classList.toggle('dark', dark);
+ *     } catch {}
+ * </script>
+ * ```
+ */
+export declare class UiThemeService {
+  private readonly document;
+  private readonly storageKey;
+  private readonly media;
+  readonly preference: import("@angular/core").WritableSignal<UiThemePreference>;
+  private readonly systemDark;
+  readonly isDark: import("@angular/core").Signal<boolean>;
+  constructor();
+  private stored;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiThemeService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare function provideUiTheme(config?: Partial<UiThemeConfig>): EnvironmentProviders;
+export declare class UiThemeSwitchComponent {
+  protected readonly theme: UiThemeService;
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  readonly fill: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly options: SegmentedOption<UiThemePreference>[];
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiThemeSwitchComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UiThemeSwitchComponent, "ui-theme-switch", never, {
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "fill": {
+      "alias": "fill";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

package/types/area8975-ui-time-select.d.ts

@@ -0,0 +1,35 @@
+import { SelectLocalDataSource } from "@area8975/ui/select";
+import * as i0 from "@angular/core";
+export declare class UiTimeSelectComponent {
+  /** 24 hour "HH:mm" string. */
+  readonly value: import("@angular/core").ModelSignal<string>;
+  readonly minuteStep: import("@angular/core").InputSignal<number>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly hours: import("@angular/core").Signal<number>;
+  protected readonly minutes: import("@angular/core").Signal<number>;
+  protected readonly hourSource: SelectLocalDataSource<number>;
+  protected readonly minuteSource: import("@angular/core").Signal<SelectLocalDataSource<number>>;
+  protected readonly pad: (value: number) => string;
+  protected setHours(hours: number | null): void;
+  protected setMinutes(minutes: number | null): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiTimeSelectComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UiTimeSelectComponent, "ui-time-select", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "minuteStep": {
+      "alias": "minuteStep";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, never>;
+}

package/types/area8975-ui-toast.d.ts

@@ -0,0 +1,78 @@
+import { IconType } from "@ng-icons/core";
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+export declare class UiToastComponent {
+  readonly intent: import("@angular/core").InputSignal<"info" | "success" | "warning" | "danger">;
+  readonly classes: import("@angular/core").InputSignal<string>;
+  readonly dismissable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** ms before the toast dismisses itself, paused while hovered or focused. null never times out. */
+  readonly timeoutMs: import("@angular/core").InputSignal<number | null>;
+  readonly dismissed: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly icon: import("@angular/core").Signal<IconType>;
+  protected readonly iconColour: import("@angular/core").Signal<string>;
+  protected readonly role: import("@angular/core").Signal<"alert" | "status">;
+  private hovered;
+  private focused;
+  private timer?;
+  private startedAt;
+  private remaining;
+  constructor();
+  protected setHovered(hovered: boolean): void;
+  protected setFocused(focused: boolean): void;
+  private updateTimer;
+  private startTimer;
+  private stopTimer;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiToastComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UiToastComponent, "ui-toast", never, {
+    "intent": {
+      "alias": "intent";
+      "required": false;
+      "isSignal": true;
+    };
+    "classes": {
+      "alias": "classes";
+      "required": false;
+      "isSignal": true;
+    };
+    "dismissable": {
+      "alias": "dismissable";
+      "required": false;
+      "isSignal": true;
+    };
+    "timeoutMs": {
+      "alias": "timeoutMs";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "dismissed": "dismissed";
+  }, never, ["*"], true, never>;
+}
+export declare const ToastIntents: readonly ["info", "success", "warning", "danger"];
+export type ToastIntent = typeof ToastIntents[number];
+/** What a toast template receives: `let-data` for the context, `let-dismiss="dismiss"` to close it. */
+export interface ToastTemplateContext<ContextType = unknown> {
+  $implicit: ContextType;
+  dismiss: () => void;
+}
+export type ToastMessage<ContextType = unknown> = string | TemplateRef<ToastTemplateContext<ContextType>>;
+export interface Toast {
+  id: number;
+  message: ToastMessage;
+  templateContext: ToastTemplateContext;
+  intent: ToastIntent;
+  dismissable: boolean;
+  timeoutMs?: number | null;
+}
+export type ToastOptions<ContextType = unknown> = Partial<Pick<Toast, 'intent' | 'dismissable' | 'timeoutMs'>> & {
+  context?: ContextType;
+};
+export declare class UiToastService {
+  private readonly _toasts;
+  private nextId;
+  readonly toasts: import("@angular/core").Signal<Toast[]>;
+  show<ContextType>(message: ToastMessage<ContextType>, options?: ToastOptions<ContextType>): number;
+  dismiss(id: number): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiToastService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}