@cute-widgets/base 20.0.1

package/table/index.d.ts

@@ -0,0 +1,395 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit } from '@angular/core';
+import * as i2 from '@angular/cdk/table';
+import { CdkTable, CdkCellDef, CdkHeaderCellDef, CdkFooterCellDef, CdkColumnDef, CdkHeaderCell, CdkFooterCell, CdkCell, CdkHeaderRowDef, CdkFooterRowDef, CdkRowDef, CdkHeaderRow, CdkFooterRow, CdkRow, CdkNoDataRow, CdkTextColumn } from '@angular/cdk/table';
+import { ThemeColor } from '@cute-widgets/base/core';
+import { BehaviorSubject } from 'rxjs';
+import { DataSource } from '@angular/cdk/collections';
+import { CuteSort } from '@cute-widgets/base/sort';
+import { CutePaginator } from '@cute-widgets/base/paginator';
+import * as i1 from '@angular/common';
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Used to provide a table to some of the subcomponents without causing a circular dependency.
+ */
+declare const CUTE_TABLE: InjectionToken<CuteTable<any>>;
+/** Type of table borders. `all` - on all sides of the table and cells, `none` - without borders */
+type TableBorders = "all" | "none";
+/**
+ * Enables the recycle view repeater strategy, which reduces rendering latency. Not compatible with
+ * tables that animate rows.
+ *
+ * @deprecated This directive is a no-op and will be removed.
+ * @breaking-change 23.0.0
+ */
+declare class CuteRecycleRows {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteRecycleRows, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteRecycleRows, "cute-table[recycleRows], table[cute-table][recycleRows]", never, {}, {}, never, never, true, never>;
+}
+declare class CuteTable<T> extends CdkTable<T> implements OnInit {
+    /** Overrides the sticky CSS class set by the `CdkTable`. */
+    protected stickyCssClass: string;
+    /** Overrides the need to add position: sticky on every sticky cell element in `CdkTable`. */
+    protected needsPositionStickyOnElement: boolean;
+    get classList(): string;
+    /** Theme color for all table cells. */
+    color: ThemeColor | undefined;
+    /** Theme color for cell borders. */
+    borderColor: ThemeColor | undefined;
+    /** Adds zebra-striping to any table row within the `<tbody>`. */
+    stripedRows: boolean;
+    /** Adds zebra-striping to any table column */
+    stripedColumns: boolean;
+    /** Enables a hover state on table rows within a `<tbody>` */
+    hoveredRows: boolean;
+    /** Makes a `<table>` more compact */
+    get compact(): boolean;
+    set compact(value: boolean);
+    private _compact;
+    /** What table borders to display. */
+    displayBorders: TableBorders | undefined;
+    /**
+     *  Adds a thicker border, darker between table groups — `<thead>`, `<tbody>`, and `<tfoot>`.
+     *  @experimental
+     */
+    divideGroups: boolean;
+    /**
+     * Whether to display `th` cells vertically.
+     * @experimental
+     */
+    get verticalHeads(): boolean;
+    set verticalHeads(value: boolean);
+    private _verticalHeads;
+    protected updateStickyStyles(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTable<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteTable<any>, "cute-table, table[cute-table]", ["cuteTable"], { "color": { "alias": "color"; "required": false; }; "borderColor": { "alias": "borderColor"; "required": false; }; "stripedRows": { "alias": "stripedRows"; "required": false; }; "stripedColumns": { "alias": "stripedColumns"; "required": false; }; "hoveredRows": { "alias": "hoveredRows"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "displayBorders": { "alias": "displayBorders"; "required": false; }; "divideGroups": { "alias": "divideGroups"; "required": false; }; "verticalHeads": { "alias": "verticalHeads"; "required": false; }; }, {}, never, ["caption", "colgroup, col", "*"], true, never>;
+    static ngAcceptInputType_stripedRows: unknown;
+    static ngAcceptInputType_stripedColumns: unknown;
+    static ngAcceptInputType_hoveredRows: unknown;
+    static ngAcceptInputType_compact: unknown;
+    static ngAcceptInputType_divideGroups: unknown;
+    static ngAcceptInputType_verticalHeads: unknown;
+}
+
+/**
+ * Cell definition for the `cute-table`.
+ * Captures the template of a column's data row cell as well as cell-specific properties.
+ */
+declare class CuteCellDef extends CdkCellDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteCellDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteCellDef, "[cuteCellDef]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Header cell definition for the `cute-table`.
+ * Captures the template of a column's header cell and as well as cell-specific properties.
+ */
+declare class CuteHeaderCellDef extends CdkHeaderCellDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteHeaderCellDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteHeaderCellDef, "[cuteHeaderCellDef]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Footer cell definition for the `cute-table`.
+ * Captures the template of a column's footer cell and as well as cell-specific properties.
+ */
+declare class CuteFooterCellDef extends CdkFooterCellDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteFooterCellDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteFooterCellDef, "[cuteFooterCellDef]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Column definition for the `cute-table`.
+ * Defines a set of cells available for a table column.
+ */
+declare class CuteColumnDef extends CdkColumnDef {
+    /** Unique name for this column. */
+    get name(): string;
+    set name(name: string);
+    /**
+     * Add "cute-column-" prefix in addition to "cdk-column-" prefix.
+     * In the future, this will only add "cute-column-" and columnCssClassName
+     * will change from type string[] to string.
+     */
+    protected _updateColumnCssClassName(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteColumnDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteColumnDef, "[cuteColumnDef]", never, { "sticky": { "alias": "sticky"; "required": false; }; "name": { "alias": "cuteColumnDef"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_sticky: unknown;
+}
+/** Header cell template container that adds the right classes and role. */
+declare class CuteHeaderCell extends CdkHeaderCell {
+    color: ThemeColor | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteHeaderCell, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteHeaderCell, "cute-header-cell, th[cute-header-cell]", never, { "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+/** Footer cell template container that adds the right classes and role. */
+declare class CuteFooterCell extends CdkFooterCell {
+    color: ThemeColor | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteFooterCell, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteFooterCell, "cute-footer-cell, td[cute-footer-cell]", never, { "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+/** Cell template container that adds the right classes and role. */
+declare class CuteCell extends CdkCell {
+    color: ThemeColor | undefined;
+    active: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteCell, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteCell, "cute-cell, td[cute-cell]", never, { "color": { "alias": "color"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_active: unknown;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Header row definition for the `cute-table`.
+ * Captures the header row's template and other header properties such as the columns to display.
+ */
+declare class CuteHeaderRowDef extends CdkHeaderRowDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteHeaderRowDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteHeaderRowDef, "[cuteHeaderRowDef]", never, { "columns": { "alias": "cuteHeaderRowDef"; "required": false; }; "sticky": { "alias": "cuteHeaderRowDefSticky"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_sticky: unknown;
+}
+/**
+ * Footer row definition for the `cute-table`.
+ * Captures the footer row's template and other footer properties such as the columns to display.
+ */
+declare class CuteFooterRowDef extends CdkFooterRowDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteFooterRowDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteFooterRowDef, "[cuteFooterRowDef]", never, { "columns": { "alias": "cuteFooterRowDef"; "required": false; }; "sticky": { "alias": "cuteFooterRowDefSticky"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_sticky: unknown;
+}
+/**
+ * Data row definition for the `cute-table`.
+ * Captures the data row's template and other properties such as the columns to display and
+ * a when predicate that describes when this row should be used.
+ */
+declare class CuteRowDef<T> extends CdkRowDef<T> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteRowDef<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteRowDef<any>, "[cuteRowDef]", never, { "columns": { "alias": "cuteRowDefColumns"; "required": false; }; "when": { "alias": "cuteRowDefWhen"; "required": false; }; }, {}, never, never, true, never>;
+}
+/** Header template container that contains the cell outlet. Adds the right class and role. */
+declare class CuteHeaderRow extends CdkHeaderRow {
+    color: ThemeColor | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteHeaderRow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteHeaderRow, "cute-header-row, tr[cute-header-row]", ["cuteHeaderRow"], { "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+/** Footer template container that contains the cell outlet. Adds the right class and role. */
+declare class CuteFooterRow extends CdkFooterRow {
+    color: ThemeColor | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteFooterRow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteFooterRow, "cute-footer-row, tr[cute-footer-row]", ["cuteFooterRow"], { "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+/** Data row template container that contains the cell outlet. Adds the right class and role. */
+declare class CuteRow extends CdkRow {
+    color: ThemeColor | undefined;
+    active: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteRow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteRow, "cute-row, tr[cute-row]", ["cuteRow"], { "color": { "alias": "color"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_active: unknown;
+}
+/** Row that can be used to display a message when no data is shown in the table. */
+declare class CuteNoDataRow extends CdkNoDataRow {
+    _cellSelector: string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteNoDataRow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteNoDataRow, "ng-template[cuteNoDataRow]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Data source that accepts a client-side data array and includes native support of filtering,
+ * sorting (using CuteSort), and pagination (using CutePaginator).
+ *
+ * Allows for sort customization by overriding sortingDataAccessor, which defines how data
+ * properties are accessed. It also allows for filter customization by overriding filterPredicate,
+ * which defines how row data is converted to a string for filter matching.
+ *
+ * **Note:** This class is meant to be a simple data source to help you get started. As such,
+ * it isn't equipped to handle some more advanced cases like robust i18n support or server-side
+ * interactions. If your app needs to support more advanced use cases, consider implementing your
+ * own `DataSource`.
+ */
+declare class CuteTableDataSource<T, P extends CutePaginator = CutePaginator> extends DataSource<T> {
+    /** Stream that emits when a new data array is set on the data source. */
+    private readonly _data;
+    /** Stream emitting render data to the table (depends on ordered data changes). */
+    private readonly _renderData;
+    /** Stream that emits when a new filter string is set on the data source. */
+    private readonly _filter;
+    /** Used to react to internal changes of the paginator that are made by the data source itself. */
+    private readonly _internalPageChanges;
+    /**
+     * Subscription to the changes that should trigger an update to the table's rendered rows, such
+     * as filtering, sorting, pagination, or base data changes.
+     */
+    private _renderChangesSubscription;
+    /**
+     * The filtered set of data that has been matched by the filter string, or all the data if there
+     * is no filter. Useful for knowing the set of data the table represents.
+     * For example, a 'selectAll()' function would likely want to select the set of filtered data
+     * shown to the user rather than all the data.
+     */
+    filteredData: T[];
+    /** Array of data that should be rendered by the table, where each object represents one row. */
+    get data(): T[];
+    set data(data: T[]);
+    /**
+     * Filter term that should be used to filter out objects from the data array. To override how
+     * data objects match to this filter string, provide a custom function for filterPredicate.
+     */
+    get filter(): string;
+    set filter(filter: string);
+    /**
+     * Instance of the CuteSort directive used by the table to control its sorting. Sort changes
+     * emitted by the CuteSort will trigger an update to the table's rendered data.
+     */
+    get sort(): CuteSort | null;
+    set sort(sort: CuteSort | null);
+    private _sort;
+    /**
+     * Instance of the paginator component used by the table to control what page of the data is
+     * displayed. Page changes emitted by the paginator will trigger an update to the
+     * table's rendered data.
+     *
+     * Note that the data source uses the paginator's properties to calculate which page of data
+     * should be displayed. If the paginator receives its properties as template inputs,
+     * e.g. `[pageLength]=100` or `[pageIndex]=1`, then be sure that the paginator's view has been
+     * initialized before assigning it to this data source.
+     */
+    get paginator(): P | null;
+    set paginator(paginator: P | null);
+    private _paginator;
+    /**
+     * Data accessor function that is used for accessing data properties for sorting through
+     * the default sortData function.
+     * This default function assumes that the sort header IDs (which defaults to the column name)
+     * matches the data's properties (e.g., column Xyz represents data['Xyz']).
+     * May be set to a custom function for different behavior.
+     * @param data Data object that is being accessed.
+     * @param sortHeaderId The name of the column that represents the data.
+     */
+    sortingDataAccessor: (data: T, sortHeaderId: string) => string | number;
+    /**
+     * Gets a sorted copy of the data array based on the state of the CuteSort. Called
+     * after changes are made to the filtered data or when sort changes are emitted from CuteSort.
+     * By default, the function retrieves the active sort and its direction and compares data
+     * by retrieving data using the sortingDataAccessor. May be overridden for a custom implementation
+     * of data ordering.
+     * @param data The array of data that should be sorted.
+     * @param sort The connected CuteSort that holds the current sort state.
+     */
+    sortData: (data: T[], sort: CuteSort) => T[];
+    /**
+     * Checks if a data object matches the data source's filter string. By default, each data object
+     * is converted to a string of its properties and returns true if the filter has
+     * at least one occurrence in that string. By default, the filter string has its whitespace
+     * trimmed and the match is case-insensitive. May be overridden for a custom implementation of
+     * filter matching.
+     * @param data Data object used to check against the filter.
+     * @param filter Filter string that has been set on the data source.
+     * @returns Whether the filter matches against the data
+     */
+    filterPredicate: (data: T, filter: string) => boolean;
+    constructor(initialData?: T[]);
+    /**
+     * Subscribe to changes that should trigger an update to the table's rendered rows. When the
+     * changes occur, process the current state of the filter, sort, and pagination along with
+     * the provided base data and send it to the table for rendering.
+     */
+    protected _updateChangeSubscription(): void;
+    /**
+     * Returns a filtered data array where each filter object contains the filter string within
+     * the result of the filterPredicate function. If no filter is set, return the data array
+     * as provided.
+     */
+    protected _filterData(data: T[]): T[];
+    /**
+     * Returns a sorted copy of the data if CuteSort has a sort applied, otherwise just returns the
+     * data array as provided. Uses the default data accessor for data lookup, unless a
+     * sortDataAccessor function is defined.
+     */
+    protected _orderData(data: T[]): T[];
+    /**
+     * Returns a paged slice of the provided data array according to the provided paginator's page
+     * index and length. If there is no paginator provided, return the data array as provided.
+     */
+    protected _pageData(data: T[]): T[];
+    /**
+     * Updates the paginator to reflect the length of the filtered data, and makes sure that the page
+     * index does not exceed the paginator's last page. Values are changed in a resolved promise to
+     * guard against making property changes within a round of change detection.
+     */
+    protected _updatePaginator(filteredDataLength: number): void;
+    /**
+     * Used by the CuteTable. Called when it connects to the data source.
+     */
+    connect(): BehaviorSubject<T[]>;
+    /**
+     * Used by the CuteTable. Called when it disconnects from the data source.
+     */
+    disconnect(): void;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Column that simply shows text content for the header and row cells. Assumes that the table
+ * is using the native table implementation (`<table>`).
+ *
+ * By default, the name of this column will be the header text and data property accessor.
+ * The header text can be overridden with the `headerText` input. Cell values can be overridden with
+ * the `dataAccessor` input. Change the text justification to the start or end using the `justify`
+ * input.
+ */
+declare class CuteTextColumn<T> extends CdkTextColumn<T> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTextColumn<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteTextColumn<any>, "cute-text-column", never, {}, {}, never, never, true, never>;
+}
+
+declare class CuteTableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteTableModule, never, [typeof i1.CommonModule, typeof i2.CdkTableModule, typeof CuteTable, typeof CuteRecycleRows, typeof CuteHeaderCellDef, typeof CuteHeaderRowDef, typeof CuteColumnDef, typeof CuteCellDef, typeof CuteRowDef, typeof CuteFooterCellDef, typeof CuteFooterRowDef, typeof CuteHeaderCell, typeof CuteCell, typeof CuteFooterCell, typeof CuteHeaderRow, typeof CuteRow, typeof CuteFooterRow, typeof CuteNoDataRow, typeof CuteTextColumn], [typeof CuteTable, typeof CuteRecycleRows, typeof CuteHeaderCellDef, typeof CuteHeaderRowDef, typeof CuteColumnDef, typeof CuteCellDef, typeof CuteRowDef, typeof CuteFooterCellDef, typeof CuteFooterRowDef, typeof CuteHeaderCell, typeof CuteCell, typeof CuteFooterCell, typeof CuteHeaderRow, typeof CuteRow, typeof CuteFooterRow, typeof CuteNoDataRow, typeof CuteTextColumn]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteTableModule>;
+}
+
+export { CUTE_TABLE, CuteCell, CuteCellDef, CuteColumnDef, CuteFooterCell, CuteFooterCellDef, CuteFooterRow, CuteFooterRowDef, CuteHeaderCell, CuteHeaderCellDef, CuteHeaderRow, CuteHeaderRowDef, CuteNoDataRow, CuteRecycleRows, CuteRow, CuteRowDef, CuteTable, CuteTableDataSource, CuteTableModule, CuteTextColumn };
+export type { TableBorders };