@sdcorejs/angular 19.0.0-rc.1

package/components/table/src/models/table-option.model.d.ts

@@ -0,0 +1,181 @@
+import { PagingReq } from '@sdcorejs/utils/models';
+import { SdTableFilterRequest, SdTableOptionFilter } from '../services/table-filter/table-filter.model';
+import { SdTableColumn } from './table-column.model';
+import { SdTableCommand, SdTableCommandOption } from './table-command.model';
+import { TableOptionConfig } from './table-option-config.model';
+import { SdTableOptionExpand } from './table-option-expand.model';
+import { SdTableOptionExport } from './table-option-export.model';
+import { SdTableOptionGroup } from './table-option-group.model';
+import { SdTableOptionPaginate } from './table-option-paginate.model';
+import { SdTableOptionReload } from './table-option-reload.model';
+import { SdTableOptionSelector } from './table-option-selector.model';
+import { SdTableOptionSort } from './table-option-sort.model';
+import { SdTableOptionStyle } from './table-option-style.model';
+import { SdTableOptionTree } from './table-option-tree.model';
+export type SdTableOption<T = any> = SdTableLocalOption<T> | SdTableServerOption<T>;
+interface SdTableBaseOption<T = any> {
+    /**
+     * Key định danh của table option.
+     * Thường dùng khi một số tính năng con cần lưu trạng thái riêng theo table,
+     * ví dụ các option có hỗ trợ cache/config theo key.
+     */
+    key?: string;
+    /**
+     * Cấu hình hiển thị/phục hồi config của table.
+     * Xem thêm kiểu chi tiết tại `TableOptionConfig`.
+     */
+    config?: TableOptionConfig;
+    /**
+     * Cấu hình chọn dòng (checkbox selector, action theo selection, pre-select...).
+     * Xem thêm tại `SdTableOptionSelector`.
+     */
+    selector?: SdTableOptionSelector<T>;
+    /**
+     * Cấu hình expand row.
+     * Xem thêm tại `SdTableOptionExpand` để biết cách disable, expand nhiều dòng,
+     * hoặc luôn hiển thị vùng expand.
+     */
+    expand?: SdTableOptionExpand<T>;
+    /**
+     * Bật/tắt sorting ở cấp table.
+     * Xem thêm tại `SdTableOptionSort`.
+     */
+    sort?: SdTableOptionSort;
+    /**
+     * Cấu hình phân trang.
+     * Xem thêm tại `SdTableOptionPaginate`.
+     */
+    paginate?: SdTableOptionPaginate;
+    /**
+     * Cấu hình hành vi reload dữ liệu.
+     * Xem thêm tại `SdTableOptionReload`.
+     */
+    reload?: SdTableOptionReload<T>;
+    /**
+     * Cấu hình export dữ liệu.
+     * Xem thêm tại `SdTableOptionExport` để biết mode `default`/`custom`, mapping,
+     * sheet export và giới hạn số dòng.
+     */
+    export?: SdTableOptionExport<T>;
+    /**
+     * Cấu hình group dữ liệu theo nhiều field.
+     * Xem thêm tại `SdTableOptionGroup`.
+     */
+    group?: SdTableOptionGroup<T>;
+    /**
+     * Cấu hình tree rows — render children inline dưới parent.
+     * Xem thêm tại `SdTableOptionTree`.
+     */
+    tree?: SdTableOptionTree<T>;
+    /**
+     * Cấu hình filter của table.
+     * Xem thêm tại `SdTableOptionFilter` để biết filter inline, external filter,
+     * manual filter, cacheable và callback clear filter.
+     */
+    filter?: SdTableOptionFilter;
+    /**
+     * Cấu hình cột đánh số thứ tự (STT) ở đầu mỗi dòng.
+     * Khi enabled = true, table render thêm 1 cột STT (sticky đầu, sau selector).
+     * Số thứ tự tính theo global index (pageIndex * pageSize + i + 1) để tương thích phân trang.
+     */
+    index?: {
+        /** Bật/tắt cột STT. */
+        enabled?: boolean;
+        /** Tiêu đề header (mặc định '#'). */
+        title?: string;
+        /** Width của cột (mặc định '50px'). */
+        width?: string;
+    };
+    /**
+     * Bật cột filler ở cuối row để hấp thụ leftover width khi tổng width các cột data < container.
+     * Khi enabled = true, các cột utility (selection / STT / command) không bị browser stretch trên màn rộng.
+     * Mặc định off — table tự stretch cột data theo `width: 100%` như cũ.
+     */
+    filler?: {
+        /** Bật/tắt cột filler. */
+        enabled?: boolean;
+    };
+    /**
+     * Cấu hình kéo-thả đổi thứ tự dòng.
+     * Chỉ bật khi table cho phép reorder dữ liệu phía client.
+     */
+    rowReorder?: {
+        /** Bật/tắt tính năng reorder row. */
+        enabled?: boolean;
+        /**
+         * Callback sau khi reorder xong.
+         * `newRows` là mảng sau khi đã đổi vị trí ở UI,
+         * `movedItem` là item vừa được kéo,
+         * `fromIndex` và `toIndex` là vị trí cũ/mới.
+         */
+        onChange?: (newRows: T[], movedItem: T, fromIndex: number, toIndex: number) => void;
+        /**
+         * Tên icon hiển thị cho drag handle.
+         * Nếu không truyền thì table dùng icon reorder mặc định của Material.
+         * Nếu truyền custom icon, nên dùng tên glyph của Material Icons:
+         * https://fonts.google.com/icons
+         */
+        icon?: string;
+        /**
+         * Disable khả năng reorder theo từng dòng.
+         * Trả về `true` để chặn kéo-thả dòng tương ứng.
+         */
+        disabled?: (row: T, index: number) => boolean;
+    };
+    /**
+     * Danh sách command thao tác theo từng dòng.
+     * Xem thêm tại `SdTableCommand`.
+     */
+    commands?: SdTableCommand<T>[];
+    /**
+     * Cấu hình vùng command tập trung.
+     * Dùng khi cần set thêm alignment hoặc bọc danh sách command trong object option.
+     * Xem thêm tại `SdTableCommandOption`.
+     */
+    command?: SdTableCommandOption<T>;
+    /**
+     * Danh sách cột hiển thị của table.
+     * Đây là phần bắt buộc. Xem thêm tại `SdTableColumn` để cấu hình field, filter,
+     * sort, transform, template và export của từng cột.
+     */
+    columns: SdTableColumn<T>[];
+    /**
+     * Cấu hình style/layout chung của table.
+     * Xem thêm tại `SdTableOptionStyle`.
+     */
+    style?: SdTableOptionStyle<T>;
+}
+interface SdTableLocalOption<T = any> extends SdTableBaseOption<T> {
+    /** Dùng dữ liệu local tại client. */
+    type: 'local';
+    /**
+     * Hàm trả dữ liệu local cho table.
+     * Table sẽ tự gọi hàm này để lấy mảng item nguồn.
+     * Có thể trả về đồng bộ hoặc `Promise<T[]>`.
+     */
+    items: () => T[] | Promise<T[]>;
+}
+interface SdTableServerOption<T = any> extends SdTableBaseOption<T> {
+    /** Dùng dữ liệu từ server, có paging/filter/sort theo request của table. */
+    type: 'server';
+    /**
+     * Hàm lấy dữ liệu từ server.
+     * `filterRequest` chứa trạng thái filter/sort/visible columns ở dạng của table.
+     * `pagingReq` là dữ liệu paging đã được chuẩn hóa để dễ map sang API backend.
+     * Hàm cần trả về `{ items, total }` để table render và tính phân trang.
+     */
+    items: (filterRequest: SdTableFilterRequest<T>, pagingReq: PagingReq<T>) => Promise<{
+        items: T[];
+        total: number;
+    }>;
+    /**
+     * Hook chạy khi table phát sinh filter request.
+     * Dùng để can thiệp thêm trước/sau khi gọi API, ví dụ sync external state,
+     * theo dõi trạng thái valid của external filter, hoặc ghi log request filter hiện tại.
+     */
+    onFilter?: (filterRequest: SdTableFilterRequest<T>, args: {
+        /** Cho biết toàn bộ external filter hiện tại có hợp lệ để trigger filter hay không. */
+        externalFilterValid: boolean;
+    }) => void;
+}
+export {};

package/components/table/src/pipes/filter-values.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FilterValuesPipe implements PipeTransform {
+    constructor();
+    transform(items: any[] | (() => Promise<any[]>) | undefined | null): Promise<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterValuesPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FilterValuesPipe, "filterValues", true>;
+}

package/components/table/src/pipes/index.d.ts

@@ -0,0 +1,2 @@
+export * from './filter-values.pipe';
+export * from './sd-tree.pipe';

package/components/table/src/pipes/sd-group.pipe.d.ts

@@ -0,0 +1,23 @@
+import { PipeTransform } from '@angular/core';
+import { SdTableOption } from '../models/table-option.model';
+import { SdTableItem } from '../models/table-item.model';
+import * as i0 from "@angular/core";
+export declare class SdGroupPipe implements PipeTransform {
+    /**
+     * Nhóm items theo `option.group.fields`. Mỗi group sinh ra 1 synthetic SdTableItem
+     * (group header) đặt trước children. Header có `meta.group.isGroupHeader = true` + `key`
+     * + `values` + `items` + `isExpanded` để template + table consume.
+     *
+     * Khi `option.group.collapsible = true` + group đang collapse → children bị lọc khỏi output.
+     *
+     * `expandState` (optional, owned by component) — Map<key, expanded> giữ trạng thái
+     * expand/collapse qua các lần transform. Pipe đọc state từ Map; nếu key chưa tồn tại,
+     * dùng `!option.group.defaultCollapsed`. Pipe ghi state về Map cho lần read sau.
+     *
+     * @example
+     * `_items | sdGroup: _tableOption : groupExpandState`
+     */
+    transform(items: SdTableItem[], gridOption: SdTableOption, expandState?: Map<string, boolean>): SdTableItem[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdGroupPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SdGroupPipe, "sdGroup", true>;
+}

package/components/table/src/pipes/sd-tree.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { SdTableOptionTree } from '../models/table-option-tree.model';
+import { SdTableItem } from '../models/table-item.model';
+import * as i0 from "@angular/core";
+export declare class SdTreePipe implements PipeTransform {
+    transform(items: SdTableItem[], treeOption?: SdTableOptionTree, _revision?: number): SdTableItem[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTreePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SdTreePipe, "sdTree", true>;
+}

package/components/table/src/pipes/selection-disabled.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { SdTableOptionSelector } from '../models/table-option-selector.model';
+import { SdTableItem } from '../models/table-item.model';
+import * as i0 from "@angular/core";
+export declare class SdSelectionDisabledPipe implements PipeTransform {
+    transform: (selectedItems: SdTableItem[], rowData: SdTableItem, selection: SdTableOptionSelector) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdSelectionDisabledPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SdSelectionDisabledPipe, "selectionDisabled", true>;
+}

package/components/table/src/pipes/selection-visible-select-all.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { SdTableOptionSelector } from '../models/table-option-selector.model';
+import { SdTableItem } from '../models/table-item.model';
+import * as i0 from "@angular/core";
+export declare class SdSelectionVisibleSelectAllPipe implements PipeTransform {
+    transform: (items: SdTableItem[], selector: SdTableOptionSelector | undefined) => Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdSelectionVisibleSelectAllPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SdSelectionVisibleSelectAllPipe, "selectionVisibleSelectAll", true>;
+}

package/components/table/src/pipes/selection-visible.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { SdTableOptionSelector } from '../models/table-option-selector.model';
+import { SdTableItem } from '../models/table-item.model';
+import * as i0 from "@angular/core";
+export declare class SdSelectionVisiblePipe implements PipeTransform {
+    transform: (rowData: SdTableItem, selection: SdTableOptionSelector | undefined) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdSelectionVisiblePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SdSelectionVisiblePipe, "selectionVisible", true>;
+}

package/components/table/src/services/column-width.util.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Build Record<field, width> từ map column hiện tại trong ConfiguredTableResult.
+ * Loại bỏ field có width undefined để consumer luôn nhận chuỗi 'NNpx'.
+ */
+export declare const buildColumnWidthMap: (column: Record<string, {
+    width?: string;
+}> | undefined | null) => Record<string, string>;

package/components/table/src/services/config.service.d.ts

@@ -0,0 +1,21 @@
+import { SdStorage, SdStorageService } from '@sdcorejs/angular/services';
+import { ConfiguredTable, ConfiguredTableResult } from '../models/table-option-config.model';
+import { SdTableOption } from '../models/table-option.model';
+import { ISdTableConfiguration } from '../configurations';
+import * as i0 from "@angular/core";
+export declare class ConfigService {
+    #private;
+    private storageService;
+    tableConfiguration: ISdTableConfiguration;
+    widthChange$: import("rxjs").Observable<{
+        field: string;
+        width: string;
+    }>;
+    constructor(storageService: SdStorageService, tableConfiguration: ISdTableConfiguration);
+    loadConfiguredTable: (option: SdTableOption) => ConfiguredTable;
+    loadConfigurationResult: (option: SdTableOption, configuration: ConfiguredTable) => ConfiguredTableResult;
+    init: (tableOption: SdTableOption) => SdStorage<ConfiguredTable>;
+    persistColumnWidth: (field: string, width: string) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigService>;
+}

package/components/table/src/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from './table-export/table-export.service';
+export * from './table-format/table-format.service';
+export * from './config.service';

package/components/table/src/services/table-export/table-export.service.d.ts

@@ -0,0 +1,26 @@
+import { SdExcelColumn } from '@sdcorejs/angular/services';
+import { ConfiguredTableResult } from '../../models/table-option-config.model';
+import { SdTableOption } from '../../models/table-option.model';
+import { SdTableFilterRequest } from '../table-filter/table-filter.model';
+import * as i0 from "@angular/core";
+export interface SdTableExportContext<T = any> {
+    option: SdTableOption<T>;
+    configuration?: ConfiguredTableResult;
+    total: number;
+    cacheObjValues: Record<string, Record<string, string>>;
+    fetchChunk: (pageNumber: number, pageSize: number) => Promise<T[] | {
+        items: any[];
+        total: number;
+    }>;
+    getFilterInfo: () => SdTableFilterRequest;
+}
+export declare class TableExportService {
+    #private;
+    exporting: import("@angular/core").WritableSignal<boolean>;
+    exportTitle: import("@angular/core").WritableSignal<string>;
+    exportExcel: (context: SdTableExportContext, columns?: SdExcelColumn[]) => Promise<void>;
+    exportCSV: (context: SdTableExportContext, columns?: SdExcelColumn[]) => Promise<void>;
+    exportCustom: (context: SdTableExportContext) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableExportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableExportService>;
+}

package/components/table/src/services/table-filter/table-filter.model.d.ts

@@ -0,0 +1,150 @@
+import { TemplateRef } from '@angular/core';
+import { SdSearch } from '@sdcorejs/angular/forms';
+import { NestedKeyOf, Operator, Order, PagingReq } from '@sdcorejs/utils/models';
+import { Observable } from 'rxjs';
+import { SdTableColumn } from '../../models/table-column.model';
+export interface SdTableQuickFilter {
+    code: string;
+    columnFilter: Record<string, any>;
+    externalFilter: Record<string, any>;
+}
+export interface TableFilterConfiguration {
+    inlineExternal: Record<string, boolean>;
+}
+export interface TableFilterValue {
+    columnOperator?: Record<string, Operator>;
+    columnFilter?: Record<string, any>;
+    externalFilter?: Record<string, any>;
+    notReload?: boolean;
+    filtered?: boolean;
+}
+export interface SdTableFilterRequest<T = any> {
+    columnOperator: Record<NestedKeyOf<T>, Operator>;
+    rawColumnFilter: Record<NestedKeyOf<T>, any>;
+    rawExternalFilter: Record<string, any>;
+    pageNumber: number;
+    pageSize: number;
+    orderBy?: string;
+    orderDirection?: Order['direction'];
+    isExported?: boolean;
+    visibledColumns?: SdTableColumn[];
+}
+export interface SdTableOptionFilter<T = any> {
+    /** Key định danh nếu muốn lưu cache */
+    key?: string;
+    /** Có bật cache giá trị filter hay không */
+    cacheable?: boolean;
+    /** Vô hiệu toàn bộ filter */
+    disabled?: boolean;
+    /** Ẩn tất cả inline filter (chỉ còn external), nếu chọn auto thì sẽ ẩn khi total row <= 10, phù hợp cho các màn detail có ít dữ liệu */
+    hideInlineFilter?: boolean | 'auto';
+    /** Hàm xử lý khi đổi Operator của filter column */
+    operatorChange?: (column?: SdTableColumn, operator?: Operator) => void;
+    /** Danh sách external filter */
+    externalFilters?: SdTableExternalFilter[];
+    /** Số lượng cột external filter trên mỗi hàng (mặc định: 6) */
+    externalFilterPerRow?: 4 | 6;
+    /** Chế độ thủ công: phải nhấn nút áp dụng mới gửi filter */
+    manualFilter?: boolean;
+    /** Có thể thu gọn bộ lọc hay không */
+    collapsable?: boolean;
+    /** Ẩn toolbar (xóa bộ lọc, thiết lập) của external filter, khi có ít external filter user không cần chức năng này */
+    hideExternalFilterToolbar?: boolean;
+    /** Hàm xử lý khi trigger clear filter từ external filter */
+    onClearFilter?: () => void;
+}
+export declare const SdConvertToPagingReq: (filterRequest: SdTableFilterRequest, args: {
+    columns?: SdTableColumn[];
+    externalFilters?: SdTableExternalFilter[];
+    fieldMapping?: Record<string, string>;
+    orders?: Order[];
+}) => PagingReq;
+export declare type SdTableExternalFilter<TData = any> = TextFilter<TData> | DateFilter<TData> | DateTimeFilter<TData> | DateRangeFilter<TData> | NumberFilter<TData> | ValuesFilter<TData> | LazyValuesFilter<TData> | BooleanFilter<TData> | CustomFilter<TData>;
+interface BaseFilter<TData = any> {
+    field: string;
+    title: string;
+    defaultShowing?: boolean;
+    required?: boolean;
+    hidden?: boolean;
+    defaultOperator?: Operator;
+    data?: TData;
+    onChange?: (value: any) => void;
+}
+interface TextFilter<TData = any> extends BaseFilter<TData> {
+    type: 'string';
+    default?: string;
+}
+interface DateFilter<TData = any> extends BaseFilter<TData> {
+    type: 'date';
+    default?: Date | string;
+    minDate?: string | number | Date;
+    maxDate?: string | number | Date;
+}
+interface DateTimeFilter<TData = any> extends BaseFilter<TData> {
+    type: 'datetime';
+    default?: Date | string;
+    minDate?: string | number | Date;
+    maxDate?: string | number | Date;
+}
+interface DateRangeFilter<TData = any> extends BaseFilter<TData> {
+    type: 'daterange';
+    enableTime?: boolean;
+    minDate?: string | number | Date;
+    maxDate?: string | number | Date;
+    default?: {
+        from?: Date | string;
+        to?: Date | string;
+    };
+}
+interface NumberFilter<TData = any> extends BaseFilter<TData> {
+    type: 'number';
+    default?: number;
+}
+interface ValuesFilter<TData = any> extends BaseFilter<TData> {
+    type: 'values';
+    option: {
+        valueField: string;
+        displayField: string;
+        items: any[] | (() => Promise<any[]>);
+        selection?: 'AUTOCOMPLETE' | 'MULTIPLE' | 'MULTIPLEAUTOCOMPLETE';
+    };
+    default?: string | string[];
+}
+interface LazyValuesFilter<TData = any> extends BaseFilter<TData> {
+    type: 'lazy-values';
+    option: {
+        valueField: string;
+        displayField: string;
+        items: SdSearch;
+        selection?: 'MULTIPLE';
+    };
+    default?: string | string[];
+}
+interface BooleanFilter<TData = any> extends BaseFilter<TData> {
+    type: 'boolean';
+    option?: {
+        displayOnTrue?: string;
+        displayOnFalse?: string;
+    };
+    default?: boolean;
+}
+interface CustomFilter<TData = any> extends BaseFilter<TData> {
+    type: 'custom';
+    filterDef?: TemplateRef<any>;
+    default?: any;
+}
+export interface TableFilterRegister {
+    configuration: {
+        get: () => TableFilterConfiguration;
+        set: (configuration: Partial<TableFilterConfiguration>) => TableFilterConfiguration;
+        remove: () => void;
+        observer: Observable<TableFilterConfiguration>;
+    };
+    value: {
+        get: () => TableFilterValue;
+        set: (value: Partial<TableFilterValue>) => TableFilterValue;
+        remove: () => void;
+        observer: Observable<TableFilterValue>;
+    };
+}
+export {};

package/components/table/src/services/table-filter/table-filter.service.d.ts

@@ -0,0 +1,20 @@
+import { SdStorageService } from '@sdcorejs/angular/services';
+import { Operator } from '@sdcorejs/utils/models';
+import { SdTableFilterDefDirective } from '../../directives/sd-table-filter-def.directive';
+import { SdTableColumn } from '../../models/table-column.model';
+import { SdTableExternalFilter, SdTableOptionFilter, TableFilterRegister } from './table-filter.model';
+import * as i0 from "@angular/core";
+export declare class SdTableFilterService {
+    #private;
+    private storageService;
+    constructor(storageService: SdStorageService);
+    register: (filter: SdTableOptionFilter | undefined, args: {
+        id: string;
+        columns: SdTableColumn[] | undefined;
+        externalFilters: SdTableExternalFilter[] | undefined;
+        filterDefs: SdTableFilterDefDirective[] | undefined;
+        columnOperator?: Record<string, Operator>;
+    }) => TableFilterRegister;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTableFilterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdTableFilterService>;
+}

package/components/table/src/services/table-format/table-format.service.d.ts

@@ -0,0 +1,16 @@
+import { SdTableColumn } from '../../models/table-column.model';
+import { SdTableItem } from '../../models/table-item.model';
+import * as i0 from "@angular/core";
+export declare class TableFormatService {
+    #private;
+    /**
+     * Tải và cache các giá trị từ điển cho cột 'values'
+     */
+    loadValues(columns: SdTableColumn[], cacheValues: Record<string, any[]>, cacheObjValues: Record<string, Record<string, string>>): Promise<void>;
+    /**
+     * Chuyển đổi dữ liệu thô thành SdTableItem kèm các thiết lập hiển thị (Display Meta)
+     */
+    format<T = any>(rawItems: T[], columns: SdTableColumn[], cacheValues: Record<string, any[]>, cacheObjValues: Record<string, Record<string, string>>): Promise<SdTableItem<T>[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableFormatService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableFormatService>;
+}

package/components/table/src/services/tree/tree.util.d.ts

@@ -0,0 +1,14 @@
+import { SdTableOptionTree } from '../../models/table-option-tree.model';
+import { SdTableItem } from '../../models/table-item.model';
+export declare const getChildrenKey: (option?: SdTableOptionTree) => string;
+export declare const getChildrenFromData: <T>(data: T, option?: SdTableOptionTree) => T[];
+export declare const resolveDefaultExpanded: (level: number, option?: SdTableOptionTree) => boolean;
+export declare const resolveHasChildren: <T>(row: SdTableItem<T>, option?: SdTableOptionTree) => boolean;
+export declare const hasLazyChildren: <T>(row: SdTableItem<T>, option?: SdTableOptionTree) => boolean;
+export declare const flattenTree: <T>(roots: SdTableItem<T>[], option?: SdTableOptionTree, visited?: Set<string>) => SdTableItem<T>[];
+/** Thu thập mọi SdTableItem đã format trong cây (kể cả node đang collapse). */
+export declare const collectFormattedTreeRows: <T>(roots: SdTableItem<T>[]) => SdTableItem<T>[];
+/** Flatten ALL nodes regardless of expand state — used for export */
+export declare const flattenTreeAll: <T>(roots: SdTableItem<T>[], option?: SdTableOptionTree, visited?: Set<string>) => SdTableItem<T>[];
+/** Flatten raw data tree for export (ignores expand state) */
+export declare const flattenDataTree: <T>(roots: T[], option?: SdTableOptionTree, visited?: Set<unknown>) => T[];