@aquera/ngx-smart-table 0.0.38 → 0.0.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aquera/ngx-smart-table",
-  "version": "0.0.38",
+  "version": "0.0.40",
   "license": "MIT",
   "publishConfig": {
     "access": "public",

package/types/aquera-ngx-smart-table.d.ts

@@ -2409,6 +2409,7 @@ interface OperatorDefinition {
  * Fields are consumer-provided via ConditionBuilderConfig.fields.
  * The library does not ship default fields.
  */
+
 /**
  * Editor variant used to render a field's value input.
  *  - 'text'         : free-form text, single value
@@ -2441,13 +2442,45 @@ interface FieldDefinition {
      * builder config are allowed. Operator keys must match an OperatorDefinition.key.
      */
     operators?: string[];
-    /** Predefined options — required when valueEditor is 'select' or 'multi-select'. */
+    /**
+     * Predefined options for 'select' / 'multi-select'. Required for static
+     * dropdowns. When `loadOptions` is also provided, this acts as the initial
+     * (seed) list shown until the first async load resolves.
+     */
     options?: FieldOption[];
     /**
      * Placeholder text shown in the value editor when nothing is selected.
      * Falls back to a sensible default per editor type when omitted.
      */
     valuePlaceholder?: string;
+    /**
+     * Show a search box inside the 'select' / 'multi-select' dropdown. Ignored
+     * for 'text' and 'chip' editors.
+     * @default true
+     */
+    searchable?: boolean;
+    /**
+     * Async options provider for 'select' / 'multi-select' editors. When set, the
+     * editor switches to server-side search: the dropdown's built-in client-side
+     * filtering is turned off and this is invoked with the current search term —
+     * once with `''` when the dropdown first opens, then again (debounced) on each
+     * search keystroke. Return the options to display, as an Observable or Promise.
+     *
+     * While a load is in flight the dropdown shows a loading indicator. The static
+     * `options` array (if any) is shown until the first load resolves. If the
+     * loader errors, the currently shown options are left unchanged.
+     *
+     * @example
+     *   loadOptions: (q) => this.api.searchGroups(q)   // returns Observable<FieldOption[]>
+     */
+    loadOptions?: (search: string) => Observable<FieldOption[]> | Promise<FieldOption[]>;
+    /**
+     * Debounce (in ms) applied to search keystrokes before `loadOptions` fires.
+     * The initial open-time load is not debounced. Only relevant when
+     * `loadOptions` is set.
+     * @default 300
+     */
+    searchDebounceMs?: number;
 }
 /**
  * Grouped fields shown as a submenu in the field picker. Matches the v1 admin-ui
@@ -6214,13 +6247,26 @@ declare class StConditionRuleComponent {
  * Value is always handled as `string[]`. Single-value editors use the first array
  * element; empty array means "no value".
  */
-declare class StConditionValueEditorComponent implements OnInit, OnDestroy {
+declare class StConditionValueEditorComponent implements OnInit, OnChanges, OnDestroy {
     field?: FieldDefinition;
     operator?: OperatorDefinition;
     value: ConditionValue;
     disabled: boolean;
     readonly valueChange: EventEmitter<ConditionValue>;
     private elementRef;
+    private cdr;
+    /**
+     * Async-search state (only used when the field declares `loadOptions`).
+     *  - `asyncOptions` holds the latest server-fetched list; null means "not
+     *    loaded yet" and we fall back to the field's static `options`.
+     *  - `optionsLoading` drives nile-select's loading indicator.
+     *  - `loadedForAttribute` guards the one-time open-time load per field.
+     */
+    asyncOptions: FieldOption[] | null;
+    optionsLoading: boolean;
+    private loadedForAttribute?;
+    private searchTimer;
+    private inFlight;
     /** Open/close + highlighted-option state for the slotted-trigger select. */
     private dropdownOpen;
     private highlightedIndex;
@@ -6231,6 +6277,14 @@ declare class StConditionValueEditorComponent implements OnInit, OnDestroy {
     private activeHost;
     constructor();
     ngOnInit(): void;
+    /**
+     * Reset the async-search state whenever the bound field switches to a
+     * different attribute. The component instance is reused across rule edits
+     * (Angular rebinds `[field]`), so stale fetched options / loading flags from
+     * the previous field must be cleared, and the next open re-triggers the
+     * initial load.
+     */
+    ngOnChanges(changes: SimpleChanges): void;
     /**
      * Host class flag — when true, the value editor host stretches to take the
      * remaining flex space in the rule (so the chip can grow up to the row's
@@ -6242,6 +6296,21 @@ declare class StConditionValueEditorComponent implements OnInit, OnDestroy {
     get hidden(): boolean;
     /** Placeholder for the current editor — field override wins, else a sensible default per editor type. */
     get placeholder(): string;
+    /**
+     * Whether the select / multi-select dropdown shows its search box. Defaults
+     * to true (the field opts out with `searchable: false`). Server-side search
+     * always needs the box, so a field that declares `loadOptions` keeps it on
+     * regardless of the flag.
+     */
+    get searchEnabled(): boolean;
+    /** True when the field provides an async `loadOptions` callback. */
+    get serverSearch(): boolean;
+    /**
+     * Options rendered into the dropdown. For server-side search this is the
+     * latest fetched list (falling back to the field's static seed list until
+     * the first load resolves); otherwise it's just the static `options`.
+     */
+    get displayOptions(): FieldOption[];
     /** Convenience: first element for single-value editors. */
     get singleValue(): string;
     /**
@@ -6283,6 +6352,22 @@ declare class StConditionValueEditorComponent implements OnInit, OnDestroy {
      * (it lives for the component's lifetime).
      */
     onSelectShow(event: Event): void;
+    /**
+     * nile-select fires `nile-search` (with `detail.query`) on every keystroke in
+     * its search box. For server-side search we debounce and re-fetch; when the
+     * field has no `loadOptions` callback the dropdown's built-in client-side
+     * filter handles it and this is a no-op.
+     */
+    onSelectSearch(event: Event): void;
+    /**
+     * Invoke the field's `loadOptions(query)` and adopt the result. Normalises
+     * the Observable-or-Promise return via `from()`, cancels any in-flight
+     * request (latest-wins), and shows nile-select's loading indicator while the
+     * fetch runs. A failed load leaves the current options untouched.
+     */
+    private fetchOptions;
+    /** Cancel any pending debounce timer and in-flight options request. */
+    private cancelLoad;
     /**
      * Nile emits `nile-hide` when its dropdown closes — for any reason (Esc,
      * click-outside, single-select pick, programmatic .hide()). Returning focus