Fix individual blocks not being filtered correctly

src/main/frontend/components/block.cljs

@@ -1416,7 +1416,7 @@
      (when ref?
        (let [children (-> (db/get-block-immediate-children repo uuid)
                           db/sort-by-pos)
-             filtered-children (filtering/filter-blocks children config)]
+             filtered-children (filtering/filter-blocks children (:filter-state config))]
          (when (seq filtered-children)
            [:div.ref-children.ml-12
             (blocks-container filtered-children (assoc config
@@ -1925,15 +1925,15 @@
    (if (:group-by-page? config)
      [:div.flex.flex-col
       (for [[page blocks] blocks]
-        (let [page (db/entity (:db/id page))
-              filtered-blocks (filtering/filter-blocks blocks config)]
-          [:div.my-2 (cond-> {:key (str "page-" (:db/id page))}
-                       (:ref? config)
-                       (assoc :class "color-level px-7 py-2 rounded"))
-           (ui/foldable
-            (page-cp config page)
-            (blocks-container filtered-blocks config))]))]
-     (blocks-container blocks config))])
+        (if (not-empty blocks)
+          (let [page (db/entity (:db/id page))]
+            [:div.my-2 (cond-> {:key (str "page-" (:db/id page))}
+                         (:ref? config)
+                         (assoc :class "bg-base-2 px-7 py-2 rounded"))
+             (ui/foldable
+              (page-cp config page)
+              (blocks-container blocks config))])))]
+     (blocks-container blocks config))]))
 
 (comment
   ;; timestamps

src/main/frontend/components/reference.cljs

@@ -67,9 +67,9 @@
           scheduled-or-deadlines (if journal?
                                    (db/get-date-scheduled-or-deadlines (string/capitalize page-name))
                                    nil)
-          references (distinct (flatten (map filtering/get-block-references (flatten (map val ref-blocks)))))
+          references (remove #{page-name} (distinct (flatten (map filtering/get-nested-block-references (flatten (map val ref-blocks))))))
           filter-state (rum/react (page-handler/get-filter page-name))
-          filtered-ref-blocks (filter #(filtering/matches-filter (filtering/get-ref-block-references %) filter-state) ref-blocks)
+          filtered-ref-blocks (map #(filtering/filter-ref-block % filter-state) ref-blocks)
           n-ref (count ref-blocks)]
       (when (or (> n-ref 0)
                 (seq scheduled-or-deadlines))

src/main/frontend/filtering.cljs

@@ -4,26 +4,40 @@
             [frontend.db :as db]))
 
 (defn get-block-references
+  [block]
+  (map #(if (= (first %) "Tag") (second %) (second (:url (second %))))
+       (filter #(and (some (partial = (first %)) ["Tag" "Link"])
+                     (or (= (first %) "Tag")
+                         (= (first (:url (second %))) "Search")))
+               (:block/title block))))
+
+(defn get-nested-block-references
   [block]
   (let [repo (state/get-current-repo)
         children (-> (db/get-block-children-unsafe repo (:block/uuid block))
                      db/sort-by-pos)
-        blocks (conj children block)]
-    (flatten (map (fn [block]
-                    (map #(if (= (first %) "Tag") (second %) (second (:url (second %))))
-                         (filter #(and (some (partial = (first %)) ["Tag" "Link"])
-                                       (or (= (first %) "Tag")
-                                           (= (first (:url (second %))) "Search")))
-                                 (:block/title block)))) blocks))))
-
-(defn get-ref-block-references
-  [ref-block]
-  (conj (distinct (flatten (map get-block-references (val ref-block)))) (:page/original-name (key ref-block))))
+        child-refs (map get-nested-block-references children)
+        block-refs (get-block-references block)]
+    (flatten (concat child-refs block-refs))))
 
 (defn matches-filter
   [references filter-state]
   (every? #(= (util/in? (first %) references) (second %)) filter-state))
 
+(defn block-matches-filter
+  [block filter-state]
+  (let [repo (state/get-current-repo)
+        children (-> (db/get-block-children-unsafe repo (:block/uuid block))
+                     db/sort-by-pos)
+        block-matches (matches-filter (get-block-references block) filter-state)
+        child-matches (delay (some #(block-matches-filter % filter-state) children))]
+    (or block-matches @child-matches)))
+
 (defn filter-blocks
-  [blocks config]
-  (filter #(matches-filter (get-block-references %) (:filter-state config)) blocks))
+  [blocks filter-state]
+  (filter #(block-matches-filter % filter-state) blocks))
+
+(defn filter-ref-block
+  [ref-block filter-state]
+  (let [blocks-filtered (filterv #(block-matches-filter % filter-state) (val ref-block))]
+    (assoc ref-block 1 blocks-filtered)))