@sdcorejs/angular 19.1.6 → 19.2.1

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

@@ -1,5 +1,5 @@
 import { Filter, Operator } from '@sdcorejs/utils/models';
-import { isQbGroup, QbComparisonMode, QbDateMode, QbGroup, QbRule, QbToken, QbValueSource, qbFieldIcon, SdQueryBuilderField, SdQueryBuilderFieldOption, SdQueryBuilderOption } from './query-builder.model';
+import { sdIsQbGroup, SdQbComparisonMode, SdQbDateMode, SdQbGroup, SdQbRule, SdQbToken, SdQbValueSource, sdQbFieldIcon, SdQueryBuilderField, SdQueryBuilderFieldOption, SdQueryBuilderOption } from './query-builder.model';
 import * as i0 from "@angular/core";
 /**
  * Visual filter / rule builder. Compose nested AND / OR groups of
@@ -17,7 +17,7 @@ export declare class SdQueryBuilder {
     /** `'edit'` (default) = interactive tree · `'view'` = read-only raw-query string. */
     readonly mode: import("@angular/core").InputSignal<"edit" | "view">;
     /** `value-only` = literal operands only · `value-or-field` = each rule may compare against another field. */
-    readonly comparisonMode: import("@angular/core").InputSignal<QbComparisonMode>;
+    readonly comparisonMode: import("@angular/core").InputSignal<SdQbComparisonMode>;
     /** Disable all editing controls. */
     readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     /** Prefix for `data-autoid` on inner controls (E2E selectors). */
@@ -28,42 +28,64 @@ export declare class SdQueryBuilder {
     readonly filters: import("@angular/core").ModelSignal<Filter[]>;
     /** Root group's logical connector. `[(rootLogic)]`. */
     readonly rootLogic: import("@angular/core").ModelSignal<"AND" | "OR">;
-    readonly tree: import("@angular/core").Signal<QbGroup>;
+    readonly tree: import("@angular/core").Signal<SdQbGroup>;
     /** `field.key` → field, for fast lookup from a rule. */
     readonly resolvedFields: import("@angular/core").Signal<SdQueryBuilderField[]>;
     readonly resolvedMode: import("@angular/core").Signal<"edit" | "view">;
-    readonly resolvedComparisonMode: import("@angular/core").Signal<QbComparisonMode>;
+    readonly resolvedComparisonMode: import("@angular/core").Signal<SdQbComparisonMode>;
     readonly resolvedDisabled: import("@angular/core").Signal<boolean>;
     readonly resolvedAutoId: import("@angular/core").Signal<string | undefined>;
     readonly fieldByKey: import("@angular/core").Signal<Record<string, SdQueryBuilderField>>;
     /** Stable option list for the date-mode select. */
-    readonly dateModes: import("@sdcorejs/angular/components/query-builder").QbDateModeOption[];
+    readonly dateModes: import("@angular/core").Signal<{
+        display: string;
+        value: SdQbDateMode;
+        labelKey: string;
+        icon: string;
+    }[]>;
     /** Stable option list for the literal-vs-field operand select. */
-    readonly valueSourceOptions: import("@sdcorejs/angular/components/query-builder").QbValueSourceOption[];
+    readonly valueSourceOptions: import("@angular/core").Signal<{
+        display: string;
+        value: SdQbValueSource;
+        labelKey: string;
+        icon: string;
+    }[]>;
     /** Stable combined unit×direction option list for the relative select. */
-    readonly relativeUnitOptions: {
-        value: string;
+    readonly relativeUnitOptions: import("@angular/core").Signal<{
         display: string;
-    }[];
-    /** View-mode token stream — recomputed from the emitted value. */
-    readonly tokens: import("@angular/core").Signal<QbToken[]>;
+        value: string;
+        labelKey: string;
+    }[]>;
+    readonly selectFieldLabel: import("@angular/core").Signal<string>;
+    readonly valueLabel: import("@angular/core").Signal<string>;
+    readonly fromLabel: import("@angular/core").Signal<string>;
+    readonly toLabel: import("@angular/core").Signal<string>;
+    readonly addLabel: import("@angular/core").Signal<string>;
+    readonly addNodeLabel: import("@angular/core").Signal<string>;
+    readonly conditionLabel: import("@angular/core").Signal<string>;
+    readonly groupLabel: import("@angular/core").Signal<string>;
+    readonly removeGroupLabel: import("@angular/core").Signal<string>;
+    readonly removeConditionLabel: import("@angular/core").Signal<string>;
+    readonly emptyLabel: import("@angular/core").Signal<string>;
+    /** View-mode token stream — recomputed from the emitted value (and from the active language). */
+    readonly tokens: import("@angular/core").Signal<SdQbToken[]>;
     readonly isView: import("@angular/core").Signal<boolean>;
     /** Expose the type-guard to the template. */
-    readonly isGroup: typeof isQbGroup;
+    readonly isGroup: typeof sdIsQbGroup;
     /** Resolve the leading icon for a field (own `icon` → per-type → `'tune'`) — used by the field picker. */
-    readonly fieldIcon: typeof qbFieldIcon;
+    readonly fieldIcon: typeof sdQbFieldIcon;
     constructor();
     /** Switch a group's AND/OR connector and re-emit. No-op when disabled or unchanged. */
-    setGroupLogic(group: QbGroup, logic: 'AND' | 'OR'): void;
+    setGroupLogic(group: SdQbGroup, logic: 'AND' | 'OR'): void;
     /** Open this group's "+" menu (closing any other open one). UI-only — does not emit. */
-    toggleDropdown(group: QbGroup, event: Event): void;
+    toggleDropdown(group: SdQbGroup, event: Event): void;
     closeAllDropdowns(): void;
     /** Append a blank rule to `group`. */
-    addRule(group: QbGroup): void;
+    addRule(group: SdQbGroup): void;
     /** Append a nested sub-group (seeded with one blank rule) to `group`. */
-    addGroup(group: QbGroup): void;
+    addGroup(group: SdQbGroup): void;
     /** Remove the child at `index` from `parent` (a rule or a whole sub-group). */
-    removeNode(parent: QbGroup, index: number): void;
+    removeNode(parent: SdQbGroup, index: number): void;
     /**
      * Point `rule` at a new field. Resets operator to the field's default and the value
      * to that operator's empty shape — the old operator/value rarely fit the new type.
@@ -72,46 +94,61 @@ export declare class SdQueryBuilder {
      * @param key - the chosen field key (from the field picker). Swap-only: a null / undefined
      *   key is a no-op — the field can be changed but never cleared (issue #2).
      */
-    setField(rule: QbRule, key: any): void;
+    setField(rule: SdQbRule, key: any): void;
     /** Change `rule`'s operator and reshape its value to fit the new operator (array / range / none). */
-    setOperator(rule: QbRule, op: Operator | undefined): void;
+    setOperator(rule: SdQbRule, op: Operator | undefined): void;
     /** Set a single-value rule's value (coercing numeric fields to `number`). */
-    setScalar(rule: QbRule, raw: any): void;
+    setScalar(rule: SdQbRule, raw: any): void;
     /** Set the lower bound of a BETWEEN rule's `{ from, to }` value. */
-    setBetweenFrom(rule: QbRule, raw: any): void;
+    setBetweenFrom(rule: SdQbRule, raw: any): void;
     /** Set the upper bound of a BETWEEN rule's `{ from, to }` value. */
-    setBetweenTo(rule: QbRule, raw: any): void;
-    setValueSource(rule: QbRule, source: unknown): void;
-    setCompareField(rule: QbRule, key: any): void;
+    setBetweenTo(rule: SdQbRule, raw: any): void;
+    setValueSource(rule: SdQbRule, source: unknown): void;
+    setCompareField(rule: SdQbRule, key: any): void;
     /** The field metadata for a rule's current `field` key (or undefined if unset). */
-    fieldOf(rule: QbRule): SdQueryBuilderField | undefined;
+    fieldOf(rule: SdQbRule): SdQueryBuilderField | undefined;
     /** Operators allowed for a rule, derived from its field's type / override. */
-    allowedOperators(rule: QbRule): Operator[];
+    allowedOperators(rule: SdQbRule): Operator[];
     /** Whether to render the operator picker — hidden when only one operator is allowed. */
-    showOperatorSelector(rule: QbRule): boolean;
-    compareFields(rule: QbRule): SdQueryBuilderField[];
-    canCompareWithField(rule: QbRule): boolean;
-    showValueSourceSelector(rule: QbRule): boolean;
-    valueSourceOf(rule: QbRule): QbValueSource;
-    isFieldSource(rule: QbRule): boolean;
+    showOperatorSelector(rule: SdQbRule): boolean;
+    compareFields(rule: SdQbRule): SdQueryBuilderField[];
+    canCompareWithField(rule: SdQbRule): boolean;
+    showValueSourceSelector(rule: SdQbRule): boolean;
+    valueSourceOf(rule: SdQbRule): SdQbValueSource;
+    isFieldSource(rule: SdQbRule): boolean;
     /** True for NULL / NOT_NULL — the template then renders no value editor. */
     isNoData(op: Operator | undefined): boolean;
     /** True for IN / NOT_IN — the template then renders a multi-select value editor. */
     isMulti(op: Operator | undefined): boolean;
     /** `[true/false]` option list for a boolean field's value select (stable reference). */
     booleanItems(field: SdQueryBuilderField): SdQueryBuilderFieldOption[];
+    /**
+     * Option list cho field `type:'values'`.
+     *
+     * why: template cũ bind thẳng `[items]="fieldOf(rule)!.values || []"`. `values` là OPTIONAL trên
+     * `SdQueryBuilderField`, nên với field khai thiếu `values`, nhánh `|| []` cấp phát một mảng MỚI
+     * mỗi lần change detection chạy — đúng nguyên nhân OOM đã ghi ở `#booleanOptionsByKey`:
+     * `sd-select` có `toObservable(items)` → `markForCheck()` → CD mới → mảng mới → lặp vô hạn.
+     *
+     * why: KHÔNG memo hoá qua `computed<Map>` snapshot. `field.values` vốn ĐÃ là mảng của consumer
+     * nên tự nó ổn định; snapshot vào Map chỉ thêm một tầng cache không bao giờ invalidate khi
+     * consumer nạp option bất đồng bộ bằng cách gán tại chỗ (`fields[0].values = loaded`) — reference
+     * `fields` không đổi nên `computed` giữ nguyên list cũ vĩnh viễn. Chỉ nhánh RỖNG cần hằng số
+     * dùng chung để tránh literal mới mỗi CD.
+     */
+    valueItems(field: SdQueryBuilderField): SdQueryBuilderFieldOption[];
     /** Current date-value mode of a rule, derived from its value (no separate state). */
-    dateMode(rule: QbRule): QbDateMode;
+    dateMode(rule: SdQbRule): SdQbDateMode;
     /** Switch a date/datetime rule's value mode, reseeding the value for the new mode. */
-    setDateMode(rule: QbRule, mode: unknown): void;
+    setDateMode(rule: SdQbRule, mode: unknown): void;
     /** Read the offset amount of a relative rule (default 1). */
-    relativeAmount(rule: QbRule): number;
+    relativeAmount(rule: SdQbRule): number;
     /** Set the offset amount (clamped to an integer >= 1). */
-    setRelativeAmount(rule: QbRule, raw: any): void;
+    setRelativeAmount(rule: SdQbRule, raw: any): void;
     /** Read the `'unit:direction'` token of a relative rule (default `'day:previous'`). */
-    relativeUnitDirValue(rule: QbRule): string;
+    relativeUnitDirValue(rule: SdQbRule): string;
     /** Set the offset unit + direction from a `'unit:direction'` token. */
-    setRelativeUnitDir(rule: QbRule, token: unknown): void;
+    setRelativeUnitDir(rule: SdQbRule, token: unknown): void;
     /** Build a `data-autoid` for an inner control under this builder's `autoId` prefix. */
     autoIdFor(suffix: string): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<SdQueryBuilder, never>;

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

@@ -19,17 +19,17 @@ export interface SdQueryBuilderField {
     label: string;
     /** Field type — picks the default operator set + value editor control. */
     type: SdQueryBuilderFieldType;
-    /** Material icon shown before the label in the field picker; falls back to `QB_TYPE_ICON[type]` then `'tune'`. */
+    /** Material icon shown before the label in the field picker; falls back to `SD_QB_TYPE_ICON[type]` then `'tune'`. */
     icon?: string;
-    /** Override the allowed operator set (otherwise `QB_OPERATORS_BY_TYPE[type]`). */
+    /** Override the allowed operator set (otherwise `SD_QB_OPERATORS_BY_TYPE[type]`). */
     operators?: Operator[];
-    /** Override the starting operator (otherwise `QB_DEFAULT_OPERATOR_BY_TYPE[type]`). */
+    /** Override the starting operator (otherwise `SD_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ó'`). */
+    /** Label for the `true` branch of a boolean field (defaults to i18n `core.component.query-builder.boolean.true`). */
     trueLabel?: string;
-    /** Label for the `false` branch of a boolean field (default `'Không'`). */
+    /** Label for the `false` branch of a boolean field (defaults to i18n `core.component.query-builder.boolean.false`). */
     falseLabel?: string;
     /** Lower bound for number / date value editors. */
     min?: number | string;
@@ -44,7 +44,7 @@ export interface SdQueryBuilderOption {
     autoId?: string;
     fields: SdQueryBuilderField[];
     mode?: 'edit' | 'view';
-    comparisonMode?: QbComparisonMode;
+    comparisonMode?: SdQbComparisonMode;
     disabled?: boolean;
     value?: Filter | null;
     filters?: Filter[];
@@ -53,22 +53,22 @@ export interface SdQueryBuilderOption {
     onFiltersChange?: (filters: Filter[]) => void;
     onRootLogicChange?: (logic: 'AND' | 'OR') => void;
 }
-export type QbNode = QbGroup | QbRule;
+export type SdQbNode = SdQbGroup | SdQbRule;
 /** Component-level capability for right-hand operands. */
-export type QbComparisonMode = 'value-only' | 'value-or-field';
+export type SdQbComparisonMode = 'value-only' | 'value-or-field';
 /** Per-rule right-hand operand source. */
-export type QbValueSource = 'literal' | 'field';
+export type SdQbValueSource = 'literal' | 'field';
 /** A logical group of nodes joined by AND / OR. Maps to `FilterAndOr`. */
-export interface QbGroup {
+export interface SdQbGroup {
     id: string;
     kind: 'group';
     logic: 'AND' | 'OR';
-    children: QbNode[];
+    children: SdQbNode[];
     /** 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 {
+export interface SdQbRule {
     id: string;
     kind: 'rule';
     field?: string;
@@ -76,91 +76,98 @@ export interface QbRule {
     /** Single value, `{ from, to }` for BETWEEN, or an array for IN / NOT_IN. */
     value?: any;
     /** Internal UI state: literal input or a same-type field reference. */
-    valueSource?: QbValueSource;
+    valueSource?: SdQbValueSource;
     /** Right-hand field key when `valueSource` is `'field'`. */
     compareField?: string;
 }
-/** 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';
+/** Type guard — narrows a `SdQbNode` to a `SdQbGroup`. */
+export declare function sdIsQbGroup(node: SdQbNode): node is SdQbGroup;
+export type SdQbTokenKind = 'field' | 'op' | 'value' | 'logic' | 'paren' | 'plain';
 /** One piece of the rendered raw query string, tagged for highlight styling. */
-export interface QbToken {
+export interface SdQbToken {
     text: string;
-    kind: QbTokenKind;
+    kind: SdQbTokenKind;
 }
 /** Allowed operators per field type — used when `field.operators` is not set. */
-export declare const QB_OPERATORS_BY_TYPE: Record<SdQueryBuilderFieldType, Operator[]>;
+export declare const SD_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>;
+export declare const SD_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[];
+export declare const SD_QB_NO_DATA_OPERATORS: Operator[];
 /** Operators whose value is an array — the value editor offers multi-select. */
-export declare const QB_MULTI_OPERATORS: Operator[];
+export declare const SD_QB_MULTI_OPERATORS: Operator[];
 /** Operators allowed for `field` — explicit override wins, else the per-type set. */
-export declare function qbAllowedOperators(field: SdQueryBuilderField | undefined): Operator[];
+export declare function sdQbAllowedOperators(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;
+export declare function sdQbDefaultOperator(field: SdQueryBuilderField | undefined): Operator | undefined;
 /** True when `op` is NULL / NOT_NULL (no value editor). */
-export declare function qbIsNoDataOperator(op: Operator | undefined): boolean;
+export declare function sdQbIsNoDataOperator(op: Operator | undefined): boolean;
 /** True when `op` is IN / NOT_IN (array value). */
-export declare function qbIsMultiOperator(op: Operator | undefined): boolean;
+export declare function sdQbIsMultiOperator(op: Operator | undefined): boolean;
 /** True when the operator accepts one right-hand operand, including a field reference. */
-export declare function qbSupportsFieldCompareOperator(op: Operator | undefined): boolean;
+export declare function sdQbSupportsFieldCompareOperator(op: Operator | undefined): boolean;
 /**
  * Icon fallback per field type when `SdQueryBuilderField.icon` is not set.
  * Mirrors query-bar's `SD_QUERY_TYPE_ICON` so the two components read consistently,
  * but kept local so query-builder has no dependency on the query-bar package.
  */
-export declare const QB_TYPE_ICON: Record<SdQueryBuilderFieldType, string>;
+export declare const SD_QB_TYPE_ICON: Record<SdQueryBuilderFieldType, string>;
 /**
  * Icon shown before a field in the field picker / selected trigger.
- * Priority: `field.icon` → `QB_TYPE_ICON[field.type]` → `'tune'` (default, like query-bar).
+ * Priority: `field.icon` → `SD_QB_TYPE_ICON[field.type]` → `'tune'` (default, like query-bar).
  */
-export declare function qbFieldIcon(field: SdQueryBuilderField | undefined): string;
+export declare function sdQbFieldIcon(field: SdQueryBuilderField | undefined): string;
 /** Next stable node id with the given prefix. */
-export declare function qbId(prefix?: string): string;
+export declare function sdQbId(prefix?: string): string;
 /** Build a fresh rule node (optionally pre-filled). */
-export declare function qbNewRule(field?: string, operator?: Operator, value?: any, valueSource?: QbValueSource, compareField?: string): QbRule;
+export declare function sdQbNewRule(field?: string, operator?: Operator, value?: any, valueSource?: SdQbValueSource, compareField?: string): SdQbRule;
 /** Build a fresh group node. */
-export declare function qbNewGroup(logic?: 'AND' | 'OR', children?: QbNode[]): QbGroup;
+export declare function sdQbNewGroup(logic?: 'AND' | 'OR', children?: SdQbNode[]): SdQbGroup;
 /** Offset unit for a relative date — re-exported from the utils `DateRelative` model. */
 export type SdQbRelativeUnit = DateRelative['unit'];
 /** Offset direction for a relative date — re-exported from the utils `DateRelative` model. */
 export type SdQbRelativeDirection = DateRelative['direction'];
 /** Sentinel held as a rule value (and emitted as `data`) for the "today" date mode. */
-export declare const QB_TODAY = "TODAY";
+export declare const SD_QB_TODAY = "TODAY";
 /** The `'TODAY'` sentinel type (matches the utils `date-today` data literal). */
-export type QbToday = typeof QB_TODAY;
+export type SdQbToday = typeof SD_QB_TODAY;
 /** Date value editor mode for a date/datetime rule (derived from the rule value). */
-export type QbDateMode = 'absolute' | 'now' | 'relative';
+export type SdQbDateMode = 'absolute' | 'now' | 'relative';
 /** Type guard — narrows a rule value to a utils `DateRelative` (offset spec). */
-export declare const qbIsRelativeDate: (v: any) => v is DateRelative;
+export declare const sdQbIsRelativeDate: (v: any) => v is DateRelative;
 /** Type guard — narrows a rule value to the `'TODAY'` sentinel ("now"/today mode). */
-export declare function qbIsToday(v: any): v is QbToday;
+export declare function sdQbIsToday(v: any): v is SdQbToday;
 /** Starting relative value when a rule first switches to "relative" mode. */
-export declare function qbDefaultRelative(): DateRelative;
+export declare function sdQbDefaultRelative(): DateRelative;
 /** One date-mode option — carries a Material icon shown in the dropdown + selected trigger. */
-export interface QbDateModeOption {
-    value: QbDateMode;
-    display: string;
+export interface SdQbDateModeOption {
+    value: SdQbDateMode;
+    /** i18n key of the label — resolved at read time, NOT at module-eval time. */
+    labelKey: string;
     /** Material icon name (outlined set). */
     icon: string;
 }
 /** Stable option list for the date-mode select (module ref — never reallocated). */
-export declare const QB_DATE_MODES: QbDateModeOption[];
+export declare const SD_QB_DATE_MODES: SdQbDateModeOption[];
 /** One value-source option for field-to-field comparison UI. */
-export interface QbValueSourceOption {
-    value: QbValueSource;
-    display: string;
+export interface SdQbValueSourceOption {
+    value: SdQbValueSource;
+    /** i18n key of the label — resolved at read time, NOT at module-eval time. */
+    labelKey: string;
     /** Material icon name (outlined set). */
     icon: string;
 }
 /** Stable option list for choosing between a literal value and another field. */
-export declare const QB_VALUE_SOURCE_OPTIONS: QbValueSourceOption[];
-/** Stable combined direction×unit option list (token `'unit:direction'`). */
-export declare const QB_RELATIVE_UNIT_OPTIONS: {
+export declare const SD_QB_VALUE_SOURCE_OPTIONS: SdQbValueSourceOption[];
+/** One combined direction×unit option (token `'unit:direction'`). */
+export interface SdQbRelativeUnitOption {
     value: string;
-    display: string;
-}[];
+    /** i18n key of the label — resolved at read time, NOT at module-eval time. */
+    labelKey: string;
+}
+/** Stable combined direction×unit option list (token `'unit:direction'`). */
+export declare const SD_QB_RELATIVE_UNIT_OPTIONS: SdQbRelativeUnitOption[];
+/** i18n key of the combined `unit`×`direction` phrase for a relative-date offset. */
+export declare function qbRelativeLabelKey(unit: SdQbRelativeUnit, direction: SdQbRelativeDirection): string;
 /** Shared empty option array — stable ref for fallbacks (avoids per-call allocation). */
-export declare const QB_EMPTY_OPTIONS: SdQueryBuilderFieldOption[];
+export declare const SD_QB_EMPTY_OPTIONS: SdQueryBuilderFieldOption[];

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

@@ -1,5 +1,11 @@
 import { Filter } from '@sdcorejs/utils/models';
-import { QbGroup, QbToken, SdQueryBuilderField } from './query-builder.model';
+import { SdQbGroup, SdQbToken, SdQueryBuilderField } from './query-builder.model';
+/**
+ * Hàm dịch một key i18n, do component truyền xuống.
+ * why: `filterToTokens` là hàm thuần cấp module nên không inject `I18nService` được; nhận translator
+ * qua tham số vẫn giữ được tính thuần mà bỏ được chuỗi tiếng Việt hardcode trong chuỗi view.
+ */
+export type SdQbTranslate = (key: string, params?: Record<string, string | number>) => string;
 /**
  * Map the internal builder tree to the public `Filter` (the root is always a
  * `FilterAndOr`). Rules missing field / operator / value — and empty nested
@@ -8,25 +14,28 @@ import { QbGroup, QbToken, SdQueryBuilderField } from './query-builder.model';
  * @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;
+export declare function treeToFilter(group: SdQbGroup): 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.
+ * @returns a fresh root `SdQbGroup` mirroring the filter's structure.
  */
-export declare function filterToTree(filter: Filter | null | undefined): QbGroup;
+export declare function filterToTree(filter: Filter | null | undefined): SdQbGroup;
 /**
  * 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`.
+ * highlight `<span>` keyed by `SdQbToken.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.
+ * @param translate - i18n lookup for language-dependent value tokens (today / relative offsets /
+ *   boolean labels). Optional so the serializer stays callable outside an Angular injection context;
+ *   omitting it renders the raw i18n keys.
  * @returns the ordered tokens, or `[]` when `filter` is empty.
  */
-export declare function filterToTokens(filter: Filter | null | undefined, fields: SdQueryBuilderField[]): QbToken[];
+export declare function filterToTokens(filter: Filter | null | undefined, fields: SdQueryBuilderField[], translate?: SdQbTranslate): SdQbToken[];

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

@@ -9,8 +9,13 @@ export declare class SdSection {
     collapsed: import("@angular/core").ModelSignal<boolean>;
     collapsible: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     hideHeader: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Id của vùng body, để header `aria-controls` trỏ tới khi section collapsible. */
+    readonly bodyId: string;
     constructor();
     toggleCollapse: () => void;
+    protected onHeaderClick: (event: MouseEvent) => void;
+    protected onCollapseButtonClick: (event: MouseEvent) => void;
+    onHeaderKeydown: (event: KeyboardEvent) => void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SdSection, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<SdSection, "sd-section", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "subTitle": { "alias": "subTitle"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconColor": { "alias": "iconColor"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "hideHeader": { "alias": "hideHeader"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, ["[sdHeaderLeft]", "[sdHeaderRight]", "*", "[sdFooterLeft]", "[sdFooterRight]"], true, never>;
 }

package/components/side-drawer/src/body-scroll-lock.service.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+export declare class SdBodyScrollLockService {
+    #private;
+    /** Số lượng khoá đang giữ trên document này — phục vụ chẩn đoán/test. */
+    get count(): number;
+    lock(): void;
+    release(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdBodyScrollLockService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdBodyScrollLockService>;
+}

package/components/splitter/src/splitter-handle/splitter-handle.component.d.ts

@@ -4,6 +4,7 @@ import * as i0 from "@angular/core";
 export declare class SdSplitterHandleComponent {
     #private;
     readonly elementRef: ElementRef<HTMLElement>;
+    constructor();
     orientation: import("@angular/core").InputSignal<SplitterOrientation>;
     disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     keyboardStep: import("@angular/core").InputSignalWithTransform<number, unknown>;

package/components/tab-router/index.d.ts

@@ -1,4 +1,5 @@
 export * from './src/components/tab-router-outlet/tab-router-outlet.component';
 export * from './src/services/tab-router.service';
 export * from './src/models/tab-router.model';
-export * from './src/decorators/tab.decorator';
+export { SdTabComponent } from './src/decorators/tab.decorator';
+export type { SdTabComponentArgs, SdTabComponentBuilder } from './src/decorators/tab.decorator';

package/components/tab-router/src/actions/tab-router.action.d.ts

@@ -1,5 +1,5 @@
-import { SdTab } from '../models/tab-router.model';
+import { SdTabRouterTab } from '../models/tab-router.model';
 export interface SdTabAction {
     type: 'close';
-    tab: SdTab;
+    tab: SdTabRouterTab;
 }

package/components/tab-router/src/components/tab-router-item/tab-router-item.component.d.ts

@@ -1,12 +1,12 @@
 import { OnDestroy, OnInit } from '@angular/core';
-import { SdTab, SdTabInfo } from '../../models';
+import { SdTabRouterTab, SdTabInfo } from '../../models';
 import * as i0 from "@angular/core";
 export declare class SdTabRouterItemComponent implements OnInit, OnDestroy {
     #private;
     private cdRef;
     private tabRouterService;
     private router;
-    tab: SdTab;
+    tab: SdTabRouterTab;
     tabInfo?: SdTabInfo;
     /** Inserted by Angular inject() migration for backwards compatibility */
     constructor(...args: unknown[]);

package/components/tab-router/src/components/tab-router-nav/tab-router-nav.component.d.ts

@@ -1,16 +1,16 @@
 import { CdkDragDrop } from '@angular/cdk/drag-drop';
 import { ChangeDetectorRef, ElementRef } from '@angular/core';
-import { SdTab } from '../../models/tab-router.model';
+import { SdTabRouterTab } from '../../models/tab-router.model';
 import * as i0 from "@angular/core";
 export declare class SdTabRouterNavComponent {
     tabRouterNav: import("@angular/core").Signal<ElementRef<any> | undefined>;
-    tabs: import("@angular/core").InputSignal<SdTab[]>;
+    tabs: import("@angular/core").InputSignal<SdTabRouterTab[]>;
     mode: 'default' | 'compact';
     cdRef: ChangeDetectorRef;
     elementRef: ElementRef<any>;
     onResize(): void;
     checkUI: () => void;
-    onDrop: (event: CdkDragDrop<SdTab[]>) => void;
+    onDrop: (event: CdkDragDrop<SdTabRouterTab[]>) => void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SdTabRouterNavComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<SdTabRouterNavComponent, "sd-tab-router-nav", never, { "tabs": { "alias": "tabs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/tab-router/src/components/tab-router-outlet/tab-router-outlet.component.d.ts

@@ -1,15 +1,15 @@
 import { OnDestroy } from '@angular/core';
-import { SdTab } from '../../models';
+import { SdTabRouterTab } from '../../models';
 import { SdTabRouterNavComponent } from '../tab-router-nav/tab-router-nav.component';
 import * as i0 from "@angular/core";
 export declare class SdTabRouterOutletComponent implements OnDestroy {
     #private;
     disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     tabRouterNav: import("@angular/core").Signal<SdTabRouterNavComponent | undefined>;
-    tabs: import("@angular/core").WritableSignal<SdTab[]>;
+    tabs: import("@angular/core").WritableSignal<SdTabRouterTab[]>;
     constructor();
     ngOnDestroy(): void;
-    tabTrackBy: (index: number, tab: SdTab) => string;
+    tabTrackBy: (index: number, tab: SdTabRouterTab) => string;
     static ɵfac: i0.ɵɵFactoryDeclaration<SdTabRouterOutletComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<SdTabRouterOutletComponent, "sd-tab-router-outlet", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/tab-router/src/decorators/tab.decorator.d.ts

@@ -13,4 +13,16 @@ export declare interface SdTabComponentBuilder {
     tooltip?: string | ((args: SdTabComponentArgs) => string);
     color?: Color | ((args: SdTabComponentArgs) => Color);
 }
-export declare function SdTabComponent<T>(builder: SdTabComponentBuilder): (constructor: T) => void;
+export declare function SdTabComponent<T>(builder: SdTabComponentBuilder): (_constructor: T) => void;
+/**
+ * @internal Outlet gọi khi khởi tạo: replay mọi builder đã đăng ký rồi nhận tiếp các builder mới.
+ * Trả về hàm ngắt kết nối để outlet gọi trong teardown.
+ */
+export declare function ɵsdConnectTabComponentBuilders(register: (builder: SdTabComponentBuilder) => void): () => void;
+/**
+ * @internal CHỈ dùng cho test — xoá collection tĩnh để các spec không rò rỉ state sang nhau.
+ *
+ * why: KHÔNG export từ `components/tab-router/index.ts`. Consumer gọi nhầm hàm này sẽ xoá sạch mọi
+ * builder mà app đã đăng ký. Spec import bằng đường dẫn tương đối.
+ */
+export declare function ɵsdResetTabComponentBuilders(): void;

package/components/tab-router/src/events/tab-router.event.d.ts

@@ -1,8 +1,8 @@
-import { SdTab } from '../models/tab-router.model';
+import { SdTabRouterTab } from '../models/tab-router.model';
 export declare class SdTabBase {
     #private;
-    constructor(tab: SdTab | undefined);
-    get tab(): SdTab | undefined;
+    constructor(tab: SdTabRouterTab | undefined);
+    get tab(): SdTabRouterTab | undefined;
 }
 export declare class SdTabActivated extends SdTabBase {
 }

package/components/tab-router/src/models/tab-router.model.d.ts

@@ -7,7 +7,7 @@ export interface SdTabInfo {
     tooltip?: string;
     color?: Color;
 }
-export interface SdTab {
+export interface SdTabRouterTab {
     component: Type<any>;
     injector?: any;
     key: string;
@@ -19,4 +19,4 @@ export interface SdTab {
     tabInfoChanges: Subject<SdTabInfo>;
     beforeClose?: () => boolean | Promise<boolean>;
 }
-export declare const SD_TAB: InjectionToken<SdTab>;
+export declare const SD_TAB: InjectionToken<SdTabRouterTab>;

package/components/tab-router/src/pipes/tab-info.pipe.d.ts

@@ -1,11 +1,11 @@
 import { PipeTransform } from '@angular/core';
-import { SdTab, SdTabInfo } from '../models/tab-router.model';
+import { SdTabRouterTab, SdTabInfo } from '../models/tab-router.model';
 import * as i0 from "@angular/core";
 export declare class SdTabInfoPipe implements PipeTransform {
     private tabRouterService;
     /** Inserted by Angular inject() migration for backwards compatibility */
     constructor(...args: unknown[]);
-    transform(tabInfo: SdTabInfo | undefined | null, tab: SdTab): SdTabInfo;
+    transform(tabInfo: SdTabInfo | undefined | null, tab: SdTabRouterTab): SdTabInfo;
     static ɵfac: i0.ɵɵFactoryDeclaration<SdTabInfoPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<SdTabInfoPipe, "sdTabInfo", true>;
 }