@sdcorejs/angular 19.0.1 → 19.0.4

package/components/query-builder/src/query-builder.model.d.ts

@@ -0,0 +1,118 @@
+import { Operator } from '@sdcorejs/utils/models';
+/** Field kinds the builder understands. Drives the operator set + value editor. */
+export type SdQueryBuilderFieldType = 'string' | 'number' | 'boolean' | 'date' | 'datetime' | 'values';
+/** One option for a `values`-type field (enum / lookup). */
+export interface SdQueryBuilderFieldOption {
+    /** Stored value (sent inside the `Filter`). */
+    value: any;
+    /** Human-readable label shown in the select + view-mode string. */
+    display: string;
+}
+/**
+ * One filterable field. `key` matches `Filter.field` (dot-notation allowed);
+ * `label` is what the view-mode raw string renders (field token = label).
+ */
+export interface SdQueryBuilderField {
+    /** Dot-notation field path — written to `Filter.field`. */
+    key: string;
+    /** Human label — shown in the field picker AND as the view-mode field token. */
+    label: string;
+    /** Field type — picks the default operator set + value editor control. */
+    type: SdQueryBuilderFieldType;
+    /** Override the allowed operator set (otherwise `QB_OPERATORS_BY_TYPE[type]`). */
+    operators?: Operator[];
+    /** Override the starting operator (otherwise `QB_DEFAULT_OPERATOR_BY_TYPE[type]`). */
+    defaultOperator?: Operator;
+    /** Options for `type: 'values'` — the select list + display-label lookup. */
+    values?: SdQueryBuilderFieldOption[];
+    /** Label for the `true` branch of a boolean field (default `'Có'`). */
+    trueLabel?: string;
+    /** Label for the `false` branch of a boolean field (default `'Không'`). */
+    falseLabel?: string;
+    /** Lower bound for number / date value editors. */
+    min?: number | string;
+    /** Upper bound for number / date value editors. */
+    max?: number | string;
+}
+export type QbNode = QbGroup | QbRule;
+/** A logical group of nodes joined by AND / OR. Maps to `FilterAndOr`. */
+export interface QbGroup {
+    id: string;
+    kind: 'group';
+    logic: 'AND' | 'OR';
+    children: QbNode[];
+    /** UI-only: whether this group's "+" dropdown is open. */
+    open?: boolean;
+}
+/** A single `field operator value` condition. Maps to a leaf `Filter`. */
+export interface QbRule {
+    id: string;
+    kind: 'rule';
+    field?: string;
+    operator?: Operator;
+    /** Single value, `{ from, to }` for BETWEEN, or an array for IN / NOT_IN. */
+    value?: any;
+}
+/** Type guard — narrows a `QbNode` to a `QbGroup`. */
+export declare function isQbGroup(node: QbNode): node is QbGroup;
+export type QbTokenKind = 'field' | 'op' | 'value' | 'logic' | 'paren' | 'plain';
+/** One piece of the rendered raw query string, tagged for highlight styling. */
+export interface QbToken {
+    text: string;
+    kind: QbTokenKind;
+}
+/** Allowed operators per field type — used when `field.operators` is not set. */
+export declare const QB_OPERATORS_BY_TYPE: Record<SdQueryBuilderFieldType, Operator[]>;
+/** Default operator when a rule is first created for a field. */
+export declare const QB_DEFAULT_OPERATOR_BY_TYPE: Record<SdQueryBuilderFieldType, Operator>;
+/** Operators with no value payload — the value editor is hidden for these. */
+export declare const QB_NO_DATA_OPERATORS: Operator[];
+/** Operators whose value is an array — the value editor offers multi-select. */
+export declare const QB_MULTI_OPERATORS: Operator[];
+/** Operators allowed for `field` — explicit override wins, else the per-type set. */
+export declare function qbAllowedOperators(field: SdQueryBuilderField | undefined): Operator[];
+/** Starting operator for a new rule on `field` — falls back to the per-type default. */
+export declare function qbDefaultOperator(field: SdQueryBuilderField | undefined): Operator | undefined;
+/** True when `op` is NULL / NOT_NULL (no value editor). */
+export declare function qbIsNoDataOperator(op: Operator | undefined): boolean;
+/** True when `op` is IN / NOT_IN (array value). */
+export declare function qbIsMultiOperator(op: Operator | undefined): boolean;
+/** Next stable node id with the given prefix. */
+export declare function qbId(prefix?: string): string;
+/** Build a fresh rule node (optionally pre-filled). */
+export declare function qbNewRule(field?: string, operator?: Operator, value?: any): QbRule;
+/** Build a fresh group node. */
+export declare function qbNewGroup(logic?: 'AND' | 'OR', children?: QbNode[]): QbGroup;
+/** Offset unit for a relative date. */
+export type SdQbRelativeUnit = 'day' | 'week' | 'month';
+/** Offset direction for a relative date. */
+export type SdQbRelativeDirection = 'previous' | 'next';
+/** A relative (resolved-at-query-time) date value stored in `Filter.data`. */
+export interface SdQbRelativeDate {
+    /** `'now'` = current moment / today · `'offset'` = now ± amount × unit. */
+    rel: 'now' | 'offset';
+    /** Offset unit — only for `rel: 'offset'`. */
+    unit?: SdQbRelativeUnit;
+    /** Offset magnitude (>= 1) — only for `rel: 'offset'`. */
+    amount?: number;
+    /** Offset direction — only for `rel: 'offset'`. */
+    direction?: SdQbRelativeDirection;
+}
+/** Date value editor mode for a date/datetime rule (derived from the rule value). */
+export type QbDateMode = 'absolute' | 'now' | 'relative';
+/** Type guard — narrows an arbitrary value to a relative-date spec. */
+export declare function qbIsRelativeDate(v: any): v is SdQbRelativeDate;
+/** Starting relative value when a rule first switches to "relative" mode. */
+export declare function qbDefaultRelative(): SdQbRelativeDate;
+/** Stable option list for the date-mode select (module ref — never reallocated). */
+export declare const QB_DATE_MODES: ReadonlyArray<{
+    value: QbDateMode;
+    display: string;
+}>;
+/** Stable combined direction×unit option list (token `'unit:direction'`). */
+export declare const QB_RELATIVE_UNIT_OPTIONS: ReadonlyArray<{
+    value: string;
+    display: string;
+}>;
+/** Shared empty option array — stable ref for fallbacks (avoids per-call allocation). */
+export declare const QB_EMPTY_OPTIONS: SdQueryBuilderFieldOption[];

package/components/query-builder/src/query-builder.serializer.d.ts

@@ -0,0 +1,32 @@
+import { Filter } from '@sdcorejs/utils/models';
+import { QbGroup, QbToken, SdQueryBuilderField } from './query-builder.model';
+/**
+ * Map the internal builder tree to the public `Filter` (the root is always a
+ * `FilterAndOr`). Rules missing field / operator / value — and empty nested
+ * groups — are dropped so the result is always a valid `Filter`.
+ *
+ * @param group - the editable tree's root group.
+ * @returns the canonical nested `Filter`, or `null` when no complete rule survives.
+ */
+export declare function treeToFilter(group: QbGroup): Filter | null;
+/**
+ * Inverse of {@link treeToFilter} — rebuild the editable tree from a `Filter` so a
+ * consumer can seed `[value]`. A non-group (bare) filter is wrapped in an AND root;
+ * `null` yields an empty AND root.
+ *
+ * @param filter - a `Filter` (group or leaf), or `null` / `undefined` for an empty tree.
+ * @returns a fresh root `QbGroup` mirroring the filter's structure.
+ */
+export declare function filterToTree(filter: Filter | null | undefined): QbGroup;
+/**
+ * Render a `Filter` to a SQL-ish token stream for view mode. Field tokens use the
+ * matching field's `label`; operators map to SQL syntax (`= != like between is null …`);
+ * `and` / `or` are lowercase; nested multi-child groups are wrapped in parentheses.
+ * Returns a token stream (not a string) so the template can wrap each piece in a
+ * highlight `<span>` keyed by `QbToken.kind`.
+ *
+ * @param filter - the `Filter` to render, or `null` / `undefined`.
+ * @param fields - field metadata, used to resolve each field key to its display label + value formatting.
+ * @returns the ordered tokens, or `[]` when `filter` is empty.
+ */
+export declare function filterToTokens(filter: Filter | null | undefined, fields: SdQueryBuilderField[]): QbToken[];

package/components/section/src/section.component.d.ts

@@ -1,7 +1,6 @@
-import { SdBaseSecureComponent } from '@sdcorejs/angular/components/base';
 import { Color } from '@sdcorejs/utils/models';
 import * as i0 from "@angular/core";
-export declare class SdSection extends SdBaseSecureComponent {
+export declare class SdSection {
     #private;
     title: import("@angular/core").InputSignal<string | null | undefined>;
     subTitle: import("@angular/core").InputSignal<string | null | undefined>;

package/components/side-drawer/src/side-drawer.component.d.ts

@@ -1,8 +1,7 @@
 import { CdkPortal } from '@angular/cdk/portal';
-import { SdBaseSecureComponent } from '@sdcorejs/angular/components/base';
 import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
-export declare class SdSideDrawer extends SdBaseSecureComponent {
+export declare class SdSideDrawer {
     #private;
     id: string;
     portal: import("@angular/core").Signal<CdkPortal>;

package/components/stepper/src/stepper.component.d.ts

@@ -1,10 +1,9 @@
 import { StepperSelectionEvent } from '@angular/cdk/stepper';
 import { MatStepper } from '@angular/material/stepper';
-import { SdBaseSecureComponent } from '@sdcorejs/angular/components/base';
 import { Color } from '@sdcorejs/utils/models';
 import { SdStep } from './step.component';
 import * as i0 from "@angular/core";
-export declare class SdStepper extends SdBaseSecureComponent {
+export declare class SdStepper {
     steps: import("@angular/core").Signal<readonly SdStep[]>;
     selectedIndex: import("@angular/core").ModelSignal<number>;
     linear: import("@angular/core").InputSignalWithTransform<boolean, unknown>;

package/components/tab/src/tab-group.component.d.ts

@@ -1,5 +1,4 @@
 import { MatTabGroup } from '@angular/material/tabs';
-import { SdBaseSecureComponent } from '@sdcorejs/angular/components/base';
 import { Color } from '@sdcorejs/utils/models';
 import { SdTab } from './tab.component';
 import * as i0 from "@angular/core";
@@ -7,7 +6,7 @@ export interface SdTabClosedEvent {
     index: number;
     tab: SdTab;
 }
-export declare class SdTabGroup extends SdBaseSecureComponent {
+export declare class SdTabGroup {
     tabs: import("@angular/core").Signal<readonly SdTab[]>;
     selectedIndex: import("@angular/core").ModelSignal<number>;
     variant: import("@angular/core").InputSignal<"line" | "pills" | "segmented">;

package/components/table/src/components/config/config.component.d.ts

@@ -6,8 +6,10 @@ import { SdTableOption } from '../../models/table-option.model';
 import * as i0 from "@angular/core";
 export declare class ConfigComponent {
     #private;
+    autoIdInput: import("@angular/core").InputSignal<string | null | undefined>;
     tableOption: import("@angular/core").InputSignal<SdTableOption | undefined>;
     changes: import("@angular/core").OutputEmitterRef<ConfiguredTableResult>;
+    autoId: import("@angular/core").Signal<string>;
     modal: import("@angular/core").Signal<SdModal | undefined>;
     table: import("@angular/core").Signal<MatTable<SdTableColumn>>;
     configuration: import("@angular/core").WritableSignal<ConfiguredTable | undefined>;
@@ -21,5 +23,5 @@ export declare class ConfigComponent {
     handleMouseDown(): void;
     handleMouseUp(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConfigComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigComponent, "config", never, { "tableOption": { "alias": "tableOption"; "required": false; "isSignal": true; }; }, { "changes": "changes"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigComponent, "config", never, { "autoIdInput": { "alias": "autoId"; "required": false; "isSignal": true; }; "tableOption": { "alias": "tableOption"; "required": false; "isSignal": true; }; }, { "changes": "changes"; }, never, never, true, never>;
 }

package/components/table/src/components/selector-action/selector-action.component.d.ts

@@ -4,13 +4,15 @@ import { Action } from './action-filter.pipe';
 import * as i0 from "@angular/core";
 export declare class SelectorActionComponent {
     #private;
+    autoIdInput: import("@angular/core").InputSignal<string | null | undefined>;
     tableOption: import("@angular/core").InputSignal<SdTableOption | undefined>;
     selectedTableItems: import("@angular/core").InputSignal<SdTableItem<any>[] | undefined>;
     clear: import("@angular/core").OutputEmitterRef<void>;
+    autoId: import("@angular/core").Signal<string>;
     message: import("@angular/core").Signal<string>;
     opened: import("@angular/core").Signal<boolean>;
     onClear: () => void;
     onClickAction: (action: Action) => void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectorActionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SelectorActionComponent, "selector-action", never, { "tableOption": { "alias": "tableOption"; "required": false; "isSignal": true; }; "selectedTableItems": { "alias": "selectedTableItems"; "required": false; "isSignal": true; }; }, { "clear": "clear"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectorActionComponent, "selector-action", never, { "autoIdInput": { "alias": "autoId"; "required": false; "isSignal": true; }; "tableOption": { "alias": "tableOption"; "required": false; "isSignal": true; }; "selectedTableItems": { "alias": "selectedTableItems"; "required": false; "isSignal": true; }; }, { "clear": "clear"; }, never, never, true, never>;
 }

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

@@ -1,12 +1,100 @@
-export interface SdTableOptionTree<T = any> {
-    /** Key trên object row chứa mảng children. Mặc định: 'children' */
-    childrenKey?: string;
-    /** Giới hạn độ sâu cây. undefined = không giới hạn. */
+import { NestedKeyOf } from '@sdcorejs/utils/models';
+/**
+ * Cấu hình tree-rows cho `<sd-table>` — render dòng con inline dưới dòng cha
+ * kèm expand/collapse.
+ *
+ * Đây là discriminated union theo `loadType`:
+ * - `'static'` ({@link TableOptionTreeStatic}) — children đã nằm sẵn trong data
+ *   (embedded array tại `childrenKey`). Không gọi API khi bung.
+ * - `'lazy'`  ({@link TableOptionTreeLazy})  — children nạp theo yêu cầu qua
+ *   `onExpandChildren` khi người dùng bung dòng lần đầu.
+ *
+ * `loadType` là discriminant: TypeScript dựa vào nó để narrow union (vd chỉ
+ * `static` mới có `childrenKey`/`defaultExpanded`, chỉ `lazy` mới có
+ * `onExpandChildren`). Dùng type-guard `isLazyTree()` trong `tree.util.ts` để
+ * narrow an toàn thay vì truy cập field trực tiếp trên union.
+ *
+ * @example Static (children embedded)
+ * ```ts
+ * tree: { loadType: 'static', childrenKey: 'children', defaultExpanded: 1 }
+ * ```
+ * @example Lazy (nạp theo yêu cầu)
+ * ```ts
+ * tree: { loadType: 'lazy', onExpandChildren: row => api.getChildren(row.id) }
+ * ```
+ */
+export type SdTableOptionTree<T = any> = TableOptionTreeStatic<T> | TableOptionTreeLazy<T>;
+/**
+ * Tree với dữ liệu children **embedded** sẵn trong mỗi row.
+ *
+ * Table đọc mảng con tại `childrenKey` ngay trên object data; không có lời gọi
+ * bất đồng bộ nào khi bung dòng. Đây cũng là chế độ hỗ trợ **search ở cấp con**
+ * cho table `type: 'local'` (xem `tree.util.ts#subtreeMatches` /
+ * `filterMatchingChildren`): khi lọc, một nhánh được giữ lại nếu chính nó hoặc
+ * bất kỳ hậu duệ nào khớp từ khoá, và nhánh khớp sẽ tự bung.
+ */
+export interface TableOptionTreeStatic<T = any> {
+    /** Chế độ nạp children: dữ liệu đã embedded sẵn trong row. */
+    loadType: 'static';
+    /**
+     * Key trên object row chứa mảng children.
+     * Mặc định: `'children'`.
+     */
+    childrenKey?: NestedKeyOf<T> | 'children';
+    /**
+     * Giới hạn độ sâu cây (level gốc = 0).
+     * `undefined` = không giới hạn.
+     */
     maxDepth?: number;
-    /** false | true | number (mở tới cấp N) */
+    /**
+     * Trạng thái bung mặc định khi load:
+     * - `false` — thu gọn hết (mặc định)
+     * - `true`  — bung toàn bộ
+     * - `number N` — bung tới cấp `N` (row có `level < N` được bung)
+     */
     defaultExpanded?: boolean | number;
-    /** Lazy load khi row chưa có children embedded */
-    onExpandChildren?: (rowData: T) => Promise<T[]> | T[];
-    /** Pixel indent mỗi cấp. Mặc định: 20 */
+    /**
+     * Số pixel thụt lề (indent) cho mỗi cấp sâu.
+     * Mặc định: `20`.
+     */
+    indentSize?: number;
+}
+/**
+ * Tree với children **nạp lười (lazy)** theo yêu cầu.
+ *
+ * Khi người dùng bung một dòng lần đầu mà dòng đó chưa có children embedded,
+ * table gọi `onExpandChildren(row)` để nạp; kết quả được cache lại trên row
+ * (ghi vào key `'children'`) nên các lần bung sau không gọi lại.
+ *
+ * Lazy tree **không hỗ trợ** `childrenKey` tuỳ biến (luôn dùng `'children'` làm
+ * nơi lưu kết quả) và **không hỗ trợ** `defaultExpanded` (không thể bung mặc
+ * định nhánh chưa nạp).
+ */
+export interface TableOptionTreeLazy<T = any> {
+    /** Chế độ nạp children: nạp lười theo yêu cầu khi bung. */
+    loadType: 'lazy';
+    /**
+     * Giới hạn độ sâu cây (level gốc = 0).
+     * `undefined` = không giới hạn.
+     */
+    maxDepth?: number;
+    /**
+     * Hàm nạp children khi bung dòng chưa có children embedded.
+     * Trả về `Promise<T[]>`; kết quả được ghi vào key `'children'` của row data
+     * và cache cho các lần bung sau.
+     */
+    onExpandChildren: (rowData: T) => Promise<T[]>;
+    /**
+     * Xác định một row có con hay không — để quyết định có hiển thị icon expand.
+     * - Không truyền: MỌI lazy node đều hiện icon expand (không biết trước được).
+     * - Truyền: chỉ hiện icon khi trả `true`; trả `false` ⇒ row là lá (ẩn icon,
+     *   không gọi `onExpandChildren`).
+     * Lưu ý: nếu row đã có children embedded sẵn thì luôn coi là có con (bỏ qua hàm này).
+     */
+    hasChildren?: (rowData: T) => boolean;
+    /**
+     * Số pixel thụt lề (indent) cho mỗi cấp sâu.
+     * Mặc định: `20`.
+     */
     indentSize?: number;
 }

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

@@ -1,10 +1,51 @@
-import { SdTableOptionTree } from '../../models/table-option-tree.model';
+import { SdTableOptionTree, TableOptionTreeLazy } from '../../models/table-option-tree.model';
 import { SdTableItem } from '../../models/table-item.model';
+/**
+ * Type-guard: tree có nạp children lười (lazy) hay không.
+ * Dùng để narrow discriminated union `SdTableOptionTree` một cách an toàn —
+ * thay vì truy cập `option.onExpandChildren` trực tiếp trên union (chỉ tồn tại
+ * ở nhánh lazy).
+ */
+export declare const isLazyTree: <T = any>(option?: SdTableOptionTree<T>) => option is TableOptionTreeLazy<T>;
+/**
+ * Key chứa mảng children trên object row.
+ * - `static`: lấy `childrenKey` đã cấu hình, mặc định `'children'`.
+ * - `lazy`: không có `childrenKey` riêng → luôn dùng `'children'` làm nơi lưu
+ *   kết quả nạp lười.
+ */
 export declare const getChildrenKey: (option?: SdTableOptionTree) => string;
 export declare const getChildrenFromData: <T>(data: T, option?: SdTableOptionTree) => T[];
+/**
+ * Trạng thái bung mặc định cho một cấp.
+ * Chỉ `static` mới có `defaultExpanded`; lazy luôn trả `false` (không thể bung
+ * mặc định nhánh chưa nạp).
+ */
 export declare const resolveDefaultExpanded: (level: number, option?: SdTableOptionTree) => boolean;
-export declare const resolveHasChildren: <T>(row: SdTableItem<T>, option?: SdTableOptionTree) => boolean;
+/**
+ * Row có khả năng có children hay không (để hiện nút bung).
+ * - Có children embedded → true.
+ * - Lazy tree: dùng `hasChildren(row.data)` nếu được cấu hình; không thì luôn
+ *   true (chưa biết cho tới khi nạp).
+ */
+export declare const resolveHasChildren: <T>(row: SdTableItem<T>, option?: SdTableOptionTree<T>) => boolean;
+/** Row cần nạp lười (lazy) khi bung: là lazy tree và chưa có children embedded. */
 export declare const hasLazyChildren: <T>(row: SdTableItem<T>, option?: SdTableOptionTree) => boolean;
+/**
+ * True nếu `data` HOẶC bất kỳ hậu duệ nào (theo `childrenKey`) thoả `predicate`.
+ *
+ * Dùng cho search ở cấp con (static tree, table `type: 'local'`): một nhánh
+ * gốc được giữ lại trong kết quả lọc nếu subtree của nó có ít nhất một node
+ * khớp từ khoá. `visited` chống đệ quy vô hạn khi data có circular reference.
+ */
+export declare const subtreeMatches: <T>(data: T, predicate: (data: T) => boolean, option?: SdTableOptionTree, visited?: Set<unknown>) => boolean;
+/**
+ * Lọc mảng children: chỉ giữ child có subtree khớp `predicate`.
+ *
+ * Trả về MẢNG MỚI nhưng GIỮ NGUYÊN object reference của từng child (không clone)
+ * — nhờ vậy `meta.id` (hash từ data) ổn định, selection / trạng thái bung không
+ * bị mất khi từ khoá search đổi. Đây là bước "prune" của tính năng search-con.
+ */
+export declare const filterMatchingChildren: <T>(children: T[], predicate: (data: T) => boolean, option?: SdTableOptionTree) => T[];
 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>[];

package/components/table/src/table.component.d.ts

@@ -13,7 +13,6 @@ import { SdTableColumn } from './models/table-column.model';
 import { SdTableOption } from './models/table-option.model';
 import { SdTableFilterRequest, TableFilterRegister } from './services/table-filter/table-filter.model';
 import { CdkDrag, CdkDragDrop, CdkDropList } from '@angular/cdk/drag-drop';
-import { SdBaseSecureComponent } from '@sdcorejs/angular/components/base';
 import { SdQuickAction } from '@sdcorejs/angular/components/quick-action';
 import { SdScrollDirective } from '@sdcorejs/angular/directives';
 import { Operator } from '@sdcorejs/utils/models';
@@ -35,7 +34,7 @@ export declare class MatPaginatorIntlCro extends MatPaginatorIntl {
     static ɵfac: i0.ɵɵFactoryDeclaration<MatPaginatorIntlCro, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MatPaginatorIntlCro>;
 }
-export declare class SdTable<T = unknown> extends SdBaseSecureComponent implements OnInit, AfterViewInit, OnDestroy {
+export declare class SdTable<T = unknown> implements OnInit, AfterViewInit, OnDestroy {
     #private;
     autoIdInput: import("@angular/core").InputSignal<string | null | undefined>;
     autoId: import("@angular/core").Signal<string | undefined>;

package/components/upload-file/src/upload-file.component.d.ts

@@ -11,6 +11,8 @@ export declare class SdUploadFile<TArgs = any> {
     #private;
     readonly id: string;
     readonly formControl: SdFormControl;
+    /** Hiển thị message "vui lòng upload": không disabled + đã touched + còn lỗi required. */
+    readonly showRequiredError: import("@angular/core").Signal<boolean>;
     readonly previewFiles: import("@angular/core").WritableSignal<PreviewFile[]>;
     readonly selectedFile: import("@angular/core").WritableSignal<PreviewFile | null | undefined>;
     readonly previewFileComponent: import("@angular/core").Signal<PreviewComponent | undefined>;

package/components/view/src/view.component.d.ts

@@ -1,16 +1,49 @@
 import { TemplateRef } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * `<sd-view>` — pure read-only display of a value (text, hyperlink, or a custom template).
+ *
+ * Presentational proxy with no state of its own: the parent form control (`<sd-select>`,
+ * `<sd-input>`, …) computes the display string + resolved selection and passes them in;
+ * `<sd-view>` only decides WHICH template renders. It is the single rendering path for every
+ * "viewed" state across the form controls (DETAIL `viewed=true` and the `viewed='inline'`
+ * text face), so a custom `valueTemplate` (e.g. `sdViewDef` / `#sdValue`) looks identical in
+ * both. OnPush — re-renders only when an input signal changes.
+ */
 export declare class SdView {
+    /** Optional label rendered above the value (omitted when a parent supplies its own label). */
     label: import("@angular/core").InputSignal<string | null | undefined>;
+    /** Raw selected value — NOT rendered directly; only exposed in the `valueTemplate` context as `value`. */
     value: import("@angular/core").InputSignal<any>;
+    /**
+     * Display string — what shows when no custom value template is bound.
+     * why: `input.required()` forces the parent to bind `[display]` (compile error otherwise),
+     * so the component never has to guess a fallback string from `value`.
+     */
     display: import("@angular/core").InputSignal<string | null | undefined>;
+    /** When set, the value renders as a link (`<a [sdHref]>`) instead of plain text. */
     hyperlink: import("@angular/core").InputSignal<string | null | undefined>;
+    /** Label template handed down by a parent control (wins over `label` + `#sdLabel`). */
     labelTemplate: import("@angular/core").InputSignal<TemplateRef<any> | undefined>;
+    /** Value template handed down by a parent control (wins over `display` + `#sdValue`). */
     valueTemplate: import("@angular/core").InputSignal<TemplateRef<any> | undefined>;
+    /**
+     * Resolved selected-item objects passed by the parent (e.g. `<sd-select>`).
+     * why: the parent owns option/lazy resolution — `<sd-view>` is a proxy and must NOT rebuild
+     * the list. Exposed in the value-template context so a "head +N" template can read `displayField`.
+     */
     selectedItems: import("@angular/core").InputSignal<any[] | undefined>;
+    /** `#sdLabel` template projected directly into `<sd-view>` (fallback when no `[labelTemplate]`). */
     contentLabelTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    /** `#sdValue` template projected directly into `<sd-view>` (fallback when no `[valueTemplate]`). */
     contentValueTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    /**
+     * Effective label template: input from parent wins, else the projected `#sdLabel`.
+     * why: `computed` caches the choice so the template's `@if (activeLabelTemplate())` doesn't
+     * re-evaluate two content-child reads on every change-detection pass.
+     */
     activeLabelTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    /** Effective value template: input from parent wins, else the projected `#sdValue`. Cached for the same reason. */
     activeValueTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<SdView, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<SdView, "sd-view", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": true; "isSignal": true; }; "hyperlink": { "alias": "hyperlink"; "required": false; "isSignal": true; }; "labelTemplate": { "alias": "labelTemplate"; "required": false; "isSignal": true; }; "valueTemplate": { "alias": "valueTemplate"; "required": false; "isSignal": true; }; "selectedItems": { "alias": "selectedItems"; "required": false; "isSignal": true; }; }, {}, ["contentLabelTemplate", "contentValueTemplate"], never, true, never>;