@quadrel-enterprise-ui/framework 1.0.0 → 18.19.2

package/esm2022/lib/table/model/sort-direction.enum.mjs

@@ -0,0 +1,7 @@
+export var QdSortDirection;
+(function (QdSortDirection) {
+    QdSortDirection[QdSortDirection["NONE"] = 0] = "NONE";
+    QdSortDirection[QdSortDirection["ASC"] = 1] = "ASC";
+    QdSortDirection[QdSortDirection["DESC"] = 2] = "DESC";
+})(QdSortDirection || (QdSortDirection = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ydC1kaXJlY3Rpb24uZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcWQtdWkvc3JjL2xpYi90YWJsZS9tb2RlbC9zb3J0LWRpcmVjdGlvbi5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLGVBSVg7QUFKRCxXQUFZLGVBQWU7SUFDekIscURBQUksQ0FBQTtJQUNKLG1EQUFHLENBQUE7SUFDSCxxREFBSSxDQUFBO0FBQ04sQ0FBQyxFQUpXLGVBQWUsS0FBZixlQUFlLFFBSTFCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gUWRTb3J0RGlyZWN0aW9uIHtcbiAgTk9ORSxcbiAgQVNDLFxuICBERVNDXG59XG4iXX0=

package/esm2022/lib/table/model/table-config-actions.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/table/model/table-config-content.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-config-content.interface.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/table/model/table-config-content.interface.ts"],"names":[],"mappings":"","sourcesContent":["// @ts-strict-ignore\nimport { QdChipColor } from '../../chips/chips.module';\nimport {\n  QdDataFacetsChipConfig,\n  QdDataFacetsCurrencyConfig,\n  QdDataFacetsDateConfig,\n  QdDataFacetsLinkConfig,\n  QdDataFacetsStatusData,\n  QdDataFacetsTextConfig\n} from '../../core/data-facets/data-facets.module';\n\nexport type QdTableColumnOptions =\n  | QdTableConfigColumnLinkOptions\n  | QdTableConfigColumnCurrencyOptions\n  | QdTableConfigColumnDateOptions\n  | QdTableConfigColumnTextOptions;\n\n/**\n * @description Defines the types and therefore the appearance of the content items.\n *\n * * Attention: Not all Content Types are actually implemented yet! They will follow later.\n */\nexport type QdTableConfigColumnType =\n  /**\n   * @description Renders a blank cell.\n   */\n  | { type: 'blank' }\n\n  /**\n   * @description Renders a checkmark icon if the value is true.\n   */\n  | { type: 'boolean' }\n\n  /**\n   * @description Renders a number/quantity.\n   */\n  | { type: 'integer' }\n\n  /**\n   * @description Renders a progress bar.\n   */\n  | { type: 'progress' }\n\n  /**\n   * @description Renders one or multiple links.\n   */\n  | { type: 'link'; options: QdDataFacetsLinkConfig }\n\n  /**\n   * @description Renders a text.\n   */\n  | { type: 'text'; options?: QdDataFacetsTextConfig }\n\n  /**\n   * @description Renders a single chip.\n   *\n   * * Note: The content type \"chip\" can handle a single chip or an array of chips.\n   *         A chip can be a simple string or an object of the form { label: string; level: QdChipColor }.\n   */\n  | { type: 'chip'; options?: QdDataFacetsChipConfig }\n\n  /**\n   * @description Renders the status with status indicator.\n   */\n  | { type: 'status'; options?: QdDataFacetsStatusData }\n\n  /**\n   * @description Renders an icon of the QD icon set.\n   */\n  | { type: 'icon' }\n\n  /**\n   * @description Renders a date and time either with default format or with the format specified in the provided options.\n   *\n   * * Note: Like the Angular DatePipe it is based on, the content type \"dateTime\" can handle multiple input types: string | number | Date\n   */\n  | { type: 'date'; options?: QdDataFacetsDateConfig }\n\n  /**\n   * @description Configuration options for currency values.\n   */\n  | { type: 'currency'; options?: QdDataFacetsCurrencyConfig };\n\n/**\n * @description Type definitions for the 'text' options.\n */\nexport type QdTableConfigColumnTextOptions = {\n  /**\n   * @description If \"true\", the value is used as i18n key segment.\n   *\n   *  * @default: false\n   */\n  isTranslated?: boolean;\n\n  /**\n   * @description Defines the text transform operation of the value.\n   *\n   *  * @default: 'none'\n   */\n  textTransform?: 'capitalize' | 'uppercase' | 'lowercase' | 'full-width' | 'full-size-kana' | 'none';\n};\n\n/**\n * @description Type definitions for the 'chip' options.\n */\nexport type QdTableConfigColumnChipOptions = {\n  /**\n   * @description If \"true\", the value is used as i18n key segment.\n   *\n   *  * @default: false\n   */\n  isTranslated?: boolean;\n\n  /**\n   * @description With this mapping you can define the chip level for each label.\n   */\n  levelMapping?: { [label: string]: QdChipColor };\n\n  /**\n   * @description Maximum number of chips that will be displayed in the cell.\n   * If this number is exceeded, a small chip with the number of exceeding chips will be displayed.\n   * When this small chip is hovered or tapped, the truncated chips will be displayed in a tooltip.\n   *\n   * @default null (unlimited)\n   */\n  maxChipCount?: number;\n};\n\n/**\n * @description Type definitions for the 'link' options.\n * Handler to handle the event.\n */\nexport type QdTableConfigColumnLinkOptions = { handler: (unknown) => void };\n\n/**\n * @description Configuration options for date display in the QdTableDataDateComponent.\n * The \"date\" type supports formatting for strings, numbers or Date objects, providing multiple display options.\n */\nexport type QdTableConfigColumnDateOptions = {\n  /**\n   * @description Set the format to be used for date display.\n   * * Note: Supports both the pre-defined format options (long, short, narrow) for relative time, and custom formats from Intl API for absolute Date/Time.\n   *\n   *  * @default: 'long'\n   */\n  format?: 'long' | 'short' | 'narrow';\n\n  /**\n   * @description Set the timezone to be used for date display.\n   *\n   * * @note Will be used for absolute time display using the Intl.DateTimeFormat.\n   *\n   * * If not provided, the timezone will be determined based on the user's browser settings.\n   * * The provided timezone takes precedence over the timezone derived from the ISO string or numeric timestamp.\n   * * If both ISO string/numeric timestamp and timezone are provided, the date will be formatted in the specified timezone.\n   * * If only the ISO string/numeric timestamp is provided, it will be formatted in the user's local timezone or the browser's timezone.\n   *\n   * @default undefined\n   */\n  timezone?: string;\n\n  /**\n   * @description If \"true\", the value is used as relative time format.\n   * * Note: When `isRelative` is set to `true`, the component utilizes the Intl.RelativeTimeFormat API for displaying relative time.\n   *\n   *  * @default: false\n   */\n  isRelative?: boolean;\n\n  /**\n   * @description The time unit to use when displaying relative time.\n   *\n   * * @note Possible values: \"year\", \"quarter\", \"month\", \"week\", \"day\", \"hour\", \"minute\", \"second\".This unit is determined by the Intl.RelativeTimeFormat API.\n   *\n   * * @default: \"day\"\n   */\n  unitIfRelative?: 'year' | 'quarter' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second';\n\n  /**\n   * @description If \"true\", the time portion of the value is included in the display.\n   *\n   *  * @default: true\n   */\n  hasTime?: boolean;\n};\n\n/**\n * @description Configuration options for currency values.\n */\nexport type QdTableConfigColumnCurrencyOptions = {\n  /**\n   * @description The currency code (e.g., 'usd', 'eur', 'chf') for formatting currency values.\n   *\n   * * @default 'chf'\n   */\n  currency?: string;\n\n  /**\n   * @description Show or hide the currency unit per column. Useful when the currency per column is always the same. If this is the case, the currency unit can be displayed in the table header instead.\n   *\n   * * @default false\n   */\n  showCurrencyUnit?: boolean;\n};\n"]}

package/esm2022/lib/table/model/table-config.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-config.interface.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/table/model/table-config.interface.ts"],"names":[],"mappings":"","sourcesContent":["import { Observable } from 'rxjs';\nimport { QdBreakpoint } from '../../core/model/breakpoint.interface';\nimport { QdSortDirection } from './sort-direction.enum';\nimport {\n  QdTableConfigGroup,\n  QdTableConfigSelection,\n  QdTablePrimaryAction,\n  QdTableSecondaryAction\n} from './table-config-actions.interface';\nimport { QdTableConfigColumnType } from './table-config-content.interface';\n\n/**\n * Describes which column is filling the table's width.\n * In \"harmonized\" mode the whitespace will be distributed evenly, considering the width of each column.\n */\nexport type QdTableFillingColumn = 'main' | 'last' | 'harmonized' | 'none';\n\n/**\n * @description Configuration Model for Qd-Tables. The generic type defines the table columns keys.\n */\nexport interface QdTableConfig<T extends string> {\n  /**\n   * @description Defines the columns of the table.\n   */\n  columns: QdTableConfigColumn<T>[];\n\n  /**\n   * @description Configures the behavior of the groups in the tree view.\n   * @deprecated use qd-tree instead\n   */\n  group?: QdTableConfigGroup;\n\n  /**\n   * @description Activates a pagination\n   *\n   * * @default: false\n   * * @deprecated\n   */\n  hasPagination?: boolean;\n\n  /**\n   * @description Activates a pagination with configurable available page sizes\n   */\n  pagination?: true | QdTablePagination;\n\n  /**\n   * @description Sets an alternative view if no elements are available in QdTableData\n   */\n  emptyStateView?: QdTableEmptyStateView;\n\n  /**\n   * @description Defines a list of secondary actions that can be executed per Click/Tab of an item in the menu.\n   *\n   * * @example\n   * This is how the two actions \"edit\" and \"delete\" are created.\n   * ```ts\n   * secondaryActions: [\n   *    {\n   *      type: 'edit',\n   *      handler: rowData => doSomethingWith(rowData)\n   *    },\n   *    {\n   *      type: 'delete',\n   *      isDisabled: true,\n   *      handler: rowData => doSomethingWith(rowData)\n   *    }\n   * ]\n   * ```\n   */\n  secondaryActions?: QdTableSecondaryAction<T>[];\n\n  /**\n   * @description Defines the primary action that can be executed by clicking on a row.\n   *\n   * @example\n   * You provide a primary action like this.\n   * ``ts\n   * primaryAction: {\n   *   handler: row => openModal(row)\n   * }\n   */\n  primaryAction?: QdTablePrimaryAction<T>;\n\n  /**\n   * @description Configures selection options for table rows.\n   *\n   * * @example\n   * This creates a \"multiSelect\".\n   * ```ts\n   * selection: {\n   *    type: 'multiSelect',\n   *    handler: selectedRows => doSomethingWith(selectedRows)\n   * }\n   * ```\n   */\n  selection?: QdTableConfigSelection<T>;\n\n  /**\n   * @description Sets the translation keys (plural) for the table headings and more, as the 'context' for instance.\n   *\n   * * @example: \"i18n.my.table.<column>\".\n   *\n   * If none exits, the value is rendered without translation.\n   */\n  i18ns?: string;\n\n  /**\n   * @description Turns a specified column into a main column. Main Columns have different presentation properties.\n   *\n   * * @default: columns[0].column\n   */\n  mainColumn?: T;\n\n  /**\n   * @description By default the main column fills the remaining width so that the table has a width of 100%.\n   * By setting this property the main column will have content width.\n   *\n   * * @default: false\n   * * @deprecated\n   */\n  mainColumnNotFillingWidth?: boolean;\n\n  /**\n   * @description Usually the table fills 100% of the width.\n   *\n   * This value defines which column fills the space in the table to its full width.\n   * In \"harmonized\" mode the whitespace will be distributed evenly, considering the width of each column.\n   * If the value \"none\" is used, the table can be less than 100% in width.\n   *\n   * Find out more in the related type \"QdTableConfig<T>['mainColumn']\".\n   *\n   * * @default: 'main'\n   */\n  whichColumnFillsWidth?: QdTableFillingColumn;\n\n  /**\n   * @description Enables \"viewonly\" mode for the table.\n   *\n   * When set to `true`, the table displays its content as read-only.\n   * Combined with `secondaryActions`, this can be used to selectively show or hide secondary actions\n   * based on the operation mode (`'view'` or `'edit'`) used in the Quadrel framework.\n   *\n   * * If `viewonly` is explicitly set, it overrides the global operation mode\n   * (which is normally controlled through external events).\n   * This gives you full control: for example, setting `viewonly: false` will allow edit actions to be shown,\n   * even if the global mode would normally hide them.\n   *\n   * * @default false\n   */\n  viewonly?: boolean;\n\n  /**\n   * @description Sets the maximum number of columns over the breakpoints.\n   *\n   * * @default: { xs: 1, sm: 2, md: 4, lg: 6, xl: 8, xxl: 10 }\n   *\n   * * @example\n   * ```ts\n   * { xs: 1, sm: 2, md: 4, lg: 6, xl: 8, xxl: 10 }\n   * ```\n   */\n  columnMapping?: { [key in QdBreakpoint]?: QdMaxColumnsCount };\n\n  /**\n   * @description Observable to trigger a table refresh from outside.\n   *\n   * - `number` sets the page index to refresh.\n   * - `undefined` triggers a general refresh (current page stays the same).\n   *\n   * @example\n   * ```ts\n   * refresh$.next();      // refresh current page\n   * refresh$.next(0);     // refresh and go to first page\n   * ```\n   */\n  refresh?: Observable<number | undefined>;\n\n  /**\n   * @description Determines if the table should refresh when the language is changed.\n   *\n   * * @default: false\n   */\n  refreshOnLanguageChange?: boolean;\n\n  /**\n   * @description When this flag is set, the table will be refreshed for every RESOURCE_UPDATED event\n   * with a path that matches the table uid.\n   * Important: You have to create the connection to the SSE backend service on your own with the QdPushEventsService\n   * (connect method).\n   */\n  refreshOnPushEvent?: boolean;\n\n  /**\n   * @description Sets a unique identifier for the table. Used as key to hold in NgRx store.\n   *\n   * * @default: random RFC 4122 Identifier\n   */\n  uid?: string;\n}\n\ninterface QdTableConfigColumnBase<T> {\n  /**\n   * @description Defines the key of the column.\n   */\n  column: T;\n\n  /**\n   * @description Makes the column sortable. If this key has been defined, the sorting will be turned on.\n   */\n  sort?: QdTableConfigColumnSort;\n\n  /**\n   * @description Defines the breakpoint at which the column is hidden. Use for mobile devices.\n   */\n  hiddenAt?: QdBreakpoint;\n}\n\n/**\n * @description Configuration for sorting\n */\nexport interface QdTableConfigColumnSort {\n  /**\n   * @description Sorting can be deactivated here.\n   *\n   * * @default: false\n   */\n  isDisabled?: boolean;\n\n  /**\n   * @description The direction of sorting.\n   *\n   * * @default: QdSortDirection.NONE\n   */\n  direction?: QdSortDirection;\n}\n\n/**\n * @description Maximum number of columns depending on the current breakpoint.\n *\n * * @default: { xs: 1, sm: 2, md: 4, lg: 6, xl: 8, xxl: 10 }\n */\ntype QdMaxColumnsCount = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;\n\nexport type QdTableConfigColumn<T> = QdTableConfigColumnType & QdTableConfigColumnBase<T>;\n\n/**\n * @description Configuration model for pagination\n */\nexport interface QdTablePagination {\n  /**\n   * @description Initial pagination page size\n   *\n   * * @default 25\n   */\n  pageSizeDefault?: number;\n\n  /**\n   * @description List of available pagination page sizes\n   *\n   * * @example [25, 50, 100]\n   */\n  pageSizes?: number[];\n\n  /**\n   * @description Activates the first & last buttons for quick navigation\n   *\n   * * @default: false\n   */\n  hasFirstLastPageNavigation?: boolean;\n}\n\n/**\n * @description Configuration model for empty state view\n */\nexport interface QdTableEmptyStateView {\n  /**\n   * @description Toggles the empty view off, if set to \"true\".\n   *\n   * * @default: false\n   */\n  disabled?: boolean;\n\n  /**\n   * @description Renders a call-to-action button.\n   *\n   * * @default: false\n   */\n  action?: boolean;\n\n  /**\n   * @description Defines a handler that is triggered by a click/tap on the call-to-action button.\n   * Will only be triggered if \"action\" is set to \"true\n   */\n  handler?: () => void;\n}\n"]}

package/esm2022/lib/table/model/table-data-resolver.mjs

@@ -0,0 +1,10 @@
+/**
+ * Represents the request state for a table using QdTableDataResolver.
+ * Additional states can be added as needed.
+ */
+export var QdTableRequestState;
+(function (QdTableRequestState) {
+    QdTableRequestState[QdTableRequestState["PENDING"] = 0] = "PENDING";
+    QdTableRequestState[QdTableRequestState["SUCCESS"] = 1] = "SUCCESS";
+})(QdTableRequestState || (QdTableRequestState = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUtZGF0YS1yZXNvbHZlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcWQtdWkvc3JjL2xpYi90YWJsZS9tb2RlbC90YWJsZS1kYXRhLXJlc29sdmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQThFQTs7O0dBR0c7QUFDSCxNQUFNLENBQU4sSUFBWSxtQkFHWDtBQUhELFdBQVksbUJBQW1CO0lBQzdCLG1FQUFPLENBQUE7SUFDUCxtRUFBTyxDQUFBO0FBQ1QsQ0FBQyxFQUhXLG1CQUFtQixLQUFuQixtQkFBbUIsUUFHOUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBRZEZpbHRlclBvc3RCb2R5RGF0YSB9IGZyb20gJy4uLy4uL2ZpbHRlci9maWx0ZXIubW9kdWxlJztcbmltcG9ydCB7IFFkU2VhcmNoUG9zdEJvZHlEYXRhIH0gZnJvbSAnLi4vLi4vc2VhcmNoL3NlYXJjaC5tb2R1bGUnO1xuaW1wb3J0IHsgUWRUYWJsZURhdGEgfSBmcm9tICcuL3RhYmxlLWRhdGEuaW50ZXJmYWNlJztcbmltcG9ydCB7IFFkVGFibGVTdGF0ZVNvcnQgfSBmcm9tICcuL3RhYmxlLXN0b3JlLmludGVyZmFjZSc7XG5cbi8qKlxuICogUmVwcmVzZW50cyB0aGUgcmVzb2x2ZWQgZGF0YSBmb3IgYSBxdWVyeS5cbiAqXG4gKiBAdGVtcGxhdGUgVCAtIFRoZSB0eXBlIHJlcHJlc2VudGluZyBjb2x1bW4gbmFtZXMuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUWRUYWJsZVJlc29sdmVkRGF0YTxUIGV4dGVuZHMgc3RyaW5nPiB7XG4gIC8qKlxuICAgKiBUaGUgY3VycmVudCBwYWdlJ3MgZGF0YSBvYmplY3QuXG4gICAqL1xuICBkYXRhOiBRZFRhYmxlRGF0YTxUPjtcblxuICAvKipcbiAgICogSW5kZXggb2YgdGhlIGN1cnJlbnQgcGFnZS4gVGhpcyBjb3JyZXNwb25kcyB0byB0aGUgJ3BhZ2UnIHBhcmFtZXRlciBpbiBQYWdlYWJsZS5cbiAgICovXG4gIHBhZ2U6IG51bWJlcjtcblxuICAvKipcbiAgICogVGhlIG51bWJlciBvZiBpdGVtcyBwZXIgcGFnZSBhcyBzcGVjaWZpZWQgYnkgU3ByaW5nIEJvb3QncyBQYWdlYWJsZSBBUEkuXG4gICAqIFRoaXMgYWxpZ25zIHdpdGggdGhlICdzaXplJyBwYXJhbWV0ZXIgaW4gUGFnZWFibGUuXG4gICAqL1xuICBzaXplOiBudW1iZXI7XG5cbiAgLyoqXG4gICAqIFRoZSB0b3RhbCBjb3VudCBvZiBpdGVtcyBhY3Jvc3MgYWxsIHBhZ2VzLlxuICAgKi9cbiAgdG90YWxFbGVtZW50czogbnVtYmVyO1xufVxuXG4vKipcbiAqIFJlcHJlc2VudHMgdGhlIHByb3BlcnRpZXMgZm9yIHJlc29sdmluZyBkYXRhLCBmb2xsb3dpbmcgdGhlIGNvbnZlbnRpb25zIG9mIFNwcmluZyBCb290J3MgUGFnZWFibGUgQVBJLlxuICpcbiAqIEB0ZW1wbGF0ZSBUIC0gVGhlIHR5cGUgcmVwcmVzZW50aW5nIGNvbHVtbiBuYW1lcy5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBRZFRhYmxlRGF0YVJlc29sdmVyUHJvcHM8VCBleHRlbmRzIHN0cmluZz4ge1xuICAvKipcbiAgICogVGhlIGluZGV4IG9mIHRoZSBwYWdlIHRvIHJlc29sdmUuIENvcnJlc3BvbmRzIHRvIHRoZSAncGFnZScgcGFyYW1ldGVyIGluIFBhZ2VhYmxlLlxuICAgKi9cbiAgcGFnZTogbnVtYmVyO1xuXG4gIC8qKlxuICAgKiBUaGUgbnVtYmVyIG9mIGl0ZW1zIHBlciBwYWdlLiBDb3JyZXNwb25kcyB0byB0aGUgJ3NpemUnIHBhcmFtZXRlciBpbiBQYWdlYWJsZS5cbiAgICovXG4gIHNpemU6IG51bWJlcjtcblxuICAvKipcbiAgICogVGhlIFNvcnQgb2JqZWN0LiBUbyBvYnRhaW4gdGhlIHF1ZXJ5IHN0cmluZyBjb21wbGlhbnQgd2l0aCBTcHJpbmcgQm9vdCdzIGNvbnZlbnRpb25zLCB1c2UgdGhlIGhlbHBlciBtZXRob2QgXCJRZFRhYmxlU3ByaW5nVG9vbHMuc29ydFBhcmFtZXRlcml6ZVwiLlxuICAgKi9cbiAgc29ydD86IFFkVGFibGVTdGF0ZVNvcnQ8VD5bXTtcblxuICAvKipcbiAgICogVGhlIGZpbHRlciBkYXRhIGlmIHlvdXIgdGFibGUgaXMgY29ubmVjdGVkIHRvIGEgZmlsdGVyLlxuICAgKi9cbiAgZmlsdGVyPzogUWRGaWx0ZXJQb3N0Qm9keURhdGE7XG5cbiAgLyoqXG4gICAqIFRoZSBzZWFyY2ggZGF0YSBpZiB5b3VyIHRhYmxlIGlzIGNvbm5lY3RlZCB0byBhIHNlYXJjaC5cbiAgICovXG4gIHNlYXJjaD86IFFkU2VhcmNoUG9zdEJvZHlEYXRhO1xufVxuXG4vKipcbiAqIFJlcHJlc2VudHMgYSBkYXRhIHJlc29sdmVyIGZvciBxdWVyeWluZyB0YWJsZSBkYXRhLlxuICpcbiAqIEB0ZW1wbGF0ZSBUIC0gVGhlIHR5cGUgcmVwcmVzZW50aW5nIGNvbHVtbiBuYW1lcy5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBRZFRhYmxlRGF0YVJlc29sdmVyPFQgZXh0ZW5kcyBzdHJpbmc+IHtcbiAgLyoqXG4gICAqIFJlc29sdmVzIHRoZSBkYXRhIGJhc2VkIG9uIHRoZSBzcGVjaWZpZWQgcmVzb2x2ZXIgcHJvcGVydGllcy5cbiAgICovXG4gIHJlc29sdmUocHJvcHM6IFFkVGFibGVEYXRhUmVzb2x2ZXJQcm9wczxUPik6IE9ic2VydmFibGU8UWRUYWJsZVJlc29sdmVkRGF0YTxUPj47XG59XG5cbi8qKlxuICogUmVwcmVzZW50cyB0aGUgcmVxdWVzdCBzdGF0ZSBmb3IgYSB0YWJsZSB1c2luZyBRZFRhYmxlRGF0YVJlc29sdmVyLlxuICogQWRkaXRpb25hbCBzdGF0ZXMgY2FuIGJlIGFkZGVkIGFzIG5lZWRlZC5cbiAqL1xuZXhwb3J0IGVudW0gUWRUYWJsZVJlcXVlc3RTdGF0ZSB7XG4gIFBFTkRJTkcsXG4gIFNVQ0NFU1Ncbn1cbiJdfQ==

package/esm2022/lib/table/model/table-data-resolver.token.mjs

@@ -0,0 +1,6 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Token for resolving table data in Angular applications.
+ */
+export const QD_TABLE_DATA_RESOLVER_TOKEN = new InjectionToken('QD_TABLE_DATA_RESOLVER_TOKEN');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUtZGF0YS1yZXNvbHZlci50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcWQtdWkvc3JjL2xpYi90YWJsZS9tb2RlbC90YWJsZS1kYXRhLXJlc29sdmVyLnRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFL0M7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSw0QkFBNEIsR0FBRyxJQUFJLGNBQWMsQ0FBUyw4QkFBOEIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqXG4gKiBUb2tlbiBmb3IgcmVzb2x2aW5nIHRhYmxlIGRhdGEgaW4gQW5ndWxhciBhcHBsaWNhdGlvbnMuXG4gKi9cbmV4cG9ydCBjb25zdCBRRF9UQUJMRV9EQVRBX1JFU09MVkVSX1RPS0VOID0gbmV3IEluamVjdGlvblRva2VuPHN0cmluZz4oJ1FEX1RBQkxFX0RBVEFfUkVTT0xWRVJfVE9LRU4nKTtcbiJdfQ==

package/esm2022/lib/table/model/table-data.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/table/model/table-row-selection.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUtcm93LXNlbGVjdGlvbi5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3FkLXVpL3NyYy9saWIvdGFibGUvbW9kZWwvdGFibGUtcm93LXNlbGVjdGlvbi5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFFkVGFibGVEYXRhUm93IH0gZnJvbSAnLi90YWJsZS1kYXRhLmludGVyZmFjZSc7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIE1vZGVsIGZvciB0aGUgc2VsZWN0ZWQgcm93cyBpbiBhIHNlbGVjdGlvbiBldmVudC4gVGhlIGdlbmVyaWMgdHlwZSBkZWZpbmVzIHRoZSB0YWJsZSBjb2x1bW5zIGtleXMuXG4gKi9cbmV4cG9ydCB0eXBlIFFkVGFibGVTZWxlY3RlZFJvd3M8VCBleHRlbmRzIHN0cmluZz4gPSBRZFRhYmxlU2VsZWN0ZWRSb3c8VD5bXTtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gTW9kZWwgZm9yIGEgc2VsZWN0ZWQgcm93IGluIGEgc2VsZWN0aW9uIGV2ZW50LlxuICovXG5leHBvcnQgdHlwZSBRZFRhYmxlU2VsZWN0ZWRSb3c8VCBleHRlbmRzIHN0cmluZz4gPSBRZFRhYmxlRGF0YVJvdzxUPiAmIHsgaW5kZXg6IG51bWJlciB9O1xuIl19

package/esm2022/lib/table/model/table-store.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/table/paginator/page-size/table-paginator-page-size.component.mjs

@@ -0,0 +1,104 @@
+// @ts-strict-ignore
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, HostListener, Inject, Input, Optional, ViewChild } from '@angular/core';
+import { combineLatest, Subject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { QdScrollingService } from '../../../core/services/scrolling.service';
+import { QdTableStoreService } from '../../store/table-store.service';
+import { QD_TABLE_DATA_RESOLVER_TOKEN } from '../../model/table-data-resolver.token';
+import * as i0 from "@angular/core";
+import * as i1 from "../../store/table-store.service";
+import * as i2 from "../../../core/services/scrolling.service";
+import * as i3 from "@angular/common";
+import * as i4 from "./table-paginator-page-size.directive";
+import * as i5 from "@ngx-translate/core";
+export class QdTablePaginatorPageSizeComponent {
+    elementRef;
+    tableDataResolver;
+    tableStoreService;
+    scrollingService;
+    changeDetectorRef;
+    pageSizes;
+    selection;
+    selectionList;
+    selectionOpened = false;
+    selectionDirection = 'up';
+    pageSize$;
+    totalCount$;
+    _destroyed$ = new Subject();
+    get pageSizes$() {
+        return combineLatest([this.pageSize$, this.totalCount$]).pipe(map(([currentPageSize, totalCount]) => this.pageSizes
+            .slice(0, this.pageSizes.findIndex(pageSize => pageSize >= totalCount) + 1 || this.pageSizes.length)
+            .map(pageSize => ({
+            value: pageSize,
+            disabled: currentPageSize === pageSize
+        }))));
+    }
+    get hasActivePageSizes$() {
+        return this.pageSizes$.pipe(map(pageSizes => !!pageSizes.find(pageSize => !pageSize.disabled)));
+    }
+    constructor(elementRef, tableDataResolver, tableStoreService, scrollingService, changeDetectorRef) {
+        this.elementRef = elementRef;
+        this.tableDataResolver = tableDataResolver;
+        this.tableStoreService = tableStoreService;
+        this.scrollingService = scrollingService;
+        this.changeDetectorRef = changeDetectorRef;
+    }
+    ngOnInit() {
+        this.pageSize$ = this.tableStoreService.pageSize$();
+        this.totalCount$ = this.tableStoreService.totalCount$();
+    }
+    ngOnDestroy() {
+        this._destroyed$.complete();
+    }
+    toggleSelection() {
+        if (!this.selectionOpened) {
+            this.openSelection();
+        }
+        else {
+            this.closeSelection();
+        }
+    }
+    openSelection() {
+        const selectionBottomDistance = this.scrollingService.getBorderDistances(this.selection.nativeElement).bottom;
+        const selectionListHeight = this.selectionList.nativeElement.offsetHeight;
+        this.selectionDirection = selectionListHeight > selectionBottomDistance ? 'up' : 'down';
+        this.selectionOpened = true;
+        this.changeDetectorRef.detectChanges();
+    }
+    closeSelection() {
+        this.selectionOpened = false;
+    }
+    clickedOutside(event) {
+        if ([
+            event.target,
+            event.target.parentNode,
+            event.target.parentNode?.parentNode,
+            event.target.parentNode?.parentNode?.parentNode
+        ].includes(this.elementRef.nativeElement))
+            return;
+        this.closeSelection();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTablePaginatorPageSizeComponent, deps: [{ token: i0.ElementRef }, { token: QD_TABLE_DATA_RESOLVER_TOKEN, optional: true }, { token: i1.QdTableStoreService }, { token: i2.QdScrollingService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdTablePaginatorPageSizeComponent, selector: "qd-table-paginator-page-size", inputs: { pageSizes: "pageSizes" }, host: { listeners: { "document:click": "clickedOutside($event)" } }, viewQueries: [{ propertyName: "selection", first: true, predicate: ["selection"], descendants: true }, { propertyName: "selectionList", first: true, predicate: ["selectionList"], descendants: true }], ngImport: i0, template: "<ng-container *ngIf=\"hasActivePageSizes$ | async\">\n  <label>\n    {{ \"i18n.qd.table.pagination.pageSize\" | translate }}\n  </label>\n  <div [ngClass]=\"{ selection: true, opened: selectionOpened }\" #selection>\n    <span (click)=\"toggleSelection()\" data-test-id=\"page-size-selection\">\n      {{ pageSize$ | async }}\n    </span>\n    <ul\n      [ngClass]=\"{ 'selection-list': true, opened: selectionOpened }\"\n      [class]=\"selectionDirection\"\n      #selectionList\n      data-test-id=\"page-size-selection-list\"\n    >\n      <li\n        *ngFor=\"let pageSize of pageSizes$ | async\"\n        [ngClass]=\"{ disabled: pageSize.disabled }\"\n        [attr.data-test-id]=\"'page-size-selection-option-' + pageSize.value\"\n        [qdTablePaginatorPageSize]=\"pageSize\"\n      >\n        {{ pageSize.value }}\n      </li>\n    </ul>\n  </div>\n</ng-container>\n", styles: [":host{position:relative;display:flex;height:2.75rem;align-items:center;text-align:right;-webkit-user-select:none;user-select:none;white-space:nowrap}:host label{margin:0 .4375rem 0 1rem}@media (max-width: 599.98px){:host label{display:none}}:host .selection{height:2.75rem;border-right:.0625rem solid rgb(229,229,229);cursor:pointer;white-space:nowrap}:host .selection span{display:inline-block;width:100%;padding:.75rem 1.625rem .6875rem .5625rem}:host .selection:hover,:host .selection.opened{border-right:.0625rem solid rgb(151,151,151);border-left:.0625rem solid rgb(151,151,151);color:#171717}:host .selection:hover span,:host .selection:hover li,:host .selection.opened span,:host .selection.opened li{padding-left:.5rem}:host .selection:after{position:absolute;top:50%;right:.4375rem;color:#454545;content:\"\\e042\";font-family:Quadrel-Icon,sans-serif;font-size:1rem;pointer-events:none;transform:translateY(-50%)}:host .selection:hover:after{color:#171717}:host .selection.opened:after{content:\"\\e040\"}:host .selection-list{position:relative;z-index:100;bottom:2.75rem;padding:0;border:.0625rem solid rgb(151,151,151);margin:0 -.0625rem;background-color:#fff;box-shadow:#d5d5d5 0 -.125rem .4375rem;list-style:none;transform:translateY(-100%);visibility:hidden}:host .selection-list.opened{visibility:visible}:host .selection-list.opened.down{bottom:0;box-shadow:#d5d5d5 .125rem .25rem .4375rem;transform:none}:host .selection-list li{width:100%;padding:.375rem 1.625rem .375rem .5625rem;white-space:nowrap}:host .selection-list li:hover{background-color:#f5f5f5}:host .selection-list li.disabled{background-color:#fff;color:#b4b4b4;cursor:default}\n"], dependencies: [{ kind: "directive", type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.QdTablePaginatorPageSizeDirective, selector: "[qdTablePaginatorPageSize]", inputs: ["qdTablePaginatorPageSize"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTablePaginatorPageSizeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-table-paginator-page-size', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"hasActivePageSizes$ | async\">\n  <label>\n    {{ \"i18n.qd.table.pagination.pageSize\" | translate }}\n  </label>\n  <div [ngClass]=\"{ selection: true, opened: selectionOpened }\" #selection>\n    <span (click)=\"toggleSelection()\" data-test-id=\"page-size-selection\">\n      {{ pageSize$ | async }}\n    </span>\n    <ul\n      [ngClass]=\"{ 'selection-list': true, opened: selectionOpened }\"\n      [class]=\"selectionDirection\"\n      #selectionList\n      data-test-id=\"page-size-selection-list\"\n    >\n      <li\n        *ngFor=\"let pageSize of pageSizes$ | async\"\n        [ngClass]=\"{ disabled: pageSize.disabled }\"\n        [attr.data-test-id]=\"'page-size-selection-option-' + pageSize.value\"\n        [qdTablePaginatorPageSize]=\"pageSize\"\n      >\n        {{ pageSize.value }}\n      </li>\n    </ul>\n  </div>\n</ng-container>\n", styles: [":host{position:relative;display:flex;height:2.75rem;align-items:center;text-align:right;-webkit-user-select:none;user-select:none;white-space:nowrap}:host label{margin:0 .4375rem 0 1rem}@media (max-width: 599.98px){:host label{display:none}}:host .selection{height:2.75rem;border-right:.0625rem solid rgb(229,229,229);cursor:pointer;white-space:nowrap}:host .selection span{display:inline-block;width:100%;padding:.75rem 1.625rem .6875rem .5625rem}:host .selection:hover,:host .selection.opened{border-right:.0625rem solid rgb(151,151,151);border-left:.0625rem solid rgb(151,151,151);color:#171717}:host .selection:hover span,:host .selection:hover li,:host .selection.opened span,:host .selection.opened li{padding-left:.5rem}:host .selection:after{position:absolute;top:50%;right:.4375rem;color:#454545;content:\"\\e042\";font-family:Quadrel-Icon,sans-serif;font-size:1rem;pointer-events:none;transform:translateY(-50%)}:host .selection:hover:after{color:#171717}:host .selection.opened:after{content:\"\\e040\"}:host .selection-list{position:relative;z-index:100;bottom:2.75rem;padding:0;border:.0625rem solid rgb(151,151,151);margin:0 -.0625rem;background-color:#fff;box-shadow:#d5d5d5 0 -.125rem .4375rem;list-style:none;transform:translateY(-100%);visibility:hidden}:host .selection-list.opened{visibility:visible}:host .selection-list.opened.down{bottom:0;box-shadow:#d5d5d5 .125rem .25rem .4375rem;transform:none}:host .selection-list li{width:100%;padding:.375rem 1.625rem .375rem .5625rem;white-space:nowrap}:host .selection-list li:hover{background-color:#f5f5f5}:host .selection-list li.disabled{background-color:#fff;color:#b4b4b4;cursor:default}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [QD_TABLE_DATA_RESOLVER_TOKEN]
+                }] }, { type: i1.QdTableStoreService }, { type: i2.QdScrollingService }, { type: i0.ChangeDetectorRef }], propDecorators: { pageSizes: [{
+                type: Input
+            }], selection: [{
+                type: ViewChild,
+                args: ['selection']
+            }], selectionList: [{
+                type: ViewChild,
+                args: ['selectionList']
+            }], clickedOutside: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-paginator-page-size.component.js","sourceRoot":"","sources":["../../../../../../../libs/qd-ui/src/lib/table/paginator/page-size/table-paginator-page-size.component.ts","../../../../../../../libs/qd-ui/src/lib/table/paginator/page-size/table-paginator-page-size.component.html"],"names":[],"mappings":"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","sourcesContent":["// @ts-strict-ignore\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  HostListener,\n  Inject,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  ViewChild\n} from '@angular/core';\nimport { combineLatest, Observable, Subject } from 'rxjs';\nimport { map } from 'rxjs/operators';\n\nimport { QdScrollingService } from '../../../core/services/scrolling.service';\nimport { QdTableStoreService } from '../../store/table-store.service';\n\nimport { QdTableDataResolver } from '../../model/table-data-resolver';\nimport { QD_TABLE_DATA_RESOLVER_TOKEN } from '../../model/table-data-resolver.token';\n\nexport type PageSize = { value: number; disabled: boolean };\n\n@Component({\n  selector: 'qd-table-paginator-page-size',\n  templateUrl: './table-paginator-page-size.component.html',\n  styleUrls: ['./table-paginator-page-size.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class QdTablePaginatorPageSizeComponent<T extends string> implements OnInit, OnDestroy {\n  @Input() pageSizes: number[];\n\n  @ViewChild('selection') selection;\n  @ViewChild('selectionList') selectionList;\n\n  selectionOpened = false;\n  selectionDirection: 'up' | 'down' = 'up';\n  pageSize$: Observable<number>;\n  totalCount$: Observable<number>;\n\n  private _destroyed$: Subject<null> = new Subject();\n\n  get pageSizes$(): Observable<Array<PageSize>> {\n    return combineLatest([this.pageSize$, this.totalCount$]).pipe(\n      map(([currentPageSize, totalCount]) =>\n        this.pageSizes\n          .slice(0, this.pageSizes.findIndex(pageSize => pageSize >= totalCount) + 1 || this.pageSizes.length)\n          .map(pageSize => ({\n            value: pageSize,\n            disabled: currentPageSize === pageSize\n          }))\n      )\n    );\n  }\n\n  get hasActivePageSizes$(): Observable<boolean> {\n    return this.pageSizes$.pipe(map(pageSizes => !!pageSizes.find(pageSize => !pageSize.disabled)));\n  }\n\n  constructor(\n    private readonly elementRef: ElementRef,\n    @Optional() @Inject(QD_TABLE_DATA_RESOLVER_TOKEN) private readonly tableDataResolver: QdTableDataResolver<T>,\n    private readonly tableStoreService: QdTableStoreService<T>,\n    private readonly scrollingService: QdScrollingService,\n    private readonly changeDetectorRef: ChangeDetectorRef\n  ) {}\n\n  ngOnInit(): void {\n    this.pageSize$ = this.tableStoreService.pageSize$();\n    this.totalCount$ = this.tableStoreService.totalCount$();\n  }\n\n  ngOnDestroy(): void {\n    this._destroyed$.complete();\n  }\n\n  toggleSelection(): void {\n    if (!this.selectionOpened) {\n      this.openSelection();\n    } else {\n      this.closeSelection();\n    }\n  }\n\n  openSelection(): void {\n    const selectionBottomDistance = this.scrollingService.getBorderDistances(this.selection.nativeElement).bottom;\n    const selectionListHeight = this.selectionList.nativeElement.offsetHeight;\n\n    this.selectionDirection = selectionListHeight > selectionBottomDistance ? 'up' : 'down';\n    this.selectionOpened = true;\n    this.changeDetectorRef.detectChanges();\n  }\n\n  closeSelection(): void {\n    this.selectionOpened = false;\n  }\n\n  @HostListener('document:click', ['$event'])\n  clickedOutside(event: PointerEvent): void {\n    if (\n      [\n        event.target,\n        (event.target as HTMLElement).parentNode,\n        (event.target as HTMLElement).parentNode?.parentNode,\n        (event.target as HTMLElement).parentNode?.parentNode?.parentNode\n      ].includes(this.elementRef.nativeElement)\n    )\n      return;\n\n    this.closeSelection();\n  }\n}\n","<ng-container *ngIf=\"hasActivePageSizes$ | async\">\n  <label>\n    {{ \"i18n.qd.table.pagination.pageSize\" | translate }}\n  </label>\n  <div [ngClass]=\"{ selection: true, opened: selectionOpened }\" #selection>\n    <span (click)=\"toggleSelection()\" data-test-id=\"page-size-selection\">\n      {{ pageSize$ | async }}\n    </span>\n    <ul\n      [ngClass]=\"{ 'selection-list': true, opened: selectionOpened }\"\n      [class]=\"selectionDirection\"\n      #selectionList\n      data-test-id=\"page-size-selection-list\"\n    >\n      <li\n        *ngFor=\"let pageSize of pageSizes$ | async\"\n        [ngClass]=\"{ disabled: pageSize.disabled }\"\n        [attr.data-test-id]=\"'page-size-selection-option-' + pageSize.value\"\n        [qdTablePaginatorPageSize]=\"pageSize\"\n      >\n        {{ pageSize.value }}\n      </li>\n    </ul>\n  </div>\n</ng-container>\n"]}

package/esm2022/lib/table/paginator/page-size/table-paginator-page-size.directive.mjs

@@ -0,0 +1,53 @@
+// @ts-strict-ignore
+import { Directive, ElementRef, Inject, Input, Optional } from '@angular/core';
+import { fromEvent, Subject } from 'rxjs';
+import { filter, takeUntil, tap } from 'rxjs/operators';
+import { QD_TABLE_DATA_RESOLVER_TOKEN } from '../../model/table-data-resolver.token';
+import { QdTableStoreService } from '../../store/table-store.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../store/table-store.service";
+/**
+ * A directive that allows the paginator to set the page size of a table paginator. Also writes the result to the store.
+ *
+ * This directive listens for click events on the element it applies to, and calls the StoreService's `setPageSize' method if necessary.
+ */
+export class QdTablePaginatorPageSizeDirective {
+    tableDataResolver;
+    elementRef;
+    tableStoreService;
+    qdTablePaginatorPageSize;
+    _destroyed$ = new Subject();
+    constructor(
+    // TODO: Remove in v16
+    tableDataResolver, elementRef, tableStoreService) {
+        this.tableDataResolver = tableDataResolver;
+        this.elementRef = elementRef;
+        this.tableStoreService = tableStoreService;
+    }
+    ngOnInit() {
+        if (this.tableDataResolver) {
+            fromEvent(this.elementRef.nativeElement, 'click')
+                .pipe(takeUntil(this._destroyed$), filter(() => !this.qdTablePaginatorPageSize.disabled), tap(() => this.tableStoreService.setPageSize(this.qdTablePaginatorPageSize.value)))
+                .subscribe();
+        }
+    }
+    ngOnDestroy() {
+        this._destroyed$.complete();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTablePaginatorPageSizeDirective, deps: [{ token: QD_TABLE_DATA_RESOLVER_TOKEN, optional: true }, { token: i0.ElementRef }, { token: i1.QdTableStoreService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.9", type: QdTablePaginatorPageSizeDirective, selector: "[qdTablePaginatorPageSize]", inputs: { qdTablePaginatorPageSize: "qdTablePaginatorPageSize" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTablePaginatorPageSizeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[qdTablePaginatorPageSize]'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [QD_TABLE_DATA_RESOLVER_TOKEN]
+                }] }, { type: i0.ElementRef }, { type: i1.QdTableStoreService }], propDecorators: { qdTablePaginatorPageSize: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/table/paginator/scroll-to-pagination.directive.mjs

@@ -0,0 +1,77 @@
+// @ts-strict-ignore
+import { Directive, ElementRef } from '@angular/core';
+import { scan, Subject } from 'rxjs';
+import { filter, takeUntil, tap } from 'rxjs/operators';
+import { QdScrollingService } from '../../core/services/scrolling.service';
+import { QdTableRequestState } from '../model/table-data-resolver';
+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 "../../core/services/scrolling.service";
+/**
+ * The `QdScrollToPaginationDirective` directive makes it possible to scroll to the pagination section of a table when changing pages. It synchronizes with the page change events of the table and triggers scrolling when it is necessary to keep the pagination section accessible to the user.
+ *
+ * Apply this directive to the HTML element representing the pagination section of the QuickDesk table.
+ */
+export class QdScrollToPaginationDirective {
+    elementRef;
+    tableStoreService;
+    scrollingService;
+    _destroyed$ = new Subject();
+    _bottom;
+    constructor(elementRef, tableStoreService, scrollingService) {
+        this.elementRef = elementRef;
+        this.tableStoreService = tableStoreService;
+        this.scrollingService = scrollingService;
+    }
+    ngOnInit() {
+        this._bottom = this.getScrollBottom();
+        this.tableStoreService
+            .pageChangeInfo$()
+            .pipe(takeUntil(this._destroyed$), filter(pageInfo => pageInfo !== undefined), scan((acc, curr) => this.handleScrollAnalysis(acc, curr)), tap(curr => this.performScrollIntoView(curr)))
+            .subscribe();
+    }
+    ngOnDestroy() {
+        this._destroyed$.complete();
+    }
+    getScrollBottom() {
+        return this.scrollingService.getBorderDistances(this.elementRef.nativeElement).bottom;
+    }
+    handleScrollAnalysis(acc, curr) {
+        const result = { ...curr, shouldScroll: acc.shouldScroll, hasRequestSucceeded: acc.hasRequestSucceeded };
+        if (!this.hasRequestBeenTriggered(acc, curr)) {
+            result.shouldScroll = false;
+            result.hasRequestSucceeded = false;
+        }
+        if (this.shouldScroll(acc, curr)) {
+            this._bottom = this.getScrollBottom();
+            result.shouldScroll = true;
+        }
+        if (this.hasRequestSucceeded(acc, curr))
+            result.hasRequestSucceeded = true;
+        return result;
+    }
+    hasRequestBeenTriggered(acc, curr) {
+        return !(acc.requestState === QdTableRequestState.SUCCESS && curr.requestState === QdTableRequestState.SUCCESS);
+    }
+    hasRequestSucceeded(acc, curr) {
+        return acc.requestState === QdTableRequestState.PENDING && curr.requestState === QdTableRequestState.SUCCESS;
+    }
+    shouldScroll(acc, curr) {
+        return acc.pageIndex !== curr.pageIndex || acc.pageSize !== curr.pageSize;
+    }
+    performScrollIntoView(curr) {
+        if (!curr.shouldScroll || !curr.hasRequestSucceeded)
+            return;
+        window.setTimeout(() => this.scrollingService.scrollIntoView(this.elementRef.nativeElement, 'bottom', this._bottom), 10);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdScrollToPaginationDirective, deps: [{ token: i0.ElementRef }, { token: i1.QdTableStoreService }, { token: i2.QdScrollingService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.9", type: QdScrollToPaginationDirective, selector: "[qdScrollToPagination]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdScrollToPaginationDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[qdScrollToPagination]'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.QdTableStoreService }, { type: i2.QdScrollingService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,128 @@
+import { ChangeDetectionStrategy, Component, ElementRef, Inject, Input, Optional, ViewChild } from '@angular/core';
+import { first, Subject } from 'rxjs';
+import { map, takeUntil, tap } from 'rxjs/operators';
+import { QdPaginatorDirection } from '../model/paginator-direction.enum';
+import { QD_TABLE_DATA_RESOLVER_TOKEN } from '../model/table-data-resolver.token';
+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";
+import * as i4 from "./scroll-to-pagination.directive";
+import * as i5 from "./page-size/table-paginator-page-size.component";
+import * as i6 from "@ngx-translate/core";
+export const PAGE_SIZE_DEFAULT = 25;
+export class QdTablePaginatorComponent {
+    tableDataResolver;
+    tableStoreService;
+    /**
+     * @description Configuration Model for Qd-Table.
+     */
+    config;
+    /**
+     * A static test ID for integration tests can be set. <br />
+     * The value for the HTML attribute [data-test-id].
+     */
+    testId;
+    paginatorButtons;
+    table$;
+    canPageForward$;
+    canPageBackward$;
+    currentPage$;
+    pageSize$;
+    totalCount$;
+    pageNav = QdPaginatorDirection;
+    _destroyed$ = new Subject();
+    get pageSizes() {
+        if (typeof this.config?.pagination !== 'object')
+            return [];
+        return this.config.pagination.pageSizes || [];
+    }
+    get hasData$() {
+        return this.table$.pipe(map(state => (state?.data?.length ?? 0) !== 0));
+    }
+    constructor(tableDataResolver, tableStoreService) {
+        this.tableDataResolver = tableDataResolver;
+        this.tableStoreService = tableStoreService;
+    }
+    ngOnInit() {
+        this.table$ = this.tableStoreService.table$();
+        this.canPageBackward$ = this.tableStoreService.canPageBackward$();
+        this.canPageForward$ = this.tableStoreService.canPageForward$();
+        this.currentPage$ = this.tableStoreService.pageInfo$();
+        this.pageSize$ = this.tableStoreService.pageSize$();
+        this.totalCount$ = this.tableStoreService.totalCount$();
+        if (this.isConfigValid())
+            this.initPagination();
+    }
+    ngOnDestroy() {
+        this._destroyed$.complete();
+    }
+    navigateToPage(direction) {
+        if (!this.paginatorButtons)
+            return;
+        this.tableStoreService
+            .table$()
+            .pipe(takeUntil(this._destroyed$), first(), tap(table => {
+            this.tableStoreService.setPageParams(this.calculatePageNumber(direction, table?.totalCount ?? 0, table?.pageSize ?? 0, table?.pageIndex ?? 0), table?.pageSize ?? 0, table?.totalCount ?? 0);
+        }))
+            .subscribe();
+    }
+    isConfigValid() {
+        if (this.config?.hasPagination) {
+            console.warn('QD-UI | QdTable Pagination - The config "hasPagination" is deprecated. Please use "pagination" instead.');
+        }
+        if (!this.tableDataResolver) {
+            console.error('QD-UI | QdTable Pagination - Provide a resolver for pagination. Please use the "QD_TABLE_DATA_RESOLVER_TOKEN" injection token.');
+            return false;
+        }
+        return true;
+    }
+    initPagination() {
+        this.tableStoreService.setupPagination(this.getPageSizeDefault());
+    }
+    getPageSizeDefault() {
+        if (typeof this.config?.pagination !== 'object')
+            return PAGE_SIZE_DEFAULT;
+        const { pageSizeDefault, pageSizes } = this.config.pagination;
+        const pageSize = pageSizes && pageSizes.length ? pageSizes[0] : PAGE_SIZE_DEFAULT;
+        return pageSizeDefault || pageSize;
+    }
+    calculatePageNumber(direction, totalCount, pageSize, currentPage) {
+        switch (direction) {
+            case QdPaginatorDirection.NextPage: {
+                return currentPage + 1;
+            }
+            case QdPaginatorDirection.PreviousPage: {
+                return currentPage - 1;
+            }
+            case QdPaginatorDirection.LastPage: {
+                return Math.ceil(totalCount / pageSize) - 1;
+            }
+            case QdPaginatorDirection.FirstPage:
+            default: {
+                return 0;
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTablePaginatorComponent, deps: [{ token: QD_TABLE_DATA_RESOLVER_TOKEN, optional: true }, { token: i1.QdTableStoreService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdTablePaginatorComponent, selector: "qd-table-paginator", inputs: { config: "config", testId: ["data-test-id", "testId"] }, viewQueries: [{ propertyName: "paginatorButtons", first: true, predicate: ["paginatorButtons"], descendants: true }], ngImport: i0, template: "<ng-container *ngIf=\"hasData$ | async\">\n  <qd-table-paginator-page-size [pageSizes]=\"pageSizes\" *ngIf=\"pageSizes.length > 0\"></qd-table-paginator-page-size>\n  <span class=\"paginator-current-page\" *ngIf=\"currentPage$ | async as page\">\n    {{ page.start }}\u2014{{ page.end }}\n    {{ \"i18n.qd.table.pagination.of\" | translate }}\n    {{ page.totalCount }}\n    {{\n      page.totalCount === 1\n        ? (\"i18n.qd.table.pagination.entry\" | translate)\n        : (\"i18n.qd.table.pagination.entries\" | translate)\n    }}\n  </span>\n  <span class=\"paginator-buttons\" data-test=\"paginator-buttons\" #paginatorButtons qdScrollToPagination>\n    <button\n      *ngIf=\"config?.pagination['hasFirstLastPageNavigation']\"\n      class=\"paginator-button\"\n      [attr.data-test-id]=\"testId + '-paginator-first-page'\"\n      (click)=\"navigateToPage(pageNav.FirstPage)\"\n      [disabled]=\"(canPageBackward$ | async) === false\"\n    >\n      <qd-icon [icon]=\"'pageFirst1'\"></qd-icon>\n    </button>\n    <button\n      class=\"paginator-button\"\n      [attr.data-test-id]=\"testId + '-paginator-backward'\"\n      (click)=\"navigateToPage(pageNav.PreviousPage)\"\n      [disabled]=\"(canPageBackward$ | async) === false\"\n    >\n      <qd-icon [icon]=\"'triangleLeftSolid'\"></qd-icon>\n    </button>\n    <button\n      class=\"paginator-button forward\"\n      [attr.data-test-id]=\"testId + '-paginator-forward'\"\n      (click)=\"navigateToPage(pageNav.NextPage)\"\n      [disabled]=\"(canPageForward$ | async) === false\"\n    >\n      <qd-icon [icon]=\"'triangleRightSolid'\"></qd-icon>\n    </button>\n    <button\n      *ngIf=\"config?.pagination['hasFirstLastPageNavigation']\"\n      class=\"paginator-button\"\n      [attr.data-test-id]=\"testId + '-paginator-last-page'\"\n      (click)=\"navigateToPage(pageNav.LastPage)\"\n      [disabled]=\"(canPageForward$ | async) === false\"\n    >\n      <qd-icon [icon]=\"'pageLast'\"></qd-icon>\n    </button>\n  </span>\n</ng-container>\n", styles: [":host{color:#454545;font-size:.875rem;font-weight:400;line-height:1.3125rem;display:flex;flex-direction:row;align-items:center;justify-content:space-between;background-color:#fff}.paginator-current-page{margin-left:1rem}.paginator-buttons{margin-left:auto;text-align:right;white-space:nowrap}button.paginator-button{width:2.75rem;height:2.75rem;border-left:.0625rem solid rgb(229,229,229);background-color:unset;color:#454545;font-size:1.5rem}button.paginator-button:disabled{color:#b4b4b4;cursor:default}button.paginator-button:not(:disabled):hover{background-color:#e5e5e5;color:#171717}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.QdIconComponent, selector: "qd-icon", inputs: ["icon"] }, { kind: "directive", type: i4.QdScrollToPaginationDirective, selector: "[qdScrollToPagination]" }, { kind: "component", type: i5.QdTablePaginatorPageSizeComponent, selector: "qd-table-paginator-page-size", inputs: ["pageSizes"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i6.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTablePaginatorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-table-paginator', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"hasData$ | async\">\n  <qd-table-paginator-page-size [pageSizes]=\"pageSizes\" *ngIf=\"pageSizes.length > 0\"></qd-table-paginator-page-size>\n  <span class=\"paginator-current-page\" *ngIf=\"currentPage$ | async as page\">\n    {{ page.start }}\u2014{{ page.end }}\n    {{ \"i18n.qd.table.pagination.of\" | translate }}\n    {{ page.totalCount }}\n    {{\n      page.totalCount === 1\n        ? (\"i18n.qd.table.pagination.entry\" | translate)\n        : (\"i18n.qd.table.pagination.entries\" | translate)\n    }}\n  </span>\n  <span class=\"paginator-buttons\" data-test=\"paginator-buttons\" #paginatorButtons qdScrollToPagination>\n    <button\n      *ngIf=\"config?.pagination['hasFirstLastPageNavigation']\"\n      class=\"paginator-button\"\n      [attr.data-test-id]=\"testId + '-paginator-first-page'\"\n      (click)=\"navigateToPage(pageNav.FirstPage)\"\n      [disabled]=\"(canPageBackward$ | async) === false\"\n    >\n      <qd-icon [icon]=\"'pageFirst1'\"></qd-icon>\n    </button>\n    <button\n      class=\"paginator-button\"\n      [attr.data-test-id]=\"testId + '-paginator-backward'\"\n      (click)=\"navigateToPage(pageNav.PreviousPage)\"\n      [disabled]=\"(canPageBackward$ | async) === false\"\n    >\n      <qd-icon [icon]=\"'triangleLeftSolid'\"></qd-icon>\n    </button>\n    <button\n      class=\"paginator-button forward\"\n      [attr.data-test-id]=\"testId + '-paginator-forward'\"\n      (click)=\"navigateToPage(pageNav.NextPage)\"\n      [disabled]=\"(canPageForward$ | async) === false\"\n    >\n      <qd-icon [icon]=\"'triangleRightSolid'\"></qd-icon>\n    </button>\n    <button\n      *ngIf=\"config?.pagination['hasFirstLastPageNavigation']\"\n      class=\"paginator-button\"\n      [attr.data-test-id]=\"testId + '-paginator-last-page'\"\n      (click)=\"navigateToPage(pageNav.LastPage)\"\n      [disabled]=\"(canPageForward$ | async) === false\"\n    >\n      <qd-icon [icon]=\"'pageLast'\"></qd-icon>\n    </button>\n  </span>\n</ng-container>\n", styles: [":host{color:#454545;font-size:.875rem;font-weight:400;line-height:1.3125rem;display:flex;flex-direction:row;align-items:center;justify-content:space-between;background-color:#fff}.paginator-current-page{margin-left:1rem}.paginator-buttons{margin-left:auto;text-align:right;white-space:nowrap}button.paginator-button{width:2.75rem;height:2.75rem;border-left:.0625rem solid rgb(229,229,229);background-color:unset;color:#454545;font-size:1.5rem}button.paginator-button:disabled{color:#b4b4b4;cursor:default}button.paginator-button:not(:disabled):hover{background-color:#e5e5e5;color:#171717}\n"] }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [QD_TABLE_DATA_RESOLVER_TOKEN]
+                }] }, { type: i1.QdTableStoreService }], propDecorators: { config: [{
+                type: Input
+            }], testId: [{
+                type: Input,
+                args: ['data-test-id']
+            }], paginatorButtons: [{
+                type: ViewChild,
+                args: ['paginatorButtons']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-paginator.component.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/table/paginator/table-paginator.component.ts","../../../../../../libs/qd-ui/src/lib/table/paginator/table-paginator.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  Inject,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  ViewChild\n} from '@angular/core';\nimport { first, Observable, Subject } from 'rxjs';\nimport { map, takeUntil, tap } from 'rxjs/operators';\n\nimport { QdPaginatorDirection } from '../model/paginator-direction.enum';\nimport { QdTableConfig } from '../model/table-config.interface';\nimport { QdTableDataResolver } from '../model/table-data-resolver';\nimport { QD_TABLE_DATA_RESOLVER_TOKEN } from '../model/table-data-resolver.token';\nimport { QdTablePaginatorCurrentPage, QdTableState } from '../model/table-store.interface';\nimport { QdTableStoreService } from '../store/table-store.service';\n\nexport const PAGE_SIZE_DEFAULT = 25;\n\n@Component({\n  selector: 'qd-table-paginator',\n  templateUrl: './table-paginator.component.html',\n  styleUrls: ['./table-paginator.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class QdTablePaginatorComponent<T extends string> implements OnInit, OnDestroy {\n  /**\n   * @description Configuration Model for Qd-Table.\n   */\n  @Input() config!: QdTableConfig<T>;\n\n  /**\n   * A static test ID for integration tests can be set. <br />\n   * The value for the HTML attribute [data-test-id].\n   */\n  @Input('data-test-id') testId?: string;\n\n  @ViewChild('paginatorButtons') paginatorButtons: ElementRef | undefined;\n\n  table$!: Observable<QdTableState<string> | undefined>;\n  canPageForward$!: Observable<boolean>;\n  canPageBackward$!: Observable<boolean>;\n  currentPage$!: Observable<QdTablePaginatorCurrentPage | undefined>;\n  pageSize$!: Observable<number>;\n  totalCount$!: Observable<number>;\n  pageNav? = QdPaginatorDirection;\n\n  private _destroyed$: Subject<null> = new Subject();\n\n  get pageSizes(): number[] {\n    if (typeof this.config?.pagination !== 'object') return [];\n\n    return this.config.pagination.pageSizes || [];\n  }\n\n  get hasData$(): Observable<boolean> {\n    return this.table$.pipe(map(state => (state?.data?.length ?? 0) !== 0));\n  }\n\n  constructor(\n    @Optional() @Inject(QD_TABLE_DATA_RESOLVER_TOKEN) private readonly tableDataResolver: QdTableDataResolver<T>,\n    private readonly tableStoreService: QdTableStoreService<T>\n  ) {}\n\n  ngOnInit(): void {\n    this.table$ = this.tableStoreService.table$();\n    this.canPageBackward$ = this.tableStoreService.canPageBackward$();\n    this.canPageForward$ = this.tableStoreService.canPageForward$();\n    this.currentPage$ = this.tableStoreService.pageInfo$();\n    this.pageSize$ = this.tableStoreService.pageSize$();\n    this.totalCount$ = this.tableStoreService.totalCount$();\n\n    if (this.isConfigValid()) this.initPagination();\n  }\n\n  ngOnDestroy(): void {\n    this._destroyed$.complete();\n  }\n\n  navigateToPage(direction: QdPaginatorDirection): void {\n    if (!this.paginatorButtons) return;\n\n    this.tableStoreService\n      .table$()\n      .pipe(\n        takeUntil(this._destroyed$),\n        first(),\n        tap(table => {\n          this.tableStoreService.setPageParams(\n            this.calculatePageNumber(direction, table?.totalCount ?? 0, table?.pageSize ?? 0, table?.pageIndex ?? 0),\n            table?.pageSize ?? 0,\n            table?.totalCount ?? 0\n          );\n        })\n      )\n      .subscribe();\n  }\n\n  private isConfigValid(): boolean {\n    if (this.config?.hasPagination) {\n      console.warn(\n        'QD-UI | QdTable Pagination - The config \"hasPagination\" is deprecated. Please use \"pagination\" instead.'\n      );\n    }\n\n    if (!this.tableDataResolver) {\n      console.error(\n        'QD-UI | QdTable Pagination - Provide a resolver for pagination. Please use the \"QD_TABLE_DATA_RESOLVER_TOKEN\" injection token.'\n      );\n\n      return false;\n    }\n\n    return true;\n  }\n\n  private initPagination(): void {\n    this.tableStoreService.setupPagination(this.getPageSizeDefault());\n  }\n\n  private getPageSizeDefault(): number {\n    if (typeof this.config?.pagination !== 'object') return PAGE_SIZE_DEFAULT;\n\n    const { pageSizeDefault, pageSizes } = this.config.pagination;\n\n    const pageSize = pageSizes && pageSizes.length ? pageSizes[0] : PAGE_SIZE_DEFAULT;\n\n    return pageSizeDefault || pageSize;\n  }\n\n  private calculatePageNumber(\n    direction: QdPaginatorDirection,\n    totalCount: number,\n    pageSize: number,\n    currentPage: number\n  ): number {\n    switch (direction) {\n      case QdPaginatorDirection.NextPage: {\n        return currentPage + 1;\n      }\n      case QdPaginatorDirection.PreviousPage: {\n        return currentPage - 1;\n      }\n      case QdPaginatorDirection.LastPage: {\n        return Math.ceil(totalCount / pageSize) - 1;\n      }\n      case QdPaginatorDirection.FirstPage:\n      default: {\n        return 0;\n      }\n    }\n  }\n}\n","<ng-container *ngIf=\"hasData$ | async\">\n  <qd-table-paginator-page-size [pageSizes]=\"pageSizes\" *ngIf=\"pageSizes.length > 0\"></qd-table-paginator-page-size>\n  <span class=\"paginator-current-page\" *ngIf=\"currentPage$ | async as page\">\n    {{ page.start }}—{{ page.end }}\n    {{ \"i18n.qd.table.pagination.of\" | translate }}\n    {{ page.totalCount }}\n    {{\n      page.totalCount === 1\n        ? (\"i18n.qd.table.pagination.entry\" | translate)\n        : (\"i18n.qd.table.pagination.entries\" | translate)\n    }}\n  </span>\n  <span class=\"paginator-buttons\" data-test=\"paginator-buttons\" #paginatorButtons qdScrollToPagination>\n    <button\n      *ngIf=\"config?.pagination['hasFirstLastPageNavigation']\"\n      class=\"paginator-button\"\n      [attr.data-test-id]=\"testId + '-paginator-first-page'\"\n      (click)=\"navigateToPage(pageNav.FirstPage)\"\n      [disabled]=\"(canPageBackward$ | async) === false\"\n    >\n      <qd-icon [icon]=\"'pageFirst1'\"></qd-icon>\n    </button>\n    <button\n      class=\"paginator-button\"\n      [attr.data-test-id]=\"testId + '-paginator-backward'\"\n      (click)=\"navigateToPage(pageNav.PreviousPage)\"\n      [disabled]=\"(canPageBackward$ | async) === false\"\n    >\n      <qd-icon [icon]=\"'triangleLeftSolid'\"></qd-icon>\n    </button>\n    <button\n      class=\"paginator-button forward\"\n      [attr.data-test-id]=\"testId + '-paginator-forward'\"\n      (click)=\"navigateToPage(pageNav.NextPage)\"\n      [disabled]=\"(canPageForward$ | async) === false\"\n    >\n      <qd-icon [icon]=\"'triangleRightSolid'\"></qd-icon>\n    </button>\n    <button\n      *ngIf=\"config?.pagination['hasFirstLastPageNavigation']\"\n      class=\"paginator-button\"\n      [attr.data-test-id]=\"testId + '-paginator-last-page'\"\n      (click)=\"navigateToPage(pageNav.LastPage)\"\n      [disabled]=\"(canPageForward$ | async) === false\"\n    >\n      <qd-icon [icon]=\"'pageLast'\"></qd-icon>\n    </button>\n  </span>\n</ng-container>\n"]}