@vadem/ui 0.0.0-stage → 0.0.1

package/types/vadem-ui-stepper.d.ts

@@ -0,0 +1,108 @@
+import * as i0 from "@angular/core";
+type VdStepperOrientation = 'horizontal' | 'vertical';
+/** Ordered process navigation. The consumer owns stage content and validation. */
+export declare class VdStepper {
+  readonly value: import("@angular/core").ModelSignal<string | undefined>;
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  readonly orientation: import("@angular/core").InputSignal<VdStepperOrientation>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly completedLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly errorLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Text inputs resolved against the active VD_LOCALE. */
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    label: string;
+    completedLabel: string;
+    errorLabel: string;
+  }, "label" | "completedLabel" | "errorLabel">>;
+  private readonly steps;
+  readonly current: import("@angular/core").Signal<string>;
+  number(step: VdStep): number;
+  select(step: VdStep): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdStepper, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdStepper, "nav[vdStepper]", ["vdStepper"], {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "completedLabel": {
+      "alias": "completedLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorLabel": {
+      "alias": "errorLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, ["steps"], never, true, never>;
+}
+/** Native button with a numbered/status indicator and compositional text parts. */
+export declare class VdStep {
+  readonly value: import("@angular/core").InputSignal<string>;
+  readonly completed: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly stepper: VdStepper;
+  protected readonly title: import("@angular/core").Signal<VdStepTitle | undefined>;
+  private readonly description;
+  protected readonly statusId: string;
+  protected readonly number: import("@angular/core").Signal<number>;
+  protected readonly current: import("@angular/core").Signal<boolean>;
+  protected readonly isDisabled: import("@angular/core").Signal<boolean>;
+  protected readonly state: import("@angular/core").Signal<"error" | "complete" | "current" | "upcoming">;
+  protected readonly status: import("@angular/core").Signal<string | undefined>;
+  protected readonly describedBy: import("@angular/core").Signal<string | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdStep, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdStep, "button[vdStep]", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "completed": {
+      "alias": "completed";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["title", "description"], ["*"], true, never>;
+}
+export declare class VdStepTitle {
+  readonly id: string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdStepTitle, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdStepTitle, "[vdStepTitle]", never, {}, {}, never, never, true, never>;
+}
+export declare class VdStepDescription {
+  readonly id: string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdStepDescription, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdStepDescription, "[vdStepDescription]", never, {}, {}, never, never, true, never>;
+}
+export declare const VD_STEPPER: readonly [typeof VdStepper, typeof VdStep, typeof VdStepTitle, typeof VdStepDescription];
+export type { VdStepperOrientation };

package/types/vadem-ui-switch.d.ts

@@ -0,0 +1,10 @@
+import { VdFieldControlBase } from "@vadem/ui/field";
+import * as i0 from "@angular/core";
+/**
+ * A native `<input type="checkbox">` exposed as `role="switch"` (on/off, takes effect
+ * immediately). Forms and keyboard stay native. Spec: specs/switch.md
+ */
+export declare class VdSwitch extends VdFieldControlBase {
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdSwitch, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdSwitch, "input[type=checkbox][vdSwitch]", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,172 @@
+import * as i0 from "@angular/core";
+type VdSortDirection = 'ascending' | 'descending';
+/** Current sort of a table: which column and which way. `null` = source order. */
+interface VdSort {
+  key: string;
+  direction: VdSortDirection;
+}
+/** Next state when a column header is activated: a new column starts ascending, the same one flips. */
+export declare function vdNextSort(current: VdSort | null, key: string): VdSort;
+interface VdSortOptions<T> {
+  /** Value to compare for a column; defaults to `row[key]`. */
+  accessor?: (row: T, key: string) => unknown;
+  /** Locale for text comparison (e.g. 'uk'); defaults to the runtime locale. */
+  locale?: string;
+}
+/**
+ * Returns a sorted copy (stable). Numbers and dates compare by value, text with `Intl.Collator`
+ * (case- and accent-aware, numeric: "file 2" < "file 10"). Empty values (null, undefined, '')
+ * always go last, in both directions.
+ */
+export declare function vdSortRows<T>(rows: readonly T[], sort: VdSort | null, options?: VdSortOptions<T>): T[];
+type VdTableSize = 'sm' | 'md';
+/**
+ * Styles a native `<table>` and owns its sort state. Rows are rendered (and sorted, e.g. with
+ * `vdSortRows`) by the consumer. Spec: specs/table.md
+ */
+export declare class VdTable {
+  readonly size: import("@angular/core").InputSignal<VdTableSize>;
+  /** Header stays visible while a `vdTableScroll` container scrolls vertically. */
+  readonly stickyHeader: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Current sort (two-way). `null` = source order. */
+  readonly sort: import("@angular/core").ModelSignal<VdSort | null>;
+  toggleSort(key: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdTable, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdTable, "table[vdTable]", ["vdTable"], {
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "stickyHeader": {
+      "alias": "stickyHeader";
+      "required": false;
+      "isSignal": true;
+    };
+    "sort": {
+      "alias": "sort";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "sort": "sortChange";
+  }, never, never, true, never>;
+}
+/**
+ * Sortable column header (APG sortable table): a button inside the `th`, `aria-sort` on the
+ * sorted column only.
+ */
+export declare class VdSortHeader {
+  /** Sort key for this column. */
+  readonly vdSortHeader: import("@angular/core").InputSignal<string>;
+  protected readonly table: VdTable;
+  protected readonly direction: import("@angular/core").Signal<import("@vadem/ui/table").VdSortDirection | null>;
+  protected readonly icon: import("@angular/core").Signal<"arrow-up" | "arrow-down" | "arrow-up-down">;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdSortHeader, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdSortHeader, "th[vdSortHeader]", never, {
+    "vdSortHeader": {
+      "alias": "vdSortHeader";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** A body row; `selected` only styles it - the row's checkbox carries the state for AT. */
+export declare class VdRow {
+  readonly selected: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdRow, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdRow, "tr[vdRow]", never, {
+    "selected": {
+      "alias": "selected";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Full-width cell for the empty / no-results state: `<td vdTableEmpty colspan="5">`. */
+export declare class VdTableEmpty {
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdTableEmpty, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdTableEmpty, "td[vdTableEmpty]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Scroll container for wide or tall tables. Focusable so keyboard users can scroll it;
+ * give it a name (`aria-label` or `aria-labelledby` the caption).
+ */
+export declare class VdTableScroll {
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdTableScroll, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdTableScroll, "[vdTableScroll]", never, {}, {}, never, never, true, never>;
+}
+export declare const VD_TABLE: readonly [typeof VdTable, typeof VdSortHeader, typeof VdRow, typeof VdTableEmpty, typeof VdTableScroll];
+type VdTableRowId = string | number;
+interface VdTableColumnDefinition {
+  key: string;
+  required?: boolean;
+}
+/** Return a new selection while preserving IDs outside the current page. */
+declare function vdSelectTableRows(selected: ReadonlySet<VdTableRowId>, ids: readonly VdTableRowId[], checked: boolean): Set<VdTableRowId>;
+/** Required columns and at least one column remain visible even with invalid external state. */
+declare function vdVisibleTableColumns(columns: readonly VdTableColumnDefinition[], hidden: ReadonlySet<string>): readonly VdTableColumnDefinition[];
+/** Opt-in state for a consumer-rendered native Table. */
+export declare class VdDataTable {
+  readonly rowIds: import("@angular/core").InputSignal<readonly VdTableRowId[]>;
+  readonly columns: import("@angular/core").InputSignal<readonly VdTableColumnDefinition[]>;
+  readonly columnOffset: import("@angular/core").InputSignal<number>;
+  readonly selected: import("@angular/core").ModelSignal<ReadonlySet<VdTableRowId>>;
+  readonly hiddenColumns: import("@angular/core").ModelSignal<ReadonlySet<string>>;
+  readonly visibleColumns: import("@angular/core").Signal<readonly VdTableColumnDefinition[]>;
+  readonly columnCount: import("@angular/core").Signal<number>;
+  readonly allSelected: import("@angular/core").Signal<boolean>;
+  readonly someSelected: import("@angular/core").Signal<boolean>;
+  setSelected(id: VdTableRowId, checked: boolean): void;
+  selectAll(checked: boolean): void;
+  clearSelection(): void;
+  isColumnVisible(key: string): boolean;
+  canHideColumn(key: string): boolean;
+  setColumnVisible(key: string, visible: boolean): void;
+  resetColumns(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdDataTable, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdDataTable, "[vdDataTable]", ["vdDataTable"], {
+    "rowIds": {
+      "alias": "rowIds";
+      "required": false;
+      "isSignal": true;
+    };
+    "columns": {
+      "alias": "columns";
+      "required": false;
+      "isSignal": true;
+    };
+    "columnOffset": {
+      "alias": "columnOffset";
+      "required": false;
+      "isSignal": true;
+    };
+    "selected": {
+      "alias": "selected";
+      "required": false;
+      "isSignal": true;
+    };
+    "hiddenColumns": {
+      "alias": "hiddenColumns";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "selected": "selectedChange";
+    "hiddenColumns": "hiddenColumnsChange";
+  }, never, never, true, never>;
+}
+export declare class VdTableColumn {
+  readonly vdTableColumn: import("@angular/core").InputSignal<string>;
+  protected readonly table: VdDataTable;
+  protected readonly index: import("@angular/core").Signal<number | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdTableColumn, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdTableColumn, "th[vdTableColumn], td[vdTableColumn]", never, {
+    "vdTableColumn": {
+      "alias": "vdTableColumn";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export type { VdSort, VdSortDirection, VdSortOptions, VdTableColumnDefinition, VdTableRowId, VdTableSize };

package/types/vadem-ui-tabs.d.ts

@@ -0,0 +1,101 @@
+import * as i0 from "@angular/core";
+import { OnInit } from "@angular/core";
+import { VdDirection, VdOrientation, VdOrientation as VdOrientation$1, VdRovingOptions, vdIsActivationKey, vdRovingTarget } from "@vadem/ui/keyboard";
+type VdTabsVariant = 'line' | 'pill';
+type VdTabsActivation = 'automatic' | 'manual';
+/**
+ * Tabs container: owns the selected value and keyboard behavior. Compose with
+ * `vdTabList`, `vdTab` and `vdTabPanel`. Spec: specs/tabs.md
+ */
+export declare class VdTabs {
+  /** Selected tab value. Defaults to the first enabled tab. */
+  readonly value: import("@angular/core").ModelSignal<string | undefined>;
+  readonly variant: import("@angular/core").InputSignal<VdTabsVariant>;
+  readonly orientation: import("@angular/core").InputSignal<VdOrientation$1>;
+  /** `automatic`: arrows select. `manual`: arrows move focus, Enter/Space select. */
+  readonly activation: import("@angular/core").InputSignal<VdTabsActivation>;
+  private readonly tabs;
+  private readonly panels;
+  /** Tabs in DOM order (registration order can differ for dynamic lists). */
+  private readonly ordered;
+  readonly selected: import("@angular/core").Signal<string | undefined>;
+  tabId(value: string): string | null;
+  panelId(value: string): string | null;
+  select(value: string): void;
+  /** Returns the unregister function. */
+  registerTab(tab: VdTab): () => void;
+  registerPanel(panel: VdTabPanel): () => void;
+  handleKeydown(tab: VdTab, event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdTabs, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdTabs, "vd-tabs", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+    "activation": {
+      "alias": "activation";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, ["*"], true, never>;
+}
+/** Container for the tabs. Needs an accessible name (`aria-label` or `aria-labelledby`). */
+export declare class VdTabList {
+  protected readonly tabs: VdTabs;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdTabList, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdTabList, "[vdTabList]", never, {}, {}, never, never, true, never>;
+}
+export declare class VdTab implements OnInit {
+  readonly value: import("@angular/core").InputSignal<string>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly tabs: VdTabs;
+  readonly el: HTMLElement;
+  readonly id: string;
+  protected readonly selected: import("@angular/core").Signal<boolean>;
+  private readonly destroyRef;
+  ngOnInit(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdTab, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdTab, "button[vdTab]", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class VdTabPanel implements OnInit {
+  readonly value: import("@angular/core").InputSignal<string>;
+  protected readonly tabs: VdTabs;
+  readonly id: string;
+  protected readonly selected: import("@angular/core").Signal<boolean>;
+  private readonly destroyRef;
+  ngOnInit(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdTabPanel, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdTabPanel, "[vdTabPanel]", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare const VD_TABS: readonly [typeof VdTabs, typeof VdTabList, typeof VdTab, typeof VdTabPanel];
+export { type VdDirection, type VdOrientation, type VdRovingOptions, type VdTabsActivation, type VdTabsVariant, vdIsActivationKey, vdRovingTarget };

package/types/vadem-ui-tag-input.d.ts

@@ -0,0 +1,170 @@
+import * as i0 from "@angular/core";
+import { OnInit, Signal } from "@angular/core";
+import { FormValueControl } from "@angular/forms/signals";
+/** Canonical display/editing identity without discarding accents or internal whitespace. */
+declare function vdTagKey(tag: string): string;
+declare function vdNormalizeTags(value: readonly string[] | null | undefined): string[];
+declare function vdAddTag(value: readonly string[], draft: string): {
+  kind: 'empty';
+  tag: string;
+} | {
+  kind: 'duplicate';
+  tag: string;
+} | {
+  kind: 'added';
+  tag: string;
+  value: string[];
+};
+type VdTagInputSize = 'sm' | 'md' | 'lg';
+/** User-defined tags with explicit editing actions. Spec: specs/tag-input.md. */
+export declare class VdTagInput implements FormValueControl<string[]>, OnInit {
+  readonly value: import("@angular/core").ModelSignal<string[]>;
+  readonly size: import("@angular/core").InputSignal<VdTagInputSize>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly placeholder: import("@angular/core").InputSignal<string>;
+  readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly ariaLabelledby: import("@angular/core").InputSignal<string | undefined>;
+  readonly addLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly tagsLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly removeLabel: import("@angular/core").InputSignal<((tag: string) => string) | undefined>;
+  readonly addedMessage: import("@angular/core").InputSignal<((tag: string) => string) | undefined>;
+  readonly removedMessage: import("@angular/core").InputSignal<((tag: string) => string) | undefined>;
+  readonly duplicateMessage: import("@angular/core").InputSignal<((tag: string) => string) | undefined>;
+  /** Text inputs resolved against the active VD_LOCALE. */
+  protected readonly t: Signal<Pick<{
+    addLabel: string;
+    tagsLabel: string;
+    removeLabel: (tag: string) => string;
+    addedMessage: (tag: string) => string;
+    removedMessage: (tag: string) => string;
+    duplicateMessage: (tag: string) => string;
+  }, "addLabel" | "tagsLabel" | "removeLabel" | "addedMessage" | "removedMessage" | "duplicateMessage">>;
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  readonly controlId: string;
+  protected readonly feedbackId: string;
+  protected readonly tagKey: typeof vdTagKey;
+  protected readonly tags: Signal<string[]>;
+  protected readonly draft: import("@angular/core").WritableSignal<string>;
+  protected readonly feedback: import("@angular/core").WritableSignal<string>;
+  protected composing: boolean;
+  private readonly pendingFeedback;
+  private readonly inputRef;
+  private readonly removeButtons;
+  private readonly hostEl;
+  private readonly field;
+  private readonly injector;
+  private readonly destroyRef;
+  private readonly formBound;
+  private readonly ngSource;
+  private readonly ngState;
+  protected readonly isDisabled: Signal<boolean>;
+  protected readonly locked: Signal<boolean>;
+  protected readonly showInvalid: Signal<boolean>;
+  protected readonly isRequired: Signal<boolean>;
+  protected readonly descriptionIds: Signal<string | null>;
+  private lastValue;
+  constructor();
+  ngOnInit(): void;
+  focus(options?: FocusOptions): void;
+  reset(): void;
+  protected onInput(event: Event): void;
+  protected add(): void;
+  protected remove(tag: string): void;
+  protected returnToInput(event: Event): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  protected onFocusOut(event: FocusEvent): void;
+  protected onFieldPointerDown(event: PointerEvent): void;
+  private commit;
+  private announce;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdTagInput, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdTagInput, "vd-tag-input", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "aria-label";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabelledby": {
+      "alias": "aria-labelledby";
+      "required": false;
+      "isSignal": true;
+    };
+    "addLabel": {
+      "alias": "addLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "tagsLabel": {
+      "alias": "tagsLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "removeLabel": {
+      "alias": "removeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "addedMessage": {
+      "alias": "addedMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "removedMessage": {
+      "alias": "removedMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "duplicateMessage": {
+      "alias": "duplicateMessage";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "touch": "touch";
+  }, never, never, true, never>;
+}
+export type { VdTagInputSize };

package/types/vadem-ui-text-highlight.d.ts

@@ -0,0 +1,27 @@
+import * as i0 from "@angular/core";
+interface VdTextHighlightPart {
+  readonly text: string;
+  readonly matched: boolean;
+}
+/** Unicode simple case folding keeps match indices tied to the original source. */
+declare function vdTextHighlightParts(text: string, query: string): readonly VdTextHighlightPart[];
+/** Preserves plain text while marking every literal, case-insensitive query match. */
+export declare class VdTextHighlight {
+  readonly text: import("@angular/core").InputSignal<string>;
+  readonly query: import("@angular/core").InputSignal<string>;
+  protected readonly parts: import("@angular/core").Signal<readonly VdTextHighlightPart[]>;
+  protected readonly matched: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdTextHighlight, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdTextHighlight, "vd-text-highlight", never, {
+    "text": {
+      "alias": "text";
+      "required": true;
+      "isSignal": true;
+    };
+    "query": {
+      "alias": "query";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

package/types/vadem-ui-time-input.d.ts

@@ -0,0 +1,47 @@
+import { VdInput } from "@vadem/ui/input";
+import * as i0 from "@angular/core";
+/** Native editor and accessors with a themed, minute-resolution selection popover. */
+export declare class VdTimeInput extends VdInput {
+  readonly pickerLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly hoursLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly minutesLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly emptyLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Text inputs resolved against the active VD_LOCALE. */
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    pickerLabel: string;
+    hoursLabel: string;
+    minutesLabel: string;
+    emptyLabel: string;
+  }, "pickerLabel" | "hoursLabel" | "minutesLabel" | "emptyLabel">>;
+  protected readonly open: import("@angular/core").WritableSignal<boolean>;
+  protected readonly panelId: import("@angular/core").WritableSignal<string | null>;
+  private readonly element;
+  private readonly container;
+  private picker?;
+  constructor();
+  protected showPicker(event: Event): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdTimeInput, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdTimeInput, "input[type=time][vdTimeInput]", never, {
+    "pickerLabel": {
+      "alias": "pickerLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "hoursLabel": {
+      "alias": "hoursLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "minutesLabel": {
+      "alias": "minutesLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyLabel": {
+      "alias": "emptyLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}