Remaining promise API

Author: blacksmithgu

datacore.api.md

@@ -344,7 +344,7 @@ export class Datacore extends Component {
     //
     // @internal
     importer: FileImporter;
-    index(): void;
+    index(): Promise<void>;
     initialize(): void;
     initialized: boolean;
     // Warning: (ae-forgotten-export) The symbol "DatacoreInitializer" needs to be exported by the entry point index.d.ts

src/api/ui/embed.tsx

@@ -164,14 +164,14 @@ export function useLineSpan(path: string, start: number, end: number): LineSpanC
         }
 
         // Try to load the file asynchronously.
-        datacore
-            .read(file)
-            .then((content) => {
+        (async () => {
+            try {
+                const content = await datacore.read(file);
                 update({ type: "loaded", content: lineRange(content, start, end) });
-            })
-            .catch((error) => {
-                update({ type: "error", message: error.message });
-            });
+            } catch (error) {
+                update({ type: "error", message: error instanceof Error ? error.message : String(error) });
+            }
+        })();
     }, [path, start, end]);
 
     return state;

src/index/datacore.ts

@@ -110,30 +110,30 @@ export class Datacore extends Component {
         this.index();
     }
 
-    /** Starts the background initializer. */
-    index() {
+    /** Indexes all documents in the vault. Wait on this if you want to wait for the whole index to be ready. */
+    async index() {
         // Asynchronously initialize actual content in the background using a lifecycle-respecting object.
         const init = (this.initializer = new DatacoreInitializer(this));
-        init.finished().then((stats) => {
-            this.initialized = true;
-            this.initializer = undefined;
-            this.removeChild(init);
+        this.addChild(init);
 
-            this.datastore.touch();
-            this.trigger("update", this.revision);
-            this.trigger("initialized");
+        await init.finished();
 
-            // Clean up any documents which no longer exist in the vault.
-            // TODO: I think this may race with other concurrent operations, so
-            // this may need to happen at the start of init and not at the end.
-            const currentFiles = this.vault.getFiles().map((file) => file.path);
-            this.persister.synchronize(currentFiles);
-        });
+        this.initialized = true;
+        this.initializer = undefined;
+        this.removeChild(init);
 
-        this.addChild(init);
+        this.datastore.touch();
+        this.trigger("update", this.revision);
+        this.trigger("initialized");
+
+        // Clean up any documents which no longer exist in the vault.
+        // TODO: I think this may race with other concurrent operations, so
+        // this may need to happen at the start of init and not at the end.
+        const currentFiles = this.vault.getFiles().map((file) => file.path);
+        this.persister.synchronize(currentFiles);
     }
 
-    private rename(file: TAbstractFile, oldPath: string) {
+    private async rename(file: TAbstractFile, oldPath: string) {
         if (!(file instanceof TFile)) {
             return;
         }
@@ -142,7 +142,9 @@ export class Datacore extends Component {
         // This is less optimal than what can probably be done, but paths are used in a bunch of places
         // (for sections, tasks, etc to refer to their parent file) and it requires some finesse to fix.
         this.datastore.delete(oldPath);
-        this.reload(file).then(() => this.trigger("rename", file.path, oldPath));
+        await this.reload(file);
+
+        this.trigger("rename", file.path, oldPath);
 
         // TODO: For correctness, probably have to either fix links in all linked files OR
         // just stop normalizing links in the store. We can traverse the links index to do so
@@ -364,9 +366,16 @@ export class DatacoreInitializer extends Component {
         const next = this.queue.pop();
         if (next) {
             this.current.push(next);
-            this.init(next)
-                .then((result) => this.handleResult(next, result))
-                .catch((result) => this.handleResult(next, result));
+
+            // Run asynchronously to allow for concurrency.
+            (async () => {
+                try {
+                    const result = await this.init(next);
+                    this.handleResult(next, result);
+                } catch (error) {
+                    this.handleResult(next, { status: "skipped" });
+                }
+            })();
 
             this.runNext();
         } else if (!next && this.current.length == 0) {

src/index/embed-queue.ts

@@ -44,9 +44,18 @@ export class EmbedQueue extends Component {
             const read = this.vault.cachedRead(file);
             this.active.set(file.path, read);
 
-            read.then((content) => this.finish(file, Result.success(content))).catch((error) =>
-                this.finish(file, Result.failure(error))
-            );
+            // This function is non-blocking and will await on the read promise in the background.
+            this.run(file, read);
+        }
+    }
+
+    /** Wait on the read promise and then finish the load, catching errors. */
+    private async run(file: TFile, data: Promise<string>) {
+        try {
+            const content = await data;
+            this.finish(file, Result.success(content));
+        } catch (error) {
+            this.finish(file, Result.failure(error));
         }
     }
 

src/index/persister.ts

@@ -35,9 +35,8 @@ export class LocalStorageCache {
 
     /** Load file metadata by path. */
     public async loadFile(path: string): Promise<Cached<Partial<unknown>> | null | undefined> {
-        return this.persister.getItem(this.fileKey(path)).then((raw) => {
-            return raw as unknown as Cached<Partial<unknown>>;
-        });
+        const raw = await this.persister.getItem(this.fileKey(path));
+        return raw as unknown as Cached<Partial<unknown>>;
     }
 
     /** Store file metadata by path. */

src/ui/loading-boundary.tsx

@@ -64,9 +64,15 @@ export function ScriptContainer({
         setElement(undefined);
         setError(undefined);
 
-        executor()
-            .then((result) => setElement(makeRenderableElement(result, sourcePath)))
-            .catch((error) => setError(error));
+        // TODO: Avoid multiple concurrent executions of the same script.
+        (async () => {
+            try {
+                const result = await executor();
+                setElement(makeRenderableElement(result, sourcePath));
+            } catch (error) {
+                setError(error instanceof Error ? error : new Error(String(error)));
+            }
+        })();
     }, [executor, sourcePath]);
 
     // Propogate error upwards.

src/ui/markdown.tsx

@@ -109,7 +109,12 @@ function RawMarkdown({
         if (!container.current) return;
 
         container.current.replaceChildren(...[]);
-        MarkdownRenderer.render(app, content, container.current, sourcePath, component).then(() => {
+
+        (async () => {
+            if (!container.current || !inline) return;
+            await MarkdownRenderer.render(app, content, container.current, sourcePath, component);
+
+            // Have to check twice since the container might disappear during the async call.
             if (!container.current || !inline) return;
 
             // Unwrap any created paragraph elements if we are inline.
@@ -137,7 +142,7 @@ function RawMarkdown({
                 embed.addClass("is-loaded");
                 embed = container.current.querySelector("span.internal-embed:not(.is-loaded)");
             }
-        });
+        })();
     }, [content, sourcePath, inline, container.current]);
 
     return (