@quadrel-enterprise-ui/framework 19.0.0-beta.2 → 19.0.0

package/lib/core/core.module.d.ts

@@ -9,6 +9,7 @@ import { QdTranslatable, QdTranslation } from './model/translation.interface';
 import { QdVisuallyHiddenDirective } from './visually-hidden/visually-hidden.directive';
 import { QdPushEventsService } from './services/push-events.service';
 import { QD_POPOVER_TOP_FIRST } from './popover/popover-top-first.token';
+import { QD_SAFE_BOTTOM_OFFSET } from './model/safe-bottom-offset.token';
 import * as i0 from "@angular/core";
 import * as i1 from "./disabled/disabled.directive";
 import * as i2 from "./pipes/file-size.pipe";
@@ -20,7 +21,7 @@ import * as i7 from "@angular/common";
 import * as i8 from "@ngx-translate/core";
 import * as i9 from "./data-facets/data-facets.module";
 import * as i10 from "./breadcrumbs/breadcrumbs.module";
-export { QdAppEnvironment, QdDisabledDirective, QdFileSizePipe, QdPlaceholderPipe, QdProjectionGuardComponent, QdRwdDisabledDirective, QdTooltipAtIntersectionDirective, QdTranslatable, QdTranslation, QdVisuallyHiddenDirective, QdPushEventsService, QD_POPOVER_TOP_FIRST };
+export { QdAppEnvironment, QdDisabledDirective, QdFileSizePipe, QdPlaceholderPipe, QdProjectionGuardComponent, QdRwdDisabledDirective, QdTooltipAtIntersectionDirective, QdTranslatable, QdTranslation, QdVisuallyHiddenDirective, QdPushEventsService, QD_POPOVER_TOP_FIRST, QD_SAFE_BOTTOM_OFFSET };
 export declare class QdCoreModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<QdCoreModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<QdCoreModule, [typeof i1.QdDisabledDirective, typeof i2.QdFileSizePipe, typeof i3.QdPlaceholderPipe, typeof i4.QdProjectionGuardComponent, typeof i5.QdRwdDisabledDirective, typeof i6.QdVisuallyHiddenDirective], [typeof i7.CommonModule, typeof i8.TranslateModule, typeof i9.QdDataFacetsModule, typeof i10.QdBreadcrumbsModule], [typeof i1.QdDisabledDirective, typeof i2.QdFileSizePipe, typeof i3.QdPlaceholderPipe, typeof i4.QdProjectionGuardComponent, typeof i5.QdRwdDisabledDirective, typeof i6.QdVisuallyHiddenDirective]>;

package/lib/core/model/safe-bottom-offset.token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+export declare const QD_SAFE_BOTTOM_OFFSET: InjectionToken<BehaviorSubject<number>>;

package/lib/core/services/push-events.service.d.ts

@@ -9,12 +9,15 @@ export type EventName = 'RESOURCE_CREATED' | 'RESOURCE_UPDATED' | 'RESOURCE_DELE
  * - **Real-Time Interaction**: Enables live updates without user actions or polling.
  * - **Scalable and Flexible**: The system is flexible and easily expandable to handle new events.
  * - **Consistency**: Ensures synchronization between server and client states for a consistent user experience.
+ * - **Authorization**: It uses the user's authentication (QdAuth) to secure the connection against the backend out-of-the-box. This requires a proper QdAuth setup. You can disable this feature when starting the connection.
  *
  * ### Usage
  *
  * ```ts
  * // Start the connection to the events
  * pushEventsService.connect('http://service-endpint/events');
+ * // or start without authentication in case you don't need:
+ * pushEventsService.connect('http://service-endpint/events', { disableAuthentication: true });
  *
  * // Subscribe to the event (Side Effect)
  * const subscription = pushEventsService.observe('RESOURCE_UPDATED').subscribe(event => handleEvent(event));
@@ -27,20 +30,28 @@ export type EventName = 'RESOURCE_CREATED' | 'RESOURCE_UPDATED' | 'RESOURCE_DELE
  * ```
  */
 export declare class QdPushEventsService {
+    private readonly authenticationService;
     private _eventSource;
     private _eventSubscriptionSubjects;
     private _listeners;
     private _heartbeatTimeout;
     private _reconnectDelayTime;
     private _heartbeatReconnectDelayTime;
+    private _accessTokenSub?;
+    private _options;
+    private _isUnauthorized;
+    constructor(authenticationService: any);
     /**
      * Establishes an EventSource connection to the given URL.
      * Automatically reconnects if heartbeat fails or is delayed.
      * Subscribers are retained across reconnections.
      *
      * @param url The backend URL for the event stream.
+     * @param options Options for the connection
      */
-    connect(url: string): void;
+    connect(url: string, options?: {
+        disableAuthentication: boolean;
+    }): void;
     /**
      * Closes the EventSource connection and clears all listeners.
      * Subscribers are preserved for reconnection.
@@ -71,6 +82,7 @@ export declare class QdPushEventsService {
     private removeAllEventListenersFromEventSource;
     private logWarn;
     private logError;
-    static ɵfac: i0.ɵɵFactoryDeclaration<QdPushEventsService, never>;
+    private connectEventSource;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QdPushEventsService, [{ optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<QdPushEventsService>;
 }

package/lib/forms/datepicker/calendar/calendar.component.d.ts

@@ -1,6 +1,13 @@
 import { EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
 import { Moment } from 'moment';
 import { QdCalendarDay, QdCalendarMode, QdDisabledDates } from '../../model/datepicker';
+/**
+ * DO NOT REMOVE — Vite/ESM does not bundle Moment locales automatically.
+ * These side-effect imports register de/fr/it for month and weekday names.
+ */
+import 'moment/locale/de';
+import 'moment/locale/fr';
+import 'moment/locale/it';
 import * as i0 from "@angular/core";
 export declare class QdCalendarComponent implements OnInit, OnChanges {
     /**
@@ -52,6 +59,7 @@ export declare class QdCalendarComponent implements OnInit, OnChanges {
     private setCurrentDate;
     private getYears;
     private isDisabled;
+    private setWeekdays;
     static ɵfac: i0.ɵɵFactoryDeclaration<QdCalendarComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<QdCalendarComponent, "qd-calendar", never, { "selectedDate": { "alias": "selectedDate"; "required": false; }; "language": { "alias": "language"; "required": false; }; "disabledDates": { "alias": "disabledDates"; "required": false; }; }, { "selectedChange": "selectedChange"; }, never, never, false, never>;
 }

package/lib/forms/input/input.component.d.ts

@@ -329,6 +329,7 @@ export declare class QdInputComponent implements OnInit, OnChanges, OnDestroy, C
     private initializeOptionsResolver;
     private emitValue;
     private initOpModeSubscription;
+    private normalizeInitialControlValueIfNeeded;
     static ɵfac: i0.ɵɵFactoryDeclaration<QdInputComponent, [null, null, { optional: true; host: true; skipSelf: true; }, { optional: true; }]>;
     static ɵcmp: i0.ɵɵComponentDeclaration<QdInputComponent, "qd-input", never, { "formControlName": { "alias": "formControlName"; "required": false; }; "value": { "alias": "value"; "required": false; }; "config": { "alias": "config"; "required": false; }; "isError": { "alias": "isError"; "required": false; }; "testId": { "alias": "data-test-id"; "required": false; }; }, { "valueChange": "valueChange"; "enterClick": "enterClick"; "clickClear": "clickClear"; "clickHint": "clickHint"; "clickReadonly": "clickReadonly"; "clickViewonly": "clickViewonly"; }, never, ["[qdIconButton]"], false, never>;
 }

package/lib/forms/model/form-input.d.ts

@@ -0,0 +1,9 @@
+import { QdFormBaseOption, QdFormBaseOptions } from './options.interface';
+/**
+ * @deprecated Use `QdFormBaseOption` instead.
+ */
+export type QdFormInput = QdFormBaseOption;
+/**
+ * @deprecated Use `QdFormBaseOptions` instead.
+ */
+export type QdFormInputs = QdFormBaseOptions;

package/lib/forms/qd-form.module.d.ts

@@ -1,11 +1,16 @@
-import { QD_FORM_OPTIONS_RESOLVER, QdFormOptionsResolver } from './model/form-options-resolver';
 import { QdCheckboxChipsComponent } from './checkbox-chips/checkbox-chips.component';
 import { QdCheckboxComponent } from './checkboxes/checkbox/checkbox.component';
 import { QdCheckboxesComponent } from './checkboxes/checkboxes.component';
 import { QdDatepickerComponent } from './datepicker/datepicker.component';
 import { QdDropdownComponent } from './dropdown/dropdown.component';
+import { QdFileUploadComponent } from './file-upload/file-upload.component';
+import { QD_FILE_UPLOAD_MANAGER_TOKEN, QD_UPLOAD_HTTP_OPTIONS, QdFileUploadManager } from './file-upload/model/file-upload.model';
+import { QdFileUploadService } from './file-upload/services/file-upload.service';
 import { QdFormsComponent } from './forms/forms.component';
 import { QdInputComponent } from './input/input.component';
+import { QdFormInput } from './model/form-input';
+import { QD_FORM_OPTIONS_RESOLVER, QdFormOptionsResolver } from './model/form-options-resolver';
+import { QdFormCheckboxChipsConfiguration, QdFormCheckboxesConfiguration, QdFormDatepickerConfiguration, QdFormDropdownConfiguration, QdFormFileUploadConfiguration, QdFormInputConfiguration, QdFormMultiInputConfiguration, QdFormPinCodeConfiguration, QdFormRadioButtonsConfiguration, QdFormSwitchesConfiguration, QdFormTextAreaConfiguration, QdRichtextConfig } from './model/forms.interface';
 import { QdMultiInputComponent } from './multi-input/multi-input.component';
 import { QdPinCodeComponent } from './pin-code/pin-code.component';
 import { QdRadioButtonsComponent } from './radio-buttons/radio-buttons.component';
@@ -19,10 +24,6 @@ import { QdValidators } from './shared/validators/validators';
 import { QdSwitchComponent } from './switches/switch/switch.component';
 import { QdSwitchesComponent } from './switches/switches.component';
 import { QdTextareaComponent } from './textarea/textarea.component';
-import { QdFileUploadComponent } from './file-upload/file-upload.component';
-import { QdFileUploadService } from './file-upload/services/file-upload.service';
-import { QD_FILE_UPLOAD_MANAGER_TOKEN, QD_UPLOAD_HTTP_OPTIONS, QdFileUploadManager } from './file-upload/model/file-upload.model';
-import { QdFormCheckboxChipsConfiguration, QdFormCheckboxesConfiguration, QdFormDatepickerConfiguration, QdFormDropdownConfiguration, QdFormFileUploadConfiguration, QdFormInputConfiguration, QdFormMultiInputConfiguration, QdFormPinCodeConfiguration, QdFormRadioButtonsConfiguration, QdFormSwitchesConfiguration, QdFormTextAreaConfiguration, QdRichtextConfig } from './model/forms.interface';
 import * as i0 from "@angular/core";
 import * as i1 from "./datepicker/calendar/calendar.component";
 import * as i2 from "./checkbox-chips/checkbox-chips.component";
@@ -64,7 +65,7 @@ import * as i37 from "../icon/icon.module";
 import * as i38 from "../core/popover/popover.module";
 import * as i39 from "../core/tooltip/tooltip.module";
 import * as i40 from "ngx-editor";
-export { QD_FILE_UPLOAD_MANAGER_TOKEN, QD_FORM_OPTIONS_RESOLVER, QD_UPLOAD_HTTP_OPTIONS, QdCheckboxChipsComponent, QdCheckboxComponent, QdCheckboxesComponent, QdDatepickerComponent, QdDropdownComponent, QdFileUploadComponent, QdFileUploadManager, QdFileUploadService, QdFilterFormItemsComponent, QdFormArray, QdFormBuilder, QdFormCheckboxChipsConfiguration, QdFormCheckboxesConfiguration, QdFormControl, QdFormDatepickerConfiguration, QdFormDropdownConfiguration, QdFormFileUploadConfiguration, QdFormGroup, QdFormInputConfiguration, QdFormMultiInputConfiguration, QdFormOptionsResolver, QdFormPinCodeConfiguration, QdFormRadioButtonsConfiguration, QdFormSwitchesConfiguration, QdFormTextAreaConfiguration, QdFormsComponent, QdInputComponent, QdMultiInputComponent, QdPinCodeComponent, QdRadioButtonsComponent, QdRichtextComponent, QdRichtextConfig, QdSwitchComponent, QdSwitchesComponent, QdTextareaComponent, QdValidators };
+export { QD_FILE_UPLOAD_MANAGER_TOKEN, QD_FORM_OPTIONS_RESOLVER, QD_UPLOAD_HTTP_OPTIONS, QdCheckboxChipsComponent, QdCheckboxComponent, QdCheckboxesComponent, QdDatepickerComponent, QdDropdownComponent, QdFileUploadComponent, QdFileUploadManager, QdFileUploadService, QdFilterFormItemsComponent, QdFormArray, QdFormBuilder, QdFormCheckboxChipsConfiguration, QdFormCheckboxesConfiguration, QdFormControl, QdFormDatepickerConfiguration, QdFormDropdownConfiguration, QdFormFileUploadConfiguration, QdFormGroup, QdFormInput, QdFormInputConfiguration, QdFormMultiInputConfiguration, QdFormOptionsResolver, QdFormPinCodeConfiguration, QdFormRadioButtonsConfiguration, QdFormsComponent, QdFormSwitchesConfiguration, QdFormTextAreaConfiguration, QdInputComponent, QdMultiInputComponent, QdPinCodeComponent, QdRadioButtonsComponent, QdRichtextComponent, QdRichtextConfig, QdSwitchComponent, QdSwitchesComponent, QdTextareaComponent, QdValidators };
 export declare class QdFormModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<QdFormModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<QdFormModule, [typeof i1.QdCalendarComponent, typeof i2.QdCheckboxChipsComponent, typeof i3.QdCheckboxChipsItemComponent, typeof i4.QdCheckboxComponent, typeof i5.QdCheckboxesComponent, typeof i6.QdDatepickerComponent, typeof i7.QdDropdownComponent, typeof i8.QdDropdownOptionsComponent, typeof i9.QdFilterFormItemsComponent, typeof i10.QdFormErrorComponent, typeof i11.QdFormHintComponent, typeof i12.QdFormLabelComponent, typeof i13.QdFormReadonlyComponent, typeof i14.QdFormViewonlyComponent, typeof i15.QdFormsComponent, typeof i16.QdInputComponent, typeof i17.QdInputUnitsComponent, typeof i18.QdInputOptionsDirective, typeof i19.QdInputOptionsComponent, typeof i20.QdMultiInputChipComponent, typeof i21.QdMultiInputMenuComponent, typeof i22.QdMultiInputComponent, typeof i23.QdPinCodeComponent, typeof i24.QdRadioButtonsComponent, typeof i25.QdSwitchComponent, typeof i26.QdSwitchesComponent, typeof i27.QdTextareaComponent, typeof i28.QdFormInputComponent, typeof i29.QdRichtextComponent, typeof i30.QdFileUploadComponent], [typeof i31.CommonModule, typeof i32.FormsModule, typeof i32.ReactiveFormsModule, typeof i33.TranslateModule, typeof i34.QdAutofocusModule, typeof i35.QdChipModule, typeof i36.QdCoreModule, typeof i37.QdIconModule, typeof i38.QdPopoverModule, typeof i39.QdTooltipModule, typeof i40.NgxEditorModule], [typeof i2.QdCheckboxChipsComponent, typeof i4.QdCheckboxComponent, typeof i5.QdCheckboxesComponent, typeof i6.QdDatepickerComponent, typeof i7.QdDropdownComponent, typeof i9.QdFilterFormItemsComponent, typeof i15.QdFormsComponent, typeof i16.QdInputComponent, typeof i22.QdMultiInputComponent, typeof i23.QdPinCodeComponent, typeof i24.QdRadioButtonsComponent, typeof i25.QdSwitchComponent, typeof i26.QdSwitchesComponent, typeof i27.QdTextareaComponent, typeof i29.QdRichtextComponent, typeof i30.QdFileUploadComponent]>;

package/lib/notifications/directives/snackbar-listener.directive.d.ts

@@ -1,21 +1,45 @@
-import { Overlay, OverlayPositionBuilder } from '@angular/cdk/overlay';
 import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { Overlay, OverlayPositionBuilder } from '@angular/cdk/overlay';
+import { BehaviorSubject } from 'rxjs';
 import { QdSnackbarService } from '../services/snackbar.service';
 import * as i0 from "@angular/core";
 /**
- * **QdNotificationsSnackbarListener** provides a CDK overlay for the **QdNotificationsSnackbar**.
+ * Shows notifications as a snackbar.
+ *
+ * #### **Behavior**
+ * - Appears in the bottom-right corner.
+ * - Adapts to the QLS (e.g., stays above a PageFooter).
+ * - Behavior is configurable via `snackbarOptions` (e.g., lifetime, close button, handlers).
+ *
+ * #### **Usage**
+ * ```html
+ *   <qd-shell [config]="shellConfig" qdSnackbarListener>
+ * ```
+ *
+ * #### **Snackbar Configuration**
+ * ```ts
+ * {
+ *   showAsSnackbar: true,
+ *   snackbarOptions?: {
+ *     ...
+ *   }
+ * }
+ * ```
  */
 export declare class QdNotificationsSnackbarListenerDirective implements OnInit, OnDestroy {
     private snackbarService;
     private hostRef;
     private overlay;
     private overlayPositionBuilder;
-    private overlayRef;
-    private destroyed$;
-    constructor(snackbarService: QdSnackbarService, hostRef: ElementRef<HTMLElement>, overlay: Overlay, overlayPositionBuilder: OverlayPositionBuilder);
+    private safeBottomOffset$;
+    private _overlayRef;
+    private _destroyed$;
+    constructor(snackbarService: QdSnackbarService, hostRef: ElementRef<HTMLElement>, overlay: Overlay, overlayPositionBuilder: OverlayPositionBuilder, safeBottomOffset$: BehaviorSubject<number>);
     ngOnInit(): void;
-    private registerHost;
     ngOnDestroy(): void;
+    private initOverlay;
+    private observeSafeBottomOffset;
+    private bottomRightPositions;
     static ɵfac: i0.ɵɵFactoryDeclaration<QdNotificationsSnackbarListenerDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<QdNotificationsSnackbarListenerDirective, "[qdSnackbarListener]", never, {}, {}, never, never, false, never>;
 }

package/lib/page/model/page-config.interface.d.ts

@@ -1,3 +1,4 @@
+import { Observable } from 'rxjs';
 import { QdMenuButtonActionConfig } from '../../button/model/button-config';
 import { QdPageHeaderFacetConfig } from './page-header-facet.interface';
 /**
@@ -368,9 +369,17 @@ export interface QdPageSaveAction {
         i18n: string;
     };
     /**
-     * @description Handler function that is triggered when the save action is executed.
+     * @description Triggered when the save action is executed.
+     *
+     * Success criteria:
+     * - If the handler returns an Observable<boolean>, only the first emission after the save click counts:
+     *   - **true:** success - toggle to view and apply the saved values
+     *   - **false:** failure/cancel - stay in edit mode
+     * - If the handler returns no Observable (void), the save is treated as instant success (toggle + apply values).
+     *
+     * On a successful save, the framework applies the values and resets its internal validation and change-tracking state.
      */
-    handler: (formValues?: any) => void;
+    handler: (formValues?: any) => void | Observable<boolean>;
     /**
      * @description Optional validation flag, defaults to true.
      * Determines whether form validation is required before saving and ensures that changes must be present in the form before saving.

package/lib/page/page.component.d.ts

@@ -1,5 +1,5 @@
 import { AfterViewInit, EventEmitter, OnChanges, OnDestroy, OnInit, QueryList, SimpleChanges } from '@angular/core';
-import { Observable } from 'rxjs';
+import { BehaviorSubject, Observable } from 'rxjs';
 import { QdDialogService } from '../dialog/dialog.module';
 import { QdPageStepperAdapterDirective } from '../page-stepper/adaptors/page-stepper-adapter.directive';
 import { QdPageStepperComponent } from '../page-stepper/page-stepper.component';
@@ -398,6 +398,7 @@ export declare class QdPageComponent<T extends object> implements OnInit, OnChan
     private readonly formGroupManagerService;
     private readonly submitActionService;
     private readonly dialog;
+    private bottomOffset$?;
     /**
      * This property defines the configuration for the QdPage component, including the page type,
      * title, and specific configurations for each type of page.
@@ -429,7 +430,7 @@ export declare class QdPageComponent<T extends object> implements OnInit, OnChan
     get hasNavigation(): boolean;
     get footerVisible(): boolean | undefined;
     get hasInfoBanners(): boolean;
-    constructor(pageStoreService: QdPageStoreService<T>, footerService: QdPageFooterService, formGroupManagerService: QdFormGroupManagerService, submitActionService: QdPageSubmitActionService, dialog: QdDialogService);
+    constructor(pageStoreService: QdPageStoreService<T>, footerService: QdPageFooterService, formGroupManagerService: QdFormGroupManagerService, submitActionService: QdPageSubmitActionService, dialog: QdDialogService, bottomOffset$?: BehaviorSubject<number>);
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
     ngAfterViewInit(): void;
@@ -442,6 +443,6 @@ export declare class QdPageComponent<T extends object> implements OnInit, OnChan
     private generateFooterActionHandler;
     private setupSubmitActionValidation;
     private initSubmitValidation;
-    static ɵfac: i0.ɵɵFactoryDeclaration<QdPageComponent<any>, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QdPageComponent<any>, [null, null, null, null, null, { optional: true; }]>;
     static ɵcmp: i0.ɵɵComponentDeclaration<QdPageComponent<any>, "qd-page", never, { "config": { "alias": "config"; "required": true; }; "testId": { "alias": "data-test-id"; "required": false; }; }, { "operationModeChanged": "operationModeChanged"; }, ["controlPanel", "stepperComponent", "tabsComponent", "stepperAdapterDirective", "tabsAdapterDirective", "sections", "infoBanners"], ["qd-page-info-banner", "qd-page-stepper", "[qdPageStepperAdapter]", "qd-page-tabs", "[qdPageTabsAdapter]", "qd-section", "[qdSectionAdapter]", "[qdPageFooter]", "qd-page-control-panel", "*"], false, never>;
 }

package/lib/section/section.component.d.ts

@@ -1,4 +1,4 @@
-import { AfterViewInit, ElementRef, EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
 import { QdFilterService } from '../filter/filter-service/filter.service';
 import { QdFilterPostBodyData } from '../filter/model/filter-post-body.interface';
 import { QdSearchPostBodyData } from '../search/model/search-post-body';
@@ -64,6 +64,7 @@ export declare class QdSectionComponent implements OnInit, AfterViewInit, OnChan
     private readonly actionService;
     private readonly filterService;
     private readonly elementRef;
+    private readonly cdr;
     /**
      * The configuration of the section.
      */
@@ -100,7 +101,7 @@ export declare class QdSectionComponent implements OnInit, AfterViewInit, OnChan
     filterValueChangeOutput: EventEmitter<QdFilterPostBodyData>;
     noHorizontalPaddingMobile: boolean;
     private _outputSubscriptions;
-    constructor(searchService: QdSearchService, actionService: QdSectionToolbarActionService, filterService: QdFilterService, elementRef: ElementRef);
+    constructor(searchService: QdSearchService, actionService: QdSectionToolbarActionService, filterService: QdFilterService, elementRef: ElementRef, cdr: ChangeDetectorRef);
     ngOnInit(): void;
     ngAfterViewInit(): void;
     ngOnChanges(changes: SimpleChanges): void;

package/lib/table/__mocks__/mock-secondary-actions.service.d.ts

@@ -0,0 +1,13 @@
+import { QdTableSecondaryAction } from '../model/table-config-actions.interface';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class QdMockTableSecondaryActionsService<T extends string> {
+    private _i18nsSubject;
+    private _secondaryActionsConfigSubject;
+    set i18ns(i18ns: any);
+    get i18ns$(): Observable<string>;
+    set secondaryActionsConfig(secondaryActions: QdTableSecondaryAction<T>[]);
+    get secondaryActionsConfig$(): Observable<QdTableSecondaryAction<T>[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QdMockTableSecondaryActionsService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QdMockTableSecondaryActionsService<any>>;
+}

package/lib/table/model/table-data-resolver.d.ts

@@ -36,11 +36,11 @@ export interface QdTableDataResolverProps<T extends string> {
     /**
      * The index of the page to resolve. Corresponds to the 'page' parameter in Pageable.
      */
-    page: number;
+    page?: number;
     /**
      * The number of items per page. Corresponds to the 'size' parameter in Pageable.
      */
-    size: number;
+    size?: number;
     /**
      * The Sort object. To obtain the query string compliant with Spring Boot's conventions, use the helper method "QdTableSpringTools.sortParameterize".
      */

package/lib/table/services/resolver.service.d.ts

@@ -11,9 +11,10 @@ export declare class QdTableResolverService<T extends string> implements OnDestr
     private readonly actionResultService;
     private _destroyed$;
     private _refreshSubscription;
+    private _hasPagination;
     constructor(tableDataResolver: QdTableDataResolver<T>, tableStoreService: QdTableStoreService<T>, translateService: TranslateService, actionResultService: QdTableExternalActionResultService);
     ngOnDestroy(): void;
-    init(refreshOnLanguageChange?: boolean): void;
+    init(refreshOnLanguageChange?: boolean, hasPagination?: boolean): void;
     refresh(resolverOptions?: {
         pageIndex?: number;
     }): void;

package/lib/table/store/table-store-selector.service.d.ts

@@ -3,7 +3,7 @@ import { QdTableConnectorState } from '../model/connectors-state.enum';
 import { QdSortDirection } from '../model/sort-direction.enum';
 import { QdTableRequestState } from '../model/table-data-resolver';
 import { QdTableData, QdTableDataRow, QdTableRecentSecondaryAction, QdTableRowIdentifier } from '../model/table-data.interface';
-import { QdTableDataResolutionCriteria, QdTableState, QdTableStoreData } from '../model/table-store.interface';
+import { QdTableDataResolutionCriteria, QdTableState, QdTableStore, QdTableStoreData } from '../model/table-store.interface';
 import * as i0 from "@angular/core";
 export declare class QdTableStoreSelectorService {
     private _tableId?;
@@ -39,7 +39,7 @@ export declare class QdTableStoreSelectorService {
     columnSortDirection(column: string): MemoizedSelector<any, QdSortDirection, (s1: QdTableStoreData<any>) => QdSortDirection>;
     selectIsLoading(): MemoizedSelector<any, boolean, (s1: QdTableStoreData<any>) => boolean>;
     selectConnectorState(connectorName: string): MemoizedSelector<any, QdTableConnectorState, (s1: QdTableStoreData<any>) => QdTableConnectorState>;
-    selectDataResolutionCriteria(): MemoizedSelector<any, QdTableDataResolutionCriteria<any>, (s1: QdTableStoreData<any>) => any>;
+    selectDataResolutionCriteria(): MemoizedSelector<QdTableStore<any>, QdTableDataResolutionCriteria<any> | undefined>;
     private selectTables;
     private getTable;
     static ɵfac: i0.ɵɵFactoryDeclaration<QdTableStoreSelectorService, never>;

package/lib/table/store/table-store.service.d.ts

@@ -18,7 +18,7 @@ export declare class QdTableStoreService<T extends string> {
     /**
      * Actions
      */
-    initTableState(data: QdTableData<T> | QdTreeData<T>, hasResolver: boolean, connectors: QdTableConnector[]): void;
+    initTableState(data: QdTableData<T> | QdTreeData<T>, hasResolver: boolean, connectors: QdTableConnector[], hasPagination?: boolean): void;
     initTableStateSelectedRows(selectedRows: QdTableRowIdentifier[]): void;
     updateTableStateData(data: QdTableData<T> | QdTreeData<T>): void;
     updateTableStateRowToSelected(rowIndex: number): void;

package/lib/table/store/table.actions.d.ts

@@ -11,11 +11,13 @@ export declare const QdTableActions: {
         data: QdTableData<string> | QdTreeData<string>;
         hasResolver: boolean;
         connectors: QdTableConnector[];
+        hasPagination: boolean;
     }) => {
         tableId: string;
         data: QdTableData<string> | QdTreeData<string>;
         hasResolver: boolean;
         connectors: QdTableConnector[];
+        hasPagination: boolean;
     } & import("@ngrx/store").Action<"[QdUi Table] Init Table">>;
     initTableStateSelectedRows: import("@ngrx/store").ActionCreator<"[QdUi Table] Init Selected Rows", (props: {
         tableId: string;

package/lib/table/table.component.d.ts

@@ -23,7 +23,7 @@ import * as i0 from "@angular/core";
  * #### **Features**
  * - **RWD Ready**: Automatically adapts to various screen sizes.
  * - **Custom Columns**: Define content types like text, date, chip, or icon.
- * - **Pagination & Sorting**: Supports data pagination and column sorting.
+ * - **Pagination & Sorting**: Supports data pagination and column sorting. Pagination is optional.
  * - **Row Selections**: Single or multiple row selection.
  * - **Actions**: Primary and secondary row actions with refresh support.
  * - **Internationalization (i18ns)**: Localize column headers and specific content types (e.g., text, chip).
@@ -56,11 +56,13 @@ import * as i0 from "@angular/core";
  *
  * Load data dynamically, manage pagination, and enable column sorting using Quadrel's interface and injection token.
  *
+ * Pagination is optional. If not configured, the full dataset is handled client-side.
+ *
  * ```typescript
  * @Injectable()
  * export class MyTableResolver implements QdTableDataResolver<ColumnDefinition> {
- *   resolve(criteria: QdTableDataResolverProps<ColumnDefinition>): Observable<QdTableResolvedData<ColumnDefinition> {
- *      // custom implementation here
+ *   resolve(criteria: QdTableDataResolverProps<ColumnDefinition>): Observable<QdTableResolvedData<ColumnDefinition>> {
+ *     // custom implementation here
  *   }
  * }
  * ```
@@ -70,24 +72,25 @@ import * as i0 from "@angular/core";
  *   selector: 'my-table',
  *   template: '<qd-table [config]="config"></qd-table>',
  *   providers: [
- *      {
- *          provide: QD_TABLE_DATA_RESOLVER_TOKEN,
- *          useClass: MyTableResolver
- *      }
+ *     {
+ *       provide: QD_TABLE_DATA_RESOLVER_TOKEN,
+ *       useClass: MyTableResolver
+ *     }
  *   ]
  * })
  * class MyTableComponent {
- * config: QdTableConfig<ColumnDefinition> = {
- *   columns: [
- *     { column: 'name', type: 'text', sort: { direction: 'asc' } },
- *     { column: 'age', type: 'integer', sort: {} },
- *     { column: 'active', type: 'boolean' }
- *   ],
- *   pagination: {
- *     pageSizes: [10, 20, 50],
- *     pageSizeDefault: 10
- *   }
- * };
+ *   config: QdTableConfig<ColumnDefinition> = {
+ *     columns: [
+ *       { column: 'name', type: 'text', sort: { direction: 'asc' } },
+ *       { column: 'age', type: 'integer', sort: {} },
+ *       { column: 'active', type: 'boolean' }
+ *     ],
+ *     pagination: {
+ *       pageSizes: [10, 20, 50],
+ *       pageSizeDefault: 10
+ *     } // ← omit this section to disable pagination
+ *   };
+ * }
  * ```
  *
  * #### **Selections and Actions**

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@quadrel-enterprise-ui/framework",
-  "version": "19.0.0-beta.2",
+  "version": "19.0.0",
   "peerDependencies": {
-    "@angular/cdk": "19.2.9",
-    "@angular/common": "19.2.9",
-    "@angular/core": "19.2.9",
-    "@ngrx/store": "19.2.1"
+    "@angular/cdk": "^19.2.9",
+    "@angular/common": "^19.2.9",
+    "@angular/core": "^19.2.9",
+    "@ngrx/store": "^19.2.1"
   },
   "dependencies": {
     "deep-object-diff": "^1.1.7",
@@ -13,7 +13,8 @@
     "uuid": "^9.0.1",
     "moment": "^2.30.1",
     "ngx-editor": "^16.0.1",
-    "@oblique/service-navigation-web-component": "12.2.3"
+    "@oblique/service-navigation-web-component": "12.2.3",
+    "event-source-polyfill": "^1.0.31"
   },
   "module": "fesm2022/quadrel-enterprise-ui-framework.mjs",
   "typings": "index.d.ts",

package/src/assets/styles/settings/_settings.iconFont.scss

@@ -1,4 +1,4 @@
 @font-face {
   font-family: Quadrel-Icon;
-  src: url(data:application/octet-stream;base64,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);
+  src: url(data:application/octet-stream;base64,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);
 }