@yuuvis/client-framework 2.6.3 → 2.7.0

package/lib/services/halo-utility/halo-utility.service.d.ts

@@ -0,0 +1,230 @@
+import { HaloFocusConfig } from '../../models';
+import * as i0 from "@angular/core";
+/**
+ * Utility service providing helper methods for the Halo Focus feature.
+ *
+ * This service contains pure utility functions for:
+ * - Element validation (focusability, visibility, focus-visible state)
+ * - Material form field detection and exclusion logic
+ * - Style calculations (colors, offsets, positioning)
+ * - DOM traversal (finding halo containers, checking parent visibility)
+ * - Halo element manipulation (size, color, position)
+ *
+ * **Scope & Performance:**
+ * This service is intentionally NOT provided in root (`providedIn: 'root'` is omitted).
+ * Instead, it's provided locally via `provideHaloFocus()`, ensuring it's only instantiated
+ * when the Halo Focus feature is actually used. This optimization prevents unnecessary
+ * service creation in applications that don't use halo focus.
+ *
+ * **Note:** This service is used exclusively by `HaloFocusService` and should not be
+ * injected or used elsewhere in the application.
+ *
+ * @internal
+ */
+export declare class HaloUtilityService {
+    /**
+     * Checks if an element is focusable (can receive keyboard focus).
+     *
+     * An element is considered focusable if:
+     * - It has a non-negative tabIndex (>= 0), OR
+     * - It's a natively focusable element (A, BUTTON, INPUT, SELECT, TEXTAREA), OR
+     * - It has contentEditable enabled
+     *
+     * @param element - Element to check
+     * @returns true if element can receive focus, false otherwise
+     */
+    isFocusable(element: Element | null): element is HTMLElement;
+    /**
+     * Checks if an element is inside a Material form field (mat-form-field).
+     *
+     * Traverses up the DOM tree from the element to check if any parent
+     * has the `mat-form-field` tag name. This is used to determine if
+     * certain elements should skip halo focus because they're already
+     * styled by Angular Material.
+     *
+     * **Search Scope:**
+     * - Starts from element itself
+     * - Stops at document.body
+     * - Returns true on first mat-form-field match
+     *
+     * @param element - The element to check
+     * @returns true if element is inside a mat-form-field, false otherwise
+     */
+    isElementInsideMatFormField(element: HTMLElement): boolean;
+    /**
+     * Determines if an element should be excluded from halo focus when inside mat-form-field.
+     *
+     * Checks two conditions:
+     * 1. Element tag name matches one of the excluded selectors (input, mat-select, etc.)
+     * 2. Element is inside a mat-form-field component
+     *
+     * If both conditions are true, the element should skip halo focus because
+     * Angular Material already provides adequate focus styling.
+     *
+     * **Excluded Elements (configurable via haloExcludedElementsInMatFormField):**
+     * - `input` elements inside mat-form-field
+     * - `textarea` elements inside mat-form-field
+     * - `mat-select` elements inside mat-form-field
+     *
+     * **Note:** Elements outside mat-form-field will NOT be skipped, even if
+     * their tag matches the exclusion list.
+     *
+     * @param element - The focused element to check
+     * @returns true if element should be skipped (no halo), false if halo should be shown
+     */
+    shouldSkipElementInMatFormField(element: HTMLElement): boolean;
+    /**
+     * Determines if an element should display the halo based on :focus-visible state.
+     *
+     * This method respects the CSS :focus-visible pseudo-class, which indicates that
+     * focus was triggered by keyboard navigation (not mouse clicks). The halo only appears
+     * when both conditions are met:
+     * 1. Element matches :focus-visible (browser determines this)
+     * 2. Last user interaction was via keyboard (tracked by service)
+     *
+     * **Fallback:** If browser doesn't support :focus-visible, falls back to checking
+     * lastInteractionWasKeyboard only.
+     *
+     * @param element - The currently focused element
+     * @param lastInteractionWasKeyboard - Whether the last interaction was a keyboard event
+     * @returns true if halo should be visible, false otherwise
+     */
+    matchesFocusVisible(element: HTMLElement, lastInteractionWasKeyboard: boolean): boolean;
+    /**
+     * Checks if an element is actually visible on the page.
+     *
+     * Performs comprehensive visibility checks including:
+     * - Element has non-zero dimensions (width and height > 0)
+     * - Element is not hidden via CSS (display: none, visibility: hidden, opacity: 0)
+     * - Element is not clipped by parent containers with overflow: hidden/clip
+     * - All parent elements in the hierarchy are visible
+     *
+     * This prevents the halo from appearing around technically focused but visually
+     * hidden elements (e.g., elements in collapsed sections, off-screen elements).
+     *
+     * @param element - Element to check for visibility
+     * @returns true if element is visible to the user, false otherwise
+     */
+    isElementVisible(element: HTMLElement): boolean;
+    /**
+     * Recursively checks if all parent elements are visible and not clipping the target element.
+     *
+     * Traverses up the DOM tree from the element to document.body, checking each parent for:
+     * - Hidden state (display: none, visibility: hidden, opacity: 0)
+     * - Overflow clipping (overflow: hidden/clip) that completely hides the element
+     *
+     * If any parent has overflow clipping, calculates the visible intersection area.
+     * Returns false if element is completely clipped (no visible area).
+     *
+     * @param element - The element whose parents should be checked
+     * @param rect - The bounding rectangle of the element
+     * @returns true if element has visible area within all parent containers, false otherwise
+     */
+    isParentVisible(element: HTMLElement, rect: DOMRect): boolean;
+    /**
+     * Generates the complete CSS styles for the halo element, merging defaults with custom config.
+     *
+     * Takes the base styles from `haloFocusStyles` constant and overrides specific properties
+     * if custom configuration is provided. This allows global style customization while
+     * maintaining all required base styles.
+     *
+     * **Configurable Properties:**
+     * - Inner color (via config.innerColor)
+     * - Outer color (via config.outerColor)
+     *
+     * **Non-configurable Properties:**
+     * - position, pointerEvents, zIndex, opacity, transform (always use defaults)
+     *
+     * @param config - Optional global configuration object
+     * @returns Complete CSS style declaration object for the halo element
+     */
+    getHaloFocusStyles(config?: HaloFocusConfig): Partial<CSSStyleDeclaration>;
+    /**
+     * Finds the nearest parent element marked as a halo container.
+     *
+     * Traverses up the DOM tree looking for an element with the `halo-container` attribute.
+     * Container elements can define default halo styles (color, offset) that apply to all
+     * their focused children, unless overridden by child-specific halo-* attributes.
+     *
+     * **Search Scope:**
+     * - Starts from element's immediate parent
+     * - Stops at document.body (does not check body itself)
+     * - Returns first matching ancestor
+     *
+     * @param element - The focused element to search from
+     * @returns The nearest halo container element, or null if none found
+     */
+    getHaloContainer(element: HTMLElement): HTMLElement | null;
+    /**
+     * Converts any CSS color format to rgba with specified alpha transparency.
+     *
+     * Handles multiple color formats:
+     * - **rgba**: Replaces existing alpha value
+     * - **rgb**: Converts to rgba by appending alpha
+     * - **Hex** (#RRGGBB): Converts to rgba format
+     * - **Named colors**: Uses modern CSS `color-mix` function with alpha
+     *
+     * Used internally to create outer colors with reduced opacity from inner colors.
+     *
+     * @param color - CSS color in any valid format (rgba, rgb, hex, named)
+     * @param alpha - Alpha transparency value (0-1)
+     * @returns Color in rgba format with specified alpha
+     */
+    getColorWithAlpha(color: string, alpha: number): string;
+    /**
+     * Calculates the offset (distance) between the halo border and element edges.
+     *
+     * Determines offset using the following priority order:
+     * 1. **Element's own attributes** (highest priority):
+     *    - `halo-offset="value"` - Custom numeric value
+     * 2. **Parent container attributes** (if element has no offset):
+     *    - `halo-container-offset="value"`
+     * 3. **Default offset** (if nothing specified): 3px
+     *
+     * @param element - The focused element to calculate offset for
+     * @returns Offset value in pixels
+     */
+    getTargetOffset(element: HTMLElement | null): number;
+    /**
+     * Applies custom color styling to the halo element based on element or container attributes.
+     *
+     * Color resolution priority:
+     * 1. **Element's own color**: `halo-color="color"` attribute (highest priority)
+     * 2. **Container's color**: `halo-container-color="color"` from nearest halo container
+     * 3. **Default color**: From global config or base styles (if no custom color found)
+     *
+     * When custom color is found:
+     * - Sets inner color (2px solid border) with the custom color
+     * - Sets outer color (shadow) to match, with 20% alpha transparency for subtle depth
+     *
+     * When no custom color:
+     * - Resets to default styles from config or haloFocusStyles constant
+     *
+     * @param element - The focused element (checked for halo-color attribute)
+     * @param haloElement - The halo DIV element to apply styles to
+     * @param config - Optional global config for default colors
+     */
+    setCustomColor(element: HTMLElement, haloElement: HTMLDivElement, config?: HaloFocusConfig): void;
+    /**
+     * Positions and sizes the halo element to surround the focused element.
+     *
+     * Calculates halo dimensions and position based on:
+     * - Element's bounding rectangle (viewport-relative position)
+     * - Calculated offset from getTargetOffset() (custom or default)
+     * - Element's border-radius for matching rounded corners
+     *
+     * **Calculation Details:**
+     * - Position: Element's top/left minus offset (for outside positioning)
+     * - Size: Element's width/height plus 2× offset (to extend on all sides)
+     * - Border radius: Inherited from focused element's computed style
+     *
+     * Uses Math.floor for position and Math.ceil for dimensions to prevent
+     * subpixel rendering issues and ensure full element coverage.
+     *
+     * @param currentElement - The currently focused element to surround
+     * @param haloElement - The halo DIV element to position and size
+     */
+    setHaloElementSize(currentElement: HTMLElement, haloElement: HTMLDivElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HaloUtilityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HaloUtilityService>;
+}

package/lib/services/index.d.ts

@@ -1,3 +1,4 @@
 export * from './halo-focus/halo-focus.service';
 export * from './snack-bar/snack-bar.interface';
 export * from './snack-bar/snack-bar.service';
+export * from './halo-utility/halo-utility.service';

package/list/lib/list.component.d.ts

@@ -4,7 +4,7 @@ import { BooleanInput } from '@angular/cdk/coercion';
 import * as i0 from "@angular/core";
 /**
  * Component rendering a simple list of items. It supports keyboard
- * navigation as well as accessibility. To create a list just wrap
+ * navigation and takes care of accessibility. To create a list just wrap
  * `yuvListItem` elements into this component:
  *
  * ```html
@@ -19,12 +19,16 @@ export declare class ListComponent implements AfterContentInit, OnDestroy {
     onKeydown(event: KeyboardEvent): void;
     onFocus(): void;
     items: import("@angular/core").Signal<readonly ListItemDirective[]>;
-    private _keyManager;
-    private _selection;
-    private _lastSelection?;
+    /**
+     * Function that returns `true` if selection changes should be prevented.
+     * This can be used to temporarily block selection changes, e.g. while
+     * there is a pending change inside another component that refers to the
+     * current selection.
+     */
     preventChangeUntil: import("@angular/core").InputSignal<() => boolean>;
     /**
      * If `true`, multiple items can be selected at once.
+     * @default false
      */
     multiselect: import("@angular/core").InputSignal<boolean>;
     /**
@@ -35,10 +39,26 @@ export declare class ListComponent implements AfterContentInit, OnDestroy {
      * @default false
      */
     selfHandleSelection: import("@angular/core").InputSignal<boolean>;
+    /**
+     * By default the list handles click events on its items to select them.
+     * If this input is set to `true`, the parent component has to handle
+     * click events itself and call the `select()` method accordingly.
+     *
+     * If you for example use the `ClickDoubleDirective` on the list items,
+     * you have to set this input to `true` to prevent the list from
+     * selecting items on single click.
+     * @default false
+     */
+    selfHandleClick: import("@angular/core").InputSignal<boolean>;
+    /**
+     * If `true`, the list will select an item automatically on initialization.
+     * First, list will search for an item item that has the "selected"-attribute
+     * and is not disabled. If no such item exists, the first item will be selected.
+     * @default false
+     */
     autoSelect: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
     /**
      * Emits the selected items indices.
-     * @type {output<number[]>}
      */
     itemSelect: import("@angular/core").OutputEmitterRef<number[]>;
     /**
@@ -54,7 +74,16 @@ export declare class ListComponent implements AfterContentInit, OnDestroy {
      */
     disableSelection: import("@angular/core").InputSignal<boolean>;
     focus(): void;
+    /**
+     * Select multiple items by their indices.
+     */
     multiSelect(index: number[]): void;
+    /**
+     * Selects a single item by its index.
+     * @param index Index of the item to select.
+     * @param shiftKey If `true`, selection will be extended from the last selected item to the given index.
+     * @param ctrlKey If `true`, the item at the given index will be toggled in the selection.
+     */
     select(index: number, shiftKey?: boolean, ctrlKey?: boolean): void;
     /**
      * Clear the current selection.
@@ -64,5 +93,5 @@ export declare class ListComponent implements AfterContentInit, OnDestroy {
     ngAfterContentInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ListComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ListComponent, "yuv-list", never, { "preventChangeUntil": { "alias": "preventChangeUntil"; "required": false; "isSignal": true; }; "multiselect": { "alias": "multiselect"; "required": false; "isSignal": true; }; "selfHandleSelection": { "alias": "selfHandleSelection"; "required": false; "isSignal": true; }; "autoSelect": { "alias": "autoSelect"; "required": false; "isSignal": true; }; "disableSelection": { "alias": "disableSelection"; "required": false; "isSignal": true; }; }, { "itemSelect": "itemSelect"; "itemFocus": "itemFocus"; }, ["items"], ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListComponent, "yuv-list", never, { "preventChangeUntil": { "alias": "preventChangeUntil"; "required": false; "isSignal": true; }; "multiselect": { "alias": "multiselect"; "required": false; "isSignal": true; }; "selfHandleSelection": { "alias": "selfHandleSelection"; "required": false; "isSignal": true; }; "selfHandleClick": { "alias": "selfHandleClick"; "required": false; "isSignal": true; }; "autoSelect": { "alias": "autoSelect"; "required": false; "isSignal": true; }; "disableSelection": { "alias": "disableSelection"; "required": false; "isSignal": true; }; }, { "itemSelect": "itemSelect"; "itemFocus": "itemFocus"; }, ["items"], ["*"], true, never>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuuvis/client-framework",
-  "version": "2.6.3",
+  "version": "2.7.0",
   "author": "OPTIMAL SYSTEMS GmbH <npm@optimal-systems.de>",
   "license": "MIT",
   "peerDependencies": {
@@ -8,15 +8,15 @@
     "@angular/common": "^19.2.1",
     "@angular/core": "^19.2.1",
     "angular-gridster2": "^19.0.0",
-    "@yuuvis/client-core": "^2.6.3",
-    "@yuuvis/client-shell-core": "^2.6.3",
+    "@yuuvis/client-core": "^2.7.0",
+    "@yuuvis/client-shell-core": "^2.7.0",
     "ng-dynamic-component": "^10.8.2",
     "modern-normalize": "^3.0.1"
   },
   "dependencies": {
     "@angular/material": "^19.2.15",
     "@ngrx/signals": "^19.2.0",
-    "@yuuvis/material": "2.6.3",
+    "@yuuvis/material": "2.7.0",
     "@yuuvis/media-viewer": "^2.0.12",
     "angular-split": "^19.0.0",
     "vis-network": "^10.0.2",
@@ -108,14 +108,14 @@
       "types": "./object-versions/index.d.ts",
       "default": "./fesm2022/yuuvis-client-framework-object-versions.mjs"
     },
-    "./overflow-menu": {
-      "types": "./overflow-menu/index.d.ts",
-      "default": "./fesm2022/yuuvis-client-framework-overflow-menu.mjs"
-    },
     "./overflow-hidden": {
       "types": "./overflow-hidden/index.d.ts",
       "default": "./fesm2022/yuuvis-client-framework-overflow-hidden.mjs"
     },
+    "./overflow-menu": {
+      "types": "./overflow-menu/index.d.ts",
+      "default": "./fesm2022/yuuvis-client-framework-overflow-menu.mjs"
+    },
     "./pagination": {
       "types": "./pagination/index.d.ts",
       "default": "./fesm2022/yuuvis-client-framework-pagination.mjs"
@@ -124,6 +124,10 @@
       "types": "./popout/index.d.ts",
       "default": "./fesm2022/yuuvis-client-framework-popout.mjs"
     },
+    "./query-list": {
+      "types": "./query-list/index.d.ts",
+      "default": "./fesm2022/yuuvis-client-framework-query-list.mjs"
+    },
     "./renderer": {
       "types": "./renderer/index.d.ts",
       "default": "./fesm2022/yuuvis-client-framework-renderer.mjs"
@@ -140,22 +144,22 @@
       "types": "./sort/index.d.ts",
       "default": "./fesm2022/yuuvis-client-framework-sort.mjs"
     },
-    "./tile-list": {
-      "types": "./tile-list/index.d.ts",
-      "default": "./fesm2022/yuuvis-client-framework-tile-list.mjs"
-    },
     "./split-view": {
       "types": "./split-view/index.d.ts",
       "default": "./fesm2022/yuuvis-client-framework-split-view.mjs"
     },
-    "./upload-progress": {
-      "types": "./upload-progress/index.d.ts",
-      "default": "./fesm2022/yuuvis-client-framework-upload-progress.mjs"
+    "./tile-list": {
+      "types": "./tile-list/index.d.ts",
+      "default": "./fesm2022/yuuvis-client-framework-tile-list.mjs"
     },
     "./tree": {
       "types": "./tree/index.d.ts",
       "default": "./fesm2022/yuuvis-client-framework-tree.mjs"
     },
+    "./upload-progress": {
+      "types": "./upload-progress/index.d.ts",
+      "default": "./fesm2022/yuuvis-client-framework-upload-progress.mjs"
+    },
     "./widget-grid": {
       "types": "./widget-grid/index.d.ts",
       "default": "./fesm2022/yuuvis-client-framework-widget-grid.mjs"

package/query-list/README.md

@@ -0,0 +1,3 @@
+# @yuuvis/client-framework/query-list
+
+Secondary entry point of `@yuuvis/client-framework`. It can be used by importing from `@yuuvis/client-framework/query-list`.

package/query-list/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/query-list.module';
+export * from './lib/query-list.component';

package/query-list/lib/query-list.component.d.ts

@@ -0,0 +1,139 @@
+import { TemplateRef } from '@angular/core';
+import { PageEvent } from '@angular/material/paginator';
+import { SearchQuery, SearchResultItem } from '@yuuvis/client-core';
+import { ListComponent } from '@yuuvis/client-framework/list';
+import { Pagination } from '@yuuvis/client-framework/pagination';
+import * as i0 from "@angular/core";
+/**
+ * Component to display a list of items based on a search query.
+ * It will execute the query and render the results using the provided item template.
+ *
+ * The component supports pagination, multi-selection, and drag selection.
+ *
+ * If you don't provide a transformer function, the raw SearchResultItem objects will be
+ * used as items and passed to the template. The transformer function allows you to map
+ * the SearchResultItem objects to a custom format before rendering.
+ *
+ * Example usage:
+ * ```html
+ * <yuv-query-list [transformer]="transformResult" [query]="query" (itemSelect)="onItemSelect($event)">
+    
+    <!-- template used to render result item -->
+    <ng-template #yuvQueryListItem let-item>
+      <yuv-list-tile>
+        <ng-template #titleSlot>{{ item.id }}</ng-template>
+        <ng-template #descriptionSlot>{{ item.modified }}</ng-template>
+      </yuv-list-tile>
+    </ng-template>
+
+    <!-- Content to display when the list is empty -->
+    <ng-template #yuvQueryListEmpty>
+      <div>No documents found.</div>
+    </ng-template>
+
+  </yuv-query-list>
+ * ```
+ *
+ * ```ts
+ * @Component({...})
+ * export class TestQueryListComponent {
+ *  query = 'SELECT * FROM system:document';
+ *
+ *  transformResult = (items: SearchResultItem[]) =>
+ *   items.map((item) => ({
+ *     id: item.fields.get(BaseObjectTypeField.OBJECT_ID),
+ *     modified: item.fields.get(BaseObjectTypeField.MODIFICATION_DATE)
+ *   }));
+ * } *
+ * ```
+ */
+export declare class QueryListComponent {
+    #private;
+    list: import("@angular/core").Signal<ListComponent>;
+    itemTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    emptyTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    isTouchDevice: boolean;
+    /**
+     * The query to execute (SearchQuery object or CMIS query string).
+     */
+    query: import("@angular/core").InputSignal<string | SearchQuery | null | undefined>;
+    /**
+     * Optional transformer function to map SearchResultItem to a custom format.
+     */
+    transformer: import("@angular/core").InputSignal<((items: SearchResultItem[]) => unknown[]) | null | undefined>;
+    /**
+     * Function that returns `true` if selection changes should be prevented.
+     * This can be used to temporarily block selection changes, e.g. while
+     * there is a pending change inside another component that refers to the
+     * current selection.
+     */
+    preventChangeUntil: import("@angular/core").InputSignal<() => boolean>;
+    /**
+     * Event emitted when items are selected. Emits an array of selected item indices.
+     *
+     */
+    itemSelect: import("@angular/core").OutputEmitterRef<number[]>;
+    /**
+     * Event emitted during drag selection, providing the current selection of item indices.
+     */
+    dragSelectChange: import("@angular/core").OutputEmitterRef<number[]>;
+    /**
+     * Event emitted when an item is double-clicked, providing the index of the item.
+     */
+    itemDoubleClick: import("@angular/core").OutputEmitterRef<number>;
+    /**
+     * Event emitted when the query result is available, providing total count of items.
+     */
+    queryResult: import("@angular/core").OutputEmitterRef<{
+        totalCount: number;
+    }>;
+    /**
+     * The list of result items after applying the optional transformer.
+     */
+    resultItems: import("@angular/core").Signal<unknown[]>;
+    /**
+     * Number of items to fetch per page when executing the query.
+     * @default SearchService.DEFAULT_QUERY_SIZE
+     */
+    pageSize: import("@angular/core").InputSignal<number>;
+    /**
+     * Enables or disables drag selection of items. If `true`, users can select multiple items by dragging the mouse.
+     * @default true
+     */
+    enableDragSelect: import("@angular/core").InputSignal<boolean>;
+    /**
+     * Sets up the ability to select multiple tiles
+     * @default false
+     */
+    multiselect: import("@angular/core").InputSignal<boolean>;
+    /**
+     * If `true`, the component will handle selection itself. This means that
+     * the parent component will be responsible for styling the selected and
+     * focused items. If `false`, the component will take care of visualizing
+     * the selection and focus states.
+     * @default false
+     */
+    selfHandleSelection: import("@angular/core").InputSignal<boolean>;
+    /**
+     * Indicator signal whether a query is currently being executed.
+     * You could use this to show a loading indicator in the UI.
+     */
+    busy: import("@angular/core").WritableSignal<boolean>;
+    pagination?: Pagination;
+    onItemClick(idx: number, event: MouseEvent): void;
+    onItemDoubleClick(idx: number, event: MouseEvent): void;
+    onDragSelectChange(sel: number[]): void;
+    onDragSelect(sel: number[]): void;
+    /**
+     * Selects multiple items in the list.
+     */
+    multiSelect(index: number[]): void;
+    /**
+     * Refreshes the list by re-executing the current query/page.
+     */
+    refresh(): void;
+    changePage(pe: PageEvent): void;
+    goToPage(page: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QueryListComponent, "yuv-query-list", never, { "query": { "alias": "query"; "required": false; "isSignal": true; }; "transformer": { "alias": "transformer"; "required": false; "isSignal": true; }; "preventChangeUntil": { "alias": "preventChangeUntil"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "enableDragSelect": { "alias": "enableDragSelect"; "required": false; "isSignal": true; }; "multiselect": { "alias": "multiselect"; "required": false; "isSignal": true; }; "selfHandleSelection": { "alias": "selfHandleSelection"; "required": false; "isSignal": true; }; }, { "itemSelect": "itemSelect"; "dragSelectChange": "dragSelectChange"; "itemDoubleClick": "itemDoubleClick"; "queryResult": "queryResult"; }, ["itemTemplate", "emptyTemplate"], never, true, never>;
+}

package/query-list/lib/query-list.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./query-list.component";
+export declare class YuvQueryListModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<YuvQueryListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<YuvQueryListModule, never, [typeof i1.QueryListComponent], [typeof i1.QueryListComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<YuvQueryListModule>;
+}