@silverbulletmd/silverbullet 2.4.1

package/plug-api/syscalls/index.ts

@@ -0,0 +1,77 @@
+import type { LuaCollectionQuery } from "../../client/space_lua/query_collection.ts";
+import { syscall } from "@silverbulletmd/silverbullet/syscall";
+import type { ObjectValue } from "../../plug-api/types/index.ts";
+
+/**
+ * Exposes the SilverBullet object indexing system
+ * @module
+ */
+
+/**
+ * Indexes objects for a specific page
+ * @param page - The page identifier where objects will be indexed
+ * @param objects - Array of objects to be indexed
+ * @returns Promise that resolves when indexing is complete
+ */
+export function indexObjects<T>(
+  page: string,
+  objects: ObjectValue<T>[],
+): Promise<void> {
+  return syscall("index.indexObjects", page, objects);
+}
+
+export function validateObjects<T>(
+  page: string,
+  objects: ObjectValue<T>[],
+): Promise<{ error: string; object: ObjectValue } | null> {
+  return syscall("index.validateObjects", page, objects);
+}
+
+/**
+ * Queries objects using a Lua-based collection query
+ * @param tag - The tag to filter objects by
+ * @param query - Lua query parameters to filter objects
+ * @param scopedVariables - Optional variables to be used in the Lua query
+ * @returns Promise that resolves with an array of matching objects
+ */
+export function queryLuaObjects<T>(
+  tag: string,
+  query: LuaCollectionQuery,
+  scopedVariables?: Record<string, any>,
+): Promise<ObjectValue<T>[]> {
+  return syscall("index.queryLuaObjects", tag, query, scopedVariables);
+}
+
+/**
+ * Retrieves a specific object by its reference
+ * @param page - The page identifier where the object is located
+ * @param tag - The tag of the object
+ * @param ref - The reference identifier of the object
+ * @returns Promise that resolves with the matching object or undefined if not found
+ */
+export function getObjectByRef<T>(
+  page: string,
+  tag: string,
+  ref: string,
+): Promise<ObjectValue<T> | undefined> {
+  return syscall("index.getObjectByRef", page, tag, ref);
+}
+
+/**
+ * Ensures that the full index is built and up-to-date
+ */
+export function ensureFullIndex(): Promise<void> {
+  return syscall("index.ensureFullIndex");
+}
+
+export function reindexSpace(): Promise<void> {
+  return syscall("index.reindexSpace");
+}
+
+export function deleteObject(
+  page: string,
+  tag: string,
+  ref: string,
+): Promise<void> {
+  return syscall("index.deleteObject", page, tag, ref);
+}

package/plug-api/syscalls/jsonschema.ts

@@ -0,0 +1,25 @@
+import { syscall } from "../syscall.ts";
+
+/**
+ * Validates a JSON object against a JSON schema.
+ * @param schema the JSON schema to validate against
+ * @param object the JSON object to validate
+ * @returns an error message if the object is invalid, or undefined if it is valid
+ */
+export function validateObject(
+  schema: any,
+  object: any,
+): Promise<string | undefined> {
+  return syscall("jsonschema.validateObject", schema, object);
+}
+
+/**
+ * Validates a JSON schema.
+ * @param schema the JSON schema to validate
+ * @returns an error message if the schema is invalid, or undefined if it is valid
+ */
+export function validateSchema(
+  schema: any,
+): Promise<string | undefined> {
+  return syscall("jsonschema.validateSchema", schema);
+}

package/plug-api/syscalls/language.ts

@@ -0,0 +1,23 @@
+import { syscall } from "../syscall.ts";
+import type { ParseTree } from "../lib/tree.ts";
+
+/**
+ * Parses a piece of code using any of the supported SB languages, see `common/languages.ts` for a list
+ * @param language the language to parse
+ * @param code the code to parse
+ * @returns a ParseTree representation of the code
+ */
+export function parseLanguage(
+  language: string,
+  code: string,
+): Promise<ParseTree> {
+  return syscall("language.parseLanguage", language, code);
+}
+
+/**
+ * Lists all supported languages in fenced code blocks
+ * @returns a list of all supported languages
+ */
+export function listLanguages(): Promise<string[]> {
+  return syscall("language.listLanguages");
+}

package/plug-api/syscalls/lua.ts

@@ -0,0 +1,20 @@
+import { syscall } from "../syscall.ts";
+import type { LuaBlock, LuaExpression } from "../../client/space_lua/ast.ts";
+
+export function parse(
+  code: string,
+): Promise<LuaBlock> {
+  return syscall("lua.parse", code);
+}
+
+export function parseExpression(
+  expression: string,
+): Promise<LuaExpression> {
+  return syscall("lua.parseExpression", expression);
+}
+
+export function evalExpression(
+  expression: string,
+): Promise<any> {
+  return syscall("lua.evalExpression", expression);
+}

package/plug-api/syscalls/markdown.ts

@@ -0,0 +1,38 @@
+import { syscall } from "../syscall.ts";
+import type { ParseTree } from "../lib/tree.ts";
+
+/**
+ * Parses a piece of markdown text into a ParseTree.
+ * @param text the markdown text to parse
+ * @returns a ParseTree representation of the markdown text
+ */
+export function parseMarkdown(text: string): Promise<ParseTree> {
+  return syscall("markdown.parseMarkdown", text);
+}
+
+/**
+ * Renders a ParseTree to markdown.
+ * @param tree the parse tree
+ * @returns the rendered markdown of a passed parse tree
+ */
+export function renderParseTree(tree: ParseTree): Promise<string> {
+  return syscall("markdown.renderParseTree", tree);
+}
+
+/**
+ * Expands custom markdown Lua directives and transclusions into plain markdown
+ * @param tree the parse tree
+ * @returns the expaneded markdown
+ */
+export function expandMarkdown(tree: ParseTree): Promise<ParseTree> {
+  return syscall("markdown.expandMarkdown", tree);
+}
+
+/**
+ * Renders markdown text to HTML.
+ * @param markdownText the markdown text to render
+ * @returns HTML representation of the markdown
+ */
+export function markdownToHtml(markdownText: string): Promise<string> {
+  return syscall("markdown.markdownToHtml", markdownText);
+}

package/plug-api/syscalls/mq.ts

@@ -0,0 +1,79 @@
+import { syscall } from "../syscall.ts";
+
+import type { MQStats } from "../../plug-api/types/datastore.ts";
+
+/**
+ * Implements a simple Message Queue system.
+ * @module
+ */
+
+/**
+ * Sends a message to a queue.
+ * @param queue the name of the queue to send the message to
+ * @param body the body of the message to send
+ */
+export function send(queue: string, body: any): Promise<void> {
+  return syscall("mq.send", queue, body);
+}
+
+/**
+ * Sends a batch of messages to a queue.
+ * @param queue the name of the queue
+ * @param bodies the bodies of the messages to send
+ */
+export function batchSend(
+  queue: string,
+  bodies: any[],
+): Promise<void> {
+  return syscall("mq.batchSend", queue, bodies);
+}
+
+/**
+ * Flushes all messages from a queue.
+ * @param queue the name of the queue to subscribe to
+ */
+export function flushQueue(queue: string): Promise<void> {
+  return syscall("mq.flushQueue", queue);
+}
+
+/**
+ * Flushes all messages from all queues.
+ */
+export function flushAllQueues(): Promise<void> {
+  return syscall("mq.flushAllQueues");
+}
+
+/**
+ * Acknowledges a message from a queue, in case it needs to be explicitly acknowledged.
+ * @param queue the name of the queue the message came from
+ * @param id the id of the message to acknowledge
+ */
+export function ack(queue: string, id: string): Promise<void> {
+  return syscall("mq.ack", queue, id);
+}
+
+/**
+ * Acknowledges a batch of messages from a queue, in case they need to be explicitly acknowledged.
+ * @param queue the name of the queue the messages came from
+ * @param ids the ids of the messages to acknowledge
+ */
+export function batchAck(queue: string, ids: string[]): Promise<void> {
+  return syscall("mq.batchAck", queue, ids);
+}
+
+/**
+ * Retrieves stats on a particular queue.
+ * @param queue the name of the queue
+ */
+export function getQueueStats(queue?: string): Promise<MQStats> {
+  return syscall("mq.getQueueStats", queue);
+}
+
+/**
+ * Waits for a queue to become empty.
+ * @param queue the name of the queue
+ * @returns a promise that resolves when the queue is empty
+ */
+export function awaitEmptyQueue(queue: string): Promise<void> {
+  return syscall("mq.awaitEmptyQueue", queue);
+}

package/plug-api/syscalls/shell.ts

@@ -0,0 +1,14 @@
+import { syscall } from "../syscall.ts";
+
+/**
+ * Runs a shell command.
+ * @param cmd the command to run
+ * @param args the arguments to pass to the command
+ * @returns the stdout, stderr, and exit code of the command
+ */
+export function run(
+  cmd: string,
+  args: string[],
+): Promise<{ stdout: string; stderr: string; code: number }> {
+  return syscall("shell.run", cmd, args);
+}

package/plug-api/syscalls/space.ts

@@ -0,0 +1,212 @@
+import { syscall } from "../syscall.ts";
+
+import type {
+  DocumentMeta,
+  FileMeta,
+  PageMeta,
+} from "../../plug-api/types/index.ts";
+import type { Ref } from "@silverbulletmd/silverbullet/lib/ref";
+
+/**
+ * Exposes the space with its pages, documents and plugs.
+ * @module
+ */
+
+/**
+ * Lists all pages (files ending in .md) in the space.
+ * @param unfiltered
+ * @returns a list of all pages in the space represented as PageMeta objects
+ */
+export function listPages(): Promise<PageMeta[]> {
+  return syscall("space.listPages");
+}
+
+/**
+ * Get metadata for a page in the space.
+ * @param name the name of the page to get metadata for
+ * @returns the metadata for the page
+ */
+export function getPageMeta(name: string): Promise<PageMeta> {
+  return syscall("space.getPageMeta", name);
+}
+
+/**
+ * Check if a page exists in the space.
+ * @param name the name of the page to check
+ * @returns true if the page exists, false otherwise
+ */
+export function pageExists(name: string): Promise<boolean> {
+  return syscall("space.pageExists", name);
+}
+
+/**
+ * Read a page from the space as text.
+ * @param name the name of the page to read
+ * @returns the text of the page
+ */
+export function readPage(
+  name: string,
+): Promise<string> {
+  return syscall("space.readPage", name);
+}
+
+/**
+ * Read a page from the space returning both its text and meta data
+ * @param name the name of the page to read
+ * @returns
+ *  - text: page text as a string
+ *  - meta: pageMeta
+ */
+export function readPageWithMeta(
+  name: string,
+): Promise<{ text: string; meta: PageMeta }> {
+  return syscall("space.readPageWithMeta", name);
+}
+
+/**
+ * Write a page to the space.
+ * @param name the name of the page to write
+ * @param text the text of the page to write
+ * @returns the metadata for the written page
+ */
+export function writePage(name: string, text: string): Promise<PageMeta> {
+  return syscall("space.writePage", name, text);
+}
+
+/**
+ * Delete a page from the space.
+ * @param name the name of the page to delete
+ */
+export function deletePage(name: string): Promise<void> {
+  return syscall("space.deletePage", name);
+}
+
+/**
+ * List all plugs in the space.
+ * @returns a list of all plugs in the space represented as FileMeta objects
+ */
+export function listPlugs(): Promise<FileMeta[]> {
+  return syscall("space.listPlugs");
+}
+
+/**
+ * Lists all documents in the space (all files not ending in .md).
+ * @returns a list of all documents in the space represented as DocumentMeta objects
+ */
+export function listDocuments(): Promise<DocumentMeta[]> {
+  return syscall("space.listDocuments");
+}
+
+/**
+ * Get metadata for an document in the space.
+ * @param name the path of the document to get metadata for
+ * @returns the metadata for the document
+ */
+export function getDocumentMeta(name: string): Promise<DocumentMeta> {
+  return syscall("space.getDocumentMeta", name);
+}
+
+/**
+ * Read an document from the space
+ * @param name path of the document to read
+ * @returns the document data as a UInt8Array
+ */
+export function readDocument(
+  name: string,
+): Promise<Uint8Array> {
+  return syscall("space.readDocument", name);
+}
+
+/**
+ * Writes a document to the space
+ * @param name path of the document to write
+ * @param data data itself
+ * @returns
+ */
+export function writeDocument(
+  name: string,
+  data: Uint8Array,
+): Promise<DocumentMeta> {
+  return syscall("space.writeDocument", name, data);
+}
+
+/**
+ * Deletes a document from the space
+ * @param name path of the document to delete
+ */
+export function deleteDocument(name: string): Promise<void> {
+  return syscall("space.deleteDocument", name);
+}
+
+// Lower level-file operations
+
+/**
+ * List all files in the space (pages, documents and plugs).
+ * @returns a list of all files in the space represented as FileMeta objects
+ */
+export function listFiles(): Promise<FileMeta[]> {
+  return syscall("space.listFiles");
+}
+
+/**
+ * Read a file from the space as a Uint8Array.
+ * @param name the name of the file to read
+ * @returns the data of the file
+ */
+export function readFile(name: string): Promise<Uint8Array> {
+  return syscall("space.readFile", name);
+}
+
+/**
+ * Reads a reference (e.g. page#header or page@20) and returns it as a string
+ */
+export function readRef(ref: string | Ref): Promise<string> {
+  return syscall("space.readRef", ref);
+}
+
+/**
+ * Read a file from the space returning both its data and meta data
+ * @param name the name of the page to read
+ * @returns
+ *  - data: file content
+ *  - meta: pageMeta
+ */
+export function readFileWithMeta(
+  name: string,
+): Promise<{ data: Uint8Array; meta: FileMeta }> {
+  return syscall("space.readFileWithMeta", name);
+}
+
+/**
+ * Get metadata for a file in the space.
+ * @param name the name of the file to get metadata for
+ * @returns the metadata for the file
+ */
+export function getFileMeta(name: string): Promise<FileMeta> {
+  return syscall("space.getFileMeta", name);
+}
+
+/**
+ * Write a file to the space.
+ * @param name the name of the file to write
+ * @param data the data of the file to write
+ * @returns the metadata for the written file
+ */
+export function writeFile(
+  name: string,
+  data: Uint8Array,
+): Promise<FileMeta> {
+  return syscall("space.writeFile", name, data);
+}
+
+/**
+ * Delete a file from the space.
+ * @param name the name of the file to delete
+ */
+export function deleteFile(name: string): Promise<void> {
+  return syscall("space.deleteFile", name);
+}
+
+export function fileExists(name: string): Promise<boolean> {
+  return syscall("space.fileExists", name);
+}

package/plug-api/syscalls/sync.ts

@@ -0,0 +1,28 @@
+import { syscall } from "../syscall.ts";
+
+/**
+ * Syscalls that interact with the sync engine (when the client runs in Sync mode)
+ * @module
+ */
+
+/**
+ * Checks if an initial sync has completed
+ */
+export function hasInitialSyncCompleted(): Promise<boolean> {
+  return syscall("sync.hasInitialSyncCompleted");
+}
+
+/**
+ * Syncs a file immediately. Sync would happen automatically, but this prioritizes the file.
+ * @param path the path to the file to sync
+ */
+export function performFileSync(path: string): Promise<void> {
+  return syscall("sync.performFileSync", path);
+}
+
+/**
+ * Performs an immediate full sync.
+ */
+export function performSpaceSync(): Promise<number> {
+  return syscall("sync.performSpaceSync");
+}

package/plug-api/syscalls/system.ts

@@ -0,0 +1,102 @@
+import { syscall } from "../syscall.ts";
+import type { CommandDef } from "../types/manifest.ts";
+import type { SyscallMeta } from "@silverbulletmd/silverbullet/type/index";
+
+/**
+ * System level syscalls
+ * @module
+ */
+
+/**
+ * Invoke a plug function
+ * @param name a string representing the name of the function to invoke ("plug.functionName")
+ * @param args arguments to pass to the function
+ * @returns
+ */
+export function invokeFunction(
+  name: string,
+  ...args: any[]
+): Promise<any> {
+  return syscall("system.invokeFunction", name, ...args);
+}
+
+/**
+ * Invoke a client command by name
+ * Note: only available on the client
+ * @param name name of the command
+ * @param args arguments to pass to the command
+ */
+export function invokeCommand(name: string, args?: string[]): Promise<any> {
+  return syscall("system.invokeCommand", name, args);
+}
+
+/**
+ * Lists all commands available
+ * @returns a map of all available commands
+ */
+export function listCommands(): Promise<Record<string, CommandDef>> {
+  return syscall("system.listCommands");
+}
+
+/**
+ * Lists all syscalls available
+ * @returns a list of all available syscalls
+ */
+export function listSyscalls(): Promise<SyscallMeta[]> {
+  return syscall("system.listSyscalls");
+}
+
+/**
+ * Trigger a reload of all plugs
+ * @returns
+ */
+export function reloadPlugs(): Promise<void> {
+  return syscall("system.reloadPlugs");
+}
+
+/**
+ * Returns the current mode of the system, either "ro" (read-only) or "rw" (read-write)
+ */
+export function getMode(): Promise<"ro" | "rw"> {
+  return syscall("system.getMode");
+}
+
+/**
+ * Returns the prefix set by SB_URL_PREFIX or "/" if the variable isn't set
+ */
+export function getURLPrefix(): Promise<string> {
+  return syscall("system.getURLPrefix");
+}
+
+/**
+ * Returns the base URI for this SilverBullet isntance
+ */
+export function getBaseURI(): Promise<string> {
+  return syscall("system.getBaseURI");
+}
+
+/**
+ * Returns the SilverBullet version
+ */
+export function getVersion(): Promise<string> {
+  return syscall("system.getVersion");
+}
+
+export function getConfig<T = any>(
+  key: string,
+  defaultValue: any = undefined,
+): Promise<T> {
+  return syscall("system.getConfig", key, defaultValue);
+}
+
+export function wipeClient(logout = false): Promise<void> {
+  return syscall("system.wipeClient", logout);
+}
+
+/**
+ * DEPRECATED
+ * Deletes all IndexedDB databases that are not connected to client (e.g. legacy databases)
+ */
+export function cleanDatabases(): Promise<boolean> {
+  return syscall("system.cleanDatabases");
+}

package/plug-api/syscalls/yaml.ts

@@ -0,0 +1,28 @@
+import { syscall } from "../syscall.ts";
+
+/**
+ * YAML operations, exposed via `index` plug
+ * @module
+ */
+
+/**
+ * Parses a YAML string into a JavaScript object.
+ * @param text the YAML text to parse
+ * @returns a JavaScript object representation of the YAML text
+ */
+export function parse(
+  text: string,
+): Promise<any> {
+  return syscall("yaml.parse", text);
+}
+
+/**
+ * Converts a JavaScript object into a YAML string.
+ * @param obj the object to stringify
+ * @returns a YAML string representation of the object
+ */
+export function stringify(
+  obj: any,
+): Promise<string> {
+  return syscall("yaml.stringify", obj);
+}

package/plug-api/syscalls.ts

@@ -0,0 +1,21 @@
+export * as editor from "./syscalls/editor.ts";
+export * as markdown from "./syscalls/markdown.ts";
+export * as space from "./syscalls/space.ts";
+export * as system from "./syscalls/system.ts";
+export * as clientStore from "./syscalls/client_store.ts";
+export * as sync from "./syscalls/sync.ts";
+export * as language from "./syscalls/language.ts";
+export * as codeWidget from "./syscalls/code_widget.ts";
+export * as asset from "./syscalls/asset.ts";
+export * as events from "./syscalls/event.ts";
+export * as shell from "./syscalls/shell.ts";
+export * as mq from "./syscalls/mq.ts";
+export * as datastore from "./syscalls/datastore.ts";
+export * as jsonschema from "./syscalls/jsonschema.ts";
+export * as lua from "./syscalls/lua.ts";
+export * as config from "./syscalls/config.ts";
+
+// Not technically syscalls, but we want to export them for convenience
+export * as index from "./syscalls/index.ts";
+
+export * from "./syscall.ts";