refactor: make Dataview querying async

src/main.ts

@@ -9,7 +9,7 @@ import {
   createDailyNote,
   getDateFromPath,
 } from "obsidian-daily-notes-interface";
-import { type STask } from "obsidian-dataview";
+import { getAPI, type STask } from "obsidian-dataview";
 import { mount } from "svelte";
 import { fromStore, get, writable, type Writable } from "svelte/store";
 import { isInstanceOf, isNotVoid } from "typed-assert";
@@ -86,7 +86,7 @@ export default class DayPlanner extends Plugin {
       this.app.workspace,
       this.vaultFacade,
     );
-    this.dataviewFacade = new DataviewFacade(this.app);
+    this.dataviewFacade = new DataviewFacade(() => getAPI(this.app));
     this.sTaskEditor = new STaskEditor(
       this.workspaceFacade,
       this.vaultFacade,
@@ -545,7 +545,7 @@ export default class DayPlanner extends Plugin {
       sTaskEditor: this.sTaskEditor,
       workspaceFacade: this.workspaceFacade,
       initWeeklyView: this.initWeeklyLeaf,
-      refreshTasks: this.dataviewFacade.getAllTasksFrom,
+      refreshTasks: this.dataviewFacade.legacy_getAllTasksFrom,
       dataviewLoaded,
       renderMarkdown: createRenderMarkdown(this.app),
       toggleCheckboxInFile: this.vaultFacade.toggleCheckboxInFile,

src/service/dataview-facade.ts

@@ -1,15 +1,38 @@
 import { App } from "obsidian";
-import { getAPI, STask } from "obsidian-dataview";
+import { getAPI, STask, type DataviewApi } from "obsidian-dataview";
+import {
+  type Scheduler,
+  createBackgroundBatchScheduler,
+} from "../util/scheduler";
 
 export class DataviewFacade {
-  constructor(private readonly app: App) {}
+  private readonly scheduler: Scheduler<STask[]> =
+    createBackgroundBatchScheduler({
+      timeRemainingLowerLimit: 5,
+    });
 
-  getAllTasksFrom = (source: string) => {
-    return getAPI(this.app)?.pages(source).file.tasks.array() || [];
+  constructor(private readonly getDataview: () => DataviewApi | undefined) {}
+
+  getAllTasksFrom = async (source: string) => {
+    return new Promise<STask[]>((resolve) => {
+      const paths: string[] = this.getDataview()?.pagePaths(source).array();
+
+      const pageQueries: Array<() => STask[]> = paths.map(
+        (path) => () => this.getDataview()?.page(path)?.file.tasks.array(),
+      );
+
+      this.scheduler.enqueueTasks(pageQueries, (results) => {
+        resolve(results.flat());
+      });
+    });
+  };
+
+  legacy_getAllTasksFrom = (source: string) => {
+    return this.getDataview()?.pages(source).file.tasks.array() || [];
   };
 
   getAllListsFrom = (source: string) => {
-    return getAPI(this.app)?.pages(source).file.lists.array() || [];
+    return this.getDataview()?.pages(source).file.lists.array() || [];
   };
 
   getTaskAtLine({ path, line }: { path: string; line: number }) {
@@ -19,6 +42,6 @@ export class DataviewFacade {
   }
 
   private getTasksFromPath = (path: string): STask[] => {
-    return getAPI(this.app)?.page(path)?.file.tasks || [];
+    return this.getDataview()?.page(path)?.file.tasks || [];
   };
 }

src/ui/hooks/use-search.svelte.ts

@@ -34,9 +34,10 @@ export function useSearch(props: {
       return [];
     }
 
+    // todo: use async
     return (
       dataviewFacade
-        .getAllTasksFrom(currentSource)
+        .legacy_getAllTasksFrom(currentSource)
         .filter((task) => {
           return task.text.toLowerCase().includes(currentQuery);
         })

src/ui/hooks/use-tasks-from-extra-sources.ts

@@ -1,6 +1,7 @@
 import { derived, type Readable } from "svelte/store";
 
 import { DataviewFacade } from "../../service/dataview-facade";
+import type { STask } from "obsidian-dataview";
 
 interface UseTasksFromExtraSourcesProps {
   dataviewSource: Readable<string>;
@@ -13,13 +14,17 @@ export function useTasksFromExtraSources({
   refreshSignal,
   dataviewFacade,
 }: UseTasksFromExtraSourcesProps) {
-  return derived([dataviewSource, refreshSignal], ([$dataviewSource]) => {
-    const noAdditionalSource = $dataviewSource.trim().length === 0;
+  return derived(
+    [dataviewSource, refreshSignal],
+    ([$dataviewSource], set: (tasks: STask[]) => void) => {
+      dataviewFacade
+        .getAllTasksFrom($dataviewSource)
+        .then(set, (reason) => {
+          console.error("Failed to fetch tasks from dataview source: ", reason);
 
-    if (noAdditionalSource) {
-      return [];
-    }
-
-    return dataviewFacade.getAllTasksFrom($dataviewSource);
-  });
+          set([]);
+        });
+    },
+    [],
+  );
 }

src/util/create-hooks.svelte.ts

@@ -139,7 +139,7 @@ export function useTasks(props: {
           $currentTime,
           task.startTime.clone().startOf("minute"),
         ),
-        truncated: "bottom",
+        truncated: "bottom" as const,
       })),
   );
 

src/util/scheduler.ts

@@ -29,18 +29,21 @@ const cancelJob =
     clearTimeout(id);
   });
 
+export type Scheduler<T> = ReturnType<typeof createBackgroundBatchScheduler<T>>;
+
 /**
  * A scheduler accepts a list of tasks (a batch) and reports back when all of them are done.
  * If a new batch of tasks is added, the scheduler will discard the previous batch and run the new one.
  */
-export function createBackgroundBatchScheduler<T>(
-  onFinish: (results: T[]) => void,
-) {
-  const timeRemainingLowerLimit = 10;
+export function createBackgroundBatchScheduler<T>(props: {
+  timeRemainingLowerLimit: number;
+}) {
+  const { timeRemainingLowerLimit } = props;
 
   let results: T[] = [];
   let tasks: Array<() => T> = [];
   let currentTaskHandle: number | null = null;
+  let currentOnFinish: (results: T[]) => void;
 
   function runTaskQueue(deadline: IdleDeadline) {
     while (
@@ -58,13 +61,17 @@ export function createBackgroundBatchScheduler<T>(
     if (tasks.length > 0) {
       currentTaskHandle = enqueueJob(runTaskQueue);
     } else {
-      onFinish(results);
+      currentOnFinish(results);
       currentTaskHandle = null;
     }
   }
 
-  function enqueueTasks(newTasks: Array<() => T>) {
-    performance.mark("batch-start");
+  function enqueueTasks(
+    newTasks: Array<() => T>,
+    onFinish: (results: T[]) => void,
+  ) {
+    currentOnFinish = onFinish;
+
     if (currentTaskHandle) {
       cancelJob(currentTaskHandle);
       currentTaskHandle = null;

src/util/use-remote-tasks.ts

@@ -10,7 +10,9 @@ import type { WithIcalConfig } from "../types";
 
 import { canHappenAfter, icalEventToTasks } from "./ical";
 import { getEarliestMoment } from "./moment";
-import { createBackgroundBatchScheduler } from "./scheduler";
+import {
+  createBackgroundBatchScheduler,
+} from "./scheduler";
 
 function isVEvent(event: ical.CalendarComponent): event is ical.VEvent {
   return event.type === "VEVENT";
@@ -93,12 +95,13 @@ export function useRemoteTasks(props: {
   const tasksFromEvents = readable<Array<ReturnType<typeof icalEventToTasks>>>(
     [],
     (set) => {
-      const scheduler =
-        createBackgroundBatchScheduler<ReturnType<typeof icalEventToTasks>>(
-          set,
-        );
+      const scheduler = createBackgroundBatchScheduler<
+        ReturnType<typeof icalEventToTasks>
+      >({ timeRemainingLowerLimit: 10 });
 
-      return schedulerQueue.subscribe(scheduler.enqueueTasks);
+      return schedulerQueue.subscribe((next) => {
+        scheduler.enqueueTasks(next, set);
+      });
     },
   );