@aquera/ngx-smart-table 0.0.39 → 0.0.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aquera/ngx-smart-table",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "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
@@ -6173,6 +6206,12 @@ declare class StConditionRuleComponent {
      * sub-rules inside a group — v1's 1-level nesting forbids groups-in-groups).
      */
     canInsertGroup: boolean;
+    /**
+     * True when this rule is a sub-condition inside a group. Only then does the
+     * first row reserve the connector column (via a spacer) so the sub-conditions
+     * align. Top-level rows are left flush — parent-level layout is unchanged.
+     */
+    inGroup: boolean;
     readonly ruleChange: EventEmitter<SubCondition>;
     readonly remove: EventEmitter<void>;
     /** User asked to insert a fresh peer Condition directly below this row. */
@@ -6193,13 +6232,13 @@ declare class StConditionRuleComponent {
     onOperatorChange(event: Event): void;
     onValueChange(value: ConditionValue): void;
     onRemoveClick(): void;
-    onInsertBelowClick(): void;
+    onInsertBelowClick(event?: MouseEvent): void;
     onAddMenuSelect(event: Event): void;
     /** Pick a sensible default operator for a given field: first allowed operator. */
     private pickDefaultOperator;
     private emit;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StConditionRuleComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StConditionRuleComponent, "st-condition-rule", never, { "rule": { "alias": "rule"; "required": true; }; "config": { "alias": "config"; "required": true; }; "isFirst": { "alias": "isFirst"; "required": false; }; "canRemove": { "alias": "canRemove"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "canInsertGroup": { "alias": "canInsertGroup"; "required": false; }; }, { "ruleChange": "ruleChange"; "remove": "remove"; "insertBelow": "insertBelow"; "insertGroupBelow": "insertGroupBelow"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StConditionRuleComponent, "st-condition-rule", never, { "rule": { "alias": "rule"; "required": true; }; "config": { "alias": "config"; "required": true; }; "isFirst": { "alias": "isFirst"; "required": false; }; "canRemove": { "alias": "canRemove"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "canInsertGroup": { "alias": "canInsertGroup"; "required": false; }; "inGroup": { "alias": "inGroup"; "required": false; }; }, { "ruleChange": "ruleChange"; "remove": "remove"; "insertBelow": "insertBelow"; "insertGroupBelow": "insertGroupBelow"; }, never, never, true, never>;
 }
 
 /**
@@ -6214,13 +6253,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 +6283,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 +6302,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 +6358,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