@odx/angular 6.0.0 → 6.1.0

package/esm2022/components/notification/lib/services/notification-center.service.mjs

@@ -7,6 +7,8 @@ import * as i0 from "@angular/core";
 /**
  * A service for managing the notification center. This service provides functionalities
  * to filter, sort, and manage actions on notifications.
+ *
+ * @internal
  */
 export class NotificationCenterService {
     constructor() {
@@ -15,12 +17,19 @@ export class NotificationCenterService {
         this.notificationService = inject(NotificationService);
         this.notificationQuery = computed(() => getNotificationsByTags(this.currentTag()));
         this.title = signal(null);
+        /** @internal */
         this.title$ = toObservable(this.title).pipe(switchMap((title) => (isObservable(title) ? title : of(title))), shareReplay({ bufferSize: 1, refCount: true }));
+        /** @internal */
         this.notifications$ = combineLatest([toObservable(this.notificationQuery), toObservable(this.currentSortFn)]).pipe(switchMap(([query, sortFn]) => this.notificationService.getNotificationsBy$(query, sortFn)));
+        /** @internal */
         this.unseenNotifications$ = this.notifications$.pipe(map((collection) => collection.values.filter(({ hasBeenSeen }) => !hasBeenSeen)), toNotificationCollection());
+        /** @internal */
         this.onNotificationAdd$ = this.queryEvent(this.notificationService.onNotificationAdd$);
+        /** @internal */
         this.onNotificationUpdate$ = this.queryEvent(this.notificationService.onNotificationUpdate$);
+        /** @internal */
         this.onNotificationRemove$ = this.queryEvent(this.notificationService.onNotificationRemove$);
+        /** @internal */
         this.onNotificationSeen$ = this.queryEvent(this.notificationService.onNotificationSeen$);
     }
     /**
@@ -93,4 +102,4 @@ export class NotificationCenterService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NotificationCenterService, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification-center.service.js","sourceRoot":"","sources":["../../../../../../../../libs/angular/components/notification/src/lib/services/notification-center.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, computed, inject, signal } from '@angular/core';\nimport { toObservable } from '@angular/core/rxjs-interop';\nimport { DynamicTextContent } from '@odx/angular/cdk/dynamic-view';\nimport { Observable, combineLatest, filter, isObservable, map, of, shareReplay, switchMap } from 'rxjs';\nimport { getNotificationsByTags, toNotificationCollection } from '../helpers';\nimport { NotificationRef, NotificationSortFn } from '../models';\nimport { NotificationService } from '../notification.service';\n\n/**\n * A service for managing the notification center. This service provides functionalities\n * to filter, sort, and manage actions on notifications.\n */\n@Injectable()\nexport class NotificationCenterService {\n  private readonly currentTag = signal<string | null>(null);\n  private readonly currentSortFn = signal<NotificationSortFn>(undefined);\n  private readonly notificationService = inject(NotificationService);\n  private readonly notificationQuery = computed(() => getNotificationsByTags(this.currentTag()));\n  private readonly title = signal<DynamicTextContent | null>(null);\n\n  public readonly title$ = toObservable(this.title).pipe(\n    switchMap((title) => (isObservable(title) ? title : of(title))),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n  public readonly notifications$ = combineLatest([toObservable(this.notificationQuery), toObservable(this.currentSortFn)]).pipe(\n    switchMap(([query, sortFn]) => this.notificationService.getNotificationsBy$(query, sortFn)),\n  );\n  public readonly unseenNotifications$ = this.notifications$.pipe(\n    map((collection) => collection.values.filter(({ hasBeenSeen }) => !hasBeenSeen)),\n    toNotificationCollection(),\n  );\n  public onNotificationAdd$ = this.queryEvent(this.notificationService.onNotificationAdd$);\n  public onNotificationUpdate$ = this.queryEvent(this.notificationService.onNotificationUpdate$);\n  public onNotificationRemove$ = this.queryEvent(this.notificationService.onNotificationRemove$);\n  public onNotificationSeen$ = this.queryEvent(this.notificationService.onNotificationSeen$);\n\n  /**\n   * Sets the title for the notification center. The title can be static text or an observable for dynamic content.\n   *\n   * @param {DynamicTextContent | null} [value] - The title content for the notification center.\n   */\n  public setTitle(value?: DynamicTextContent | null): void {\n    this.title.set(value ?? null);\n  }\n\n  /**\n   * Sets the current tag to filter notifications. Only notifications with this tag will be included.\n   *\n   * @param {string | null} [value] - The tag to filter notifications by.\n   */\n  public setTag(value?: string | null): void {\n    this.currentTag.set(value ?? null);\n  }\n\n  /**\n   * Sets the sort function used to order the notifications.\n   *\n   * @param {NotificationSortFn} [value] - The sort function to apply to the notifications.\n   */\n  public setSortFn(value?: NotificationSortFn): void {\n    this.currentSortFn.set(value);\n  }\n\n  /**\n   * Marks a given notification as seen. This does not remove the notification but updates its seen status.\n   *\n   * @param {NotificationRef} notificationRef - The reference to the notification to be marked as seen.\n   */\n  public markAsSeen(notificationRef: NotificationRef): void {\n    this.notificationService.markAsSeen(notificationRef);\n  }\n\n  /**\n   * Marks all current filtered notifications as seen.\n   */\n  public markAllAsSeen(): void {\n    this.notificationService.markAsSeenBy(this.notificationQuery());\n  }\n\n  /**\n   * Dismisses a specific notification.\n   *\n   * @param {NotificationRef} notificationRef - The reference to the notification to dismiss.\n   */\n  public dismiss(notificationRef: NotificationRef): void {\n    this.notificationService.dismiss(notificationRef);\n  }\n\n  /**\n   * Dismisses all notifications that match the current filter criteria.\n   */\n  public dismissAll(): void {\n    this.notificationService.dismissBy(this.notificationQuery());\n  }\n\n  /**\n   * Executes the action associated with a specific notification and marks it as seen.\n   *\n   * @param {NotificationRef} notificationRef - The reference to the notification whose action to execute.\n   */\n  public executeAction(notificationRef: NotificationRef): void {\n    this.markAsSeen(notificationRef);\n    this.notificationService.executeAction(notificationRef);\n  }\n\n  private queryEvent(source$: Observable<NotificationRef>): Observable<NotificationRef> {\n    return combineLatest([source$, toObservable(this.notificationQuery)]).pipe(\n      filter(([notificationRef, query]) => query(notificationRef)),\n      map(([notificationRef]) => notificationRef),\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification-center.service.js","sourceRoot":"","sources":["../../../../../../../../libs/angular/components/notification/src/lib/services/notification-center.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, computed, inject, signal } from '@angular/core';\nimport { toObservable } from '@angular/core/rxjs-interop';\nimport { DynamicTextContent } from '@odx/angular/cdk/dynamic-view';\nimport { Observable, combineLatest, filter, isObservable, map, of, shareReplay, switchMap } from 'rxjs';\nimport { getNotificationsByTags, toNotificationCollection } from '../helpers';\nimport { NotificationRef, NotificationSortFn } from '../models';\nimport { NotificationService } from '../notification.service';\n\n/**\n * A service for managing the notification center. This service provides functionalities\n * to filter, sort, and manage actions on notifications.\n *\n * @internal\n */\n@Injectable()\nexport class NotificationCenterService {\n  private readonly currentTag = signal<string | null>(null);\n  private readonly currentSortFn = signal<NotificationSortFn>(undefined);\n  private readonly notificationService = inject(NotificationService);\n  private readonly notificationQuery = computed(() => getNotificationsByTags(this.currentTag()));\n  private readonly title = signal<DynamicTextContent | null>(null);\n\n  /** @internal */\n  public readonly title$ = toObservable(this.title).pipe(\n    switchMap((title) => (isObservable(title) ? title : of(title))),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  /** @internal */\n  public readonly notifications$ = combineLatest([toObservable(this.notificationQuery), toObservable(this.currentSortFn)]).pipe(\n    switchMap(([query, sortFn]) => this.notificationService.getNotificationsBy$(query, sortFn)),\n  );\n\n  /** @internal */\n  public readonly unseenNotifications$ = this.notifications$.pipe(\n    map((collection) => collection.values.filter(({ hasBeenSeen }) => !hasBeenSeen)),\n    toNotificationCollection(),\n  );\n\n  /** @internal */\n  public onNotificationAdd$ = this.queryEvent(this.notificationService.onNotificationAdd$);\n\n  /** @internal */\n  public onNotificationUpdate$ = this.queryEvent(this.notificationService.onNotificationUpdate$);\n\n  /** @internal */\n  public onNotificationRemove$ = this.queryEvent(this.notificationService.onNotificationRemove$);\n\n  /** @internal */\n  public onNotificationSeen$ = this.queryEvent(this.notificationService.onNotificationSeen$);\n\n  /**\n   * Sets the title for the notification center. The title can be static text or an observable for dynamic content.\n   *\n   * @param {DynamicTextContent | null} [value] - The title content for the notification center.\n   */\n  public setTitle(value?: DynamicTextContent | null): void {\n    this.title.set(value ?? null);\n  }\n\n  /**\n   * Sets the current tag to filter notifications. Only notifications with this tag will be included.\n   *\n   * @param {string | null} [value] - The tag to filter notifications by.\n   */\n  public setTag(value?: string | null): void {\n    this.currentTag.set(value ?? null);\n  }\n\n  /**\n   * Sets the sort function used to order the notifications.\n   *\n   * @param {NotificationSortFn} [value] - The sort function to apply to the notifications.\n   */\n  public setSortFn(value?: NotificationSortFn): void {\n    this.currentSortFn.set(value);\n  }\n\n  /**\n   * Marks a given notification as seen. This does not remove the notification but updates its seen status.\n   *\n   * @param {NotificationRef} notificationRef - The reference to the notification to be marked as seen.\n   */\n  public markAsSeen(notificationRef: NotificationRef): void {\n    this.notificationService.markAsSeen(notificationRef);\n  }\n\n  /**\n   * Marks all current filtered notifications as seen.\n   */\n  public markAllAsSeen(): void {\n    this.notificationService.markAsSeenBy(this.notificationQuery());\n  }\n\n  /**\n   * Dismisses a specific notification.\n   *\n   * @param {NotificationRef} notificationRef - The reference to the notification to dismiss.\n   */\n  public dismiss(notificationRef: NotificationRef): void {\n    this.notificationService.dismiss(notificationRef);\n  }\n\n  /**\n   * Dismisses all notifications that match the current filter criteria.\n   */\n  public dismissAll(): void {\n    this.notificationService.dismissBy(this.notificationQuery());\n  }\n\n  /**\n   * Executes the action associated with a specific notification and marks it as seen.\n   *\n   * @param {NotificationRef} notificationRef - The reference to the notification whose action to execute.\n   */\n  public executeAction(notificationRef: NotificationRef): void {\n    this.markAsSeen(notificationRef);\n    this.notificationService.executeAction(notificationRef);\n  }\n\n  private queryEvent(source$: Observable<NotificationRef>): Observable<NotificationRef> {\n    return combineLatest([source$, toObservable(this.notificationQuery)]).pipe(\n      filter(([notificationRef, query]) => query(notificationRef)),\n      map(([notificationRef]) => notificationRef),\n    );\n  }\n}\n"]}

package/esm2022/components/paginator/lib/paginator.component.mjs

@@ -11,6 +11,11 @@ import { injectPaginatorConfig } from './paginator.config';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
 import * as i2 from "@odx/angular";
+/**
+ * Paginator component for navigating between pages of content in a dataset.
+ * It provides configurable options for page size, total content length, and navigational controls,
+ * and emits an event when the page is changed.
+ */
 export let PaginatorComponent = class PaginatorComponent {
     constructor() {
         this.disabledController = DisabledController.inject();
@@ -20,83 +25,167 @@ export let PaginatorComponent = class PaginatorComponent {
         this._length = 0;
         this.buttonSize = ButtonSize.SMALL;
         this.element = injectElement();
+        /**
+         * Function to generate summary content for display, such as "Items 1-10 of 100".
+         */
         this.getSummaryContentFn = null;
+        /**
+         * Function to generate range content for display, such as "Page 1 of 10".
+         */
         this.getRangeContentFn = null;
+        /**
+         * Determines whether the summary content is displayed.
+         */
         this.showSummary = true;
+        /**
+         * Determines whether buttons for navigating to the first and last pages are displayed.
+         */
         this.showFirstLastButtons = true;
+        /**
+         * Event emitted when the page index changes, providing details of the new page context.
+         */
         this.pageChanged = new EventEmitter();
     }
+    /**
+     * The current page index. Setter ensures the page index is non-negative.
+     */
     set pageIndex(value) {
         if (value >= 0)
             this._pageIndex = value;
     }
+    /**
+     * Gets the current page index, returns -1 if length is zero.
+     */
     get pageIndex() {
         return this._length ? this._pageIndex : -1;
     }
+    /**
+     * The number of items per page. Setter ensures the page size is positive.
+     */
     set pageSize(value) {
         if (value > 0)
             this._pageSize = value;
     }
+    /**
+     * Gets the number of items per page.
+     */
     get pageSize() {
         return this._pageSize;
     }
+    /**
+     * The total number of items. Setter ensures the length is non-negative.
+     */
     set length(value) {
         if (value >= 0)
             this._length = value;
     }
+    /**
+     * Gets the total number of items.
+     */
     get length() {
         return this._length;
     }
+    /**
+     * Determines whether pagination controls are disabled.
+     */
     get isDisabled() {
         return !!this.disabledController?.disabled;
     }
+    /**
+     * Default function to generate summary content if no function is provided.
+     */
     get defaultGetSummaryContentFn() {
         return this.config.getSummaryContent;
     }
+    /**
+     * Default function to generate range content if no function is provided.
+     */
     get defaultGetRangeContentFn() {
         return this.config.getRangeContent;
     }
+    /**
+     * Computes and returns the dynamic summary content.
+     */
     get summaryContent() {
         const fn = this.getSummaryContentFn ?? this.defaultGetSummaryContentFn;
         return fn(this.startItemIndex + 1, this.endItemIndex, this.length);
     }
+    /**
+     * Computes and returns the dynamic range content.
+     */
     get rangeContent() {
         const fn = this.getRangeContentFn ?? this.defaultGetRangeContentFn;
         return fn(this.pageIndex, this.totalPages);
     }
+    /**
+     * Navigates to the first page.
+     */
     firstPage() {
         this.pageChange(0);
     }
+    /**
+     * Navigates to the previous page.
+     */
     previousPage() {
         this.pageChange(this._pageIndex - 1);
     }
+    /**
+     * Navigates to the next page.
+     */
     nextPage() {
         this.pageChange(this._pageIndex + 1);
     }
+    /**
+     * Navigates to the last page.
+     */
     lastPage() {
         this.pageChange(this.totalPages - 1);
     }
+    /**
+     * Determines whether the current page is the first page.
+     */
     get isFirstPage() {
         return this._pageIndex === 0;
     }
+    /**
+     * Determines whether the current page is the last page.
+     */
     get isLastPage() {
         return this._pageIndex === this.totalPages - 1;
     }
+    /**
+     * Determines whether the previous button is disabled.
+     */
     get isPreviousDisabled() {
         return this.isFirstPage || !this._length;
     }
+    /**
+     * Determines whether the next button is disabled.
+     */
     get isNextDisabled() {
         return this.isLastPage || !this._length;
     }
+    /**
+     * Gets the total number of pages.
+     */
     get totalPages() {
         return Math.ceil(this._length / this._pageSize);
     }
+    /**
+     * Gets the index of the first item on the current page.
+     */
     get startItemIndex() {
         return this._length ? this._pageIndex * this._pageSize : -1;
     }
+    /**
+     * Gets the index of the last item on the current page.
+     */
     get endItemIndex() {
         return Math.min(this.startItemIndex + this._pageSize, this._length);
     }
+    /**
+     * Navigates to the specified page index.
+     */
     pageChange(pageIndex) {
         if (pageIndex < 0)
             return;
@@ -135,4 +224,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
             }], pageChanged: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"paginator.component.js","sourceRoot":"","sources":["../../../../../../../libs/angular/components/paginator/src/lib/paginator.component.ts","../../../../../../../libs/angular/components/paginator/src/lib/paginator.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewEncapsulation } from '@angular/core';\nimport { CoreModule, DisabledController } from '@odx/angular';\nimport { DynamicTextContent, DynamicViewDirective } from '@odx/angular/cdk/dynamic-view';\nimport { ActionGroupComponent } from '@odx/angular/components/action-group';\nimport { ButtonComponent, ButtonSize } from '@odx/angular/components/button';\nimport { IconComponent } from '@odx/angular/components/icon';\nimport { CSSComponent } from '@odx/angular/internal';\nimport { injectElement } from '@odx/angular/utils';\nimport { PageChangeEvent } from './interfaces';\nimport { GetRangeContentFn, GetSummaryContentFn } from './models';\nimport { injectPaginatorConfig } from './paginator.config';\n\n@CSSComponent('paginator')\n@Component({\n  standalone: true,\n  selector: 'odx-paginator',\n  imports: [CoreModule, ActionGroupComponent, ButtonComponent, IconComponent, DynamicViewDirective],\n  providers: [DisabledController.connect()],\n  templateUrl: './paginator.component.html',\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: {\n    '[class.is-disabled]': 'isDisabled',\n  },\n})\nexport class PaginatorComponent {\n  private readonly disabledController = DisabledController.inject();\n\n  private readonly config = injectPaginatorConfig();\n\n  private _pageIndex = 0;\n  private _pageSize = this.config.pageSize;\n  private _length = 0;\n\n  protected buttonSize = ButtonSize.SMALL;\n\n  public readonly element = injectElement();\n\n  @Input()\n  public getSummaryContentFn?: GetSummaryContentFn | null = null;\n\n  @Input()\n  public getRangeContentFn?: GetRangeContentFn | null = null;\n\n  @Input()\n  public showSummary = true;\n\n  @Input()\n  public showFirstLastButtons = true;\n\n  @Input()\n  public set pageIndex(value: number) {\n    if (value >= 0) this._pageIndex = value;\n  }\n\n  public get pageIndex(): number {\n    return this._length ? this._pageIndex : -1;\n  }\n\n  @Input()\n  public set pageSize(value: number) {\n    if (value > 0) this._pageSize = value;\n  }\n\n  public get pageSize(): number {\n    return this._pageSize;\n  }\n\n  @Input()\n  public set length(value: number) {\n    if (value >= 0) this._length = value;\n  }\n\n  public get length(): number {\n    return this._length;\n  }\n\n  @Output()\n  public pageChanged = new EventEmitter<PageChangeEvent>();\n\n  public get isDisabled(): boolean {\n    return !!this.disabledController?.disabled;\n  }\n\n  public get defaultGetSummaryContentFn(): GetSummaryContentFn {\n    return this.config.getSummaryContent;\n  }\n\n  public get defaultGetRangeContentFn(): GetRangeContentFn {\n    return this.config.getRangeContent;\n  }\n\n  public get summaryContent(): DynamicTextContent {\n    const fn = this.getSummaryContentFn ?? this.defaultGetSummaryContentFn;\n    return fn(this.startItemIndex + 1, this.endItemIndex, this.length);\n  }\n\n  public get rangeContent(): DynamicTextContent {\n    const fn = this.getRangeContentFn ?? this.defaultGetRangeContentFn;\n    return fn(this.pageIndex, this.totalPages);\n  }\n\n  public firstPage(): void {\n    this.pageChange(0);\n  }\n\n  public previousPage(): void {\n    this.pageChange(this._pageIndex - 1);\n  }\n\n  public nextPage(): void {\n    this.pageChange(this._pageIndex + 1);\n  }\n\n  public lastPage(): void {\n    this.pageChange(this.totalPages - 1);\n  }\n\n  public get isFirstPage(): boolean {\n    return this._pageIndex === 0;\n  }\n\n  public get isLastPage(): boolean {\n    return this._pageIndex === this.totalPages - 1;\n  }\n\n  public get isPreviousDisabled(): boolean {\n    return this.isFirstPage || !this._length;\n  }\n\n  public get isNextDisabled(): boolean {\n    return this.isLastPage || !this._length;\n  }\n\n  public get totalPages(): number {\n    return Math.ceil(this._length / this._pageSize);\n  }\n\n  public get startItemIndex(): number {\n    return this._length ? this._pageIndex * this._pageSize : -1;\n  }\n\n  public get endItemIndex(): number {\n    return Math.min(this.startItemIndex + this._pageSize, this._length);\n  }\n\n  public pageChange(pageIndex: number): void {\n    if (pageIndex < 0) return;\n\n    this._pageIndex = pageIndex;\n\n    this.pageChanged.emit({\n      pageIndex: this._pageIndex,\n      length: this._length,\n      pageSize: this._pageSize,\n    });\n  }\n}\n","<div *ngIf=\"showSummary\" class=\"odx-paginator__summary\">\n  <ng-template [odxDynamicView]=\"summaryContent\"></ng-template>\n</div>\n\n<div class=\"odx-paginator__navigation\">\n  <odx-action-group>\n    <button\n      *ngIf=\"showFirstLastButtons\"\n      odxButton\n      [size]=\"buttonSize\"\n      class=\"odx-paginator__navigation_first\"\n      (click)=\"firstPage()\"\n      [disabled]=\"isPreviousDisabled\"\n    >\n      <odx-icon name=\"chevron-left-end\" iconSet=\"core\"></odx-icon>\n    </button>\n\n    <button odxButton [size]=\"buttonSize\" class=\"odx-paginator__navigation_previous\" (click)=\"previousPage()\" [disabled]=\"isPreviousDisabled\">\n      <odx-icon name=\"chevron-left\" iconSet=\"core\"></odx-icon>\n    </button>\n  </odx-action-group>\n\n  <div class=\"odx-paginator__range\">\n    <ng-template [odxDynamicView]=\"rangeContent\"></ng-template>\n  </div>\n\n  <odx-action-group>\n    <button odxButton [size]=\"buttonSize\" class=\"odx-paginator__navigation_next\" (click)=\"nextPage()\" [disabled]=\"isNextDisabled\">\n      <odx-icon name=\"chevron-right\" iconSet=\"core\"></odx-icon>\n    </button>\n\n    <button *ngIf=\"showFirstLastButtons\" [size]=\"buttonSize\" odxButton class=\"odx-paginator__navigation_last\" (click)=\"lastPage()\" [disabled]=\"isNextDisabled\">\n      <odx-icon name=\"chevron-right-end\" iconSet=\"core\"></odx-icon>\n    </button>\n  </odx-action-group>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"paginator.component.js","sourceRoot":"","sources":["../../../../../../../libs/angular/components/paginator/src/lib/paginator.component.ts","../../../../../../../libs/angular/components/paginator/src/lib/paginator.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewEncapsulation } from '@angular/core';\nimport { CoreModule, DisabledController } from '@odx/angular';\nimport { DynamicTextContent, DynamicViewDirective } from '@odx/angular/cdk/dynamic-view';\nimport { ActionGroupComponent } from '@odx/angular/components/action-group';\nimport { ButtonComponent, ButtonSize } from '@odx/angular/components/button';\nimport { IconComponent } from '@odx/angular/components/icon';\nimport { CSSComponent } from '@odx/angular/internal';\nimport { injectElement } from '@odx/angular/utils';\nimport { PageChangeEvent } from './interfaces';\nimport { GetRangeContentFn, GetSummaryContentFn } from './models';\nimport { injectPaginatorConfig } from './paginator.config';\n\n/**\n * Paginator component for navigating between pages of content in a dataset.\n * It provides configurable options for page size, total content length, and navigational controls,\n * and emits an event when the page is changed.\n */\n@CSSComponent('paginator')\n@Component({\n  standalone: true,\n  selector: 'odx-paginator',\n  imports: [CoreModule, ActionGroupComponent, ButtonComponent, IconComponent, DynamicViewDirective],\n  providers: [DisabledController.connect()],\n  templateUrl: './paginator.component.html',\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: {\n    '[class.is-disabled]': 'isDisabled',\n  },\n})\nexport class PaginatorComponent {\n  private readonly disabledController = DisabledController.inject();\n\n  private readonly config = injectPaginatorConfig();\n\n  private _pageIndex = 0;\n  private _pageSize = this.config.pageSize;\n  private _length = 0;\n\n  protected buttonSize = ButtonSize.SMALL;\n\n  public readonly element = injectElement();\n\n  /**\n   * Function to generate summary content for display, such as \"Items 1-10 of 100\".\n   */\n  @Input()\n  public getSummaryContentFn?: GetSummaryContentFn | null = null;\n\n  /**\n   * Function to generate range content for display, such as \"Page 1 of 10\".\n   */\n  @Input()\n  public getRangeContentFn?: GetRangeContentFn | null = null;\n\n  /**\n   * Determines whether the summary content is displayed.\n   */\n  @Input()\n  public showSummary = true;\n\n  /**\n   * Determines whether buttons for navigating to the first and last pages are displayed.\n   */\n  @Input()\n  public showFirstLastButtons = true;\n\n  /**\n   * The current page index. Setter ensures the page index is non-negative.\n   */\n  @Input()\n  public set pageIndex(value: number) {\n    if (value >= 0) this._pageIndex = value;\n  }\n\n  /**\n   * Gets the current page index, returns -1 if length is zero.\n   */\n  public get pageIndex(): number {\n    return this._length ? this._pageIndex : -1;\n  }\n\n  /**\n   * The number of items per page. Setter ensures the page size is positive.\n   */\n  @Input()\n  public set pageSize(value: number) {\n    if (value > 0) this._pageSize = value;\n  }\n\n  /**\n   * Gets the number of items per page.\n   */\n  public get pageSize(): number {\n    return this._pageSize;\n  }\n\n  /**\n   * The total number of items. Setter ensures the length is non-negative.\n   */\n  @Input()\n  public set length(value: number) {\n    if (value >= 0) this._length = value;\n  }\n\n  /**\n   * Gets the total number of items.\n   */\n  public get length(): number {\n    return this._length;\n  }\n\n  /**\n   * Event emitted when the page index changes, providing details of the new page context.\n   */\n  @Output()\n  public pageChanged = new EventEmitter<PageChangeEvent>();\n\n  /**\n   * Determines whether pagination controls are disabled.\n   */\n  public get isDisabled(): boolean {\n    return !!this.disabledController?.disabled;\n  }\n\n  /**\n   * Default function to generate summary content if no function is provided.\n   */\n  public get defaultGetSummaryContentFn(): GetSummaryContentFn {\n    return this.config.getSummaryContent;\n  }\n\n  /**\n   * Default function to generate range content if no function is provided.\n   */\n  public get defaultGetRangeContentFn(): GetRangeContentFn {\n    return this.config.getRangeContent;\n  }\n\n  /**\n   * Computes and returns the dynamic summary content.\n   */\n  public get summaryContent(): DynamicTextContent {\n    const fn = this.getSummaryContentFn ?? this.defaultGetSummaryContentFn;\n    return fn(this.startItemIndex + 1, this.endItemIndex, this.length);\n  }\n\n  /**\n   * Computes and returns the dynamic range content.\n   */\n  public get rangeContent(): DynamicTextContent {\n    const fn = this.getRangeContentFn ?? this.defaultGetRangeContentFn;\n    return fn(this.pageIndex, this.totalPages);\n  }\n\n  /**\n   * Navigates to the first page.\n   */\n  public firstPage(): void {\n    this.pageChange(0);\n  }\n\n  /**\n   * Navigates to the previous page.\n   */\n  public previousPage(): void {\n    this.pageChange(this._pageIndex - 1);\n  }\n\n  /**\n   * Navigates to the next page.\n   */\n  public nextPage(): void {\n    this.pageChange(this._pageIndex + 1);\n  }\n\n  /**\n   * Navigates to the last page.\n   */\n  public lastPage(): void {\n    this.pageChange(this.totalPages - 1);\n  }\n\n  /**\n   * Determines whether the current page is the first page.\n   */\n  public get isFirstPage(): boolean {\n    return this._pageIndex === 0;\n  }\n\n  /**\n   * Determines whether the current page is the last page.\n   */\n  public get isLastPage(): boolean {\n    return this._pageIndex === this.totalPages - 1;\n  }\n\n  /**\n   * Determines whether the previous button is disabled.\n   */\n  public get isPreviousDisabled(): boolean {\n    return this.isFirstPage || !this._length;\n  }\n\n  /**\n   * Determines whether the next button is disabled.\n   */\n  public get isNextDisabled(): boolean {\n    return this.isLastPage || !this._length;\n  }\n\n  /**\n   * Gets the total number of pages.\n   */\n  public get totalPages(): number {\n    return Math.ceil(this._length / this._pageSize);\n  }\n\n  /**\n   * Gets the index of the first item on the current page.\n   */\n  public get startItemIndex(): number {\n    return this._length ? this._pageIndex * this._pageSize : -1;\n  }\n\n  /**\n   * Gets the index of the last item on the current page.\n   */\n  public get endItemIndex(): number {\n    return Math.min(this.startItemIndex + this._pageSize, this._length);\n  }\n\n  /**\n   * Navigates to the specified page index.\n   */\n  public pageChange(pageIndex: number): void {\n    if (pageIndex < 0) return;\n\n    this._pageIndex = pageIndex;\n\n    this.pageChanged.emit({\n      pageIndex: this._pageIndex,\n      length: this._length,\n      pageSize: this._pageSize,\n    });\n  }\n}\n","<div *ngIf=\"showSummary\" class=\"odx-paginator__summary\">\n  <ng-template [odxDynamicView]=\"summaryContent\"></ng-template>\n</div>\n\n<div class=\"odx-paginator__navigation\">\n  <odx-action-group>\n    <button\n      *ngIf=\"showFirstLastButtons\"\n      odxButton\n      [size]=\"buttonSize\"\n      class=\"odx-paginator__navigation_first\"\n      (click)=\"firstPage()\"\n      [disabled]=\"isPreviousDisabled\"\n    >\n      <odx-icon name=\"chevron-left-end\" iconSet=\"core\"></odx-icon>\n    </button>\n\n    <button odxButton [size]=\"buttonSize\" class=\"odx-paginator__navigation_previous\" (click)=\"previousPage()\" [disabled]=\"isPreviousDisabled\">\n      <odx-icon name=\"chevron-left\" iconSet=\"core\"></odx-icon>\n    </button>\n  </odx-action-group>\n\n  <div class=\"odx-paginator__range\">\n    <ng-template [odxDynamicView]=\"rangeContent\"></ng-template>\n  </div>\n\n  <odx-action-group>\n    <button odxButton [size]=\"buttonSize\" class=\"odx-paginator__navigation_next\" (click)=\"nextPage()\" [disabled]=\"isNextDisabled\">\n      <odx-icon name=\"chevron-right\" iconSet=\"core\"></odx-icon>\n    </button>\n\n    <button *ngIf=\"showFirstLastButtons\" [size]=\"buttonSize\" odxButton class=\"odx-paginator__navigation_last\" (click)=\"lastPage()\" [disabled]=\"isNextDisabled\">\n      <odx-icon name=\"chevron-right-end\" iconSet=\"core\"></odx-icon>\n    </button>\n  </odx-action-group>\n</div>\n"]}

package/esm2022/components/paginator/lib/paginator.config.mjs

@@ -1,4 +1,11 @@
 import { createConfigTokens } from '@odx/angular/utils';
+/**
+ * Generates summary content for display in the paginator.
+ * @param startItemIndex Start index of the items on the current page.
+ * @param endItemIndex End index of the items on the current page.
+ * @param length Total number of items available.
+ * @returns Formatted summary as dynamic HTML content.
+ */
 const getSummaryContent = (startItemIndex, endItemIndex, length) => {
     return `
     <strong>${startItemIndex}</strong>
@@ -6,15 +13,36 @@ const getSummaryContent = (startItemIndex, endItemIndex, length) => {
     of <strong>${length}</strong>
   `;
 };
+/**
+ * Generates range content for display in the paginator.
+ * @param pageIndex Current page index.
+ * @param totalPages Total number of pages available.
+ * @returns Formatted range as dynamic HTML content.
+ */
 const getRangeContent = (pageIndex, totalPages) => {
     return `
     Page <strong>${pageIndex + 1}</strong>
     of <strong>${totalPages}</strong>
   `;
 };
+/**
+ * Utility for creating and retrieving configuration tokens for the Paginator.
+ * This facilitates dependency injection of configuration in Angular applications.
+ *
+ * @example
+ * ```ts
+ * // In module providers:
+ * providers: [
+ *  providePaginatorConfig({
+ *   pageSize: 20,
+ *   getSummaryContent: (startItemIndex: number, endItemIndex: number, length: number) => `...`
+ *  }),
+ * ]
+ * ```
+ */
 export const { PaginatorConfig, PaginatorDefaultConfig, injectPaginatorConfig, providePaginatorConfig } = createConfigTokens('Paginator', '@odx/angular/components/paginator', {
     getSummaryContent,
     getRangeContent,
     pageSize: 10,
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/progress/lib/progress.component.mjs

@@ -3,10 +3,18 @@ import { ChangeDetectionStrategy, Component, Input, numberAttribute, ViewEncapsu
 import { CSSComponent, CSSModifier } from '@odx/angular/internal';
 import { injectElement } from '@odx/angular/utils';
 import * as i0 from "@angular/core";
+/**
+ * Progress component for visually indicating the completion level of a task or process.
+ * The component can display definite progress or operate in an indeterminate mode to indicate ongoing activity.
+ */
 export let ProgressComponent = class ProgressComponent {
     constructor() {
         this._value = 0;
         this.element = injectElement();
+        /**
+         * Indicates if the progress bar is in indeterminate state, which is typically used for loading processes
+         * where the completion percentage is unknown.
+         */
         this.indeterminate = false;
     }
     get ariaValueNow() {
@@ -15,12 +23,19 @@ export let ProgressComponent = class ProgressComponent {
     get progressValue() {
         return this.indeterminate ? 1 : this.value / 100;
     }
+    /**
+     * Sets the current value of the progress bar. Accepts a number between 0 and 100 or -1 for indeterminate.
+     * @param value The new value of the progress bar. -1 sets the bar to indeterminate.
+     */
     set value(value) {
         if (value <= 100 && value >= -1) {
             this._value = value;
             this.indeterminate = value === -1;
         }
     }
+    /**
+     * Gets the current value of the progress bar.
+     */
     get value() {
         return this._value;
     }
@@ -46,4 +61,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                 type: Input,
                 args: [{ transform: numberAttribute }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/radio-group/lib/components/radio-button/radio-button.component.mjs

@@ -7,6 +7,23 @@ import { CSSComponent, CSSModifier } from '@odx/angular/internal';
 import { injectElement } from '@odx/angular/utils';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/cdk/observers";
+/**
+ * Represents a radio button component.
+ * @extends {RadioControlDirective<T>}
+ *
+ * @remarks
+ * To add subtitle text to the radio button, use class `odx-radio-button__subtitle` in template's content.
+ *
+ * @example
+ * ```html
+ * <odx-radio-group>
+ *  <odx-radio-button [value]="'a'" >
+ *   Radio button label
+ *   <span class="odx-radio-button__subtitle">Subtitle text</span>
+ *  </odx-radio-button>
+ * </odx-radio-group>
+ * ```
+ */
 export let RadioButtonComponent = class RadioButtonComponent extends RadioControlDirective {
     constructor() {
         super(...arguments);
@@ -20,7 +37,7 @@ export let RadioButtonComponent = class RadioButtonComponent extends RadioContro
         this.withLabel = !!this.contentElement.nativeElement.textContent?.trim();
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RadioButtonComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: RadioButtonComponent, isStandalone: true, selector: "odx-radio-button", providers: [DisabledController.connect(), ReadonlyController.connect()], viewQueries: [{ propertyName: "contentElement", first: true, predicate: ["content"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<label class=\"odx-radio-button__label\">\n  <input\n    class=\"odx-radio-button__input\"\n    type=\"radio\"\n    [attr.aria-checked]=\"ariaChecked\"\n    [attr.aria-invalid]=\"radioGroupControl.hasError || null\"\n    [attr.aria-readonly]=\"readonlyController?.readonly || null\"\n    [attr.aria-required]=\"radioGroupControl.isRequired || null\"\n    [checked]=\"isActive\"\n    [disabled]=\"disabledController?.disabled || readonlyController?.readonly\"\n    [name]=\"radioGroupControl.name\"\n    [readonly]=\"readonlyController?.readonly\"\n    [required]=\"radioGroupControl.isRequired\"\n    [value]=\"value\"\n    (change)=\"radioGroupControl.updateValue(value)\"\n  />\n  <div class=\"odx-radio-button__indicator\"></div>\n  <div class=\"odx-radio-button__content\" [cdkObserveContentDisabled]=\"disabledController?.disabled\" (cdkObserveContent)=\"onContentChange()\" #content>\n    <ng-content></ng-content>\n  </div>\n</label>\n", dependencies: [{ kind: "ngmodule", type: ObserversModule }, { kind: "directive", type: i1.CdkObserveContent, selector: "[cdkObserveContent]", inputs: ["cdkObserveContentDisabled", "debounce"], outputs: ["cdkObserveContent"], exportAs: ["cdkObserveContent"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: RadioButtonComponent, isStandalone: true, selector: "odx-radio-button", providers: [DisabledController.connect(), ReadonlyController.connect()], viewQueries: [{ propertyName: "contentElement", first: true, predicate: ["content"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<label class=\"odx-radio-button__label\">\n  <input\n    class=\"odx-radio-button__input\"\n    type=\"radio\"\n    [attr.aria-checked]=\"ariaChecked\"\n    [attr.aria-invalid]=\"radioGroupControl.hasError || null\"\n    [attr.aria-readonly]=\"readonlyController?.readonly || null\"\n    [attr.aria-required]=\"radioGroupControl.isRequired || null\"\n    [checked]=\"isActive\"\n    [disabled]=\"disabledController?.disabled || readonlyController?.readonly\"\n    [name]=\"radioGroupControl.name\"\n    [readonly]=\"readonlyController?.readonly\"\n    [required]=\"radioGroupControl.isRequired\"\n    [value]=\"value\"\n    (change)=\"radioGroupControl.updateValue(value)\"\n  />\n  <div class=\"odx-radio-button__indicator\"></div>\n  <div class=\"odx-radio-button__content\" [cdkObserveContentDisabled]=\"disabledController?.disabled\" (cdkObserveContent)=\"onContentChange()\" #content>\n    <ng-content></ng-content>\n    <ng-content select=\".odx-radio-button__subtitle\" />\n  </div>\n</label>\n", dependencies: [{ kind: "ngmodule", type: ObserversModule }, { kind: "directive", type: i1.CdkObserveContent, selector: "[cdkObserveContent]", inputs: ["cdkObserveContentDisabled", "debounce"], outputs: ["cdkObserveContent"], exportAs: ["cdkObserveContent"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
 };
 __decorate([
     CSSModifier(),
@@ -31,9 +48,9 @@ RadioButtonComponent = __decorate([
 ], RadioButtonComponent);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RadioButtonComponent, decorators: [{
             type: Component,
-            args: [{ standalone: true, selector: 'odx-radio-button', imports: [ObserversModule], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [DisabledController.connect(), ReadonlyController.connect()], template: "<label class=\"odx-radio-button__label\">\n  <input\n    class=\"odx-radio-button__input\"\n    type=\"radio\"\n    [attr.aria-checked]=\"ariaChecked\"\n    [attr.aria-invalid]=\"radioGroupControl.hasError || null\"\n    [attr.aria-readonly]=\"readonlyController?.readonly || null\"\n    [attr.aria-required]=\"radioGroupControl.isRequired || null\"\n    [checked]=\"isActive\"\n    [disabled]=\"disabledController?.disabled || readonlyController?.readonly\"\n    [name]=\"radioGroupControl.name\"\n    [readonly]=\"readonlyController?.readonly\"\n    [required]=\"radioGroupControl.isRequired\"\n    [value]=\"value\"\n    (change)=\"radioGroupControl.updateValue(value)\"\n  />\n  <div class=\"odx-radio-button__indicator\"></div>\n  <div class=\"odx-radio-button__content\" [cdkObserveContentDisabled]=\"disabledController?.disabled\" (cdkObserveContent)=\"onContentChange()\" #content>\n    <ng-content></ng-content>\n  </div>\n</label>\n" }]
+            args: [{ standalone: true, selector: 'odx-radio-button', imports: [ObserversModule], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [DisabledController.connect(), ReadonlyController.connect()], template: "<label class=\"odx-radio-button__label\">\n  <input\n    class=\"odx-radio-button__input\"\n    type=\"radio\"\n    [attr.aria-checked]=\"ariaChecked\"\n    [attr.aria-invalid]=\"radioGroupControl.hasError || null\"\n    [attr.aria-readonly]=\"readonlyController?.readonly || null\"\n    [attr.aria-required]=\"radioGroupControl.isRequired || null\"\n    [checked]=\"isActive\"\n    [disabled]=\"disabledController?.disabled || readonlyController?.readonly\"\n    [name]=\"radioGroupControl.name\"\n    [readonly]=\"readonlyController?.readonly\"\n    [required]=\"radioGroupControl.isRequired\"\n    [value]=\"value\"\n    (change)=\"radioGroupControl.updateValue(value)\"\n  />\n  <div class=\"odx-radio-button__indicator\"></div>\n  <div class=\"odx-radio-button__content\" [cdkObserveContentDisabled]=\"disabledController?.disabled\" (cdkObserveContent)=\"onContentChange()\" #content>\n    <ng-content></ng-content>\n    <ng-content select=\".odx-radio-button__subtitle\" />\n  </div>\n</label>\n" }]
         }], propDecorators: { withLabel: [], contentElement: [{
                 type: ViewChild,
                 args: ['content']
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/radio-group/lib/radio-group.component.mjs

@@ -2,14 +2,25 @@ var RadioGroupComponent_1;
 import { __decorate, __metadata } from "tslib";
 import { ChangeDetectionStrategy, Component, forwardRef, Input, ViewEncapsulation } from '@angular/core';
 import { DisabledController, ReadonlyController } from '@odx/angular';
-import { RadioGroupControlDirective, RADIO_GROUP_CONTROL } from '@odx/angular/cdk/radio-group-control';
+import { RADIO_GROUP_CONTROL, RadioGroupControlDirective } from '@odx/angular/cdk/radio-group-control';
 import { CSSComponent, CSSModifier } from '@odx/angular/internal';
 import { injectElement } from '@odx/angular/utils';
 import * as i0 from "@angular/core";
+/**
+ * RadioGroupComponent manages a group of radio buttons, providing Angular form control integration
+ * and additional states like disabled and readonly. It supports both vertical and horizontal layouts.
+ *
+ * The component extends the `RadioGroupControlDirective`, which provides the core functionality for managing.
+ * @see {RadioGroupControlDirective}
+ */
 export let RadioGroupComponent = class RadioGroupComponent extends RadioGroupControlDirective {
     constructor() {
         super(...arguments);
         this.element = injectElement();
+        /**
+         * Determines whether the radio buttons are arranged horizontally.
+         * When set to `true`, radio buttons are aligned side by side.
+         */
         this.horizontal = false;
     }
     static { RadioGroupComponent_1 = this; }
@@ -45,4 +56,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
         }], propDecorators: { horizontal: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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