@iris-ui-kit/vue 0.2.7 → 0.2.9

package/dist/index.cjs

@@ -9347,7 +9347,14 @@ var IrisTable = vue.defineComponent({
     getSubRows: {
       type: Function,
       default: void 0
-    }
+    },
+    /**
+     * Cascade multi-row selection through the complete tree supplied by
+     * `getSubRows`. Selecting a branch selects every descendant (including
+     * collapsed rows); partially selected branches render indeterminate.
+     * Ignored outside tree mode and for non-multi selection.
+     */
+    treeSelectionCascade: { type: Boolean, default: false }
   },
   emits: {
     "update:selection": (_value) => true,
@@ -9433,27 +9440,97 @@ var IrisTable = vue.defineComponent({
     const bodyData = vue.computed(
       () => flatTree.value ? flatTree.value.map((t2) => t2.row) : sortedRows.value
     );
-    const isSelected = (id) => displaySelection.value.includes(id);
-    const allRowIds = vue.computed(() => bodyData.value.map((r, i) => rowId(r, i)));
+    const cascadingTreeSelection = vue.computed(
+      () => props.treeSelectionCascade && props.selectable === "multi" && treeMode.value
+    );
+    const treeSelectionNodes = vue.computed(() => {
+      const getChildren = props.getSubRows;
+      if (!cascadingTreeSelection.value || !getChildren) return [];
+      const nodes = [];
+      const seen = /* @__PURE__ */ new Set();
+      let rowIndex = 0;
+      const walk = (rows, parentKey) => {
+        for (const row of rows) {
+          const key = rowId(row, rowIndex);
+          rowIndex += 1;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          nodes.push({ key, parentKey });
+          const children = getChildren(row);
+          if (children && children.length > 0) walk(children, key);
+        }
+      };
+      walk(sortedRows.value);
+      return nodes;
+    });
+    const compactTreeSelectionSeed = (keys) => {
+      const selected = new Set(keys);
+      const parentByKey = new Map(
+        treeSelectionNodes.value.map((node) => [node.key, node.parentKey])
+      );
+      return keys.filter((key) => {
+        const visited = /* @__PURE__ */ new Set();
+        let parent = parentByKey.get(key);
+        while (parent !== void 0 && !visited.has(parent)) {
+          if (selected.has(parent)) return false;
+          visited.add(parent);
+          parent = parentByKey.get(parent);
+        }
+        return true;
+      });
+    };
+    const resolvedTreeSelection = vue.computed(
+      () => cascadingTreeSelection.value ? core.createTreeSelection({
+        nodes: treeSelectionNodes.value,
+        // Canonical payloads contain fully-selected branches and their
+        // leaves. Seed only the highest selected ancestors so rebuilding a
+        // large fully-selected tree does not cascade once per descendant.
+        defaultChecked: compactTreeSelectionSeed(displaySelection.value)
+      }) : null
+    );
+    const isSelected = (id) => resolvedTreeSelection.value?.isChecked(id) ?? displaySelection.value.includes(id);
+    const isSelectionIndeterminate = (id) => resolvedTreeSelection.value?.isIndeterminate(id) ?? false;
+    const allRowIds = vue.computed(
+      () => cascadingTreeSelection.value ? treeSelectionNodes.value.map((node) => node.key) : bodyData.value.map((row, index) => rowId(row, index))
+    );
     const allSelected = vue.computed(() => {
-      const sel = displaySelection.value;
-      return allRowIds.value.length > 0 && allRowIds.value.every((id) => sel.includes(id));
+      return allRowIds.value.length > 0 && allRowIds.value.every((id) => isSelected(id));
     });
     const someSelected = vue.computed(() => {
-      const sel = displaySelection.value;
-      return !allSelected.value && allRowIds.value.some((id) => sel.includes(id));
+      return !allSelected.value && allRowIds.value.some((id) => isSelected(id) || isSelectionIndeterminate(id));
     });
     const toggleRow = (id) => {
       rebaseToProp();
       if (props.selectable === "single") {
         selectionModel.set(selectionModel.isSelected(id) ? [] : [id]);
       } else if (props.selectable === "multi") {
-        selectionModel.toggle(id);
+        if (cascadingTreeSelection.value) {
+          const treeSelection = core.createTreeSelection({
+            nodes: treeSelectionNodes.value,
+            defaultChecked: compactTreeSelectionSeed(displaySelection.value)
+          });
+          treeSelection.toggle(id);
+          selectionModel.set(treeSelection.getChecked());
+        } else {
+          selectionModel.toggle(id);
+        }
       }
     };
     const toggleAll = () => {
       rebaseToProp();
-      selectionModel.set(allSelected.value ? [] : [...allRowIds.value]);
+      if (allSelected.value) {
+        selectionModel.set([]);
+        return;
+      }
+      if (cascadingTreeSelection.value) {
+        const treeSelection = core.createTreeSelection({
+          nodes: treeSelectionNodes.value,
+          defaultChecked: allRowIds.value
+        });
+        selectionModel.set(treeSelection.getChecked());
+        return;
+      }
+      selectionModel.set([...allRowIds.value]);
     };
     const editingCellId = vue.ref(null);
     const editingDraft = vue.ref("");
@@ -10015,7 +10092,7 @@ var IrisTable = vue.defineComponent({
               },
               [
                 vue.h(IrisCheckbox, {
-                  modelValue: selected,
+                  modelValue: isSelectionIndeterminate(id) ? "indeterminate" : selected,
                   size: "sm",
                   ariaLabel: t("table.selectRow", { key: id }),
                   "onUpdate:modelValue": () => toggleRow(id),