@mozaic-ds/angular 2.0.51 → 2.0.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mozaic-ds/angular",
-  "version": "2.0.51",
+  "version": "2.0.53",
   "type": "module",
   "peerDependencies": {
     "@angular/common": ">=20.3.15",

package/types/mozaic-ds-angular.d.ts

@@ -4680,6 +4680,12 @@ declare class TreeStateService<T = unknown> {
     readonly loadingIds: _angular_core.WritableSignal<Set<string | number>>;
     readonly internalNodes: _angular_core.WritableSignal<TreeNode<T>[]>;
     readonly loadChildrenFn: _angular_core.WritableSignal<LoadChildrenFn<T> | null>;
+    /**
+     * Parent IDs for which children have been patched in (via lazy-load).
+     * Grows monotonically — consumers diff against their own "processed" set.
+     * Not emitted for statically-populated children present at init.
+     */
+    readonly loadedParentIds: _angular_core.WritableSignal<ReadonlySet<string | number>>;
     readonly flatVisibleNodes: _angular_core.Signal<FlatNode<T>[]>;
     private _flatten;
     setExpanded(ids: Set<string | number>): void;
@@ -4705,10 +4711,19 @@ declare class TreeSelectionService<T = unknown> {
     setMode(mode: TreeSelectionMode): void;
     setRootNodes(nodes: TreeNode<T>[]): void;
     isSelected(id: string | number): boolean;
-    isDisabled(node: TreeNode<T>, ancestors: TreeNode<T>[]): boolean;
     /**
-     * A node is indeterminate when it has loaded children AND
-     * some (but not all) of its leaf-level descendants are selected.
+     * A node is considered disabled only by its own `disabled` flag — a disabled
+     * parent does not propagate the state to its descendants. Children of a
+     * disabled parent remain individually interactable; the parent itself just
+     * has its bulk "toggle all" action locked. This mirrors the combobox's
+     * disabled-section semantics.
+     */
+    isDisabled(node: TreeNode<T>): boolean;
+    /**
+     * A node is indeterminate when it has loaded children AND at least one
+     * descendant is selected without the node being fully checked. Disabled
+     * descendants count so a pre-selected disabled leaf still surfaces on the
+     * parent (useful when the parent itself is also disabled).
      */
     isIndeterminate(node: TreeNode<T>): boolean;
     /**
@@ -4737,6 +4752,9 @@ declare class TreeSelectionService<T = unknown> {
     /**
      * Collect leaf-level IDs (terminal nodes that have no loaded children).
      * Returns empty array if the node itself is a leaf.
+     * When `includeDisabled` is true, disabled descendants are also collected —
+     * used by the indeterminate computation so pre-selected disabled leaves
+     * count toward a parent's state.
      */
     private _collectLeafIds;
     /**