From f55bab1b67b19c8e43036ef792658ff23db60488 Mon Sep 17 00:00:00 2001
From: OganM <ogan.mancarcii@gmail.com>
Date: Wed, 27 Aug 2025 18:31:29 -0700
Subject: [PATCH 01/12] negative selection frontend

---
 src/components/AnnotationSelector.vue | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/src/components/AnnotationSelector.vue b/src/components/AnnotationSelector.vue
index f84d949..85b47c9 100644
--- a/src/components/AnnotationSelector.vue
+++ b/src/components/AnnotationSelector.vue
@@ -28,6 +28,15 @@
                     :filter="filter"
                     :class="debug ? '' : 'hide-root-checkboxes'"
         >
+            <template v-slot:prepend="{item,leaf}">
+              <v-icon
+                  v-if="leaf"
+                  :class="iconForState(selection[item.id]|| 0)"
+                  @click.stop="toggleSelection(item.id)"
+                  :color="selection[item.id]===-1 ? 'red darken-3' : ''"
+              >
+              </v-icon>
+            </template>
             <template v-slot:label="{item}">
                 <i v-if="item.isCategory && isUncategorized(item)">Uncategorized</i>
                 <span v-else
@@ -100,6 +109,7 @@ export default {
        * Search for annotations.
        */
       search: null,
+      selection:{},
       /**
        * A list of opened categories.
        */
@@ -208,6 +218,19 @@ export default {
   },
   methods: {
     formatNumber,
+    toggleSelection(id){
+      let current = this.selection[id] || 0;
+      let next = current === 0 ? 1: current === 1 ? -1 : 0;
+      this.$set(this.selection, id, next);
+    },
+    iconForState(state){
+      let box_class = "v-icon notranslate v-treeview-node__checkbox v-icon--link theme--light mdi "
+      switch (state){
+        case 1: return box_class + 'accent--text mdi-checkbox-marked';   // positive
+        case -1: return box_class + 'mdi-minus-box';       // negative
+        default: return box_class + 'mdi-checkbox-blank-outline'; // unselected
+      }
+    },
     filter(item, search) {
       let fragments = pluralize.singular(search.toLowerCase()).split(" ");
       return fragments.every(fragment => this.getTitle(item).toLowerCase().includes(fragment) || this.getUri(item)?.toLowerCase() === fragment);
@@ -357,4 +380,7 @@ export default {
 .hide-root-checkboxes >>> .v-treeview-node__toggle + .v-treeview-node__checkbox {
     display: none !important;
 }
+.v-treeview-node__prepend {
+  min-width: 0;
+}
 </style>
\ No newline at end of file

From e5413e813ad8bbbd55a1cb5924e03c20228a185e Mon Sep 17 00:00:00 2001
From: OganM <ogan.mancarcii@gmail.com>
Date: Wed, 27 Aug 2025 20:28:37 -0700
Subject: [PATCH 02/12] AnnotationSelector to searchSettings connection for
 negative choices

---
 src/components/SearchSettings.vue | 2 ++
 src/lib/models.js                 | 4 ++++
 2 files changed, 6 insertions(+)

diff --git a/src/components/SearchSettings.vue b/src/components/SearchSettings.vue
index dbba3d0..531a219 100644
--- a/src/components/SearchSettings.vue
+++ b/src/components/SearchSettings.vue
@@ -61,6 +61,8 @@
                 class="mb-1"/>
         <AnnotationSelector
                 v-model="searchSettings.annotations"
+                :negativeAnnotations.sync="searchSettings.negativeAnnotations"
+                :negativeCategories.sync="searchSettings.negativeCategories"
                 :annotations="annotations"
                 :loading="annotationLoading"
                 :disabled="annotationDisabled"
diff --git a/src/lib/models.js b/src/lib/models.js
index 2a34700..662ae4f 100644
--- a/src/lib/models.js
+++ b/src/lib/models.js
@@ -66,7 +66,9 @@ export function QualityRange(low, high) {
  * @property quality {QualityRange} Filter results by quality, if applicable
  * @property technologyTypes  {} Selected technology types
  * @property annotations {} Selected terms
+ * @property negativeAnnotations {} Negatively selected terms
  * @property categories {} Selected categories
+ * @property negativeCategories {} Negatively selected categories
  * @constructor
  */
 export function SearchSettings(taxon, query, resultTypes, platforms) {
@@ -79,7 +81,9 @@ export function SearchSettings(taxon, query, resultTypes, platforms) {
   this.technologyTypes = [];
   this.selectedTech = platforms || [];
   this.annotations = [];
+  this.negativeAnnotations=[];
   this.categories = [];
+  this.negativeCategories = [];
   this.ignoreExcludedTerms = false;
 }
 

From 8ff85645cfe3c9534f427d977d290ebfe5b4b5c7 Mon Sep 17 00:00:00 2001
From: OganM <ogan.mancarcii@gmail.com>
Date: Wed, 27 Aug 2025 20:50:21 -0700
Subject: [PATCH 03/12] AnnotationSelector to searchSettings connection for
 negative choices part 2

---
 src/components/AnnotationSelector.vue | 43 ++++++++++++++++++++-------
 1 file changed, 32 insertions(+), 11 deletions(-)

diff --git a/src/components/AnnotationSelector.vue b/src/components/AnnotationSelector.vue
index 85b47c9..db2c016 100644
--- a/src/components/AnnotationSelector.vue
+++ b/src/components/AnnotationSelector.vue
@@ -30,7 +30,7 @@
         >
             <template v-slot:prepend="{item,leaf}">
               <v-icon
-                  v-if="leaf"
+                  v-if="leaf || debug"
                   :class="iconForState(selection[item.id]|| 0)"
                   @click.stop="toggleSelection(item.id)"
                   :color="selection[item.id]===-1 ? 'red darken-3' : ''"
@@ -110,6 +110,7 @@ export default {
        */
       search: null,
       selection:{},
+      oldSelection:{},
       /**
        * A list of opened categories.
        */
@@ -327,10 +328,18 @@ export default {
       return highlightedWords.join(" ");
     },
     dispatchValues:debounce(function(newVal,oldVal){
-      let sc = this.computeSelectedCategories(newVal);
-      let sa = this.computeSelectedAnnotations(newVal, sc);
-      let scOld = this.computeSelectedCategories(oldVal);
-      let saOld = this.computeSelectedAnnotations(oldVal, scOld);
+      let marked =   Object.keys(newVal).filter((x,i)=>( Object.values(newVal)[i] !== 0  ))
+      let selected =  Object.keys(newVal).filter((x,i)=>( Object.values(newVal)[i] === 1  ))
+      let unselected = Object.keys(newVal).filter((x,i)=>( Object.values(newVal)[i] === -1  ))
+
+      // let oldMarked =   Object.keys(oldVal).filter((x,i)=>( Object.values(oldVal)[i] !== 0  ))
+      let oldSelected =  Object.keys(oldVal).filter((x,i)=>( Object.values(oldVal)[i] === 1  ))
+      let oldUnselected = Object.keys(oldVal).filter((x,i)=>( Object.values(oldVal)[i] === -1  ))
+
+      let sc = this.computeSelectedCategories(selected);
+      let sa = this.computeSelectedAnnotations(selected, sc);
+      let scOld = this.computeSelectedCategories(oldSelected);
+      let saOld = this.computeSelectedAnnotations(oldSelected, scOld);
       if (!isEqual(sa.map(this.getId), saOld.map(this.getId))) {
         this.$emit("input", sa);
       }
@@ -338,9 +347,20 @@ export default {
         this.$emit("update:selectedCategories", sc);
       }
 
-      let allAnnots = this.rankedAnnotations.reduce((acc,annot)=>(acc.concat(annot.children)),[])
-      let selectedURIs = this.selectedValues.map(x => x.split(SEPARATOR)[1])
+      let unSc = this.computeSelectedCategories(unselected);
+      let unsa = this.computeSelectedAnnotations(unselected,unSc);
+      let unScOld = this.computeSelectedCategories(oldUnselected);
+      let unSaOld = this.computeSelectedAnnotations(oldUnselected,unScOld);
+      if (!isEqual(unsa.map(this.getId), unSaOld.map(this.getId))) {
+        this.$emit("update:negativeAnnotations", sa);
+      }
+      if (!isEqual(unSc.map(getCategoryId), unScOld.map(getCategoryId))) {
+        this.$emit("update:negativeCategories", sc);
+      }
+
 
+      let allAnnots = this.rankedAnnotations.reduce((acc,annot)=>(acc.concat(annot.children)),[])
+      let selectedURIs = marked.map(x => x.split(SEPARATOR)[1])
 
       this.dispatchedSelectedAnnotations =  allAnnots
           .filter(annot=>selectedURIs.includes(annot.termUri))
@@ -367,9 +387,10 @@ export default {
       // make sure that newVal is an option
       this.selectedValues = newVal.map(term => this.getId(term));
     },
-    selectedValues:function(newVal, oldVal) {
-      if(!isEqual(newVal,oldVal)){
-        this.dispatchValues(newVal,oldVal)
+    selection(newVal) {
+      if (!isEqual(newVal, this.oldSelection)) {
+        this.dispatchValues(newVal, this.oldSelection)
+        this.$set(this.oldSelection, Object.assign({}, newVal))
       }
     }
   }
@@ -380,7 +401,7 @@ export default {
 .hide-root-checkboxes >>> .v-treeview-node__toggle + .v-treeview-node__checkbox {
     display: none !important;
 }
-.v-treeview-node__prepend {
+>>> .v-treeview-node__prepend {
   min-width: 0;
 }
 </style>
\ No newline at end of file

From dd2ec0fae15362e0f7acfdde7b2e0a1db753bd57 Mon Sep 17 00:00:00 2001
From: OganM <ogan.mancarcii@gmail.com>
Date: Tue, 2 Sep 2025 18:42:04 -0700
Subject: [PATCH 04/12] parent child selection behaviour

---
 src/components/AnnotationSelector.vue | 69 +++++++++++++++++++++++----
 1 file changed, 61 insertions(+), 8 deletions(-)

diff --git a/src/components/AnnotationSelector.vue b/src/components/AnnotationSelector.vue
index db2c016..ccc41cc 100644
--- a/src/components/AnnotationSelector.vue
+++ b/src/components/AnnotationSelector.vue
@@ -31,9 +31,10 @@
             <template v-slot:prepend="{item,leaf}">
               <v-icon
                   v-if="leaf || debug"
+                  :disabled="disabled"
                   :class="iconForState(selection[item.id]|| 0)"
                   @click.stop="toggleSelection(item.id)"
-                  :color="selection[item.id]===-1 ? 'red darken-3' : ''"
+                  :color="[-1,3].includes(selection[item.id]) ? 'red darken-3' : ''"
               >
               </v-icon>
             </template>
@@ -221,14 +222,60 @@ export default {
     formatNumber,
     toggleSelection(id){
       let current = this.selection[id] || 0;
-      let next = current === 0 ? 1: current === 1 ? -1 : 0;
+      let next = current === 0 ? 1: current === 1 ? -1 : current === -1 ? 0: current === 2 ? 1 : current === 3 ? -1 : current === 4 ? 1 : 0
       this.$set(this.selection, id, next);
+
+      // if a parent id is clicked, apply the change to all children
+      this.rankedAnnotations
+          .filter(annot => {return annot.id === id})
+          .map(annot => {
+            annot.children.map(children => {
+              this.$set(this.selection, children.id, next);
+            })
+          })
+
+      // if a child id is clicked, check it's parent to figure out how to mark it
+      let split_id = id.split("|")
+      if(split_id.length > 1){
+        let selected =  Object.keys(this.selection).filter((x,i)=>( Object.values(this.selection)[i] === 1  ))
+        let unselected =  Object.keys(this.selection).filter((x,i)=>( Object.values(this.selection)[i] === -1  ))
+
+        let category = split_id[0]
+        let child_ids = this.rankedAnnotations
+            .filter(annot => {return annot.id === category})[0]
+            .children.map(child=>child.id)
+
+        // all/no children are selected are states 1,-1
+        // some children selected/unselected are states 2,3
+        // a mix of selected/unselected is state 4
+        if (child_ids.every(c=>selected.includes(c))){
+          this.$set(this.selection, category, 1);
+        } else if (child_ids.every(c=>unselected.includes(c))){
+          this.$set(this.selection, category, -1);
+        } else if (child_ids.some(c=>selected.includes(c)) && !child_ids.some(c=>unselected.includes(c))){
+          this.$set(this.selection, category, 2);
+        } else if(child_ids.some(c=>unselected.includes(c)) && !child_ids.some(c=>selected.includes(c))) {
+          this.$set(this.selection, category, 3);
+        } else if(child_ids.some(c=>unselected.includes(c)) && child_ids.some(c=>selected.includes(c))){
+          this.$set(this.selection, category, 4);
+        } else{
+          this.$set(this.selection, category, 0);
+        }
+
+      }
+
+
+
+
     },
     iconForState(state){
       let box_class = "v-icon notranslate v-treeview-node__checkbox v-icon--link theme--light mdi "
       switch (state){
         case 1: return box_class + 'accent--text mdi-checkbox-marked';   // positive
-        case -1: return box_class + 'mdi-minus-box';       // negative
+        case -1: return box_class + 'mdi-close-box';       // negative
+        case 2: return box_class + 'accent--text mdi-minus-box';
+        case 3: return box_class + 'mdi-minus-box';
+        case 4: return box_class + 'mdi-minus-box';
         default: return box_class + 'mdi-checkbox-blank-outline'; // unselected
       }
     },
@@ -336,6 +383,10 @@ export default {
       let oldSelected =  Object.keys(oldVal).filter((x,i)=>( Object.values(oldVal)[i] === 1  ))
       let oldUnselected = Object.keys(oldVal).filter((x,i)=>( Object.values(oldVal)[i] === -1  ))
 
+      // assign old selection here instead of the main watcher since it can skip steps while
+      // waiting for debounce otherise
+      this.oldSelection = Object.assign({},newVal);
+
       let sc = this.computeSelectedCategories(selected);
       let sa = this.computeSelectedAnnotations(selected, sc);
       let scOld = this.computeSelectedCategories(oldSelected);
@@ -387,12 +438,14 @@ export default {
       // make sure that newVal is an option
       this.selectedValues = newVal.map(term => this.getId(term));
     },
-    selection(newVal) {
-      if (!isEqual(newVal, this.oldSelection)) {
-        this.dispatchValues(newVal, this.oldSelection)
-        this.$set(this.oldSelection, Object.assign({}, newVal))
+    selection:{
+      handler:function(newVal) {
+        if (!isEqual(newVal, this.oldSelection)) {
+          this.dispatchValues(newVal, this.oldSelection);
+        }
+      },
+      deep: true
       }
-    }
   }
 };
 </script>

From 6df088da96fc55c6a930092127341924bfdf9a71 Mon Sep 17 00:00:00 2001
From: OganM <ogan.mancarcii@gmail.com>
Date: Tue, 2 Sep 2025 19:58:55 -0700
Subject: [PATCH 05/12] replace remaining uses of selectedValues, allow
 external changes to annotation selections

---
 src/components/AnnotationSelector.vue | 122 +++++++++++++++-----------
 src/components/SearchSettings.vue     |   2 +-
 2 files changed, 70 insertions(+), 54 deletions(-)

diff --git a/src/components/AnnotationSelector.vue b/src/components/AnnotationSelector.vue
index ccc41cc..76d1771 100644
--- a/src/components/AnnotationSelector.vue
+++ b/src/components/AnnotationSelector.vue
@@ -11,7 +11,7 @@
                 Counts in this section may be approximate. For more explanation see the help.
             </v-tooltip>
             <v-spacer></v-spacer>
-            <v-btn v-if="selectedValues.length > 0" @click="selectedValues = []" small text color="primary"
+            <v-btn v-if="Object.keys(this.selection).filter((x,i)=>( Object.values(this.selection)[i] !== 0  )).length > 0" @click="selection = {}" small text color="primary"
                    :disabled="disabled">
                 Clear Selection
             </v-btn>
@@ -20,8 +20,7 @@
         <v-text-field v-model="search" dense label="Filter Annotations" outlined hide-details
                       prepend-inner-icon="filter_list" :disabled="disabled"
                       class="my-1"/>
-        <v-treeview v-model="selectedValues" :items="rankedAnnotations" :disabled="disabled" item-key="id"
-                    selectable
+        <v-treeview :items="rankedAnnotations" :disabled="disabled" item-key="id"
                     dense
                     :open.sync="open"
                     :search="search"
@@ -87,7 +86,10 @@ export default {
      *
      * Only selected terms are listed in the array, selected categories are handled separately.
      */
-    value: Array,
+    selectedAnnotations:Array,
+    negativeAnnotations: Array,
+    selectedCategories:Array,
+    negativeCategories:Array,
     /**
      * Annotations to be displayed in this selector.
      */
@@ -104,7 +106,6 @@ export default {
        * An array of selected values formatted as "categoryId|termId".
        * @type Array
        */
-      selectedValues: this.value.map(term => this.getId(term)),
       dispatchedSelectedAnnotations:{},
       /**
        * Search for annotations.
@@ -112,6 +113,7 @@ export default {
       search: null,
       selection:{},
       oldSelection:{},
+      oldAnnotations:[],
       /**
        * A list of opened categories.
        */
@@ -220,6 +222,37 @@ export default {
   },
   methods: {
     formatNumber,
+    markParent(id){
+      let split_id = id.split("|")
+      if(split_id.length > 1){
+        if(split_id.length > 1){
+          let selected =  Object.keys(this.selection).filter((x,i)=>( Object.values(this.selection)[i] === 1  ))
+          let unselected =  Object.keys(this.selection).filter((x,i)=>( Object.values(this.selection)[i] === -1  ))
+
+          let category = split_id[0]
+          let child_ids = this.rankedAnnotations
+              .filter(annot => {return annot.id === category})[0]
+              .children.map(child=>child.id)
+
+          // all/no children are selected are states 1,-1
+          // some children selected/unselected are states 2,3
+          // a mix of selected/unselected is state 4
+          if (child_ids.every(c=>selected.includes(c))){
+            this.$set(this.selection, category, 1);
+          } else if (child_ids.every(c=>unselected.includes(c))){
+            this.$set(this.selection, category, -1);
+          } else if (child_ids.some(c=>selected.includes(c)) && !child_ids.some(c=>unselected.includes(c))){
+            this.$set(this.selection, category, 2);
+          } else if(child_ids.some(c=>unselected.includes(c)) && !child_ids.some(c=>selected.includes(c))) {
+            this.$set(this.selection, category, 3);
+          } else if(child_ids.some(c=>unselected.includes(c)) && child_ids.some(c=>selected.includes(c))){
+            this.$set(this.selection, category, 4);
+          } else{
+            this.$set(this.selection, category, 0);
+          }
+        }
+      }
+    },
     toggleSelection(id){
       let current = this.selection[id] || 0;
       let next = current === 0 ? 1: current === 1 ? -1 : current === -1 ? 0: current === 2 ? 1 : current === 3 ? -1 : current === 4 ? 1 : 0
@@ -235,38 +268,7 @@ export default {
           })
 
       // if a child id is clicked, check it's parent to figure out how to mark it
-      let split_id = id.split("|")
-      if(split_id.length > 1){
-        let selected =  Object.keys(this.selection).filter((x,i)=>( Object.values(this.selection)[i] === 1  ))
-        let unselected =  Object.keys(this.selection).filter((x,i)=>( Object.values(this.selection)[i] === -1  ))
-
-        let category = split_id[0]
-        let child_ids = this.rankedAnnotations
-            .filter(annot => {return annot.id === category})[0]
-            .children.map(child=>child.id)
-
-        // all/no children are selected are states 1,-1
-        // some children selected/unselected are states 2,3
-        // a mix of selected/unselected is state 4
-        if (child_ids.every(c=>selected.includes(c))){
-          this.$set(this.selection, category, 1);
-        } else if (child_ids.every(c=>unselected.includes(c))){
-          this.$set(this.selection, category, -1);
-        } else if (child_ids.some(c=>selected.includes(c)) && !child_ids.some(c=>unselected.includes(c))){
-          this.$set(this.selection, category, 2);
-        } else if(child_ids.some(c=>unselected.includes(c)) && !child_ids.some(c=>selected.includes(c))) {
-          this.$set(this.selection, category, 3);
-        } else if(child_ids.some(c=>unselected.includes(c)) && child_ids.some(c=>selected.includes(c))){
-          this.$set(this.selection, category, 4);
-        } else{
-          this.$set(this.selection, category, 0);
-        }
-
-      }
-
-
-
-
+      this.markParent(id)
     },
     iconForState(state){
       let box_class = "v-icon notranslate v-treeview-node__checkbox v-icon--link theme--light mdi "
@@ -324,9 +326,10 @@ export default {
       }
     },
     getNumberCategorySelections(item) {
+      let marked = Object.keys(this.selection).filter((x,i)=>( Object.values(this.selection)[i] !== 0  ))
       let classUri = item.classUri;
-      let selectedValuesClassUris = this.selectedValues.map(Values => Values.split("|")[0]);
-      return selectedValuesClassUris.filter(value => value.includes(classUri)).length;
+      let selectedValuesClassUris = marked.map(Values => Values.split("|")[0]);
+      return selectedValuesClassUris.filter(value => value.includes(classUri)).length-1;
     },
     /**
      * Selected annotations, excluding those in selected categories.
@@ -354,9 +357,9 @@ export default {
      * When other filters are applied, it may happen that a category becomes unexpectedly selected, so to prevent this
      * we require at least 10 terms in the category.
      */
-    computeSelectedCategories(newVal) {
+    computeSelectedCategories(newVal,annotations) {
       let s = new Set(newVal);
-      return this.annotations
+      return annotations
         .filter(a => a.children.length > 10 && a.children.every(b => s.has(this.getId(b))))
         .map(a => ({ classUri: a.classUri, className: a.className }));
     },
@@ -383,24 +386,22 @@ export default {
       let oldSelected =  Object.keys(oldVal).filter((x,i)=>( Object.values(oldVal)[i] === 1  ))
       let oldUnselected = Object.keys(oldVal).filter((x,i)=>( Object.values(oldVal)[i] === -1  ))
 
-      // assign old selection here instead of the main watcher since it can skip steps while
-      // waiting for debounce otherise
-      this.oldSelection = Object.assign({},newVal);
 
-      let sc = this.computeSelectedCategories(selected);
+
+      let sc = this.computeSelectedCategories(selected,this.annotations);
       let sa = this.computeSelectedAnnotations(selected, sc);
-      let scOld = this.computeSelectedCategories(oldSelected);
+      let scOld = this.computeSelectedCategories(oldSelected,this.oldAnnotations);
       let saOld = this.computeSelectedAnnotations(oldSelected, scOld);
       if (!isEqual(sa.map(this.getId), saOld.map(this.getId))) {
-        this.$emit("input", sa);
+        this.$emit("update:selectedAnnotations", sa);
       }
       if (!isEqual(sc.map(getCategoryId), scOld.map(getCategoryId))) {
         this.$emit("update:selectedCategories", sc);
       }
 
-      let unSc = this.computeSelectedCategories(unselected);
+      let unSc = this.computeSelectedCategories(unselected,this.annotations);
       let unsa = this.computeSelectedAnnotations(unselected,unSc);
-      let unScOld = this.computeSelectedCategories(oldUnselected);
+      let unScOld = this.computeSelectedCategories(oldUnselected,this.oldAnnotations);
       let unSaOld = this.computeSelectedAnnotations(oldUnselected,unScOld);
       if (!isEqual(unsa.map(this.getId), unSaOld.map(this.getId))) {
         this.$emit("update:negativeAnnotations", sa);
@@ -409,6 +410,10 @@ export default {
         this.$emit("update:negativeCategories", sc);
       }
 
+      // assign old selection here instead of the main watcher since it can skip steps while
+      // waiting for debounce otherise
+      this.oldSelection = Object.assign({},newVal);
+      this.oldAnnotations = this.annotations;
 
       let allAnnots = this.rankedAnnotations.reduce((acc,annot)=>(acc.concat(annot.children)),[])
       let selectedURIs = marked.map(x => x.split(SEPARATOR)[1])
@@ -422,6 +427,21 @@ export default {
     },1000)
   },
   watch: {
+    selectedAnnotations(newVal){
+      let annot_ids = newVal.map(term => this.getId(term))
+      annot_ids.
+          map(id => {
+            this.$set(this.selection,id,1)
+            this.markParent(id)
+      })
+      let selected =  Object.keys(this.selection).filter((x,i)=>( Object.values(this.selection)[i] === 1  ))
+      selected.filter(s=>!annot_ids.includes(s))
+          .map(s=>{
+            this.$set(this.selection,s,0)
+            this.markParent(s)
+          })
+
+    },
     search(newVal) {
       if (newVal) {
         if (this.previouslyOpen === null) {
@@ -434,10 +454,6 @@ export default {
         this.previouslyOpen = null;
       }
     },
-    value(newVal) {
-      // make sure that newVal is an option
-      this.selectedValues = newVal.map(term => this.getId(term));
-    },
     selection:{
       handler:function(newVal) {
         if (!isEqual(newVal, this.oldSelection)) {
diff --git a/src/components/SearchSettings.vue b/src/components/SearchSettings.vue
index 531a219..12cdd58 100644
--- a/src/components/SearchSettings.vue
+++ b/src/components/SearchSettings.vue
@@ -60,7 +60,7 @@
                 v-show="false"
                 class="mb-1"/>
         <AnnotationSelector
-                v-model="searchSettings.annotations"
+                :selectedAnnotations.sync="searchSettings.annotations"
                 :negativeAnnotations.sync="searchSettings.negativeAnnotations"
                 :negativeCategories.sync="searchSettings.negativeCategories"
                 :annotations="annotations"

From b53df6c36da8e41acd61279a0f83c07696578f66 Mon Sep 17 00:00:00 2001
From: OganM <ogan.mancarcii@gmail.com>
Date: Tue, 2 Sep 2025 21:35:15 -0700
Subject: [PATCH 06/12] split root selection from term selection to remain
 consistent between annotation updates

---
 src/components/AnnotationSelector.vue | 54 ++++++++++++++++++++++++---
 1 file changed, 48 insertions(+), 6 deletions(-)

diff --git a/src/components/AnnotationSelector.vue b/src/components/AnnotationSelector.vue
index 76d1771..e15f302 100644
--- a/src/components/AnnotationSelector.vue
+++ b/src/components/AnnotationSelector.vue
@@ -112,6 +112,7 @@ export default {
        */
       search: null,
       selection:{},
+      rootSelection: {},
       oldSelection:{},
       oldAnnotations:[],
       /**
@@ -262,13 +263,48 @@ export default {
       this.rankedAnnotations
           .filter(annot => {return annot.id === id})
           .map(annot => {
+            this.$set(this.rootSelection,annot.id,next)
             annot.children.map(children => {
               this.$set(this.selection, children.id, next);
             })
           })
 
       // if a child id is clicked, check it's parent to figure out how to mark it
-      this.markParent(id)
+      let split_id = id.split("|")
+      if(split_id.length > 1){
+        if(split_id.length > 1){
+          let selected =  Object.keys(this.selection).filter((x,i)=>( Object.values(this.selection)[i] === 1  ))
+          let unselected =  Object.keys(this.selection).filter((x,i)=>( Object.values(this.selection)[i] === -1  ))
+
+          let category = split_id[0]
+          let child_ids = this.rankedAnnotations
+              .filter(annot => {return annot.id === category})[0]
+              .children.map(child=>child.id)
+
+          // all/no children are selected are states 1,-1
+          // some children selected/unselected are states 2,3
+          // a mix of selected/unselected is state 4
+          if (child_ids.every(c=>selected.includes(c))){
+            this.$set(this.selection, category, 1);
+            this.$set(this.rootSelection,category,1);
+          } else if (child_ids.every(c=>unselected.includes(c))){
+            this.$set(this.selection, category, -1);
+            this.$set(this.rootSelection,category,-1);
+          } else if (child_ids.some(c=>selected.includes(c)) && !child_ids.some(c=>unselected.includes(c))){
+            this.$set(this.selection, category, 2);
+            this.$set(this.rootSelection,category,0);
+          } else if(child_ids.some(c=>unselected.includes(c)) && !child_ids.some(c=>selected.includes(c))) {
+            this.$set(this.selection, category, 3);
+            this.$set(this.rootSelection,category,0);
+          } else if(child_ids.some(c=>unselected.includes(c)) && child_ids.some(c=>selected.includes(c))){
+            this.$set(this.selection, category, 4);
+            this.$set(this.rootSelection,category,0);
+          } else{
+            this.$set(this.selection, category, 0);
+            this.$set(this.rootSelection,category,0);
+          }
+        }
+      }
     },
     iconForState(state){
       let box_class = "v-icon notranslate v-treeview-node__checkbox v-icon--link theme--light mdi "
@@ -429,17 +465,23 @@ export default {
   watch: {
     selectedAnnotations(newVal){
       let annot_ids = newVal.map(term => this.getId(term))
-      annot_ids.
-          map(id => {
+      annot_ids
+          .map(id => {
             this.$set(this.selection,id,1)
-            this.markParent(id)
-      })
+          })
+      //annot_ids
+      //    .map(id => {
+      //      this.markParent(id)
+      //    })
       let selected =  Object.keys(this.selection).filter((x,i)=>( Object.values(this.selection)[i] === 1  ))
       selected.filter(s=>!annot_ids.includes(s))
           .map(s=>{
             this.$set(this.selection,s,0)
-            this.markParent(s)
           })
+      //selected.filter(s=>!annot_ids.includes(s))
+      //    .map(s=>{
+      //      this.markParent(s)
+      //    })
 
     },
     search(newVal) {

From 6d019d4ae2e2f468513450a3e79c6080d29661d8 Mon Sep 17 00:00:00 2001
From: OganM <ogan.mancarcii@gmail.com>
Date: Wed, 3 Sep 2025 15:56:55 -0700
Subject: [PATCH 07/12] fix to root selection and additional annotations

---
 src/components/AnnotationSelector.vue | 85 +++++++++++++++++++--------
 src/components/SearchSettings.vue     |  9 +--
 2 files changed, 61 insertions(+), 33 deletions(-)

diff --git a/src/components/AnnotationSelector.vue b/src/components/AnnotationSelector.vue
index e15f302..c67bf37 100644
--- a/src/components/AnnotationSelector.vue
+++ b/src/components/AnnotationSelector.vue
@@ -90,6 +90,7 @@ export default {
     negativeAnnotations: Array,
     selectedCategories:Array,
     negativeCategories:Array,
+    additionalAnnotations:Array,
     /**
      * Annotations to be displayed in this selector.
      */
@@ -113,6 +114,7 @@ export default {
       search: null,
       selection:{},
       rootSelection: {},
+      oldRoots: {},
       oldSelection:{},
       oldAnnotations:[],
       /**
@@ -268,6 +270,10 @@ export default {
               this.$set(this.selection, children.id, next);
             })
           })
+      // clear stray terms in selection
+      Object.keys(this.selection)
+          .filter(k=>k.split("|")[0] === id)
+          .map(k=>this.$set(this.selection,k,next))
 
       // if a child id is clicked, check it's parent to figure out how to mark it
       let split_id = id.split("|")
@@ -414,6 +420,7 @@ export default {
       return highlightedWords.join(" ");
     },
     dispatchValues:debounce(function(newVal,oldVal){
+
       let marked =   Object.keys(newVal).filter((x,i)=>( Object.values(newVal)[i] !== 0  ))
       let selected =  Object.keys(newVal).filter((x,i)=>( Object.values(newVal)[i] === 1  ))
       let unselected = Object.keys(newVal).filter((x,i)=>( Object.values(newVal)[i] === -1  ))
@@ -422,11 +429,16 @@ export default {
       let oldSelected =  Object.keys(oldVal).filter((x,i)=>( Object.values(oldVal)[i] === 1  ))
       let oldUnselected = Object.keys(oldVal).filter((x,i)=>( Object.values(oldVal)[i] === -1  ))
 
+      let selectedRoots = Object.keys(this.rootSelection).filter((x,i)=>( Object.values(this.rootSelection)[i] === 1  ))
+      let unselectedRoots = Object.keys(this.rootSelection).filter((x,i)=>( Object.values(this.rootSelection)[i] === -1  ))
+
+      let oldSelectedRoots = Object.keys(this.oldRoots).filter((x,i)=>( Object.values(this.oldRoots)[i] === 1  ))
+      let oldUnselectedRoots = Object.keys(this.oldRoots).filter((x,i)=>( Object.values(this.oldRoots)[i] === -1  ))
 
 
-      let sc = this.computeSelectedCategories(selected,this.annotations);
+      let sc =  this.annotations.filter(annot=>selectedRoots.includes(annot.classUri))
       let sa = this.computeSelectedAnnotations(selected, sc);
-      let scOld = this.computeSelectedCategories(oldSelected,this.oldAnnotations);
+      let scOld = this.annotations.filter(annot=>oldSelectedRoots.includes(annot.classUri))
       let saOld = this.computeSelectedAnnotations(oldSelected, scOld);
       if (!isEqual(sa.map(this.getId), saOld.map(this.getId))) {
         this.$emit("update:selectedAnnotations", sa);
@@ -434,10 +446,9 @@ export default {
       if (!isEqual(sc.map(getCategoryId), scOld.map(getCategoryId))) {
         this.$emit("update:selectedCategories", sc);
       }
-
-      let unSc = this.computeSelectedCategories(unselected,this.annotations);
+      let unSc = this.annotations.filter(annot=>unselectedRoots.includes(annot.classUri))
       let unsa = this.computeSelectedAnnotations(unselected,unSc);
-      let unScOld = this.computeSelectedCategories(oldUnselected,this.oldAnnotations);
+      let unScOld = this.annotations.filter(annot=>oldUnselectedRoots.includes(annot.classUri))
       let unSaOld = this.computeSelectedAnnotations(oldUnselected,unScOld);
       if (!isEqual(unsa.map(this.getId), unSaOld.map(this.getId))) {
         this.$emit("update:negativeAnnotations", sa);
@@ -450,10 +461,10 @@ export default {
       // waiting for debounce otherise
       this.oldSelection = Object.assign({},newVal);
       this.oldAnnotations = this.annotations;
+      this.oldRoots = Object.assign({},this.rootSelection);
 
       let allAnnots = this.rankedAnnotations.reduce((acc,annot)=>(acc.concat(annot.children)),[])
       let selectedURIs = marked.map(x => x.split(SEPARATOR)[1])
-
       this.dispatchedSelectedAnnotations =  allAnnots
           .filter(annot=>selectedURIs.includes(annot.termUri))
           .reduce((acc,annot)=>{
@@ -463,25 +474,49 @@ export default {
     },1000)
   },
   watch: {
-    selectedAnnotations(newVal){
-      let annot_ids = newVal.map(term => this.getId(term))
-      annot_ids
-          .map(id => {
-            this.$set(this.selection,id,1)
-          })
-      //annot_ids
-      //    .map(id => {
-      //      this.markParent(id)
-      //    })
-      let selected =  Object.keys(this.selection).filter((x,i)=>( Object.values(this.selection)[i] === 1  ))
-      selected.filter(s=>!annot_ids.includes(s))
-          .map(s=>{
-            this.$set(this.selection,s,0)
-          })
-      //selected.filter(s=>!annot_ids.includes(s))
-      //    .map(s=>{
-      //      this.markParent(s)
-      //    })
+    annotations(newVal,oldVal){
+      if (!isEqual(newVal,oldVal)) {
+        let markedRoots = Object.keys(this.rootSelection).filter((x,i)=>( Object.values(this.rootSelection)[i] === 1 || Object.values(this.rootSelection)[i] === -1  ))
+        let selectedRoots = Object.keys(this.rootSelection).filter((x,i)=>( Object.values(this.rootSelection)[i] === 1  ))
+        let unselectedRoots = Object.keys(this.rootSelection).filter((x,i)=>( Object.values(this.rootSelection)[i] === -1  ))
+
+        // clear previous dispatched list for root selections since we don't want to accumulate terms for no reason
+        let dispatchAnnots = Object.assign({},this.dispatchedSelectedAnnotations)
+        Object.values(dispatchAnnots)
+            .filter((annot=>markedRoots.includes(annot.classUri)))
+            .map(annot=>this.$delete(this.dispatchedSelectedAnnotations,annot.id))
+
+
+        // if a root is selected, make sure any new additions are selected as well
+        newVal
+            .filter(annot=>selectedRoots.includes(annot.classUri))
+            .map(annot=>{
+              annot.children.map(child=>{
+                this.$set(this.selection,this.getId(child),1)
+              })
+            })
+        newVal
+            .filter(annot=>unselectedRoots.includes(annot.classUri))
+            .map(annot=>{
+              annot.children.map(child=>{
+                this.$set(this.selection,this.getId(child),-1)
+              })
+            })
+
+      }
+    },
+    additionalAnnotations(newVal,oldVal){
+      let newIds = newVal.map(this.getId)
+      let oldIds = oldVal.map(this.getId)
+      let removedIds = oldIds.filter(id=>!newIds.includes(id))
+
+      newIds.map(id=>{
+        this.$set(this.selection,id,1)
+      })
+
+      removedIds.map(id=>{
+        this.$set(this.selection,id,0)
+      })
 
     },
     search(newVal) {
diff --git a/src/components/SearchSettings.vue b/src/components/SearchSettings.vue
index 12cdd58..5c8da6a 100644
--- a/src/components/SearchSettings.vue
+++ b/src/components/SearchSettings.vue
@@ -66,6 +66,7 @@
                 :annotations="annotations"
                 :loading="annotationLoading"
                 :disabled="annotationDisabled"
+                :additionalAnnotations.sync="additionalAnnotations"
                 :selectedCategories.sync="searchSettings.categories"/>
         <div :class="debug ? '' : 'd-lg-none'">
             <div style="margin-bottom: 59px;"></div>
@@ -175,14 +176,6 @@ export default {
         this.$emit("input", newValue);
       },
       deep: true
-    },
-    additionalAnnotations: function(newVal,oldVal){
-      // remove annotations that are unselected
-      let newUris = newVal.map(annot=>annot.termUri)
-      let oldUris = oldVal.map(annot=>annot.termUri)
-      let removedUris = oldUris.filter(uri=>!newUris.includes(uri))
-      let annots = this.searchSettings.annotations.filter(annot =>!removedUris.includes(annot.termUri))
-      this.searchSettings.annotations = Object.assign([],annots,newVal)
     }
   }
 };

From d6e1ee6864e91faa886e106e4d62ea371306bebe Mon Sep 17 00:00:00 2001
From: OganM <ogan.mancarcii@gmail.com>
Date: Wed, 3 Sep 2025 18:52:02 -0700
Subject: [PATCH 08/12] add negation terms to filter

---
 src/lib/filter.js | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/src/lib/filter.js b/src/lib/filter.js
index db96297..56684c2 100644
--- a/src/lib/filter.js
+++ b/src/lib/filter.js
@@ -108,6 +108,50 @@ export function generateFilter(searchSettings) {
       filter.push(f);
     }
   }
+  if (searchSettings.negativeCategories.length>0){
+    let negativeCategories = searchSettings.negativeCategories
+    if (negativeCategories.length > MAX_URIS_IN_CLAUSE) {
+      console.warn(`Too many negative categories (${negativeCategories.length}) in clause, will only retain the first ${MAX_URIS_IN_CLAUSE} categories.`);
+      negativeCategories = negativeCategories.slice(0, MAX_URIS_IN_CLAUSE);
+    }
+    let idCategories = negativeCategories.filter(cat=>cat.classUri)
+    let nameCategories = negativeCategories
+        .filter(cat=>cat.classUri === null)
+        .filter(cat=>cat.className)
+    let idString = idCategories.map(cat=>cat.classUri).join(',')
+    let nameString =  nameCategories.map(cat=>cat.className).join(',')
+
+    if (idString){
+      filter.push( ["none(allCharacteristics.categoryUri in ("+ idString +"))"])
+    }
+    if(nameString){
+      filter.push( ["none(allCharacteristics.category in ("+ nameString +"))"])
+    }
+  }
+
+  if (searchSettings.negativeAnnotations.length>0){
+    let negativeAnnots = searchSettings.negativeAnnotations
+    if (negativeAnnots.length > MAX_URIS_IN_CLAUSE) {
+      console.warn(`Too many negative annotations (${negativeAnnots.length}) in clause, will only retain the first ${MAX_URIS_IN_CLAUSE} annotations.`);
+      negativeAnnots = negativeAnnots.slice(0, MAX_URIS_IN_CLAUSE);
+    }
+
+    let idAnnots = negativeAnnots.filter(annot=>annot.termUri)
+    let nameAnnots = negativeAnnots
+        .filter(annot=>annot.termUri === null)
+        .filter(annot=>annot.termName)
+
+    let idString = idAnnots.map(cat=>cat.termUri).join(',')
+    let nameString = nameAnnots.map(cat=>cat.termName).join(',')
+
+    if(idString){
+      filter.push(["none(allCharacteristics.valueUri in (" + idString + "))"])
+    }
+    if(nameString){
+      filter.push(["none(allCharacteristics.value in (" + nameString + "))"])
+    }
+  }
+
   let numberOfClauses = sumBy(filter, f => f.length);
   if (numberOfClauses > 100) {
     console.error("Too many clauses (" + numberOfClauses + ") in filter.");

From 46adba34c926f631243fa9b48e65a1113c375059 Mon Sep 17 00:00:00 2001
From: OganM <ogan.mancarcii@gmail.com>
Date: Wed, 3 Sep 2025 18:52:42 -0700
Subject: [PATCH 09/12] fixes to regressions and ensure categories do not
 disappear

---
 src/components/AnnotationSelector.vue | 69 ++++++++++++++++++++-------
 src/components/SearchSettings.vue     |  5 +-
 2 files changed, 56 insertions(+), 18 deletions(-)

diff --git a/src/components/AnnotationSelector.vue b/src/components/AnnotationSelector.vue
index c67bf37..b899f0a 100644
--- a/src/components/AnnotationSelector.vue
+++ b/src/components/AnnotationSelector.vue
@@ -11,7 +11,7 @@
                 Counts in this section may be approximate. For more explanation see the help.
             </v-tooltip>
             <v-spacer></v-spacer>
-            <v-btn v-if="Object.keys(this.selection).filter((x,i)=>( Object.values(this.selection)[i] !== 0  )).length > 0" @click="selection = {}" small text color="primary"
+            <v-btn v-if="Object.keys(this.selection).filter((x,i)=>( Object.values(this.selection)[i] !== 0  )).length > 0" @click="clearSelection()" small text color="primary"
                    :disabled="disabled">
                 Clear Selection
             </v-btn>
@@ -117,6 +117,7 @@ export default {
       oldRoots: {},
       oldSelection:{},
       oldAnnotations:[],
+      annotationComplete:{},
       /**
        * A list of opened categories.
        */
@@ -145,14 +146,15 @@ export default {
      * @returns {(*&{isCategory: boolean, children: *, id: *})[]}
      */
     rankedAnnotations() {
-      return this.annotations
+      return Object.values(this.annotationComplete)
         .map((a,i) => {
           let that = this;
           /**
            * Recursively construct a tree of annotations for a given category.
            */
+
           let relevantSelectedAnnots = Object.values(that.dispatchedSelectedAnnotations)
-              .filter(annot=> annot.classUri === that.annotations[i].classUri)
+              .filter(annot=> annot.classUri === Object.values(that.annotationComplete)[i].classUri)
           let selectedUris = relevantSelectedAnnots.map(annot => annot.termUri);
 
           function getChildren(a) {
@@ -161,7 +163,7 @@ export default {
                 ...c,
                 id: that.getId(c),
                 isCategory: false,
-                children: c.children && getChildren(c)
+                children: c.children ? c.children && getChildren(c) : null
               };
             })
             let unrankedUris = unrankedAnnots.map(annot => annot.termUri)
@@ -188,7 +190,7 @@ export default {
             ...a,
             id: getCategoryId(a),
             isCategory: true,
-            children: getChildren(a)
+            children: Object.keys(a.children).length >0 ? getChildren(a) : null
           };
         })
         .sort((a, b) => {
@@ -256,6 +258,11 @@ export default {
         }
       }
     },
+    clearSelection(){
+      this.dispatchedSelectedAnnotations={};
+      this.selection = {};
+      this.rootSelection={}
+    },
     toggleSelection(id){
       let current = this.selection[id] || 0;
       let next = current === 0 ? 1: current === 1 ? -1 : current === -1 ? 0: current === 2 ? 1 : current === 3 ? -1 : current === 4 ? 1 : 0
@@ -266,9 +273,11 @@ export default {
           .filter(annot => {return annot.id === id})
           .map(annot => {
             this.$set(this.rootSelection,annot.id,next)
-            annot.children.map(children => {
-              this.$set(this.selection, children.id, next);
-            })
+            if (annot.children){
+              annot.children.map(children => {
+                this.$set(this.selection, children.id, next);
+              })
+            }
           })
       // clear stray terms in selection
       Object.keys(this.selection)
@@ -420,7 +429,6 @@ export default {
       return highlightedWords.join(" ");
     },
     dispatchValues:debounce(function(newVal,oldVal){
-
       let marked =   Object.keys(newVal).filter((x,i)=>( Object.values(newVal)[i] !== 0  ))
       let selected =  Object.keys(newVal).filter((x,i)=>( Object.values(newVal)[i] === 1  ))
       let unselected = Object.keys(newVal).filter((x,i)=>( Object.values(newVal)[i] === -1  ))
@@ -435,7 +443,6 @@ export default {
       let oldSelectedRoots = Object.keys(this.oldRoots).filter((x,i)=>( Object.values(this.oldRoots)[i] === 1  ))
       let oldUnselectedRoots = Object.keys(this.oldRoots).filter((x,i)=>( Object.values(this.oldRoots)[i] === -1  ))
 
-
       let sc =  this.annotations.filter(annot=>selectedRoots.includes(annot.classUri))
       let sa = this.computeSelectedAnnotations(selected, sc);
       let scOld = this.annotations.filter(annot=>oldSelectedRoots.includes(annot.classUri))
@@ -443,7 +450,7 @@ export default {
       if (!isEqual(sa.map(this.getId), saOld.map(this.getId))) {
         this.$emit("update:selectedAnnotations", sa);
       }
-      if (!isEqual(sc.map(getCategoryId), scOld.map(getCategoryId))) {
+      if (!isEqual(selectedRoots, oldSelectedRoots)) {
         this.$emit("update:selectedCategories", sc);
       }
       let unSc = this.annotations.filter(annot=>unselectedRoots.includes(annot.classUri))
@@ -451,10 +458,10 @@ export default {
       let unScOld = this.annotations.filter(annot=>oldUnselectedRoots.includes(annot.classUri))
       let unSaOld = this.computeSelectedAnnotations(oldUnselected,unScOld);
       if (!isEqual(unsa.map(this.getId), unSaOld.map(this.getId))) {
-        this.$emit("update:negativeAnnotations", sa);
+        this.$emit("update:negativeAnnotations", unsa);
       }
-      if (!isEqual(unSc.map(getCategoryId), unScOld.map(getCategoryId))) {
-        this.$emit("update:negativeCategories", sc);
+      if (!isEqual(unselectedRoots, oldUnselectedRoots)) {
+        this.$emit("update:negativeCategories", unSc);
       }
 
       // assign old selection here instead of the main watcher since it can skip steps while
@@ -464,9 +471,10 @@ export default {
       this.oldRoots = Object.assign({},this.rootSelection);
 
       let allAnnots = this.rankedAnnotations.reduce((acc,annot)=>(acc.concat(annot.children)),[])
-      let selectedURIs = marked.map(x => x.split(SEPARATOR)[1])
+      let selectedIds = marked.filter(x => x.split(SEPARATOR).length>1)
       this.dispatchedSelectedAnnotations =  allAnnots
-          .filter(annot=>selectedURIs.includes(annot.termUri))
+          .filter(annot=>annot)
+          .filter(annot=>selectedIds.includes(annot.id))
           .reduce((acc,annot)=>{
             acc[annot.classUri+"|"+annot.termUri] = annot
             return acc
@@ -503,6 +511,35 @@ export default {
               })
             })
 
+        // add all terms to an annotationComplete object to keep track of missing parents,
+        // set children and counts to zero when a parent goes missing
+        // populate annotationComplete with missing IDs
+        newVal.map(annot=>
+            this.$set(this.annotationComplete,annot.classUri,annot)
+        )
+        let currentCats = newVal.map(annot=>annot.classUri)
+        Object
+           .keys(this.annotationComplete)
+           .filter(key=>!currentCats.includes(key))
+           .map(key=>{
+             let annot = this.annotationComplete[key]
+             annot.children = []
+             annot.numberOfExpressionExperiments= 0
+           })
+
+
+
+
+        let newClasses = newVal.map(annot=>annot.classUri)
+        let missingClasses = oldVal
+            .filter(annot => !newClasses.includes(annot.classUri))
+            .map(annot=>{
+              annot.children = {}
+              annot.numberOfExpressionExperiments = 0
+              return annot
+            })
+        this.annotations.concat(missingClasses)
+
       }
     },
     additionalAnnotations(newVal,oldVal){
diff --git a/src/components/SearchSettings.vue b/src/components/SearchSettings.vue
index 5c8da6a..eed0e93 100644
--- a/src/components/SearchSettings.vue
+++ b/src/components/SearchSettings.vue
@@ -60,6 +60,7 @@
                 v-show="false"
                 class="mb-1"/>
         <AnnotationSelector
+                ref = "annotationSelector"
                 :selectedAnnotations.sync="searchSettings.annotations"
                 :negativeAnnotations.sync="searchSettings.negativeAnnotations"
                 :negativeCategories.sync="searchSettings.negativeCategories"
@@ -156,10 +157,10 @@ export default {
     },
     clearAllSelections() {
       this.searchSettings.selectedTech = [];
-      this.searchSettings.annotations = [];
-      this.searchSettings.taxon = []; 
+      this.searchSettings.taxon = [];
       this.searchSettings.query = undefined;
       this.currentQuery = undefined;
+      this.$refs.annotationSelector.clearSelection();
     },
     isMobile() {
       if(/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {

From 33cb6ebe78cc9ad0ab814657776ad69499fa30b1 Mon Sep 17 00:00:00 2001
From: OganM <ogan.mancarcii@gmail.com>
Date: Thu, 4 Sep 2025 14:04:54 -0700
Subject: [PATCH 10/12] mark parents of terms added via additionalAnnotations
 correctly

---
 src/components/AnnotationSelector.vue | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/components/AnnotationSelector.vue b/src/components/AnnotationSelector.vue
index b899f0a..052652e 100644
--- a/src/components/AnnotationSelector.vue
+++ b/src/components/AnnotationSelector.vue
@@ -228,6 +228,7 @@ export default {
   methods: {
     formatNumber,
     markParent(id){
+      // currently only used for additionalAnnotations to update parents accordingly
       let split_id = id.split("|")
       if(split_id.length > 1){
         if(split_id.length > 1){
@@ -244,16 +245,22 @@ export default {
           // a mix of selected/unselected is state 4
           if (child_ids.every(c=>selected.includes(c))){
             this.$set(this.selection, category, 1);
+            this.$set(this.rootSelection,category,1)
           } else if (child_ids.every(c=>unselected.includes(c))){
             this.$set(this.selection, category, -1);
+            this.$set(this.rootSelection,category,-1)
           } else if (child_ids.some(c=>selected.includes(c)) && !child_ids.some(c=>unselected.includes(c))){
             this.$set(this.selection, category, 2);
+            this.$set(this.rootSelection,category,0)
           } else if(child_ids.some(c=>unselected.includes(c)) && !child_ids.some(c=>selected.includes(c))) {
             this.$set(this.selection, category, 3);
+            this.$set(this.rootSelection,category,0)
           } else if(child_ids.some(c=>unselected.includes(c)) && child_ids.some(c=>selected.includes(c))){
             this.$set(this.selection, category, 4);
+            this.$set(this.rootSelection,category,0)
           } else{
             this.$set(this.selection, category, 0);
+            this.$set(this.rootSelection,category,0)
           }
         }
       }
@@ -549,10 +556,12 @@ export default {
 
       newIds.map(id=>{
         this.$set(this.selection,id,1)
+        this.markParent(id)
       })
 
       removedIds.map(id=>{
         this.$set(this.selection,id,0)
+        this.markParent(id)
       })
 
     },

From 359697e32a1e387c6a2b69e8e916368bd35e4388 Mon Sep 17 00:00:00 2001
From: OganM <ogan.mancarcii@gmail.com>
Date: Thu, 4 Sep 2025 18:16:02 -0700
Subject: [PATCH 11/12] fix regression to datasetPreview term selection

---
 src/components/AnnotationSelector.vue |  9 +++++++--
 src/components/SearchSettings.vue     |  6 +++++-
 src/views/Browser.vue                 | 26 +++++---------------------
 3 files changed, 17 insertions(+), 24 deletions(-)

diff --git a/src/components/AnnotationSelector.vue b/src/components/AnnotationSelector.vue
index 052652e..5c1d070 100644
--- a/src/components/AnnotationSelector.vue
+++ b/src/components/AnnotationSelector.vue
@@ -270,9 +270,14 @@ export default {
       this.selection = {};
       this.rootSelection={}
     },
-    toggleSelection(id){
+    toggleSelection(id,allowNegative = true){
       let current = this.selection[id] || 0;
-      let next = current === 0 ? 1: current === 1 ? -1 : current === -1 ? 0: current === 2 ? 1 : current === 3 ? -1 : current === 4 ? 1 : 0
+      let next = 0
+      if (allowNegative){
+        next = current === 0 ? 1: current === 1 ? -1 : current === -1 ? 0: current === 2 ? 1 : current === 3 ? -1 : current === 4 ? 1 : 0
+      } else {
+        next = current === 0 ? 1: 0
+      }
       this.$set(this.selection, id, next);
 
       // if a parent id is clicked, apply the change to all children
diff --git a/src/components/SearchSettings.vue b/src/components/SearchSettings.vue
index eed0e93..bd1f4eb 100644
--- a/src/components/SearchSettings.vue
+++ b/src/components/SearchSettings.vue
@@ -116,7 +116,8 @@ export default {
     annotationLoading: Boolean,
     platformLoading: Boolean,
     taxaLoading: Boolean,
-    totalNumberOfExpressionExperiments: Number
+    totalNumberOfExpressionExperiments: Number,
+    browserAnnotations:[Array]
   },
   emits: ["input"],
   data() {
@@ -148,6 +149,9 @@ export default {
     })
   },
   methods: {
+    toggleTerm(term){
+      this.$refs.annotationSelector.toggleSelection(this.$refs.annotationSelector.getId(term),false)
+    },
     setQuery(){
       this.searchSettings.query = this.searchSettings.currentQuery
     },
diff --git a/src/views/Browser.vue b/src/views/Browser.vue
index 35c2d35..44313eb 100644
--- a/src/views/Browser.vue
+++ b/src/views/Browser.vue
@@ -2,7 +2,9 @@
     <v-layout>
         <v-navigation-drawer v-model="drawer" app width="400">
             <SearchSettings v-model="searchSettings"
+                            ref= "searchSettings"
                             class="py-3 px-3"
+                            :browserAnnotations="browserAnnotations"
                             :taxon-disabled="loadingTaxa"
                             :query-disabled="loadingDatasets"
                             :annotation-disabled="loadingAnnotation"
@@ -106,8 +108,8 @@
                                         :selected-categories="searchSettings.categories"
                                         :selected-annotations="searchSettings.annotations"
                                         :available-annotations="datasetsAnnotations"
-                                        @annotation-selected="selectTerm"
-                                        @annotation-unselected="unselectTerm"/>
+                                        @annotation-selected="$refs.searchSettings.toggleTerm"
+                                        @annotation-unselected="$refs.searchSettings.toggleTerm"/>
                     </td>
                 </template>
                 <template v-slot:item.isSingleCell="{ item }">
@@ -254,6 +256,7 @@ export default {
       tableWidth: "",
       inferredTermLabelsByCategory:{},
       hasDifferentialExpression:{},
+      browserAnnotations:[],
       /**
      * Basically a browse with a debounce when the user is actively typing a query.
      * @return {Promise|undefined} initially undefined, then a promise once the function has been invoked at least once
@@ -701,25 +704,6 @@ export default {
       return item.characteristics.some((characteristic)=>characteristic.valueUri === "http://www.ebi.ac.uk/efo/EFO_0008913")
     },
     ...mapMutations(["setTitle", "setFilterSummary", "setFilterDescription", "setLastError"]),
-    selectTerm(previewTerm) {
-      this.searchSettings.annotations.push({
-        classUri: previewTerm.classUri,
-        className: previewTerm.className,
-        termUri: previewTerm.termUri,
-        termName: previewTerm.termName
-      });
-    },
-    unselectTerm(previewTerm) {
-      let categoryId = getCategoryId(previewTerm);
-      let termId = getTermId(previewTerm);
-      for (let [i, a] of this.searchSettings.annotations.entries()) {
-        if (getCategoryId(a) === categoryId && getTermId(a) === termId) {
-          this.searchSettings.annotations.splice(i, 1);
-          return;
-        }
-      }
-      console.warn(`${previewTerm} is not selected and thus cannot be unselected.`);
-    },
     ...mapMutations(["setTitle", "setFilterSummary", "setFilterDescription"]),
     toggleAllDatasetsExpanded() {
       // check whether all datasets are expanded

From 46c60f8376302c3de536f004a5e8d1e0eb87e68b Mon Sep 17 00:00:00 2001
From: OganM <ogan.mancarcii@gmail.com>
Date: Thu, 4 Sep 2025 18:32:55 -0700
Subject: [PATCH 12/12] fix incomplete parents appearing as leaves in non-debug
 mode

---
 src/components/AnnotationSelector.vue | 31 +++++++++------------------
 1 file changed, 10 insertions(+), 21 deletions(-)

diff --git a/src/components/AnnotationSelector.vue b/src/components/AnnotationSelector.vue
index 5c1d070..0c7eae1 100644
--- a/src/components/AnnotationSelector.vue
+++ b/src/components/AnnotationSelector.vue
@@ -146,7 +146,9 @@ export default {
      * @returns {(*&{isCategory: boolean, children: *, id: *})[]}
      */
     rankedAnnotations() {
-      return Object.values(this.annotationComplete)
+      let annots = this.debug ?  Object.assign({},this.annotationComplete): Object.assign({},this.annotations)
+
+      return Object.values(annots)
         .map((a,i) => {
           let that = this;
           /**
@@ -154,7 +156,7 @@ export default {
            */
 
           let relevantSelectedAnnots = Object.values(that.dispatchedSelectedAnnotations)
-              .filter(annot=> annot.classUri === Object.values(that.annotationComplete)[i].classUri)
+              .filter(annot=> annot.classUri === Object.values(annots)[i].classUri)
           let selectedUris = relevantSelectedAnnots.map(annot => annot.termUri);
 
           function getChildren(a) {
@@ -531,26 +533,13 @@ export default {
         )
         let currentCats = newVal.map(annot=>annot.classUri)
         Object
-           .keys(this.annotationComplete)
-           .filter(key=>!currentCats.includes(key))
-           .map(key=>{
-             let annot = this.annotationComplete[key]
-             annot.children = []
-             annot.numberOfExpressionExperiments= 0
-           })
-
-
-
-
-        let newClasses = newVal.map(annot=>annot.classUri)
-        let missingClasses = oldVal
-            .filter(annot => !newClasses.includes(annot.classUri))
-            .map(annot=>{
-              annot.children = {}
-              annot.numberOfExpressionExperiments = 0
-              return annot
+            .keys(this.annotationComplete)
+            .filter(key=>!currentCats.includes(key))
+            .map(key=>{
+              let annot = this.annotationComplete[key]
+              annot.children = []
+              annot.numberOfExpressionExperiments= 0
             })
-        this.annotations.concat(missingClasses)
 
       }
     },