detects has-more loading by whether there's a next open block

src/main/frontend/components/block.cljs

@@ -2879,14 +2879,15 @@
   [state config flat-blocks blocks->vec-tree]
   (let [db-id (:db/id config)
         blocks (blocks->vec-tree flat-blocks)]
-    (if (:custom-query? config)
+    (if-not db-id
       (block-list config blocks)
-      (let [last-block-id (:db/id (last flat-blocks))
-            bottom-reached (fn []
-                             (when (and db-id
-                                        ;; To prevent scrolling after inserting new blocks
-                                        (> (- (util/time-ms) (:start-time config)) 100))
+      (let [bottom-reached (fn []
+                             ;; To prevent scrolling after inserting new blocks
+                             (when (> (- (util/time-ms) (:start-time config)) 100)
                                (load-more-blocks! config flat-blocks)))
+            has-more? (and
+                       (> (count flat-blocks) model/initial-blocks-length)
+                       (some? (model/get-next-open-block (last flat-blocks) db-id)))
             dom-id (str "lazy-blocks-" (::id state))]
         [:div {:id dom-id}
          (ui/infinite-list
@@ -2896,8 +2897,10 @@
            :bottom-reached (fn []
                              (when-let [node (gdom/getElement dom-id)]
                                (ui/bottom-reached? node 1000)))
-           :has-more true
-           :more "More"})]))))
+           :has-more has-more?
+           :more (if (or (:preview? config) (:sidebar? config))
+                   "More"
+                   (ui/loading "Loading"))})]))))
 
 (rum/defcs blocks-container <
   {:init (fn [state]

src/main/frontend/db/model.cljs

@@ -482,6 +482,33 @@
           '[:db/id :block/collapsed? :block/properties {:block/parent ...}]
           [:block/uuid block-id]))
 
+(defn get-next-open-block
+  ([block]
+   (get-next-open-block block nil))
+  ([block scoped-block-id]
+   (let [conn (conn/get-conn false)
+         block-id (:db/id block)
+         block-parent-id (:db/id (:block/parent block))
+         next-block (or
+                     (if (collapsed-and-has-children? block) ; skips children
+                       ;; Sibling
+                       (get-by-parent-&-left conn block-parent-id block-id)
+                       (or
+                        ;; Child
+                        (get-by-parent-&-left conn block-id block-id)
+                        ;; Sibling
+                        (get-by-parent-&-left conn block-parent-id block-id)))
+
+                     ;; Next outdented block
+                     (get-next-outdented-block block-id))]
+     (if (and scoped-block-id next-block)
+       (let [parents (->> (get-block-parents (state/get-current-repo) (:block/uuid next-block))
+                          (map :db/id)
+                          (set))]
+         (when (contains? parents scoped-block-id)
+           next-block))
+       next-block))))
+
 (defn get-paginated-blocks-no-cache
   "Result should be sorted."
   [start-id {:keys [limit include-start? scoped-block-id]}]
@@ -491,25 +518,11 @@
                                    (->> (get-block-parents (state/get-current-repo) (:block/uuid block))
                                         (map :db/id)
                                         (set))))
-          conn (conn/get-conn false)
           result (loop [block start
                         result []]
                    (if (and limit (>= (count result) limit))
                      result
-                     (let [block-id (:db/id block)
-                           block-parent-id (:db/id (:block/parent block))
-                           next-block (or
-                                       (if (collapsed-and-has-children? block) ; skips children
-                                         ;; Sibling
-                                         (get-by-parent-&-left conn block-parent-id block-id)
-                                         (or
-                                          ;; Child
-                                          (get-by-parent-&-left conn block-id block-id)
-                                          ;; Sibling
-                                          (get-by-parent-&-left conn block-parent-id block-id)))
-
-                                       ;; Next outdented block
-                                       (get-next-outdented-block block-id))]
+                     (let [next-block (get-next-open-block block)]
                        (if next-block
                          (if (and (seq scoped-block-parents)
                                   (contains? scoped-block-parents (:db/id (:block/parent next-block))))