perf: lazy render references

deps/db/src/logseq/db/common/initial_data.cljs

@@ -162,14 +162,15 @@
     m))
 
 (defn- entity->map
-  [entity & {:keys [level]
+  [entity & {:keys [level properties]
              :or {level 0}}]
   (let [opts {:level (inc level)}
         f (if (> level 0)
             identity
             (fn [e]
               (keep (fn [[k v]]
-                      (when-not (contains? #{:block/path-refs} k)
+                      (when (and (not (contains? #{:block/path-refs} k))
+                                 (or (empty? properties) (properties k)))
                         (let [v' (cond
                                    (= k :block/parent)
                                    (:db/id v)
@@ -256,7 +257,7 @@
                                 (dissoc :block/tx-id :block/created-at :block/updated-at)
                                 entity->map))
                           children)))
-            block' (cond-> (entity->map block)
+            block' (cond-> (entity->map block {:properties (set properties)})
                      block-refs-count?
                      (assoc :block.temp/refs-count (get-block-refs-count db (:db/id block))))]
         (cond->

deps/db/src/logseq/db/common/view.cljs

@@ -414,88 +414,89 @@
   [db view-id {:keys [journals? _view-for-id view-feature-type group-by-property-ident input query-entity-ids filters sorting]
                :as opts}]
   ;; TODO: create a view for journals maybe?
-  (cond
-    journals?
-    (let [ids (->> (ldb/get-latest-journals db)
-                   (mapv :db/id))]
-      {:count (count ids)
-       :data ids})
-    :else
-    (let [view (d/entity db view-id)
-          group-by-property (:logseq.property.view/group-by-property view)
-          list-view? (= :logseq.property.view/type.list (:db/ident (:logseq.property.view/type view)))
-          group-by-property-ident (or (:db/ident group-by-property) group-by-property-ident)
-          group-by-closed-values? (some? (:property/closed-values group-by-property))
-          ref-property? (= (:db/valueType group-by-property) :db.type/ref)
-          filters (or (:logseq.property.table/filters view) filters)
-          feat-type (or view-feature-type (:logseq.property.view/feature-type view))
-          query? (= feat-type :query-result)
-          entities-result (if query?
-                            (keep #(d/entity db %) query-entity-ids)
-                            (get-view-entities db view-id opts))
-          entities (if (= feat-type :linked-references)
-                     (:ref-blocks entities-result)
-                     entities-result)
-          sorting (let [sorting* (:logseq.property.table/sorting view)]
-                    (if (or (= sorting* :logseq.property/empty-placeholder) (empty? sorting*))
-                      (or sorting [{:id :block/updated-at, :asc? false}])
-                      sorting*))
-          filtered-entities (if (or (seq filters) (not (string/blank? input)))
-                              (filter (fn [row] (row-matched? db row filters input)) entities)
-                              entities)
-          group-by-page? (= group-by-property-ident :block/page)
-          readable-property-value-or-ent
-          (fn readable-property-value-or-ent [ent]
-            (let [pvalue (get ent group-by-property-ident)]
-              (if (de/entity? pvalue)
-                (if (match-property-value-as-entity? pvalue group-by-property)
-                  pvalue
-                  (db-property/property-value-content pvalue))
-                pvalue)))
-          result (if group-by-property-ident
-                   (->> filtered-entities
-                        (group-by readable-property-value-or-ent)
-                        (seq)
-                        (sort-by (fn [[by-value _]]
-                                   (cond
-                                     group-by-page?
-                                     (:block/updated-at by-value)
-                                     group-by-closed-values?
-                                     (:block/order by-value)
-                                     ref-property?
-                                     (db-property/property-value-content by-value)
-                                     :else
-                                     by-value))
-                                 (if group-by-page? #(compare %2 %1) compare)))
-                   (sort-entities db sorting filtered-entities))
-          data' (if group-by-property-ident
-                  (map
-                   (fn [[by-value entities]]
-                     (let [by-value' (if (de/entity? by-value)
-                                       (select-keys by-value [:db/id :db/ident :block/uuid :block/title :block/name :logseq.property/value :logseq.property/icon :block/tags])
-                                       by-value)
-                           pages? (not (some :block/page entities))
-                           group (if (and list-view? (not pages?))
-                                   (let [parent-groups (->> entities
-                                                            (group-by :block/parent)
-                                                            (sort-by (fn [[parent _]] (:block/order parent))))]
-                                     (map
-                                      (fn [[_parent blocks]]
-                                        [(:block/uuid (first blocks))
-                                         (map (fn [b]
-                                                {:db/id (:db/id b)
-                                                 :block/parent (:block/uuid (:block/parent b))})
-                                              (ldb/sort-by-order blocks))])
-                                      parent-groups))
-                                   (->> (sort-entities db sorting entities)
-                                        (map :db/id)))]
-                       [by-value' group]))
-                   result)
-                  (map :db/id result))]
-      (cond->
-       {:count (count filtered-entities)
-        :data (distinct data')}
-        (= feat-type :linked-references)
-        (merge (select-keys entities-result [:ref-pages-count :ref-matched-children-ids]))
-        query?
-        (assoc :properties (get-query-properties entities-result))))))
+  (time
+   (cond
+     journals?
+     (let [ids (->> (ldb/get-latest-journals db)
+                    (mapv :db/id))]
+       {:count (count ids)
+        :data ids})
+     :else
+     (let [view (d/entity db view-id)
+           group-by-property (:logseq.property.view/group-by-property view)
+           list-view? (= :logseq.property.view/type.list (:db/ident (:logseq.property.view/type view)))
+           group-by-property-ident (or (:db/ident group-by-property) group-by-property-ident)
+           group-by-closed-values? (some? (:property/closed-values group-by-property))
+           ref-property? (= (:db/valueType group-by-property) :db.type/ref)
+           filters (or (:logseq.property.table/filters view) filters)
+           feat-type (or view-feature-type (:logseq.property.view/feature-type view))
+           query? (= feat-type :query-result)
+           entities-result (if query?
+                             (keep #(d/entity db %) query-entity-ids)
+                             (get-view-entities db view-id opts))
+           entities (if (= feat-type :linked-references)
+                      (:ref-blocks entities-result)
+                      entities-result)
+           sorting (let [sorting* (:logseq.property.table/sorting view)]
+                     (if (or (= sorting* :logseq.property/empty-placeholder) (empty? sorting*))
+                       (or sorting [{:id :block/updated-at, :asc? false}])
+                       sorting*))
+           filtered-entities (if (or (seq filters) (not (string/blank? input)))
+                               (filter (fn [row] (row-matched? db row filters input)) entities)
+                               entities)
+           group-by-page? (= group-by-property-ident :block/page)
+           readable-property-value-or-ent
+           (fn readable-property-value-or-ent [ent]
+             (let [pvalue (get ent group-by-property-ident)]
+               (if (de/entity? pvalue)
+                 (if (match-property-value-as-entity? pvalue group-by-property)
+                   pvalue
+                   (db-property/property-value-content pvalue))
+                 pvalue)))
+           result (if group-by-property-ident
+                    (->> filtered-entities
+                         (group-by readable-property-value-or-ent)
+                         (seq)
+                         (sort-by (fn [[by-value _]]
+                                    (cond
+                                      group-by-page?
+                                      (:block/updated-at by-value)
+                                      group-by-closed-values?
+                                      (:block/order by-value)
+                                      ref-property?
+                                      (db-property/property-value-content by-value)
+                                      :else
+                                      by-value))
+                                  (if group-by-page? #(compare %2 %1) compare)))
+                    (sort-entities db sorting filtered-entities))
+           data' (if group-by-property-ident
+                   (map
+                    (fn [[by-value entities]]
+                      (let [by-value' (if (de/entity? by-value)
+                                        (select-keys by-value [:db/id :db/ident :block/uuid :block/title :block/name :logseq.property/value :logseq.property/icon :block/tags])
+                                        by-value)
+                            pages? (not (some :block/page entities))
+                            group (if (and list-view? (not pages?))
+                                    (let [parent-groups (->> entities
+                                                             (group-by :block/parent)
+                                                             (sort-by (fn [[parent _]] (:block/order parent))))]
+                                      (map
+                                       (fn [[_parent blocks]]
+                                         [(:block/uuid (first blocks))
+                                          (map (fn [b]
+                                                 {:db/id (:db/id b)
+                                                  :block/parent (:block/uuid (:block/parent b))})
+                                               (ldb/sort-by-order blocks))])
+                                       parent-groups))
+                                    (->> (sort-entities db sorting entities)
+                                         (map :db/id)))]
+                        [by-value' group]))
+                    result)
+                   (map :db/id result))]
+       (cond->
+        {:count (count filtered-entities)
+         :data (distinct data')}
+         (= feat-type :linked-references)
+         (merge (select-keys entities-result [:ref-pages-count :ref-matched-children-ids]))
+         query?
+         (assoc :properties (get-query-properties entities-result)))))))

src/main/frontend/components/reference.cljs

@@ -53,7 +53,7 @@
   (let [block (db/sub-block (:db/id entity))]
     (references-aux block config)))
 
-(rum/defc references
+(rum/defc references-inner
   [entity config]
   (when-let [id (:db/id entity)]
     (let [[has-references? set-has-references!] (hooks/use-state nil)]
@@ -71,6 +71,13 @@
                                "Linked References: Unexpected error. Please re-index your graph first."))
          (references-cp entity config))))))
 
+(rum/defc references
+  [entity config]
+  (ui/lazy-visible
+   (fn []
+     (references-inner entity config))
+   {:trigger-once? true}))
+
 (rum/defc unlinked-references
   [entity config]
   (when-let [id (:db/id entity)]