@cdevhub/ngx-tw 0.2.1 → 0.4.0

package/types/cdevhub-ngx-tw-time-picker.d.ts

@@ -1,6 +1,6 @@
 import * as _angular_core from '@angular/core';
 import { Provider, OnInit, Signal } from '@angular/core';
-import { ControlValueAccessor } from '@angular/forms';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
 import { TwSize, TwColor, TimePickerFormat, ErrorStateMatcher, TimePickerMeridiem } from '@cdevhub/ngx-tw/core';
 export { TimePickerFormat, TimePickerMeridiem } from '@cdevhub/ngx-tw/core';
 import { FormFieldControl } from '@cdevhub/ngx-tw/form-field';
@@ -97,7 +97,24 @@ interface TimePickerInputEvent<D> {
  * `DateAdapter<D>`, so the component works with the default native adapter
  * (`provideNativeDateAdapter()`) or any custom adapter a consumer ships.
  */
-declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implements ControlValueAccessor, OnInit {
+/**
+ * Validation errors a `tw-time-picker` can place on its bound control.
+ *
+ * Mirrors the shape of `CalendarValidationErrors` so the two pickers report
+ * constraint violations the same way: a code keyed by what was violated, with
+ * the offending value and the bound it broke.
+ */
+type TimePickerValidationErrors = Partial<{
+    timePickerMin: {
+        min: unknown;
+        actual: unknown;
+    };
+    timePickerMax: {
+        max: unknown;
+        actual: unknown;
+    };
+}>;
+declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implements ControlValueAccessor, Validator, OnInit {
     /** Id on the time-picker's host element. Auto-generated when not provided. Used by the form-field's `<label for>` attribute. */
     readonly idInput: _angular_core.InputSignal<string | undefined>;
     /** When true, the whole component is disabled and every field sets `aria-disabled="true"`. Defaults to `false`. */
@@ -122,9 +139,9 @@ declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implemen
     readonly minuteStep: _angular_core.InputSignal<number>;
     /** Amount to add/subtract when stepping seconds. Defaults to `1`. */
     readonly secondStep: _angular_core.InputSignal<number>;
-    /** Earliest accepted time-of-day. Values earlier than this set `errorState`. Defaults to `null`. Note: when `showSeconds` is `false`, the seconds component of any value still participates in the range comparison — supply `minTime` with zeroed seconds to match the 2-field display. */
+    /** Earliest accepted time-of-day. Values earlier than this set `errorState` and mark the bound control invalid with `timePickerMin`. Defaults to `null`. Note: when `showSeconds` is `false`, the seconds component of any value still participates in the range comparison — supply `minTime` with zeroed seconds to match the 2-field display. */
     readonly minTime: _angular_core.InputSignal<D | null>;
-    /** Latest accepted time-of-day. Values later than this set `errorState`. Defaults to `null`. Note: when `showSeconds` is `false`, the seconds component of any value still participates in the range comparison — supply `maxTime` with zeroed seconds to match the 2-field display. */
+    /** Latest accepted time-of-day. Values later than this set `errorState` and mark the bound control invalid with `timePickerMax`. Defaults to `null`. Note: when `showSeconds` is `false`, the seconds component of any value still participates in the range comparison — supply `maxTime` with zeroed seconds to match the 2-field display. */
     readonly maxTime: _angular_core.InputSignal<D | null>;
     /** Date portion used when the user types a time while `value` is `null`. Defaults to today. */
     readonly referenceDate: _angular_core.InputSignal<D | null>;
@@ -155,8 +172,9 @@ declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implemen
     private readonly liveAnnouncer;
     private readonly elementRef;
     private readonly destroyRef;
+    private readonly injector;
     private readonly formField;
-    private readonly ngControl;
+    private ngControl;
     private readonly parentForm;
     private readonly parentFormGroup;
     private readonly defaultMatcher;
@@ -287,6 +305,13 @@ declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implemen
     private stepFor;
     private fieldMinFor;
     private fieldMaxFor;
+    private validatorOnChange;
+    /** @internal */
+    validate(control: AbstractControl): ValidationErrors | null;
+    /** @internal */
+    registerOnValidatorChange(fn: () => void): void;
+    /** Time-of-day in seconds, ignoring the date part — the same basis `isInRange` uses. */
+    private secondsOf;
     writeValue(value: unknown): void;
     registerOnChange(fn: (value: D | null) => void): void;
     registerOnTouched(fn: () => void): void;
@@ -300,4 +325,4 @@ declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implemen
 }
 
 export { TimePickerComponent, TimePickerIntl, provideTimePickerIntl };
-export type { TimePickerChangeEvent, TimePickerChangeSource, TimePickerField, TimePickerInputEvent, TimePickerVariant };
+export type { TimePickerChangeEvent, TimePickerChangeSource, TimePickerField, TimePickerInputEvent, TimePickerValidationErrors, TimePickerVariant };

package/types/cdevhub-ngx-tw-transfer.d.ts

@@ -0,0 +1,330 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, Signal, TemplateRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { ListboxValueChangeEvent } from '@angular/cdk/listbox';
+import { TwSize, ErrorStateMatcher } from '@cdevhub/ngx-tw/core';
+import { FormFieldControl } from '@cdevhub/ngx-tw/form-field';
+
+/** Which panel of the transfer an item / event belongs to. */
+type TwTransferSide = 'source' | 'target';
+/** i18n strings for the transfer. Pass any subset; unset keys fall back to the English defaults. */
+interface TwTransferLabels {
+    /** Source (left) panel title. Defaults to `'Source'`. */
+    sourceTitle?: string;
+    /** Target (right) panel title. Defaults to `'Target'`. */
+    targetTitle?: string;
+    /** Placeholder + accessible name for the per-panel search inputs. Defaults to `'Search'`. */
+    searchPlaceholder?: string;
+    /** Text shown in a panel body when it has no visible items. Defaults to `'No items'`. */
+    emptyText?: string;
+    /** Accessible name for the header select-all checkbox. Defaults to `'Select all'`. */
+    selectAllLabel?: string;
+    /** Accessible name for the → (move-to-target) button. Defaults to `'Move selected to target'`. */
+    moveToTargetLabel?: string;
+    /** Accessible name for the ← (move-to-source) button. Defaults to `'Move selected to source'`. */
+    moveToSourceLabel?: string;
+    /** Count template rendered in each panel header. Variables: `{total}`, `{selected}`. Defaults to `'{total} items'`. */
+    countFormat?: string;
+    /** LiveAnnouncer template announced after a move. Variables: `{count}`, `{target}`. Defaults to `'{count} items moved to {target}'`. */
+    moveAnnouncement?: string;
+}
+/** Visual configuration for the transfer. Pass any subset; unset keys fall back to the defaults. */
+interface TwTransferDisplayConfig {
+    /** Row / control density across the design-system ramps. Defaults to `'md'`. */
+    size?: TwSize;
+    /** Scroll-viewport height of each list, in px (a number) or `'auto'` (flow with content). Defaults to `240`. */
+    listHeight?: number | 'auto';
+    /** When true, each panel gets a labelled search input above its list. Defaults to `false`. */
+    showSearch?: boolean;
+    /** When true, each panel header shows a tri-state select-all checkbox. Defaults to `true`. */
+    showSelectAll?: boolean;
+}
+/** Behavioural configuration for the transfer. Generic over item type `T`. Pass any subset; unset keys fall back to the defaults. */
+interface TwTransferBehaviorConfig<T = unknown> {
+    /** When true, items only flow source → target; the ← button is not rendered. Defaults to `false`. */
+    oneWay?: boolean;
+    /** Custom search predicate. Defaults to a case-insensitive substring match of the query against `labelFn(item)`. */
+    filterFn?: (item: T, query: string) => boolean;
+    /** Per-item disable predicate. A disabled item renders as a disabled option and is excluded from select-all and all moves. Defaults to `() => false`. */
+    disabledItem?: (item: T) => boolean;
+}
+/** Context surfaced to a `*twTransferItem` template. Generic over the item type `T`. */
+interface TwTransferItemContext<T> {
+    /** The item data (implicit `let-item`). */
+    $implicit: T;
+    /** Resolved `labelFn(item)`. */
+    label: string;
+    /** Ephemeral pending-move checked state of this row's option. */
+    checked: boolean;
+    /** Whether the item is disabled (via `behavior.disabledItem`). */
+    disabled: boolean;
+    /** Which panel this row renders in. */
+    side: TwTransferSide;
+}
+/** Payload emitted by `moved`. Generic over the key type `K`. */
+interface TwTransferMovedEvent<K> {
+    /** The keys that moved in this interaction. */
+    keys: readonly K[];
+    /** The direction of the move. */
+    direction: 'toTarget' | 'toSource';
+}
+/** Structural directive (`*twTransferItem="let item"`) declaring the per-item template. Typed as `TwTransferItemContext<T>`. */
+declare class TransferItemDefDirective<T = unknown> {
+    /** @internal Consumer-projected per-item template. */
+    readonly template: TemplateRef<any>;
+    /** @internal */
+    static ngTemplateContextGuard<T>(_dir: TransferItemDefDirective<T>, _ctx: unknown): _ctx is TwTransferItemContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TransferItemDefDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TransferItemDefDirective<any>, "[twTransferItem]", never, {}, {}, never, never, true, never>;
+}
+interface RowBase<T, K> {
+    readonly item: T;
+    readonly key: K;
+    readonly label: string;
+    readonly disabled: boolean;
+}
+interface RowView<T, K> extends RowBase<T, K> {
+    readonly checked: boolean;
+    readonly optionClass: string;
+    readonly checkClass: string;
+    readonly context: TwTransferItemContext<T>;
+}
+interface PanelView<T, K> {
+    readonly side: TwTransferSide;
+    readonly title: string;
+    readonly titleId: string;
+    readonly countText: string;
+    readonly emptyText: string;
+    readonly searchPlaceholder: string;
+    readonly selectAllLabel: string;
+    readonly query: string;
+    readonly rows: readonly RowView<T, K>[];
+    readonly checkedValue: readonly K[];
+    readonly selectAllChecked: boolean;
+    readonly selectAllIndeterminate: boolean;
+}
+/**
+ * A dual-listbox shuttle: two panels (source / target) with a column of move
+ * buttons between them. The user ticks items in a panel and shuttles them across;
+ * an optional per-panel search and a tri-state header select-all accelerate bulk
+ * moves. The component's value is the set of keys on the target side, exposed
+ * through `ControlValueAccessor` + `FormFieldControl` so it works with reactive,
+ * template-driven, and signal forms and integrates with `<tw-form-field>`.
+ *
+ * Each panel composes `@angular/cdk/listbox` (`CdkListbox` / `CdkOption`) for
+ * focus-managed, accessible, keyboard-navigable selection. Consumers supply
+ * `keyFn` (required) and `labelFn` (defaulted to `String(item)`), and may project
+ * a `*twTransferItem` template for rich row content.
+ */
+declare class TransferComponent<T = unknown, K = unknown> extends FormFieldControl<readonly K[]> implements ControlValueAccessor, OnInit {
+    /** All items across both panels. The source/target split derives from the value, not the reverse. Defaults to `[]`. */
+    readonly data: _angular_core.InputSignal<readonly T[]>;
+    /** Resolves a stable key for an item — drives membership (the value), checked state, tracking, the cdkOption value, and compareWith. Required. */
+    readonly keyFn: _angular_core.InputSignal<(item: T) => K>;
+    /** Resolves an item's display label — used for the default row render, search filtering, and listbox typeahead. Defaults to `(item) => String(item)`. */
+    readonly labelFn: _angular_core.InputSignal<(item: T) => string>;
+    /** Per-panel text + ARIA labels. Partial; unset keys fall back to the English defaults. */
+    readonly labels: _angular_core.InputSignal<Partial<TwTransferLabels>>;
+    /** Visual configuration — size, list viewport height, search / select-all visibility. Partial; unset keys fall back to the defaults. */
+    readonly display: _angular_core.InputSignal<Partial<TwTransferDisplayConfig>>;
+    /** Behavioural configuration — oneWay, custom filterFn, per-item disabledItem predicate. Partial; unset keys fall back to the defaults. */
+    readonly behavior: _angular_core.InputSignal<Partial<TwTransferBehaviorConfig<T>>>;
+    /** Disables the entire control — panels non-interactive, search + buttons disabled, muted styling. Also driven by Forms `setDisabledState`. Defaults to `false`. */
+    readonly disabledInput: _angular_core.InputSignal<boolean>;
+    /** Marks the control as required. Mirrored to `aria-required` chrome via the form-field; also inferred from `Validators.required` on a bound control. Defaults to `false`. */
+    readonly requiredInput: _angular_core.InputSignal<boolean>;
+    /** Reserved for control identification (e.g. analytics, future native-submission parity). The transfer has no single native value element, so it is not currently reflected to the DOM. Defaults to `undefined`. */
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    /** Id on the host element. Auto-generated as `tw-transfer-N` when unset. Used by the form-field's `<label for>` association. */
+    readonly idInput: _angular_core.InputSignal<string | undefined>;
+    /** Accessible name applied to the control when no visible label is wired. Mirrored to `aria-label`. Defaults to `undefined`. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** ID of an external element that labels the control. Mirrored to `aria-labelledby`. Defaults to `undefined`. */
+    readonly ariaLabelledby: _angular_core.InputSignal<string | undefined>;
+    /** ID of an external element that describes the control. The form-field merges its hint / error ids alongside. Defaults to `undefined`. */
+    readonly ariaDescribedby: _angular_core.InputSignal<string | undefined>;
+    /** Per-instance override of the {@link ErrorStateMatcher}. When omitted, uses the `TW_ERROR_STATE_MATCHER` token's value. Defaults to `undefined`. */
+    readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | undefined>;
+    /** Fires when items move between panels by user interaction. Payload is the new full target-keys array. Does not fire on `writeValue`. */
+    readonly valueChange: _angular_core.OutputEmitterRef<readonly K[]>;
+    /** Fires after each directional move, identifying the moved keys and their direction. Does not fire on `writeValue`. */
+    readonly moved: _angular_core.OutputEmitterRef<TwTransferMovedEvent<K>>;
+    /** @internal Consumer-projected per-item template (`*twTransferItem`). */
+    readonly itemTemplate: Signal<TransferItemDefDirective<any> | undefined>;
+    private readonly elementRef;
+    private readonly injector;
+    private readonly destroyRef;
+    private readonly focusMonitor;
+    private readonly liveAnnouncer;
+    private readonly ngControl;
+    private readonly parentForm;
+    private readonly parentFormGroup;
+    private readonly defaultMatcher;
+    private readonly platform;
+    private readonly uid;
+    /** @internal Fallback id used when the consumer does not set `[id]`. */
+    readonly hostId: string;
+    private readonly sourceTitleId;
+    private readonly targetTitleId;
+    /** @internal The value: keys currently on the target side. Source of truth for membership. */
+    private readonly targetKeys;
+    /** @internal Per-panel search queries. */
+    private readonly sourceQuery;
+    private readonly targetQuery;
+    private readonly cvaDisabled;
+    private readonly _focused;
+    private readonly _ngControlRev;
+    private readonly _formSubmitRev;
+    private readonly describedByIdsSignal;
+    private readonly labelledByIdsSignal;
+    private onChange;
+    private onTouched;
+    /** @internal Stable comparator for `[cdkListboxCompareWith]`. Keys are identity-comparable. */
+    readonly compareKeys: (a: K, b: K) => boolean;
+    /** @internal */
+    readonly resolvedLabels: Signal<Required<TwTransferLabels>>;
+    private readonly resolvedDisplay;
+    private readonly resolvedBehavior;
+    /** @internal */
+    readonly resolvedSize: Signal<TwSize>;
+    /** @internal Checkbox tops out at `lg` density; map xl → lg. */
+    readonly checkboxSize: Signal<TwSize>;
+    /** @internal */
+    readonly showSearch: Signal<boolean>;
+    /** @internal */
+    readonly showSelectAll: Signal<boolean>;
+    /** @internal */
+    readonly oneWay: Signal<boolean>;
+    /** @internal Fixed list height in px, or `null` when `'auto'`. */
+    readonly listHeightPx: Signal<number | null>;
+    /** @internal Map from key to item across all data — for orphan-aware target rendering and disabled lookups. */
+    private readonly itemByKey;
+    private readonly targetKeySet;
+    /** @internal Items on the source side (in `data` order). */
+    private readonly sourceItems;
+    /** @internal Items on the target side (in `targetKeys` order; orphan keys with no item are skipped). */
+    private readonly targetItems;
+    private readonly sourceRowsBase;
+    private readonly sourceRenderedKeys;
+    /**
+     * @internal Ephemeral pending-move checked keys for the source panel — the
+     * controlled `[cdkListboxValue]`. A `linkedSignal` over the rendered-key set so
+     * it auto-prunes keys whose option a filter / move removed (kept ⊆ rendered → no
+     * CdkListbox `_invalid`; dropped keys do not re-surface). Cleared after moves.
+     */
+    readonly sourceChecked: _angular_core.WritableSignal<readonly K[]>;
+    private readonly sourceCheckedSet;
+    private readonly sourceRows;
+    private readonly targetRowsBase;
+    private readonly targetRenderedKeys;
+    /** @internal Ephemeral pending-move checked keys for the target panel — see {@link sourceChecked}. */
+    readonly targetChecked: _angular_core.WritableSignal<readonly K[]>;
+    private readonly targetCheckedSet;
+    private readonly targetRows;
+    /** @internal Checked, enabled, visible source keys — what the → button moves. */
+    readonly sourceMovableKeys: Signal<readonly K[]>;
+    /** @internal Checked, enabled, visible target keys — what the ← button moves. */
+    readonly targetMovableKeys: Signal<readonly K[]>;
+    private readonly sourceSelectAllKeys;
+    private readonly targetSelectAllKeys;
+    /** @internal */
+    readonly sourcePanel: Signal<PanelView<T, K>>;
+    /** @internal */
+    readonly targetPanel: Signal<PanelView<T, K>>;
+    private readonly variants;
+    /** @internal */
+    readonly rootClasses: Signal<string>;
+    /** @internal */
+    readonly panelClasses: Signal<string>;
+    /** @internal */
+    readonly panelHeaderClasses: Signal<string>;
+    /** @internal */
+    readonly panelTitleClasses: Signal<string>;
+    /** @internal */
+    readonly panelCountClasses: Signal<string>;
+    /** @internal */
+    readonly searchClasses: Signal<string>;
+    /** @internal */
+    readonly listClasses: Signal<string>;
+    /** @internal */
+    readonly optionLabelClasses: Signal<string>;
+    /** @internal */
+    readonly controlsClasses: Signal<string>;
+    /** @internal */
+    readonly moveButtonClasses: Signal<string>;
+    /** @internal */
+    readonly moveIconClasses: Signal<string>;
+    /** @internal */
+    readonly emptyClasses: Signal<string>;
+    constructor();
+    /** Moves the given items (by key) to the target side; ignores keys already there or whose item is disabled. Clears the source panel's pending checks, emits `valueChange` + `moved`, calls the CVA onChange, and announces the move. No-op when the control is disabled. */
+    moveToTarget(keys: readonly K[]): void;
+    /** Moves the given items (by key) to the source side; ignores keys not on target or whose item is disabled. Clears the target panel's pending checks. No-op when the control is disabled or `behavior.oneWay` is on. Same emissions as {@link moveToTarget}. */
+    moveToSource(keys: readonly K[]): void;
+    /** @internal */
+    onCheckedChange(side: TwTransferSide, event: ListboxValueChangeEvent<K>): void;
+    /** @internal Select-all toggles the visible, enabled keys for the panel (replace semantics). */
+    onSelectAll(side: TwTransferSide, checked: boolean): void;
+    /** @internal */
+    onSearch(side: TwTransferSide, event: Event): void;
+    /** @internal */
+    onMoveToTarget(): void;
+    /** @internal */
+    onMoveToSource(): void;
+    /**
+     * @internal Focuses the destination panel's listbox after the move re-renders.
+     * Deferred to the next render (the destination listbox may have just mounted
+     * from empty) and matched by its title id rather than DOM order (the *other*
+     * panel may have emptied, removing its listbox).
+     */
+    private focusDestination;
+    private applyValue;
+    private filterItems;
+    private toRowsBase;
+    private toRows;
+    private buildPanel;
+    private selectAllState;
+    private hasAccessibleNameHint;
+    /** @internal */
+    readonly id: Signal<string>;
+    /** The current target-keys array. Doubles as the `FormFieldControl` value member. */
+    readonly value: Signal<readonly K[]>;
+    /** @internal */
+    readonly focused: Signal<boolean>;
+    /** @internal Empty when nothing is on the target side — drives the form-field floating label. */
+    readonly empty: Signal<boolean>;
+    /** @internal */
+    readonly disabled: Signal<boolean>;
+    /** @internal */
+    readonly required: Signal<boolean>;
+    /** @internal */
+    readonly errorState: Signal<boolean>;
+    /** @internal Active validation errors from the bound control, for `[twError match="…"]` filtering. */
+    readonly errors: Signal<Record<string, unknown> | null>;
+    /** @internal */
+    readonly controlType = "transfer";
+    /** @internal */
+    readonly userAriaDescribedBy: Signal<string | undefined>;
+    /** @internal */
+    readonly userAriaLabelledby: Signal<string | undefined>;
+    /** @internal Merged `aria-describedby` (form-field hint/error ids + consumer-supplied). */
+    readonly resolvedDescribedBy: Signal<string>;
+    /** @internal Merged `aria-labelledby` (form-field label id + consumer-supplied). */
+    readonly resolvedLabelledBy: Signal<string>;
+    writeValue(value: readonly K[] | null | undefined): void;
+    registerOnChange(fn: (value: readonly K[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** @internal */
+    setDescribedByIds(ids: string[]): void;
+    /** @internal */
+    setLabelledByIds(ids: string[]): void;
+    /** @internal Clicking the form-field surface focuses the first listbox. */
+    onContainerClick(event: MouseEvent): void;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TransferComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TransferComponent<any, any>, "tw-transfer", ["twTransfer"], { "data": { "alias": "data"; "required": false; "isSignal": true; }; "keyFn": { "alias": "keyFn"; "required": true; "isSignal": true; }; "labelFn": { "alias": "labelFn"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "behavior": { "alias": "behavior"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "requiredInput": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "idInput": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "moved": "moved"; }, ["itemTemplate"], never, true, never>;
+}
+
+export { TransferComponent, TransferItemDefDirective };
+export type { TwTransferBehaviorConfig, TwTransferDisplayConfig, TwTransferItemContext, TwTransferLabels, TwTransferMovedEvent, TwTransferSide };

package/types/cdevhub-ngx-tw-tree.d.ts

@@ -0,0 +1,189 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, TrackByFunction } from '@angular/core';
+import { TwSize } from '@cdevhub/ngx-tw/core';
+
+/** Tri-state selection status of a tree node. */
+type TwTreeSelectionState = 'checked' | 'unchecked' | 'indeterminate';
+/** Configuration for node selection behavior. Pass any subset; unset keys fall back to the defaults. */
+interface TwTreeSelectionConfig {
+    /** Selection mode. `'single'` is scalar (one node, no cascade/indeterminate); `'multiple'` supports cascade + tri-state. `'none'` disables selection. Defaults to `'none'`. */
+    mode: 'none' | 'single' | 'multiple';
+    /** In `'multiple'` mode, selecting a branch selects all its leaf descendants and a branch renders `'indeterminate'` when only some are selected. Ignored in `'single'`/`'none'`. Defaults to `true`. */
+    cascade?: boolean;
+    /** Pre-selected node keys (matched via `trackBy`). In cascade mode these are leaf-node keys. Defaults to `[]`. */
+    initialKeys?: readonly unknown[];
+}
+/** Display configuration for the tree. Pass any subset; unset keys fall back to the defaults. */
+interface TwTreeDisplayConfig {
+    /** Row vertical density. Defaults to `'md'`. */
+    size?: TwSize;
+    /** Indentation per level, in pixels. Defaults to `16`. */
+    indent?: number;
+    /** Render connecting guide lines down the indent gutter. Defaults to `false`. */
+    showLines?: boolean;
+}
+/** Context surfaced to a `*twTreeNode` template. Generic over the node type `T`. */
+interface TwTreeNodeContext<T> {
+    /** The node data (implicit `let-node`). */
+    $implicit: T;
+    /** The node data, aliased for readability. */
+    node: T;
+    /** Zero-based depth of the node. */
+    level: number;
+    /** Whether the node is currently expanded. Always `false` for leaf nodes. */
+    expanded: boolean;
+    /** Whether the node has children (is a branch, not a leaf). */
+    hasChildren: boolean;
+    /** Tri-state selection status of this node. `'unchecked'` when selection is disabled. */
+    selectionState: TwTreeSelectionState;
+    /** Toggles this node's expand/collapse state. No-op on leaf nodes. */
+    toggle: () => void;
+    /** Expands this node. No-op on leaf nodes or when already expanded. */
+    expand: () => void;
+    /** Collapses this node. No-op when already collapsed. */
+    collapse: () => void;
+    /** Toggles this node's selection (cascades in `'multiple'` mode with `cascade` on). No-op when selection is disabled. */
+    toggleSelection: () => void;
+}
+/** Structural directive (`*twTreeNode="let node"`) declaring the per-node template. Typed as `TwTreeNodeContext<T>`. */
+declare class TreeNodeDefDirective<T = unknown> {
+    /** @internal Consumer-projected per-node template. */
+    readonly template: TemplateRef<any>;
+    /** @internal */
+    static ngTemplateContextGuard<T>(_dir: TreeNodeDefDirective<T>, _ctx: unknown): _ctx is TwTreeNodeContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeNodeDefDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeNodeDefDirective<any>, "[twTreeNode]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * A hierarchical, keyboard-navigable tree-view wrapping `@angular/cdk/tree`
+ * (children-accessor model). Consumers supply the per-node template via the
+ * `*twTreeNode` structural directive and receive a typed context exposing the
+ * node, its depth/expansion/children flags, its selection state, and action
+ * functions (`toggle`, `expand`, `collapse`, `toggleSelection`).
+ *
+ * Selection is optional and managed internally (`'none' | 'single' | 'multiple'`).
+ * In `'multiple'` mode with `cascade`, selecting a branch selects all its leaf
+ * descendants and the branch reports `'indeterminate'` when partially selected.
+ * This is NOT a form control — selection is exposed via the `selectionChange`
+ * output and the public `toggleSelection` / `selectionState` methods.
+ */
+declare class TreeComponent<T = unknown> {
+    /** Root nodes of the tree. Each node's children are resolved via `childrenAccessor`. Defaults to `[]`. */
+    readonly data: _angular_core.InputSignal<readonly T[]>;
+    /** Resolves a node's direct children; return an empty array for leaf nodes. Required. */
+    readonly childrenAccessor: _angular_core.InputSignal<(node: T) => readonly T[]>;
+    /** Identifies a node across data changes and keys both expansion and selection state. When unset, node identity is used. */
+    readonly trackBy: _angular_core.InputSignal<((node: T) => unknown) | undefined>;
+    /** Node-selection behavior — `mode`, `cascade`, `initialKeys`. Accepts a partial; unset keys fall back to the defaults. Defaults to selection disabled. */
+    readonly selection: _angular_core.InputSignal<Partial<TwTreeSelectionConfig>>;
+    /** Display configuration — `size`, `indent`, `showLines`. Accepts a partial; unset keys fall back to the defaults. */
+    readonly display: _angular_core.InputSignal<Partial<TwTreeDisplayConfig>>;
+    /** Two-way bound list of expansion key values (resolved via `trackBy`) for currently-expanded nodes. Set a new array on every change; do not mutate in place. Changes when a node is expanded or collapsed. Defaults to `[]` (all collapsed). */
+    readonly expandedKeys: _angular_core.ModelSignal<readonly unknown[]>;
+    /** Fires after the selection changes by user interaction. Payload is every node whose `selectionState` is `'checked'` (selected leaves plus fully-checked branches in cascade mode). */
+    readonly selectionChange: _angular_core.OutputEmitterRef<readonly T[]>;
+    /** Fires after a node is expanded or collapsed by user interaction. Payload identifies the node and its new expansion state. */
+    readonly expandedChange: _angular_core.OutputEmitterRef<{
+        node: T;
+        expanded: boolean;
+    }>;
+    /** @internal Consumer-projected per-node template (`*twTreeNode`). */
+    readonly nodeTemplate: _angular_core.Signal<TreeNodeDefDirective<any> | undefined>;
+    /** @internal The CDK tree inside our view. */
+    private readonly cdkTree;
+    /** @internal Selected node keys. In cascade mode this holds leaf keys only; branch state is derived. */
+    private readonly selectedKeys;
+    /** @internal One-shot guard so `initialKeys` seeds selection exactly once. */
+    private seeded;
+    /** @internal Resolved selection configuration. */
+    private readonly resolvedSelection;
+    /** @internal Resolved display configuration. */
+    private readonly resolvedDisplay;
+    /** @internal Indentation width in px per level. */
+    readonly indentWidth: _angular_core.Signal<number>;
+    /** @internal Snapshot of the root nodes as a mutable array (CDK's `dataSource` rejects `readonly T[]`). */
+    readonly dataArray: _angular_core.Signal<T[]>;
+    private readonly variants;
+    readonly rootClasses: _angular_core.Signal<string>;
+    readonly spacerClasses: _angular_core.Signal<string>;
+    readonly contentClasses: _angular_core.Signal<string>;
+    constructor();
+    /** @internal Resolves a node's identity key via `trackBy`, falling back to the node itself. */
+    private keyOf;
+    /** @internal Direct children of a node (always a fresh mutable array). */
+    private childrenOf;
+    /** Whether the node has at least one child (is a branch). */
+    hasChildren(node: T): boolean;
+    /** @internal Depth-first list of every node in the tree (under collapsed parents too). */
+    private flattenAll;
+    /** @internal All leaf descendants of a node (the node itself if it is a leaf). */
+    private leavesOf;
+    /** @internal Array of length `level` used to render per-level indent spacers. */
+    indentMarkers(level: number): readonly number[];
+    /** @internal Per-node row classes (incorporates the selected state). */
+    nodeClasses(node: T): string;
+    /** @internal Builds the typed context handed to the consumer's `*twTreeNode` template. */
+    buildContext(node: T, level: number): TwTreeNodeContext<T>;
+    /**
+     * @internal `aria-selected` for `'single'` mode (boolean selection), or `null`
+     * otherwise. Multiple mode uses `aria-checked` instead so the tri-state
+     * `'mixed'` value is exposed to assistive tech on the focusable treeitem.
+     */
+    ariaSelected(node: T): 'true' | 'false' | null;
+    /**
+     * @internal Tri-state `aria-checked` for `'multiple'` mode (`'mixed'` for a
+     * partially-selected branch), or `null` otherwise. APG exposes checkbox-tree
+     * selection on the treeitem via `aria-checked`; `aria-selected` cannot carry
+     * the indeterminate state.
+     */
+    ariaChecked(node: T): 'true' | 'false' | 'mixed' | null;
+    /** @internal Adapts the consumer's `readonly`-returning accessor to CDK's mutable-array contract. */
+    readonly cdkChildrenAccessor: (node: T) => T[];
+    /** @internal CDK row-tracking function keyed via `trackBy`. */
+    readonly cdkTrackBy: TrackByFunction<T>;
+    /** @internal Keys CDK's expansion model via `trackBy`. */
+    readonly cdkExpansionKey: (node: T) => unknown;
+    /** Whether the node is currently expanded. */
+    isExpanded(node: T): boolean;
+    /** Expands the node if collapsed. Emits `expandedChange` and updates `expandedKeys` via the CDK callback. */
+    expand(node: T): void;
+    /** Collapses the node if expanded. Emits `expandedChange` and updates `expandedKeys` via the CDK callback. */
+    collapse(node: T): void;
+    /** Toggles the node's expand/collapse state. No-op on leaf nodes. */
+    toggle(node: T): void;
+    /**
+     * @internal Bridges CDK's per-node `(expandedChange)` to the `expandedKeys`
+     * model. Compare-before-write: only mutates the model and emits when the
+     * key's membership actually changes, so the model→CDK effect cannot loop.
+     */
+    onCdkExpandedChange(node: T, expanded: boolean): void;
+    /**
+     * Returns the tri-state selection status of a node. `'unchecked'` when
+     * selection is disabled.
+     *
+     * For cascade branches this walks the node's leaf descendants on each call and
+     * is invoked a few times per node per change-detection pass (row class, ARIA,
+     * context). This assumes small-to-medium trees; the component has no
+     * virtualization and is not tuned for very large data sets.
+     */
+    selectionState(node: T): TwTreeSelectionState;
+    /** Toggles selection for a node (cascades to leaf descendants in `'multiple'` mode with `cascade` on). No-op when `selection.mode === 'none'`. */
+    toggleSelection(node: T): void;
+    /** @internal Every node currently reporting `selectionState() === 'checked'`. */
+    private selectedNodes;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeComponent<any>, "tw-tree", ["twTree"], { "data": { "alias": "data"; "required": false; "isSignal": true; }; "childrenAccessor": { "alias": "childrenAccessor"; "required": true; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "expandedKeys": { "alias": "expandedKeys"; "required": false; "isSignal": true; }; }, { "expandedKeys": "expandedKeysChange"; "selectionChange": "selectionChange"; "expandedChange": "expandedChange"; }, ["nodeTemplate"], never, true, never>;
+}
+/** Attribute directive (`[twTreeNodeToggle]="node"`) that toggles the given node's expansion on click. */
+declare class TreeNodeToggleDirective<T = unknown> {
+    private readonly tree;
+    /** The node whose expansion this control toggles. */
+    readonly node: _angular_core.InputSignal<T>;
+    /** @internal Toggles the node and stops the click from bubbling to row activation. */
+    onClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeNodeToggleDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeNodeToggleDirective<any>, "[twTreeNodeToggle]", never, { "node": { "alias": "twTreeNodeToggle"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { TreeComponent, TreeNodeDefDirective, TreeNodeToggleDirective };
+export type { TwTreeDisplayConfig, TwTreeNodeContext, TwTreeSelectionConfig, TwTreeSelectionState };

package/types/cdevhub-ngx-tw.d.ts

@@ -19,6 +19,7 @@ export * from '@cdevhub/ngx-tw/popover';
 export * from '@cdevhub/ngx-tw/dialog';
 export * from '@cdevhub/ngx-tw/command-palette';
 export * from '@cdevhub/ngx-tw/toast';
+export * from '@cdevhub/ngx-tw/transfer';
 export * from '@cdevhub/ngx-tw/form-field';
 export * from '@cdevhub/ngx-tw/switch';
 export * from '@cdevhub/ngx-tw/checkbox';
@@ -26,6 +27,9 @@ export * from '@cdevhub/ngx-tw/radio';
 export * from '@cdevhub/ngx-tw/select';
 export * from '@cdevhub/ngx-tw/input';
 export * from '@cdevhub/ngx-tw/textarea';
+export * from '@cdevhub/ngx-tw/file-upload';
+export * from '@cdevhub/ngx-tw/number-input';
+export * from '@cdevhub/ngx-tw/tags-input';
 export * from '@cdevhub/ngx-tw/spinner';
 export * from '@cdevhub/ngx-tw/progress-bar';
 export * from '@cdevhub/ngx-tw/skeleton';
@@ -47,3 +51,6 @@ export * from '@cdevhub/ngx-tw/stat';
 export * from '@cdevhub/ngx-tw/combobox';
 export * from '@cdevhub/ngx-tw/empty-state';
 export * from '@cdevhub/ngx-tw/sheet';
+export * from '@cdevhub/ngx-tw/aspect-ratio';
+export * from '@cdevhub/ngx-tw/tree';
+export * from '@cdevhub/ngx-tw/theme';