@silverbulletmd/silverbullet 2.4.2 → 2.6.1

package/client/plugos/syscalls/language.ts

@@ -1,23 +1,27 @@
 import type { SysCallMapping } from "../system.ts";
 import { parse } from "../../markdown_parser/parse_tree.ts";
 import type { ParseTree } from "@silverbulletmd/silverbullet/lib/tree";
-import { builtinLanguages, languageFor } from "../../languages.ts";
+import {
+  allLanguageNames,
+  languageFor,
+  loadLanguageFor,
+} from "../../languages.ts";
 
 export function languageSyscalls(): SysCallMapping {
   return {
-    "language.parseLanguage": (
+    "language.parseLanguage": async (
       _ctx,
       language: string,
       code: string,
-    ): ParseTree => {
-      const lang = languageFor(language);
+    ): Promise<ParseTree> => {
+      const lang = languageFor(language) ?? await loadLanguageFor(language);
       if (!lang) {
         throw new Error(`Unknown language ${language}`);
       }
       return parse(lang, code);
     },
     "language.listLanguages": (): string[] => {
-      return Object.keys(builtinLanguages);
+      return allLanguageNames;
     },
   };
 }

package/client/plugos/syscalls/markdown.ts

@@ -4,7 +4,7 @@ import {
   type ParseTree,
   renderToText,
 } from "@silverbulletmd/silverbullet/lib/tree";
-import { extendedMarkdownLanguage } from "../../markdown_parser/parser.ts";
+import { buildExtendedMarkdownLanguage } from "../../markdown_parser/parser.ts";
 import {
   expandMarkdown,
   type MarkdownExpandOptions,
@@ -18,11 +18,12 @@ import {
   jsonToMDTable,
   refCellTransformer,
 } from "../../markdown_renderer/result_render.ts";
+import * as TagConstants from "../../../plugs/index/constants.ts";
 
 export function markdownSyscalls(client: Client): SysCallMapping {
   return {
     "markdown.parseMarkdown": (_ctx, text: string): ParseTree => {
-      return parse(extendedMarkdownLanguage, text);
+      return parse(markdownLanguageWithUserExtensions(client), text);
     },
     "markdown.renderParseTree": (_ctx, tree: ParseTree): string => {
       return renderToText(tree);
@@ -34,7 +35,10 @@ export function markdownSyscalls(client: Client): SysCallMapping {
     ): Promise<ParseTree | string> => {
       const outputString = typeof treeOrText === "string";
       if (typeof treeOrText === "string") {
-        treeOrText = parse(extendedMarkdownLanguage, treeOrText);
+        treeOrText = parse(
+          markdownLanguageWithUserExtensions(client),
+          treeOrText,
+        );
       }
       const result = await expandMarkdownWithClient(
         client,
@@ -52,23 +56,38 @@ export function markdownSyscalls(client: Client): SysCallMapping {
       text: string,
       options: MarkdownRenderOptions = {},
     ) => {
-      let mdTree = parse(extendedMarkdownLanguage, text);
+      let mdTree = parse(markdownLanguageWithUserExtensions(client), text);
       if (options.expand) {
         mdTree = await expandMarkdownWithClient(client, mdTree);
       }
+      if (!options.resolveTagHref) {
+        options.resolveTagHref = (tagName: string) => {
+          return client.config.get<string | null>(
+            ["tags", tagName, "tagPage"],
+            null,
+          ) ?? TagConstants.tagPrefix + tagName;
+        };
+      }
       return renderMarkdownToHtml(mdTree, options);
     },
     "markdown.objectsToTable": (
       _ctx,
       data: any[],
-      options: { renderCell?: (val: any, key: string) => Promise<any> | any } =
-        {},
+      options: {
+        renderCell?: (val: any, key: string) => Promise<any> | any;
+      } = {},
     ) => {
       return jsonToMDTable(data, options.renderCell || refCellTransformer);
     },
   };
 }
 
+function markdownLanguageWithUserExtensions(client: Client) {
+  return buildExtendedMarkdownLanguage(
+    client.config.get("syntaxExtensions", {}),
+  );
+}
+
 function expandMarkdownWithClient(
   client: Client,
   tree: ParseTree,
@@ -79,6 +98,9 @@ function expandMarkdownWithClient(
     client.currentName(),
     tree,
     client.clientSystem.spaceLuaEnv,
-    options,
+    {
+      ...options,
+      syntaxExtensions: client.config.get("syntaxExtensions", {}),
+    },
   );
 }

package/client/plugos/syscalls/mq.ts

@@ -6,23 +6,15 @@ export type EventSubscription = MQListenerSpec & {
   run: (...args: any[]) => Promise<any>;
 };
 
-export function mqSyscalls(
-  mq: DataStoreMQ,
-): SysCallMapping {
+export function mqSyscalls(mq: DataStoreMQ): SysCallMapping {
   return {
     /**
      * Define a Lua event listener
      */
-    "mq.subscribe": (
-      _ctx,
-      def: MQListenerSpec,
-    ) => {
-      def.autoAck = def.autoAck != false;
+    "mq.subscribe": (_ctx, def: MQListenerSpec) => {
+      def.autoAck = def.autoAck !== false;
       // console.log("Registering Lua event listener: ", def.name);
-      client.config.insert([
-        "mqSubscriptions",
-        def.queue,
-      ], def);
+      client.config.insert(["mqSubscriptions", def.queue], def);
     },
     "mq.send": (_ctx, queue: string, body: any) => {
       return mq.send(queue, body);

package/client/plugos/syscalls/service_registry.ts

@@ -12,10 +12,7 @@ export function serviceRegistrySyscalls(
     /**
      * Define a Lua event listener
      */
-    "service.define": (
-      _ctx,
-      def: ServiceSpec,
-    ) => {
+    "service.define": (_ctx, def: ServiceSpec) => {
       return serviceRegistry.define(def);
     },
     "service.discover": (

package/client/plugos/syscalls/shell.ts

@@ -2,9 +2,7 @@ import type { SysCallMapping } from "../system.ts";
 import type { Client } from "../../client.ts";
 import { fsEndpoint } from "../../spaces/constants.ts";
 
-export function shellSyscalls(
-  client: Client,
-): SysCallMapping {
+export function shellSyscalls(client: Client): SysCallMapping {
   return {
     "shell.run": async (
       _ctx,
@@ -34,6 +32,5 @@ export function shellSyscalls(
 
 function buildShellUrl(client: Client) {
   // Strip off the /.fs and replace with /.shell
-  return client.httpSpacePrimitives.url.slice(0, -fsEndpoint.length) +
-    "/.shell";
+  return `${client.httpSpacePrimitives.url.slice(0, -fsEndpoint.length)}/.shell`;
 }

package/client/plugos/syscalls/space.ts

@@ -32,7 +32,7 @@ export function spaceReadSyscalls(client: Client): SysCallMapping {
       return (await client.space.readRef(ref)).text;
     },
     "space.pageExists": (_ctx, name: string): boolean => {
-      return client.clientSystem.allKnownFiles.has(name + ".md");
+      return client.clientSystem.allKnownFiles.has(`${name}.md`);
     },
     "space.getPageMeta": (_ctx, name: string): Promise<PageMeta> => {
       return client.space.getPageMeta(name);

package/client/plugos/syscalls/sync.ts

@@ -1,77 +1,86 @@
 import type { SysCallMapping } from "../system.ts";
 import type { Client } from "../../client.ts";
 
-// TODO: Reimplement this
 export function syncSyscalls(client: Client): SysCallMapping {
-  return {
-    "sync.hasInitialSyncCompleted": (): boolean => {
-      return client.fullSyncCompleted;
-    },
-    "sync.performFileSync": (_ctx, path: string): Promise<void> => {
-      client.postServiceWorkerMessage({ type: "perform-file-sync", path });
-      return waitForServiceWorkerActivation(path);
-    },
-    "sync.performSpaceSync": (): Promise<number> => {
-      client.postServiceWorkerMessage({ type: "perform-space-sync" });
-      return waitForServiceWorkerActivation();
-    },
-  };
-}
+  const syncTimeoutMs = 30000;
 
-function waitForServiceWorkerActivation(path?: string): Promise<any> {
-  return new Promise<any>((resolve, reject) => {
-    client.eventHook.addLocalListener(
-      "service-worker:file-sync-complete",
-      eventHandler,
-    );
-    client.eventHook.addLocalListener(
-      "service-worker:space-sync-complete",
-      eventHandler,
-    );
-    client.eventHook.addLocalListener(
-      "service-worker:sync-error",
-      errorHandler,
-    );
-    function eventHandler(data: any) {
-      // If data.path is set, we are notified about a specific file sync -> all good, even for an individual file sync
-      // If data.path is not set, we are notified about a full space sync
-      // If we were waiting for a specific path, ignore other paths
-      if (data.path && path && data.path !== path) {
-        // Event for other file sync
-        return;
+  function waitForServiceWorkerActivation(path?: string): Promise<any> {
+    return new Promise<any>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        cleanup();
+        reject(new Error(`Sync timeout after ${syncTimeoutMs / 1000}s`));
+      }, syncTimeoutMs);
+
+      function cleanup() {
+        clearTimeout(timeout);
+        client.eventHook.removeLocalListener(
+          "service-worker:file-sync-complete",
+          eventHandler,
+        );
+        client.eventHook.removeLocalListener(
+          "service-worker:space-sync-complete",
+          eventHandler,
+        );
+        client.eventHook.removeLocalListener(
+          "service-worker:sync-error",
+          errorHandler,
+        );
       }
-      // If we were waiting for a specific path, ignore other paths
-      resolve(data);
 
-      // Unsubscribe from all these events
-      client.eventHook.removeLocalListener(
-        "service-worker:file-sync-complete",
-        eventHandler,
-      );
-      client.eventHook.removeLocalListener(
-        "service-worker:space-sync-complete",
-        eventHandler,
-      );
-      client.eventHook.removeLocalListener(
-        "service-worker:sync-error",
-        errorHandler,
-      );
-    }
-    function errorHandler(e: any) {
-      reject(e);
-      // Unsubscribe from all these events
-      client.eventHook.removeLocalListener(
+      client.eventHook.addLocalListener(
         "service-worker:file-sync-complete",
         eventHandler,
       );
-      client.eventHook.removeLocalListener(
+      client.eventHook.addLocalListener(
         "service-worker:space-sync-complete",
         eventHandler,
       );
-      client.eventHook.removeLocalListener(
+      client.eventHook.addLocalListener(
         "service-worker:sync-error",
         errorHandler,
       );
-    }
-  });
+
+      function eventHandler(data: any) {
+        if (data.path && path && data.path !== path) {
+          return;
+        }
+        cleanup();
+        resolve(data);
+      }
+
+      function errorHandler(e: any) {
+        // Only reject if the error is for our specific path, or if no path was specified
+        if (e.path && path && e.path !== path) {
+          return;
+        }
+        cleanup();
+        reject(e);
+      }
+    });
+  }
+
+  return {
+    "sync.hasInitialSyncCompleted": (): boolean => {
+      return client.fullSyncCompleted;
+    },
+    "sync.performFileSync": async (_ctx, path: string): Promise<void> => {
+      await client.postServiceWorkerMessage({
+        type: "perform-file-sync",
+        path,
+      });
+      // postServiceWorkerMessage returns silently if no SW, so only wait if SW is active
+      const registration = await navigator.serviceWorker.getRegistration();
+      if (registration?.active) {
+        return waitForServiceWorkerActivation(path);
+      }
+    },
+    "sync.performSpaceSync": async (): Promise<number> => {
+      await client.postServiceWorkerMessage({ type: "perform-space-sync" });
+      const registration = await navigator.serviceWorker.getRegistration();
+      if (registration?.active) {
+        return waitForServiceWorkerActivation();
+      }
+      return 0;
+    },
+  };
 }

package/client/plugos/syscalls/system.ts

@@ -66,9 +66,8 @@ export function systemSyscalls(
     },
     "system.listSyscalls": (): SyscallMeta[] => {
       const syscalls: SyscallMeta[] = [];
-      for (
-        const [name, info] of client.clientSystem.system.registeredSyscalls
-      ) {
+      for (const [name, info] of client.clientSystem.system
+        .registeredSyscalls) {
         syscalls.push({
           name,
           requiredPermissions: info.requiredPermissions,

package/client/plugos/system.ts

@@ -24,9 +24,7 @@ export type SyscallContext = {
   plug?: string;
 };
 
-type SyscallSignature = (
-  ...args: any[]
-) => Promise<any> | any;
+type SyscallSignature = (...args: any[]) => Promise<any> | any;
 
 type Syscall = {
   requiredPermissions: string[];
@@ -112,11 +110,7 @@ export class System<HookT> extends EventEmitter<SystemEvents<HookT>> {
     return this.syscall({}, name, args);
   }
 
-  syscall(
-    ctx: SyscallContext,
-    name: string,
-    args: any[],
-  ): Promise<any> {
+  syscall(ctx: SyscallContext, name: string, args: any[]): Promise<any> {
     const syscall = this.registeredSyscalls.get(name);
     if (!syscall) {
       throw Error(`Unregistered syscall ${name}`);
@@ -188,13 +182,13 @@ export class System<HookT> extends EventEmitter<SystemEvents<HookT>> {
     if (!plug) {
       return;
     }
-    plug.stop();
-    this.emit("plugUnloaded", name);
+    void plug.stop();
+    void this.emit("plugUnloaded", name);
     this.plugs.delete(name);
   }
 
-  unloadAll(): Promise<void[]> {
-    return Promise.all(
+  async unloadAll(): Promise<void> {
+    await Promise.all(
       Array.from(this.plugs.keys()).map(this.unload.bind(this)),
     );
   }

package/client/plugos/worker_runtime.ts

@@ -15,35 +15,15 @@ let workerPostMessage = (_msg: ControllerMessage): void => {
   throw new Error("Not initialized yet");
 };
 
-// Are we running in a (web) worker?
-
-// Determines if we're running in a web worker environment (Deno or browser)
-// - in a browser's main threads, typeof window is "object"
+// Determines if we're running in a web worker environment
+// - in a browser's main thread, typeof window is "object"
 // - in a browser's worker threads, typeof window === "undefined"
-// - in Deno's main thread typeof window === "object"
-// - in Deno's workers typeof window === "undefined
 // - in Cloudflare workers typeof window === "undefined", but typeof globalThis.WebSocketPair is defined
-const runningAsWebWorker = typeof window === "undefined" &&
-  // @ts-ignore: globalThis
+const runningAsWebWorker =
+  typeof window === "undefined" &&
+  // @ts-expect-error: globalThis
   typeof globalThis.WebSocketPair === "undefined";
 
-// @ts-ignore: Check if Deno is defined
-if (typeof Deno === "undefined") {
-  // @ts-ignore: Deno hack
-  self.Deno = {
-    args: [],
-    // @ts-ignore: Deno hack
-    build: {
-      arch: "x86_64",
-    },
-    env: {
-      // @ts-ignore: Deno hack
-      get() {
-      },
-    },
-  };
-}
-
 const pendingRequests = new Map<
   number,
   {
@@ -157,20 +137,19 @@ export async function sandboxFetch(
   return syscall("sandboxFetch.fetch", reqInfo, options);
 }
 
-// @ts-ignore: monkey patching fetch
 globalThis.nativeFetch = globalThis.fetch;
 
 // Monkey patch fetch()
 export function monkeyPatchFetch() {
-  // @ts-ignore: monkey patching fetch
-  globalThis.fetch = async function (
+  // @ts-expect-error: monkey patching fetch
+  globalThis.fetch = async (
     reqInfo: RequestInfo,
     init?: RequestInit,
-  ): Promise<Response> {
-    const encodedBody = init && init.body
+  ): Promise<Response> => {
+    const encodedBody = init?.body
       ? base64Encode(
-        new Uint8Array(await (new Response(init.body)).arrayBuffer()),
-      )
+          new Uint8Array(await new Response(init.body).arrayBuffer()),
+        )
       : undefined;
     const r = await sandboxFetch(
       reqInfo,
@@ -180,7 +159,7 @@ export function monkeyPatchFetch() {
         base64Body: encodedBody,
       },
     );
-    // Casting the response to "any" for now, since of weird Deno typing
+    // Casting to any due to TypeScript fetch type limitations
     return new Response(
       (r.base64Body ? base64Decode(r.base64Body) : null) as any,
       {