@yuuvis/client-framework 3.12.0 → 3.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuuvis/client-framework",
-  "version": "3.12.0",
+  "version": "3.13.0",
   "author": "OPTIMAL SYSTEMS GmbH <npm@optimal-systems.de>",
   "license": "MIT",
   "peerDependencies": {
@@ -8,16 +8,16 @@
     "@angular/common": "^21.2.9",
     "@angular/core": "^21.2.9",
     "angular-gridster2": "^21.0.1",
-    "@yuuvis/client-core": "^3.12.0",
-    "@yuuvis/client-shell-core": "^3.12.0",
-    "@yuuvis/client-components": "^3.12.0",
+    "@yuuvis/client-core": "^3.13.0",
+    "@yuuvis/client-shell-core": "^3.13.0",
+    "@yuuvis/client-components": "^3.13.0",
     "ng-dynamic-component": "^10.8.2",
     "modern-normalize": "^3.0.1"
   },
   "dependencies": {
     "@angular/material": "^21.2.7",
     "@ngrx/signals": "^21.1.0",
-    "@yuuvis/material": "^3.12.0",
+    "@yuuvis/material": "^3.13.0",
     "@yuuvis/media-viewer": "^3.0.6",
     "angular-split": "^20.0.0",
     "vis-network": "^10.0.2",

package/types/yuuvis-client-framework-query-list.d.ts

@@ -305,6 +305,24 @@ declare class QueryListComponent<T = any> {
      * Re-evaluates automatically whenever any of the three sources change.
      */
     resultItems: _angular_core.Signal<T[]>;
+    /**
+     * Object IDs of the currently selected rows — the id-based source of truth for the
+     * visual selection.
+     *
+     * The inner list tracks selection by positional index, which becomes meaningless the
+     * moment a re-query reorders or replaces the rendered rows (the `@for` reuses/recreates
+     * the projected item directives, so index-based visual state points at the wrong — or
+     * detached — directives). When `idProperty` is set, the inner list is switched into
+     * `selfHandleSelection` mode and each row's `[selected]` is bound to this set instead, so
+     * Angular re-applies the correct selection by ID on every render — a multi-selection then
+     * survives sort, page changes, and refreshes. Kept in sync from every committed selection
+     * via `onInnerItemSelect()`.
+     */
+    selectedIds: _angular_core.WritableSignal<Set<string>>;
+    /** Whether this component drives the inner list's selection visuals via each row's id-based
+     * `[selected]` binding (and thus the inner list should not write them imperatively). Enabled
+     * whenever an `idProperty` is configured — the prerequisite for id-based selection. */
+    idSelection: _angular_core.Signal<boolean>;
     /**
      * Indicates whether a search request is currently in flight.
      *
@@ -320,6 +338,25 @@ declare class QueryListComponent<T = any> {
     constructor();
     /** Resolves the tracking key for a result item in the `@for` loop. */
     trackItem(item: T, index: number): unknown;
+    /**
+     * Whether the given row is part of the current selection, resolved by ID.
+     *
+     * Bound to each row's `[selected]` in the template so the visual selection is driven by
+     * {@link selectedIds} (id-based) rather than the inner list's positional state. This is
+     * what makes a multi-selection survive a re-query/reorder.
+     */
+    isRowSelected(item: T): boolean;
+    /**
+     * Choke point for every committed selection emitted by the inner list.
+     *
+     * Translates the positional indices into object IDs against the currently rendered
+     * `resultItems()` and stores them in {@link selectedIds}, then re-emits the original
+     * indices via `itemSelect` so existing consumers are unaffected. Keeping the id set in
+     * sync here (rather than in each caller) means clicks, keyboard, drag-select, and
+     * programmatic selection all feed the same source of truth. A no-op passthrough when no
+     * `idProperty` is configured (the inner list then owns the visual selection as before).
+     */
+    onInnerItemSelect(indices: number[]): void;
     /**
      * Handles a single click on a list item.
      *
@@ -341,10 +378,16 @@ declare class QueryListComponent<T = any> {
      * to trigger a secondary action (e.g. opening a detail panel or navigating to a route)
      * that is distinct from the primary single-click selection.
      *
+     * When a modifier key (Ctrl/Shift/Meta) is held, the double-click is instead treated as a
+     * selection gesture: while the user is rapidly building a multi-selection, two quick clicks
+     * on the same row are easily coalesced by the browser into a `dblclick`. Emitting the
+     * double-click action then would navigate away / open a preview and tear down the whole
+     * multi-selection. So we toggle selection for that item and suppress the double-click action.
+     *
      * Called from the template via `ClickDoubleDirective`. Not intended for external callers.
      *
      * @param idx   Zero-based index of the double-clicked item.
-     * @param event The originating mouse event (unused, kept for directive compatibility).
+     * @param event The originating mouse event; its modifier flags decide open-vs-select.
      */
     onItemDoubleClick(idx: number, event: MouseEvent): void;
     /**