@quadrel-enterprise-ui/framework 1.0.0 → 18.19.2

package/esm2022/lib/table/services/resolver.service.mjs

@@ -0,0 +1,82 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import isEqual from 'lodash/isEqual';
+import { first, Subject, switchMap } from 'rxjs';
+import { distinctUntilChanged, filter, map, takeUntil, tap } from 'rxjs/operators';
+import { TranslateService } from '@ngx-translate/core';
+import { QdTableConnectorState } from '../model/connectors-state.enum';
+import { QdTableRequestState } from '../model/table-data-resolver';
+import { QD_TABLE_DATA_RESOLVER_TOKEN } from '../model/table-data-resolver.token';
+import { QdTableStoreService } from '../store/table-store.service';
+import { QdTableExternalActionResultService } from './external-action-result.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../store/table-store.service";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "./external-action-result.service";
+export class QdTableResolverService {
+    tableDataResolver;
+    tableStoreService;
+    translateService;
+    actionResultService;
+    _destroyed$ = new Subject();
+    _refreshSubscription;
+    constructor(tableDataResolver, tableStoreService, translateService, actionResultService) {
+        this.tableDataResolver = tableDataResolver;
+        this.tableStoreService = tableStoreService;
+        this.translateService = translateService;
+        this.actionResultService = actionResultService;
+        this.subscribeToExternalRefresh();
+    }
+    ngOnDestroy() {
+        this._destroyed$.complete();
+    }
+    init(refreshOnLanguageChange) {
+        if (!this.tableDataResolver)
+            return;
+        if (refreshOnLanguageChange)
+            this.subscribeToLangChanges();
+        // TODO: Add Error handling
+        this.tableStoreService
+            .selectDataResolutionCriteria$()
+            .pipe(takeUntil(this._destroyed$), distinctUntilChanged(isEqual), filter(resolutionCriteria => this.shouldDataBeResolved(resolutionCriteria)), map(({ tableParams, connectorParams }) => ({ ...tableParams, ...connectorParams })), tap(() => this.tableStoreService.setRequestState(QdTableRequestState.PENDING)), switchMap(resolutionParams => this.tableDataResolver.resolve(resolutionParams)), tap(({ data, size, page, totalElements }) => this.tableStoreService.setPage(page, size, totalElements, data)), tap(() => this.tableStoreService.setRequestState(QdTableRequestState.SUCCESS)))
+            .subscribe();
+    }
+    refresh(resolverOptions = {}) {
+        if (!this.tableDataResolver)
+            return console.warn('QD-UI | QdTable - Refresh skipped: resolver not provided.');
+        const { pageIndex } = resolverOptions;
+        if (this._refreshSubscription)
+            this._refreshSubscription.unsubscribe();
+        this._refreshSubscription = this.tableStoreService
+            .selectDataResolutionCriteria$()
+            .pipe(first(), tap(() => this.tableStoreService.setRequestState(QdTableRequestState.PENDING)), switchMap(resolutionCriteria => this.tableDataResolver.resolve({
+            ...resolutionCriteria.tableParams,
+            ...resolutionCriteria.connectorParams,
+            ...(pageIndex !== undefined ? { page: pageIndex } : {})
+        })), tap(({ page, data, size, totalElements }) => this.tableStoreService.setPage(page, size, totalElements, data)), tap(() => this.tableStoreService.setRequestState(QdTableRequestState.SUCCESS)))
+            .subscribe();
+    }
+    subscribeToLangChanges() {
+        this.translateService.onLangChange.pipe(takeUntil(this._destroyed$)).subscribe(() => this.refresh());
+    }
+    shouldDataBeResolved({ hasConnectors, connectorsState, tableParams }) {
+        if (hasConnectors && connectorsState === QdTableConnectorState.AWAITING)
+            return false;
+        return tableParams.size !== undefined && tableParams.page !== undefined;
+    }
+    subscribeToExternalRefresh() {
+        this.actionResultService.actionSuccess$
+            .pipe(takeUntil(this._destroyed$))
+            .subscribe(pageIndex => this.refresh({ pageIndex }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableResolverService, deps: [{ token: QD_TABLE_DATA_RESOLVER_TOKEN, optional: true }, { token: i1.QdTableStoreService }, { token: i2.TranslateService }, { token: i3.QdTableExternalActionResultService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableResolverService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableResolverService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [QD_TABLE_DATA_RESOLVER_TOKEN]
+                }] }, { type: i1.QdTableStoreService }, { type: i2.TranslateService }, { type: i3.QdTableExternalActionResultService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resolver.service.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/table/services/resolver.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, OnDestroy, Optional } from '@angular/core';\nimport isEqual from 'lodash/isEqual';\nimport { first, Subject, Subscription, switchMap } from 'rxjs';\nimport { distinctUntilChanged, filter, map, takeUntil, tap } from 'rxjs/operators';\nimport { TranslateService } from '@ngx-translate/core';\n\nimport { QdTableConnectorState } from '../model/connectors-state.enum';\nimport { QdTableDataResolver, QdTableRequestState } from '../model/table-data-resolver';\nimport { QD_TABLE_DATA_RESOLVER_TOKEN } from '../model/table-data-resolver.token';\nimport { QdTableDataResolutionCriteria } from '../model/table-store.interface';\nimport { QdTableStoreService } from '../store/table-store.service';\nimport { QdTableExternalActionResultService } from './external-action-result.service';\n\n@Injectable()\nexport class QdTableResolverService<T extends string> implements OnDestroy {\n  private _destroyed$: Subject<null> = new Subject();\n  private _refreshSubscription!: Subscription;\n\n  constructor(\n    @Optional() @Inject(QD_TABLE_DATA_RESOLVER_TOKEN) private readonly tableDataResolver: QdTableDataResolver<T>,\n    private readonly tableStoreService: QdTableStoreService<T>,\n    private readonly translateService: TranslateService,\n    private readonly actionResultService: QdTableExternalActionResultService\n  ) {\n    this.subscribeToExternalRefresh();\n  }\n\n  ngOnDestroy(): void {\n    this._destroyed$.complete();\n  }\n\n  init(refreshOnLanguageChange?: boolean): void {\n    if (!this.tableDataResolver) return;\n    if (refreshOnLanguageChange) this.subscribeToLangChanges();\n\n    // TODO: Add Error handling\n    this.tableStoreService\n      .selectDataResolutionCriteria$()\n      .pipe(\n        takeUntil(this._destroyed$),\n        distinctUntilChanged(isEqual),\n        filter(resolutionCriteria => this.shouldDataBeResolved(resolutionCriteria)),\n        map(({ tableParams, connectorParams }) => ({ ...tableParams, ...connectorParams })),\n        tap(() => this.tableStoreService.setRequestState(QdTableRequestState.PENDING)),\n        switchMap(resolutionParams => this.tableDataResolver.resolve(resolutionParams)),\n        tap(({ data, size, page, totalElements }) => this.tableStoreService.setPage(page, size, totalElements, data)),\n        tap(() => this.tableStoreService.setRequestState(QdTableRequestState.SUCCESS))\n      )\n      .subscribe();\n  }\n\n  refresh(resolverOptions: { pageIndex?: number } = {}): void {\n    if (!this.tableDataResolver) return console.warn('QD-UI | QdTable - Refresh skipped: resolver not provided.');\n\n    const { pageIndex } = resolverOptions;\n\n    if (this._refreshSubscription) this._refreshSubscription.unsubscribe();\n\n    this._refreshSubscription = this.tableStoreService\n      .selectDataResolutionCriteria$()\n      .pipe(\n        first(),\n        tap(() => this.tableStoreService.setRequestState(QdTableRequestState.PENDING)),\n        switchMap(resolutionCriteria =>\n          this.tableDataResolver.resolve({\n            ...resolutionCriteria.tableParams,\n            ...resolutionCriteria.connectorParams,\n            ...(pageIndex !== undefined ? { page: pageIndex } : {})\n          })\n        ),\n        tap(({ page, data, size, totalElements }) => this.tableStoreService.setPage(page, size, totalElements, data)),\n        tap(() => this.tableStoreService.setRequestState(QdTableRequestState.SUCCESS))\n      )\n      .subscribe();\n  }\n\n  private subscribeToLangChanges(): void {\n    this.translateService.onLangChange.pipe(takeUntil(this._destroyed$)).subscribe(() => this.refresh());\n  }\n\n  private shouldDataBeResolved({\n    hasConnectors,\n    connectorsState,\n    tableParams\n  }: QdTableDataResolutionCriteria<T>): boolean {\n    if (hasConnectors && connectorsState === QdTableConnectorState.AWAITING) return false;\n\n    return tableParams.size !== undefined && tableParams.page !== undefined;\n  }\n\n  private subscribeToExternalRefresh(): void {\n    this.actionResultService.actionSuccess$\n      .pipe(takeUntil(this._destroyed$))\n      .subscribe(pageIndex => this.refresh({ pageIndex }));\n  }\n}\n"]}

package/esm2022/lib/table/services/responsive-row.service.mjs

@@ -0,0 +1,106 @@
+// @ts-strict-ignore
+import { Injectable } from '@angular/core';
+import isEqual from 'lodash/isEqual';
+import isObject from 'lodash/isObject';
+import { breakpoints } from '../../core/model/breakpoint.interface';
+import { ReplaySubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class QdTableResponsiveRowService {
+    _config;
+    _breakpoints = breakpoints;
+    _currentBreakpoint = Object.keys(breakpoints)[0];
+    _defaultColumnMapping = { xs: 1, sm: 2, md: 4, lg: 6, xl: 8, xxl: 10 };
+    _headCellDefinitionsSubject = new ReplaySubject(1);
+    _columnsDefinitions;
+    _columnsDefinitionsSubject = new ReplaySubject(1);
+    headCellDefinitions$ = this._headCellDefinitionsSubject.asObservable();
+    columnsDefinitions$ = this._columnsDefinitionsSubject.asObservable();
+    set config(config) {
+        this._config = config;
+        this.updateDefinitions();
+    }
+    get config() {
+        return this._config;
+    }
+    set currentBreakpoint(currentBreakpoint) {
+        this._currentBreakpoint = currentBreakpoint;
+        this.updateDefinitions();
+    }
+    get currentBreakpoint() {
+        return this._currentBreakpoint;
+    }
+    get mainColumn() {
+        return this._config.mainColumn || this._config.columns[0].column;
+    }
+    get mainColumnIndex() {
+        if (!this._config.mainColumn)
+            return 0;
+        return this._config.columns.findIndex(column => column.column === this._config.mainColumn);
+    }
+    get columnMapping() {
+        return Object.keys(this._breakpoints).reduce((acc, cur) => ({
+            ...acc,
+            ...{ [cur]: this._config.columnMapping?.[cur] || this._defaultColumnMapping[cur] }
+        }), {});
+    }
+    isMainColumn(column) {
+        return this.mainColumn === column || isObject(column);
+    }
+    isLastColumn(column) {
+        const columnsDefinitions = this._columnsDefinitions;
+        const lastColumnDefinition = columnsDefinitions[columnsDefinitions.length - 1];
+        return isEqual(lastColumnDefinition, column) || lastColumnDefinition.includes?.(column) || false;
+    }
+    updateDefinitions() {
+        this._headCellDefinitionsSubject.next(this.getHeadCellDefinitions());
+        this._columnsDefinitions = this.getColumnsDefinitions();
+        this._columnsDefinitionsSubject.next(this._columnsDefinitions);
+    }
+    getHeadCellDefinitions() {
+        if (!this._config || !this._currentBreakpoint)
+            return [];
+        const columnsLength = this._config.columns.length;
+        const maxCurrentColumns = this.columnMapping[this._currentBreakpoint];
+        if (maxCurrentColumns >= columnsLength || this.mainColumnIndex >= maxCurrentColumns)
+            return [];
+        return [...Array(columnsLength - maxCurrentColumns).keys()].map(i => this.mainColumnIndex + i + 1);
+    }
+    getColumnsDefinitions() {
+        if (!this._config || !this._currentBreakpoint)
+            return [];
+        const columnsLength = this._config.columns.length;
+        const maxCurrentColumns = this.columnMapping[this._currentBreakpoint];
+        let columnsDefinitions = this._config.columns.map(column => column.column);
+        if (this.mainColumnIndex >= maxCurrentColumns) {
+            console.warn('QD-UI | QdTableComponent - The index of the "mainColumn" cannot be equal or greater than maximum columns for this breakpoint.');
+            return columnsDefinitions;
+        }
+        if (maxCurrentColumns >= columnsLength)
+            return columnsDefinitions;
+        columnsDefinitions = [];
+        const mergedColumns = [];
+        let alreadyMerged = false;
+        for (let i = 0; i <= columnsLength - maxCurrentColumns; i++) {
+            mergedColumns.push(this.getColumnByIndex(this.mainColumnIndex + i));
+        }
+        for (let i = 0; i < columnsLength; i++) {
+            if (mergedColumns.includes(this.getColumnByIndex(i)) && !alreadyMerged) {
+                columnsDefinitions.push(mergedColumns);
+                alreadyMerged = true;
+            }
+            if (!mergedColumns.includes(this.getColumnByIndex(i))) {
+                columnsDefinitions.push(this.getColumnByIndex(i));
+            }
+        }
+        return columnsDefinitions;
+    }
+    getColumnByIndex(columnIndex) {
+        return this._config.columns[columnIndex].column;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableResponsiveRowService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableResponsiveRowService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableResponsiveRowService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"responsive-row.service.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/table/services/responsive-row.service.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-strict-ignore\nimport { Injectable } from '@angular/core';\nimport isEqual from 'lodash/isEqual';\nimport isObject from 'lodash/isObject';\nimport { breakpoints } from '../../core/model/breakpoint.interface';\nimport { ReplaySubject } from 'rxjs';\n\n@Injectable()\nexport class QdTableResponsiveRowService<T extends string> {\n  private _config;\n  private _breakpoints = breakpoints;\n  private _currentBreakpoint = Object.keys(breakpoints)[0];\n  private _defaultColumnMapping = { xs: 1, sm: 2, md: 4, lg: 6, xl: 8, xxl: 10 };\n  private _headCellDefinitionsSubject = new ReplaySubject<number[]>(1);\n  private _columnsDefinitions: T[];\n  private _columnsDefinitionsSubject = new ReplaySubject<T[]>(1);\n\n  headCellDefinitions$ = this._headCellDefinitionsSubject.asObservable();\n  columnsDefinitions$ = this._columnsDefinitionsSubject.asObservable();\n\n  set config(config: unknown) {\n    this._config = config;\n    this.updateDefinitions();\n  }\n\n  get config(): unknown {\n    return this._config;\n  }\n\n  set currentBreakpoint(currentBreakpoint) {\n    this._currentBreakpoint = currentBreakpoint;\n    this.updateDefinitions();\n  }\n\n  get currentBreakpoint(): string {\n    return this._currentBreakpoint;\n  }\n\n  get mainColumn(): T {\n    return this._config.mainColumn || this._config.columns[0].column;\n  }\n\n  get mainColumnIndex(): number {\n    if (!this._config.mainColumn) return 0;\n\n    return this._config.columns.findIndex(column => column.column === this._config.mainColumn);\n  }\n\n  get columnMapping(): object {\n    return Object.keys(this._breakpoints).reduce(\n      (acc, cur) => ({\n        ...acc,\n        ...{ [cur]: this._config.columnMapping?.[cur] || this._defaultColumnMapping[cur] }\n      }),\n      {}\n    );\n  }\n\n  isMainColumn(column: T | T[]): boolean {\n    return this.mainColumn === column || isObject(column);\n  }\n\n  isLastColumn(column: T | T[]): boolean {\n    const columnsDefinitions = this._columnsDefinitions;\n    const lastColumnDefinition = columnsDefinitions[columnsDefinitions.length - 1];\n    return isEqual(lastColumnDefinition, column) || lastColumnDefinition.includes?.(<string>column) || false;\n  }\n\n  private updateDefinitions(): void {\n    this._headCellDefinitionsSubject.next(this.getHeadCellDefinitions());\n    this._columnsDefinitions = this.getColumnsDefinitions();\n    this._columnsDefinitionsSubject.next(this._columnsDefinitions);\n  }\n\n  private getHeadCellDefinitions(): number[] {\n    if (!this._config || !this._currentBreakpoint) return [];\n\n    const columnsLength = this._config.columns.length;\n    const maxCurrentColumns = this.columnMapping[this._currentBreakpoint];\n\n    if (maxCurrentColumns >= columnsLength || this.mainColumnIndex >= maxCurrentColumns) return [];\n\n    return [...Array(columnsLength - maxCurrentColumns).keys()].map(i => this.mainColumnIndex + i + 1);\n  }\n\n  private getColumnsDefinitions(): T[] {\n    if (!this._config || !this._currentBreakpoint) return [];\n\n    const columnsLength = this._config.columns.length;\n    const maxCurrentColumns = this.columnMapping[this._currentBreakpoint];\n\n    let columnsDefinitions: any[] = this._config.columns.map(column => column.column);\n\n    if (this.mainColumnIndex >= maxCurrentColumns) {\n      console.warn(\n        'QD-UI | QdTableComponent - The index of the \"mainColumn\" cannot be equal or greater than maximum columns for this breakpoint.'\n      );\n\n      return columnsDefinitions;\n    }\n\n    if (maxCurrentColumns >= columnsLength) return columnsDefinitions;\n\n    columnsDefinitions = [];\n\n    const mergedColumns = [];\n    let alreadyMerged = false;\n\n    for (let i = 0; i <= columnsLength - maxCurrentColumns; i++) {\n      mergedColumns.push(this.getColumnByIndex(this.mainColumnIndex + i));\n    }\n\n    for (let i = 0; i < columnsLength; i++) {\n      if (mergedColumns.includes(this.getColumnByIndex(i)) && !alreadyMerged) {\n        columnsDefinitions.push(mergedColumns);\n        alreadyMerged = true;\n      }\n\n      if (!mergedColumns.includes(this.getColumnByIndex(i))) {\n        columnsDefinitions.push(this.getColumnByIndex(i));\n      }\n    }\n\n    return columnsDefinitions;\n  }\n\n  private getColumnByIndex(columnIndex: number): T {\n    return this._config.columns[columnIndex].column;\n  }\n}\n"]}

package/esm2022/lib/table/services/row-selection.service.mjs

@@ -0,0 +1,60 @@
+// @ts-strict-ignore
+import { Injectable } from '@angular/core';
+import { combineLatest } from 'rxjs';
+import { map, skip, tap } from 'rxjs/operators';
+import { QdTableStoreService } from '../store/table-store.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../store/table-store.service";
+export class QdTableRowSelectionService {
+    tableStoreService;
+    _config;
+    _selectedRows = [];
+    constructor(tableStoreService) {
+        this.tableStoreService = tableStoreService;
+    }
+    set config(config) {
+        this._config = config;
+        this.tableStoreService.initTableStateSelectedRows(config.selection?.selectedRows || []);
+    }
+    get tableId() {
+        return this.tableStoreService.tableId;
+    }
+    get selectionType() {
+        return this._config.selection.type;
+    }
+    get selectedRows$() {
+        const isRowSelected = this.isRowSelected.bind(this);
+        return combineLatest([
+            this.tableStoreService.tableDataEntries$(),
+            this.tableStoreService.selectedRows$().pipe(tap(selectedRows => {
+                this._selectedRows = selectedRows;
+            }))
+        ]).pipe(skip(this._config.selection?.emitOutputInitially ? 0 : 1), map(([tableData]) => (tableData || []).map(this.getIndexedRows).filter(isRowSelected)));
+    }
+    isRowSelected(row, index) {
+        return this._selectedRows.includes(row.uid) || this._selectedRows.includes(index);
+    }
+    getIndexedRows(row, index) {
+        return { ...row, index };
+    }
+    isRowSelected$(rowIndex) {
+        return this.tableStoreService.isTableRowSelected$(rowIndex);
+    }
+    setRowSelected(rowIndex) {
+        if (this._config.selection.type === 'singleSelect') {
+            this.tableStoreService.updateTableStateSingleRowToSelected(rowIndex);
+        }
+        else {
+            this.tableStoreService.updateTableStateRowToSelected(rowIndex);
+        }
+    }
+    setRowUnselected(rowIndex) {
+        this.tableStoreService.updateTableStateRowToUnselected(rowIndex);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableRowSelectionService, deps: [{ token: i1.QdTableStoreService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableRowSelectionService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableRowSelectionService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.QdTableStoreService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/table/services/secondary-actions.service.mjs

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class QdTableSecondaryActionsService {
+    _configSubject = new ReplaySubject(1);
+    set configs(config) {
+        this._configSubject.next(config);
+    }
+    get configs$() {
+        return this._configSubject.asObservable();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableSecondaryActionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableSecondaryActionsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableSecondaryActionsService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vjb25kYXJ5LWFjdGlvbnMuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcWQtdWkvc3JjL2xpYi90YWJsZS9zZXJ2aWNlcy9zZWNvbmRhcnktYWN0aW9ucy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFjLGFBQWEsRUFBRSxNQUFNLE1BQU0sQ0FBQzs7QUFLakQsTUFBTSxPQUFPLDhCQUE4QjtJQUNqQyxjQUFjLEdBQUcsSUFBSSxhQUFhLENBQThCLENBQUMsQ0FBQyxDQUFDO0lBRTNFLElBQUksT0FBTyxDQUFDLE1BQW1DO1FBQzdDLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ25DLENBQUM7SUFFRCxJQUFJLFFBQVE7UUFDVixPQUFPLElBQUksQ0FBQyxjQUFjLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDNUMsQ0FBQzt1R0FUVSw4QkFBOEI7MkdBQTlCLDhCQUE4Qjs7MkZBQTlCLDhCQUE4QjtrQkFEMUMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE9ic2VydmFibGUsIFJlcGxheVN1YmplY3QgfSBmcm9tICdyeGpzJztcblxuaW1wb3J0IHsgUWRUYWJsZVNlY29uZGFyeUFjdGlvbiB9IGZyb20gJy4uL21vZGVsL3RhYmxlLWNvbmZpZy1hY3Rpb25zLmludGVyZmFjZSc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBRZFRhYmxlU2Vjb25kYXJ5QWN0aW9uc1NlcnZpY2U8VCBleHRlbmRzIHN0cmluZz4ge1xuICBwcml2YXRlIF9jb25maWdTdWJqZWN0ID0gbmV3IFJlcGxheVN1YmplY3Q8UWRUYWJsZVNlY29uZGFyeUFjdGlvbjxUPltdPigxKTtcblxuICBzZXQgY29uZmlncyhjb25maWc6IFFkVGFibGVTZWNvbmRhcnlBY3Rpb248VD5bXSkge1xuICAgIHRoaXMuX2NvbmZpZ1N1YmplY3QubmV4dChjb25maWcpO1xuICB9XG5cbiAgZ2V0IGNvbmZpZ3MkKCk6IE9ic2VydmFibGU8UWRUYWJsZVNlY29uZGFyeUFjdGlvbjxUPltdPiB7XG4gICAgcmV0dXJuIHRoaXMuX2NvbmZpZ1N1YmplY3QuYXNPYnNlcnZhYmxlKCk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/table/sort/table-sort.component.mjs

@@ -0,0 +1,126 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { filter, map, tap } from 'rxjs/operators';
+import { QdSortDirection } from '../model/sort-direction.enum';
+import { QdTableStoreService } from '../store/table-store.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../store/table-store.service";
+import * as i2 from "@angular/common";
+import * as i3 from "../../icon/icon/icon.component";
+// TODO: Add multi sort feature
+const MULTI_SORT = false;
+export class QdTableSortComponent {
+    tableStoreService;
+    isSortable = false;
+    config;
+    column;
+    testId;
+    isHovered = false;
+    isActive = false;
+    showAsc$;
+    showDesc$;
+    _isActiveSubscription = new Subscription();
+    _direction = QdSortDirection.NONE;
+    _multiSort = MULTI_SORT;
+    get direction() {
+        return this._direction;
+    }
+    set direction(direction) {
+        this._direction = direction;
+        this.isActive = direction === QdSortDirection.ASC || direction === QdSortDirection.DESC;
+    }
+    get sortDirection() {
+        return QdSortDirection;
+    }
+    constructor(tableStoreService) {
+        this.tableStoreService = tableStoreService;
+    }
+    ngOnInit() {
+        this.setInitialSort();
+        this.subscribeIsActive();
+        this.setShowAsc();
+        this.setShowDesc();
+    }
+    ngOnDestroy() {
+        this._isActiveSubscription.unsubscribe(); // takeUntil(_$destroyed) does not prevent call of selector projector
+    }
+    getOpacity() {
+        return this.isSortable && !this.isActive ? '.5' : '1';
+    }
+    handleMouseEnter() {
+        this.isHovered = true;
+    }
+    handleMouseLeave() {
+        this.isHovered = false;
+    }
+    handleClick() {
+        if (!this.isSortable)
+            return;
+        this.updateSortDirection();
+        if (!this._multiSort)
+            this.tableStoreService.setSort(this.column, this.direction);
+        if (this._multiSort)
+            this.tableStoreService.updateSort(this.column, this.direction);
+    }
+    setInitialSort() {
+        this.direction = this.config?.direction || QdSortDirection.NONE;
+    }
+    subscribeIsActive() {
+        this._isActiveSubscription = this.tableStoreService
+            .columnSortDirection$(this.column)
+            .pipe(filter(() => this.isSortable), tap(direction => (this.isActive = direction !== QdSortDirection.NONE)), tap(() => {
+            if (!this.isActive && !this._multiSort)
+                this.direction = QdSortDirection.NONE;
+        }))
+            .subscribe();
+    }
+    updateSortDirection() {
+        switch (this.direction) {
+            case QdSortDirection.NONE:
+                this.direction = QdSortDirection.ASC;
+                break;
+            case QdSortDirection.ASC:
+                this.direction = QdSortDirection.DESC;
+                break;
+            default:
+                this.direction = QdSortDirection.NONE;
+                break;
+        }
+    }
+    setShowAsc() {
+        this.showAsc$ = this.tableStoreService
+            .columnSortDirection$(this.column)
+            .pipe(map(direction => this.shouldShowArrow(direction, QdSortDirection.ASC)));
+    }
+    setShowDesc() {
+        this.showDesc$ = this.tableStoreService
+            .columnSortDirection$(this.column)
+            .pipe(map(direction => this.shouldShowArrow(direction, QdSortDirection.DESC)));
+    }
+    shouldShowArrow(direction, targetDirection) {
+        return (!this.isActive && direction !== targetDirection) || direction === targetDirection;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableSortComponent, deps: [{ token: i1.QdTableStoreService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdTableSortComponent, selector: "qd-table-sort", inputs: { isSortable: "isSortable", config: "config", column: "column", testId: ["data-test-id", "testId"] }, host: { listeners: { "mouseenter": "handleMouseEnter()", "mouseleave": "handleMouseLeave()", "click": "handleClick()" }, properties: { "class.sortable": "isSortable", "class.active": "isActive", "class.hovered": "isHovered" } }, ngImport: i0, template: "<div class=\"heading\">\n  <ng-content></ng-content>\n</div>\n\n<div *ngIf=\"isSortable\" class=\"buttons\" [style.opacity]=\"getOpacity()\" [attr.data-test-id]=\"testId + '-buttons'\">\n  <qd-icon *ngIf=\"showDesc$ | async\" icon=\"arrowDown\" [attr.data-test-id]=\"testId + '-button-arrow-down'\"></qd-icon>\n  <qd-icon *ngIf=\"showAsc$ | async\" icon=\"arrowTop\" [attr.data-test-id]=\"testId + '-button-arrow-top'\"></qd-icon>\n</div>\n", styles: [":host.sortable{display:flex;width:100%;height:2.625rem;box-sizing:content-box;justify-content:flex-end;border:solid rgb(229,229,229);border-width:0 1rem;margin-top:-.125rem;margin-left:-1rem;cursor:pointer}:host.active,:host.hovered{border-color:#d5d5d5;background:#d5d5d5}:host.active .buttons,:host.hovered .buttons{opacity:1!important}:host .heading{flex-grow:1}:host .buttons{width:1.75rem;margin-left:-1.875rem;transform:translate(1.75rem)}.qd-icon{display:inline-flex;width:.5rem;font-size:1rem;font-weight:400;transform:translate(-.625rem)}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.QdIconComponent, selector: "qd-icon", inputs: ["icon"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableSortComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-table-sort', changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        '[class.sortable]': 'isSortable',
+                        '[class.active]': 'isActive',
+                        '[class.hovered]': 'isHovered',
+                        '(mouseenter)': 'handleMouseEnter()',
+                        '(mouseleave)': 'handleMouseLeave()',
+                        '(click)': 'handleClick()'
+                    }, template: "<div class=\"heading\">\n  <ng-content></ng-content>\n</div>\n\n<div *ngIf=\"isSortable\" class=\"buttons\" [style.opacity]=\"getOpacity()\" [attr.data-test-id]=\"testId + '-buttons'\">\n  <qd-icon *ngIf=\"showDesc$ | async\" icon=\"arrowDown\" [attr.data-test-id]=\"testId + '-button-arrow-down'\"></qd-icon>\n  <qd-icon *ngIf=\"showAsc$ | async\" icon=\"arrowTop\" [attr.data-test-id]=\"testId + '-button-arrow-top'\"></qd-icon>\n</div>\n", styles: [":host.sortable{display:flex;width:100%;height:2.625rem;box-sizing:content-box;justify-content:flex-end;border:solid rgb(229,229,229);border-width:0 1rem;margin-top:-.125rem;margin-left:-1rem;cursor:pointer}:host.active,:host.hovered{border-color:#d5d5d5;background:#d5d5d5}:host.active .buttons,:host.hovered .buttons{opacity:1!important}:host .heading{flex-grow:1}:host .buttons{width:1.75rem;margin-left:-1.875rem;transform:translate(1.75rem)}.qd-icon{display:inline-flex;width:.5rem;font-size:1rem;font-weight:400;transform:translate(-.625rem)}\n"] }]
+        }], ctorParameters: () => [{ type: i1.QdTableStoreService }], propDecorators: { isSortable: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], column: [{
+                type: Input
+            }], testId: [{
+                type: Input,
+                args: ['data-test-id']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-sort.component.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/table/sort/table-sort.component.ts","../../../../../../libs/qd-ui/src/lib/table/sort/table-sort.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, Input, OnDestroy, OnInit } from '@angular/core';\nimport { Observable, Subscription } from 'rxjs';\nimport { filter, map, tap } from 'rxjs/operators';\n\nimport { QdSortDirection } from '../model/sort-direction.enum';\nimport { QdTableConfigColumnSort } from '../model/table-config.interface';\nimport { QdTableStoreService } from '../store/table-store.service';\n\n// TODO: Add multi sort feature\nconst MULTI_SORT = false;\n\n@Component({\n  selector: 'qd-table-sort',\n  templateUrl: 'table-sort.component.html',\n  styleUrls: ['table-sort.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: {\n    '[class.sortable]': 'isSortable',\n    '[class.active]': 'isActive',\n    '[class.hovered]': 'isHovered',\n    '(mouseenter)': 'handleMouseEnter()',\n    '(mouseleave)': 'handleMouseLeave()',\n    '(click)': 'handleClick()'\n  }\n})\nexport class QdTableSortComponent<T extends string> implements OnInit, OnDestroy {\n  @Input() isSortable = false;\n  @Input() config!: QdTableConfigColumnSort;\n  @Input() column!: string;\n\n  @Input('data-test-id') testId?: string;\n\n  isHovered = false;\n  isActive = false;\n  showAsc$?: Observable<boolean>;\n  showDesc$?: Observable<boolean>;\n\n  private _isActiveSubscription: Subscription = new Subscription();\n  private _direction: QdSortDirection = QdSortDirection.NONE;\n  private _multiSort = MULTI_SORT;\n\n  get direction(): QdSortDirection {\n    return this._direction;\n  }\n\n  set direction(direction: QdSortDirection) {\n    this._direction = direction;\n    this.isActive = direction === QdSortDirection.ASC || direction === QdSortDirection.DESC;\n  }\n\n  get sortDirection(): typeof QdSortDirection {\n    return QdSortDirection;\n  }\n\n  constructor(private readonly tableStoreService: QdTableStoreService<T>) {}\n\n  ngOnInit(): void {\n    this.setInitialSort();\n\n    this.subscribeIsActive();\n    this.setShowAsc();\n    this.setShowDesc();\n  }\n\n  ngOnDestroy(): void {\n    this._isActiveSubscription.unsubscribe(); // takeUntil(_$destroyed) does not prevent call of selector projector\n  }\n\n  getOpacity(): string {\n    return this.isSortable && !this.isActive ? '.5' : '1';\n  }\n\n  handleMouseEnter(): void {\n    this.isHovered = true;\n  }\n\n  handleMouseLeave(): void {\n    this.isHovered = false;\n  }\n\n  handleClick(): void {\n    if (!this.isSortable) return;\n\n    this.updateSortDirection();\n\n    if (!this._multiSort) this.tableStoreService.setSort(this.column, this.direction);\n\n    if (this._multiSort) this.tableStoreService.updateSort(this.column, this.direction);\n  }\n\n  private setInitialSort(): void {\n    this.direction = this.config?.direction || QdSortDirection.NONE;\n  }\n\n  private subscribeIsActive(): void {\n    this._isActiveSubscription = this.tableStoreService\n      .columnSortDirection$(this.column)\n      .pipe(\n        filter(() => this.isSortable),\n        tap(direction => (this.isActive = direction !== QdSortDirection.NONE)),\n        tap(() => {\n          if (!this.isActive && !this._multiSort) this.direction = QdSortDirection.NONE;\n        })\n      )\n      .subscribe();\n  }\n\n  private updateSortDirection(): void {\n    switch (this.direction) {\n      case QdSortDirection.NONE:\n        this.direction = QdSortDirection.ASC;\n        break;\n      case QdSortDirection.ASC:\n        this.direction = QdSortDirection.DESC;\n        break;\n      default:\n        this.direction = QdSortDirection.NONE;\n        break;\n    }\n  }\n\n  private setShowAsc(): void {\n    this.showAsc$ = this.tableStoreService\n      .columnSortDirection$(this.column)\n      .pipe(map(direction => this.shouldShowArrow(direction, QdSortDirection.ASC)));\n  }\n\n  private setShowDesc(): void {\n    this.showDesc$ = this.tableStoreService\n      .columnSortDirection$(this.column)\n      .pipe(map(direction => this.shouldShowArrow(direction, QdSortDirection.DESC)));\n  }\n\n  private shouldShowArrow(direction: QdSortDirection, targetDirection: QdSortDirection): boolean {\n    return (!this.isActive && direction !== targetDirection) || direction === targetDirection;\n  }\n}\n","<div class=\"heading\">\n  <ng-content></ng-content>\n</div>\n\n<div *ngIf=\"isSortable\" class=\"buttons\" [style.opacity]=\"getOpacity()\" [attr.data-test-id]=\"testId + '-buttons'\">\n  <qd-icon *ngIf=\"showDesc$ | async\" icon=\"arrowDown\" [attr.data-test-id]=\"testId + '-button-arrow-down'\"></qd-icon>\n  <qd-icon *ngIf=\"showAsc$ | async\" icon=\"arrowTop\" [attr.data-test-id]=\"testId + '-button-arrow-top'\"></qd-icon>\n</div>\n"]}

package/esm2022/lib/table/store/table-store-selector.service.mjs

@@ -0,0 +1,123 @@
+import { Injectable } from '@angular/core';
+import { createSelector } from '@ngrx/store';
+import { QdTableConnectorState } from '../model/connectors-state.enum';
+import { QdSortDirection } from '../model/sort-direction.enum';
+import { QdTableRequestState } from '../model/table-data-resolver';
+import * as i0 from "@angular/core";
+export class QdTableStoreSelectorService {
+    _tableId;
+    set tableId(tableId) {
+        this._tableId = tableId;
+    }
+    table() {
+        return createSelector(this.selectTables, tables => this.getTable(tables));
+    }
+    tableDataEntries() {
+        return createSelector(this.selectTables, tables => this.getTable(tables)?.data ?? []);
+    }
+    tableRow(rowIndex) {
+        return createSelector(this.selectTables, tables => this.getTable(tables)?.data[rowIndex]);
+    }
+    selectedRows() {
+        return createSelector(this.selectTables, tables => this.getTable(tables)?.selectedRows ?? []);
+    }
+    isTableRowSelected(rowIndex) {
+        return createSelector(this.selectTables, tables => {
+            const table = this.getTable(tables);
+            if (!table)
+                return false;
+            const tableUid = table.data[rowIndex]?.uid;
+            return table.selectedRows?.includes(rowIndex) || (tableUid && table.selectedRows?.includes(tableUid)) || false;
+        });
+    }
+    recentSecondaryAction() {
+        return createSelector(this.selectTables, tables => this.getTable(tables)?.recentSecondaryAction);
+    }
+    canPageForward() {
+        return createSelector(this.selectTables, tables => (this.getTable(tables)?.pageSize ?? 0) * ((this.getTable(tables)?.pageIndex ?? 0) + 1) <
+            (this.getTable(tables)?.totalCount ?? 0));
+    }
+    canPageBackward() {
+        return createSelector(this.selectTables, tables => (this.getTable(tables)?.pageIndex ?? 0) > 0);
+    }
+    pageSize() {
+        return createSelector(this.selectTables, tables => this.getTable(tables)?.pageSize ?? 0);
+    }
+    pageInfo() {
+        return createSelector(this.selectTables, tables => {
+            const { pageIndex, pageSize, totalCount } = this.getTable(tables) || {};
+            if (pageIndex === undefined || pageSize === undefined || totalCount === undefined)
+                return undefined;
+            return {
+                start: pageIndex * pageSize + 1,
+                end: pageSize * (pageIndex + 1) < totalCount ? (pageIndex + 1) * pageSize : totalCount,
+                totalCount
+            };
+        });
+    }
+    totalCount() {
+        return createSelector(this.selectTables, tables => this.getTable(tables)?.totalCount ?? 0);
+    }
+    pageChangeInfo() {
+        return createSelector(this.selectTables, tables => {
+            const { pageIndex, pageSize, requestState } = this.getTable(tables) || {};
+            if (pageIndex === undefined || pageSize === undefined || requestState === undefined)
+                return undefined;
+            return {
+                pageIndex,
+                pageSize,
+                requestState
+            };
+        });
+    }
+    columnSortDirection(column) {
+        return createSelector(this.selectTables, tables => {
+            const { sort } = this.getTable(tables) || {};
+            if (!sort)
+                return QdSortDirection.NONE;
+            return sort.find(entry => entry.column === column)?.direction ?? QdSortDirection.NONE;
+        });
+    }
+    selectIsLoading() {
+        return createSelector(this.selectTables, tables => {
+            const { requestState } = this.getTable(tables) || {};
+            return requestState === QdTableRequestState.PENDING;
+        });
+    }
+    selectConnectorState(connectorName) {
+        return createSelector(this.selectTables, tables => {
+            const { connectors } = this.getTable(tables) || {};
+            return (connectors?.find(connector => connector.connectorName === connectorName)?.connectorState ??
+                QdTableConnectorState.NONE);
+        });
+    }
+    selectDataResolutionCriteria() {
+        // @ts-ignore
+        return createSelector(this.selectTables, tables => {
+            const { connectors, connectorCriteria, pageIndex, pageSize, sort } = this.getTable(tables) || {};
+            const connectorsState = connectors?.some(c => c.connectorState === QdTableConnectorState.AWAITING)
+                ? QdTableConnectorState.AWAITING
+                : connectors
+                    ? QdTableConnectorState.ESTABLISHED
+                    : QdTableConnectorState.NONE;
+            return {
+                hasConnectors: (connectors?.length ?? 0) > 0,
+                connectorsState,
+                tableParams: { page: pageIndex, size: pageSize, sort },
+                connectorParams: connectorCriteria ? { ...connectorCriteria } : undefined
+            };
+        });
+    }
+    selectTables(state) {
+        return state.qdUiTable;
+    }
+    getTable(tables) {
+        return this._tableId ? tables[this._tableId] : undefined;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableStoreSelectorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableStoreSelectorService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTableStoreSelectorService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-store-selector.service.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/table/store/table-store-selector.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { createSelector, MemoizedSelector } from '@ngrx/store';\n\nimport { QdTableConnectorState } from '../model/connectors-state.enum';\nimport { QdSortDirection } from '../model/sort-direction.enum';\nimport { QdTableRequestState } from '../model/table-data-resolver';\nimport {\n  QdTableData,\n  QdTableDataRow,\n  QdTableRecentSecondaryAction,\n  QdTableRowIdentifier\n} from '../model/table-data.interface';\nimport {\n  QdTableDataResolutionCriteria,\n  QdTableState,\n  QdTableStore,\n  QdTableStoreData\n} from '../model/table-store.interface';\n\n@Injectable()\nexport class QdTableStoreSelectorService {\n  private _tableId?: string;\n\n  set tableId(tableId: string | undefined) {\n    this._tableId = tableId;\n  }\n\n  table(): MemoizedSelector<\n    any,\n    QdTableState<any> | undefined,\n    (s: QdTableStoreData<any>) => QdTableState<any> | undefined\n  > {\n    return createSelector(this.selectTables, tables => this.getTable(tables));\n  }\n\n  tableDataEntries(): MemoizedSelector<any, QdTableData<any>, (s: QdTableStoreData<any>) => QdTableData<any>> {\n    return createSelector(this.selectTables, tables => this.getTable(tables)?.data ?? []);\n  }\n\n  tableRow(\n    rowIndex: number\n  ): MemoizedSelector<\n    any,\n    QdTableDataRow<any> | undefined,\n    (s: QdTableStoreData<any>) => QdTableDataRow<any> | undefined\n  > {\n    return createSelector(this.selectTables, tables => this.getTable(tables)?.data[rowIndex]);\n  }\n\n  selectedRows(): MemoizedSelector<any, QdTableRowIdentifier[], (s: QdTableStoreData<any>) => QdTableRowIdentifier[]> {\n    return createSelector(this.selectTables, tables => this.getTable(tables)?.selectedRows ?? []);\n  }\n\n  isTableRowSelected(rowIndex: number): MemoizedSelector<any, boolean, (s: QdTableStoreData<any>) => boolean> {\n    return createSelector(this.selectTables, tables => {\n      const table = this.getTable(tables);\n      if (!table) return false;\n      const tableUid = table.data[rowIndex]?.uid;\n      return table.selectedRows?.includes(rowIndex) || (tableUid && table.selectedRows?.includes(tableUid)) || false;\n    });\n  }\n\n  recentSecondaryAction(): MemoizedSelector<\n    any,\n    QdTableRecentSecondaryAction<any> | undefined,\n    (s: QdTableStoreData<any>) => QdTableRecentSecondaryAction<any> | undefined\n  > {\n    return createSelector(this.selectTables, tables => this.getTable(tables)?.recentSecondaryAction);\n  }\n\n  canPageForward(): MemoizedSelector<any, boolean, (s1: QdTableStoreData<any>) => boolean> {\n    return createSelector(\n      this.selectTables,\n      tables =>\n        (this.getTable(tables)?.pageSize ?? 0) * ((this.getTable(tables)?.pageIndex ?? 0) + 1) <\n        (this.getTable(tables)?.totalCount ?? 0)\n    );\n  }\n\n  canPageBackward(): MemoizedSelector<any, boolean, (s1: QdTableStoreData<any>) => boolean> {\n    return createSelector(this.selectTables, tables => (this.getTable(tables)?.pageIndex ?? 0) > 0);\n  }\n\n  pageSize(): MemoizedSelector<any, number, (s1: QdTableStoreData<any>) => number> {\n    return createSelector(this.selectTables, tables => this.getTable(tables)?.pageSize ?? 0);\n  }\n\n  pageInfo(): MemoizedSelector<\n    any,\n    | {\n        start: number;\n        end: number;\n        totalCount: number;\n      }\n    | undefined,\n    (s1: QdTableStoreData<any>) =>\n      | {\n          start: number;\n          end: number;\n          totalCount: number;\n        }\n      | undefined\n  > {\n    return createSelector(this.selectTables, tables => {\n      const { pageIndex, pageSize, totalCount } = this.getTable(tables) || {};\n      if (pageIndex === undefined || pageSize === undefined || totalCount === undefined) return undefined;\n      return {\n        start: pageIndex * pageSize + 1,\n        end: pageSize * (pageIndex + 1) < totalCount ? (pageIndex + 1) * pageSize : totalCount,\n        totalCount\n      };\n    });\n  }\n\n  totalCount(): MemoizedSelector<any, number, (s1: QdTableStoreData<any>) => number> {\n    return createSelector(this.selectTables, tables => this.getTable(tables)?.totalCount ?? 0);\n  }\n\n  pageChangeInfo(): MemoizedSelector<\n    any,\n    | {\n        pageIndex: number;\n        pageSize: number;\n        requestState: QdTableRequestState;\n      }\n    | undefined,\n    (s1: QdTableStoreData<any>) =>\n      | {\n          pageIndex: number;\n          pageSize: number;\n          requestState: QdTableRequestState;\n        }\n      | undefined\n  > {\n    return createSelector(this.selectTables, tables => {\n      const { pageIndex, pageSize, requestState } = this.getTable(tables) || {};\n      if (pageIndex === undefined || pageSize === undefined || requestState === undefined) return undefined;\n\n      return {\n        pageIndex,\n        pageSize,\n        requestState\n      };\n    });\n  }\n\n  columnSortDirection(\n    column: string\n  ): MemoizedSelector<any, QdSortDirection, (s1: QdTableStoreData<any>) => QdSortDirection> {\n    return createSelector(this.selectTables, tables => {\n      const { sort } = this.getTable(tables) || {};\n\n      if (!sort) return QdSortDirection.NONE;\n\n      return sort.find(entry => entry.column === column)?.direction ?? QdSortDirection.NONE;\n    });\n  }\n\n  selectIsLoading(): MemoizedSelector<any, boolean, (s1: QdTableStoreData<any>) => boolean> {\n    return createSelector(this.selectTables, tables => {\n      const { requestState } = this.getTable(tables) || {};\n\n      return requestState === QdTableRequestState.PENDING;\n    });\n  }\n\n  selectConnectorState(\n    connectorName: string\n  ): MemoizedSelector<any, QdTableConnectorState, (s1: QdTableStoreData<any>) => QdTableConnectorState> {\n    return createSelector(this.selectTables, tables => {\n      const { connectors } = this.getTable(tables) || {};\n\n      return (\n        connectors?.find(connector => connector.connectorName === connectorName)?.connectorState ??\n        QdTableConnectorState.NONE\n      );\n    });\n  }\n\n  selectDataResolutionCriteria(): MemoizedSelector<\n    any,\n    QdTableDataResolutionCriteria<any>,\n    (s1: QdTableStoreData<any>) => any\n  > {\n    // @ts-ignore\n    return createSelector(this.selectTables, tables => {\n      const { connectors, connectorCriteria, pageIndex, pageSize, sort } = this.getTable(tables) || {};\n      const connectorsState = connectors?.some(c => c.connectorState === QdTableConnectorState.AWAITING)\n        ? QdTableConnectorState.AWAITING\n        : connectors\n        ? QdTableConnectorState.ESTABLISHED\n        : QdTableConnectorState.NONE;\n\n      return {\n        hasConnectors: (connectors?.length ?? 0) > 0,\n        connectorsState,\n        tableParams: { page: pageIndex, size: pageSize, sort },\n        connectorParams: connectorCriteria ? { ...connectorCriteria } : undefined\n      };\n    });\n  }\n\n  private selectTables(state: QdTableStore<any>): QdTableStoreData<any> {\n    return state.qdUiTable;\n  }\n\n  private getTable(tables: QdTableStoreData<any>): QdTableState<any> | undefined {\n    return this._tableId ? tables[this._tableId] : undefined;\n  }\n}\n"]}