fix indeterminate state being lost

src/presentation/Scripts/ScriptsTree/SelectableTree/LiquorTree/LiquorTree.d.ts

@@ -20,6 +20,7 @@ declare module 'liquor-tree' {
     // https://github.com/amsik/liquor-tree/blob/master/src/lib/Node.js
     export interface ILiquorTreeNodeState {
         checked: boolean;
+        indeterminate: boolean;
     }
 
     export interface ILiquorTreeNode {

src/presentation/Scripts/ScriptsTree/SelectableTree/LiquorTree/LiquorTreeOptions.ts

@@ -5,9 +5,10 @@ export class LiquorTreeOptions implements ILiquorTreeOptions {
     public readonly checkbox = true;
     public readonly checkOnSelect = true;
     /*  For checkbox mode only. Children will have the same checked state as their parent.
+        ⚠️ Setting this false, does not update indeterminate state of nodes.
         This is false as it's handled manually to be able to batch select for performance + highlighting */
     public readonly autoCheckChildren = false;
-    public readonly parentSelect = false;
+    public readonly parentSelect = true;
     public readonly keyboardNavigation = true;
     public readonly filter = { // Wrap this in an arrow function as setting filter directly does not work JS APIs
         emptyText: this.liquorTreeFilter.emptyText,

src/presentation/Scripts/ScriptsTree/SelectableTree/LiquorTree/NodeWrapper/NodeStateUpdater.ts

@@ -1,14 +1,37 @@
-import { ILiquorTreeNode } from 'liquor-tree';
+import { ILiquorTreeNode, ILiquorTreeNodeState } from 'liquor-tree';
 import { NodeType } from './../../Node/INode';
 
-export function getNewCheckedState(
-    oldNode: ILiquorTreeNode,
+export function getNewState(
+    node: ILiquorTreeNode,
+    selectedNodeIds: ReadonlyArray<string>): ILiquorTreeNodeState {
+    const checked = getNewCheckedState(node, selectedNodeIds);
+    const indeterminate = !checked && getNewIndeterminateState(node, selectedNodeIds);
+    return {
+        checked, indeterminate,
+    };
+}
+
+function getNewIndeterminateState(
+    node: ILiquorTreeNode,
     selectedNodeIds: ReadonlyArray<string>): boolean {
-    switch (oldNode.data.type) {
+    switch (node.data.type) {
         case NodeType.Script:
-            return selectedNodeIds.some((id) => id === oldNode.id);
+            return false;
         case NodeType.Category:
-            return parseAllSubScriptIds(oldNode).every((id) => selectedNodeIds.includes(id));
+            return parseAllSubScriptIds(node).some((id) => selectedNodeIds.includes(id));
+        default:
+            throw new Error('Unknown node type');
+    }
+}
+
+function getNewCheckedState(
+    node: ILiquorTreeNode,
+    selectedNodeIds: ReadonlyArray<string>): boolean {
+    switch (node.data.type) {
+        case NodeType.Script:
+            return selectedNodeIds.some((id) => id === node.id);
+        case NodeType.Category:
+            return parseAllSubScriptIds(node).every((id) => selectedNodeIds.includes(id));
         default:
             throw new Error('Unknown node type');
     }

src/presentation/Scripts/ScriptsTree/SelectableTree/LiquorTree/NodeWrapper/NodeTranslator.ts

@@ -23,6 +23,7 @@ export function toNewLiquorTreeNode(node: INode): ILiquorTreeNewNode {
         text: node.text,
         state: {
             checked: false,
+            indeterminate: false,
         },
         children: convertChildren(node.children, toNewLiquorTreeNode),
         data: {

src/presentation/Scripts/ScriptsTree/SelectableTree/SelectableTree.vue

@@ -18,14 +18,15 @@
 
 <script lang="ts">
     import { Component, Prop, Vue, Watch } from 'vue-property-decorator';
-    import LiquorTree, { ILiquorTreeNewNode, ILiquorTreeExistingNode, ILiquorTree } from 'liquor-tree';
+    import LiquorTree from 'liquor-tree';
     import Node from './Node/Node.vue';
     import { INode } from './Node/INode';
     import { convertExistingToNode, toNewLiquorTreeNode } from './LiquorTree/NodeWrapper/NodeTranslator';
     import { INodeSelectedEvent } from './/INodeSelectedEvent';
-    import { getNewCheckedState } from './LiquorTree/NodeWrapper/NodeStateUpdater';
+    import { getNewState } from './LiquorTree/NodeWrapper/NodeStateUpdater';
     import { LiquorTreeOptions } from './LiquorTree/LiquorTreeOptions';
     import { FilterPredicate, NodePredicateFilter } from './LiquorTree/NodeWrapper/NodePredicateFilter';
+    import { ILiquorTreeNewNode, ILiquorTreeExistingNode, ILiquorTree, ILiquorTreeNode, ILiquorTreeNodeState } from 'liquor-tree';
 
     /** Wrapper for Liquor Tree, reveals only abstracted INode for communication */
     @Component({
@@ -49,7 +50,7 @@
                 const initialNodes = this.initialNodes.map((node) => toNewLiquorTreeNode(node));
                 if (this.selectedNodeIds) {
                     recurseDown(initialNodes,
-                        (node) => node.state.checked = getNewCheckedState(node, this.selectedNodeIds));
+                        (node) => node.state = updateState(node.state, node, this.selectedNodeIds));
                 }
                 this.initialLiquourTreeNodes = initialNodes;
             } else {
@@ -82,11 +83,11 @@
         @Watch('selectedNodeIds')
         public setSelectedStatusAsync(selectedNodeIds: ReadonlyArray<string>) {
             if (!selectedNodeIds) {
-                throw new Error('Selected nodes are undefined');
+                throw new Error('SelectedrecurseDown nodes are undefined');
             }
-            this.getLiquorTreeApi().recurseDown((node) => {
-                node.states.checked = getNewCheckedState(node, selectedNodeIds);
-            });
+            this.getLiquorTreeApi().recurseDown(
+                (node) => node.states = updateState(node.states, node, selectedNodeIds),
+            );
         }
 
         private getLiquorTreeApi(): ILiquorTree {
@@ -97,6 +98,13 @@
         }
     }
 
+    function updateState(
+        old: ILiquorTreeNodeState,
+        node: ILiquorTreeNode,
+        selectedNodeIds: ReadonlyArray<string>): ILiquorTreeNodeState {
+        return {...old, ...getNewState(node, selectedNodeIds)};
+    }
+
     function recurseDown(
         nodes: ReadonlyArray<ILiquorTreeNewNode>,
         handler: (node: ILiquorTreeNewNode) => void) {