@silverbulletmd/silverbullet 2.4.1

package/client/plugos/syscalls/client_code_widget.ts

@@ -0,0 +1,12 @@
+import type { SysCallMapping } from "../../plugos/system.ts";
+import { reloadAllWidgets } from "../../codemirror/code_widget.ts";
+import { broadcastReload } from "../../components/widget_sandbox_iframe.ts";
+
+export function clientCodeWidgetSyscalls(): SysCallMapping {
+  return {
+    "codeWidget.refreshAll": () => {
+      broadcastReload();
+      return reloadAllWidgets();
+    },
+  };
+}

package/client/plugos/syscalls/code_widget.ts

@@ -0,0 +1,24 @@
+import type { SysCallMapping } from "../system.ts";
+import type { CodeWidgetHook } from "../hooks/code_widget.ts";
+import type { CodeWidgetContent } from "@silverbulletmd/silverbullet/type/client";
+
+export function codeWidgetSyscalls(
+  codeWidgetHook: CodeWidgetHook,
+): SysCallMapping {
+  return {
+    "codeWidget.render": (
+      _ctx,
+      lang: string,
+      body: string,
+      pageName: string,
+    ): Promise<CodeWidgetContent | null> => {
+      const langCallback = codeWidgetHook.codeWidgetCallbacks.get(
+        lang,
+      );
+      if (!langCallback) {
+        throw new Error(`Code widget ${lang} not found`);
+      }
+      return langCallback(body, pageName);
+    },
+  };
+}

package/client/plugos/syscalls/config.ts

@@ -0,0 +1,46 @@
+import type { SysCallMapping } from "../system.ts";
+import type { Config } from "../../config.ts";
+import { LuaStackFrame, luaValueToJS } from "../../space_lua/runtime.ts";
+
+export function configSyscalls(config: Config): SysCallMapping {
+  return {
+    "config.get": (_ctx, path: string, defaultValue: any) => {
+      return config.get(path, defaultValue);
+    },
+    "config.set": (
+      _ctx,
+      keyOrValues: string | string[] | Record<string, any>,
+      value?: any,
+    ) => {
+      config.set(keyOrValues as any, value);
+    },
+    "lua:config.setLuaValue": async (
+      _ctx,
+      keyOrValues: string | string[] | Record<string, any>,
+      value?: any,
+    ) => {
+      // This is for special cases where we explicitly want to NOT convert a value to a JS value, but maintain its Lua version (mostly for LuaTables) — main use case: metatable
+      keyOrValues = await luaValueToJS(keyOrValues, LuaStackFrame.lostFrame);
+      config.set(keyOrValues as any, value);
+    },
+    "config.insert": (
+      _ctx,
+      key: string | string[],
+      value: any,
+    ) => {
+      config.insert(key, value);
+    },
+    "config.has": (_ctx, path: string) => {
+      return config.has(path);
+    },
+    "config.define": (_ctx, key: string, schema: any) => {
+      config.define(key, schema);
+    },
+    "config.getValues": () => {
+      return config.values;
+    },
+    "config.getSchemas": () => {
+      return config.schemas;
+    },
+  };
+}

package/client/plugos/syscalls/datastore.ts

@@ -0,0 +1,89 @@
+import {
+  type LuaCollectionQuery,
+  queryLua,
+} from "../../space_lua/query_collection.ts";
+import type { DataStore } from "../../data/datastore.ts";
+import type { SysCallMapping } from "../system.ts";
+import {
+  jsToLuaValue,
+  LuaEnv,
+  LuaStackFrame,
+  luaValueToJS,
+} from "../../space_lua/runtime.ts";
+import type { KvQueryOptions } from "../../data/kv_primitives.ts";
+import type { ClientSystem } from "../../client_system.ts";
+
+import type { KV, KvKey } from "@silverbulletmd/silverbullet/type/datastore";
+
+/**
+ * Exposes the datastore API to plugs, but scoping everything to a prefix based on the plug's name
+ * @param ds the datastore to wrap
+ * @param prefix prefix to scope all keys to to which the plug name will be appended
+ */
+export function dataStoreReadSyscalls(
+  ds: DataStore,
+  clientSystem: ClientSystem,
+): SysCallMapping {
+  return {
+    "datastore.batchGet": (
+      _ctx,
+      keys: KvKey[],
+    ): Promise<(any | undefined)[]> => {
+      return ds.batchGet(keys);
+    },
+
+    "datastore.get": (_ctx, key: KvKey): Promise<any | null> => {
+      return ds.get(key);
+    },
+
+    "datastore.query": async (_ctx, options: KvQueryOptions): Promise<KV[]> => {
+      const results: KV[] = [];
+      for await (const item of ds.query(options)) {
+        results.push(item);
+      }
+      return results;
+    },
+
+    "datastore.queryLua": async (
+      _ctx,
+      prefix: string[],
+      query: LuaCollectionQuery,
+      scopeVariables?: Record<string, any>,
+    ): Promise<any[]> => {
+      const sf = LuaStackFrame.createWithGlobalEnv(
+        clientSystem.spaceLuaEnv.env,
+      );
+      let env = clientSystem.spaceLuaEnv.env;
+      if (scopeVariables) {
+        env = new LuaEnv(clientSystem.spaceLuaEnv.env);
+        for (const [key, value] of Object.entries(scopeVariables)) {
+          env.setLocal(key, jsToLuaValue(value));
+        }
+      }
+      return (await queryLua<any>(ds.kv, prefix, query, env, sf)).map((item) =>
+        luaValueToJS(item, sf)
+      );
+    },
+  };
+}
+
+export function dataStoreWriteSyscalls(ds: DataStore): SysCallMapping {
+  return {
+    "datastore.delete": (_ctx, key: KvKey) => {
+      console.log("Deleting key", key);
+      return ds.delete(key);
+    },
+
+    "datastore.set": (_ctx, key: KvKey, value: any) => {
+      return ds.set(key, value);
+    },
+
+    "datastore.batchSet": (_ctx, kvs: KV[]) => {
+      return ds.batchSet(kvs);
+    },
+
+    "datastore.batchDelete": (_ctx, keys: KvKey[]) => {
+      return ds.batchDelete(keys);
+    },
+  };
+}