@silverbulletmd/silverbullet 2.9.0 → 2.11.0

package/client/space_lua/render_lua_markdown.ts

@@ -99,8 +99,7 @@ export type Classified =
       headers: string[];
       rowCount: number;
       getCell: (rowIndex: number, header: string) => any;
-      // LuaTable record-arrays are historically tagged as "list", while
-      // JS record-arrays are tagged as "table". Preserved for compatibility.
+      // Compatibility contract: LuaTable record-arrays use "list"; JS arrays use "table".
       dataType: "table" | "list";
     }
   | { kind: "scalarArray"; items: any[]; dataType: "list" };
@@ -138,7 +137,6 @@ export function classifyResult(result: any): Classified {
     const arrayLen = result.length;
     const hasStrKeys = keys.some((k) => typeof k === "string");
 
-    // Pure array
     if (arrayLen > 0 && !hasStrKeys) {
       const elements: any[] = [];
       for (let i = 1; i <= arrayLen; i++) elements.push(result.rawGet(i));
@@ -162,7 +160,6 @@ export function classifyResult(result: any): Classified {
       return { kind: "scalarArray", items: elements, dataType: "list" };
     }
 
-    // Has string keys (record or mixed) — single-row table
     const headers = keys.map(String);
     return {
       kind: "record",
@@ -267,9 +264,7 @@ export function renderResultToMarkdown(
 /**
  * Cell transformer for the clean-markdown (copy) path. Renders:
  *  - `ref` columns as wiki links,
- *  - scalar arrays as `<br/>`-joined lines (mirrors the HTML display
- *    path, and relies on the markdown renderer now handling self-closing
- *    `<br/>` inside GFM table cells),
+ *  - scalar arrays as `<br/>`-joined lines inside GFM table cells,
  *  - everything else via `defaultTransformer` (which Lua-encodes nested
  *    tables and escapes pipes for scalars).
  */

package/client/space_lua/render_widget.ts

@@ -0,0 +1,173 @@
+import type { ASTCtx } from "./ast.ts";
+import { evalExpression } from "./eval.ts";
+import { parseExpressionString } from "./parse.ts";
+import {
+  type ILuaFunction,
+  LuaEnv,
+  LuaRuntimeError,
+  LuaStackFrame,
+  LuaTable,
+  type LuaValue,
+  luaValueToJS,
+  singleResult,
+} from "./runtime.ts";
+import {
+  BUSY_LIMIT_DEFAULT_MS,
+  LuaBudgetStopped,
+  makeLuaBudget,
+} from "./budget.ts";
+import { isTaggedFloat } from "./numeric.ts";
+import {
+  encodeRef,
+  getNameFromPath,
+} from "@silverbulletmd/silverbullet/lib/ref";
+import { resolveASTReference } from "../space_lua.ts";
+import type { Client } from "../client.ts";
+import { isViewValue } from "../navigator/view_value.ts";
+import {
+  classifyResult,
+  renderResultToCleanMarkdown,
+} from "./render_lua_markdown.ts";
+
+/**
+ * Run a Space Lua computation and convert its result into something the
+ * LuaWidget renderer understands (a widget table, markdown string, or number).
+ * Shared by the `${...}` directive and Lua code widgets so the conversion +
+ * error formatting live in one place.
+ */
+export async function renderLuaWidgetResult(
+  client: Client,
+  compute: (env: LuaEnv, sf: LuaStackFrame) => Promise<LuaValue> | LuaValue,
+  ctx: ASTCtx,
+  currentPageMeta?: { name: string } | undefined,
+): Promise<any> {
+  try {
+    const tl = new LuaEnv();
+    tl.setLocal(
+      "currentPage",
+      currentPageMeta ||
+        (client.ui.viewState.current
+          ? { name: getNameFromPath(client.ui.viewState.current.path) }
+          : undefined),
+    );
+    const sf = LuaStackFrame.createWithGlobalEnv(
+      client.clientSystem.spaceLuaEnv.env,
+      ctx,
+    );
+    sf.threadState.budget = makeLuaBudget({
+      busyLimitMs: BUSY_LIMIT_DEFAULT_MS,
+      onLimit: (b) => {
+        b.stopped = true;
+      },
+    });
+    const env = new LuaEnv(client.clientSystem.spaceLuaEnv.env);
+    env.setLocal("_CTX", tl);
+    const rawResult = singleResult(await compute(env, sf));
+    if (isTaggedFloat(rawResult) || typeof rawResult === "number") {
+      return rawResult;
+    }
+    if (rawResult instanceof LuaTable) {
+      if (rawResult.rawGet("_isWidget")) {
+        return luaValueToJS(rawResult, sf);
+      }
+      return rawResult;
+    }
+    return luaValueToJS(rawResult, sf);
+  } catch (e: any) {
+    if (e instanceof LuaBudgetStopped) {
+      return `**Lua timeout:** this widget took too long to render and was stopped. Reload the page to try again.`;
+    }
+    if (e instanceof LuaRuntimeError && e.sf?.astCtx) {
+      const source = resolveASTReference(e.sf.astCtx);
+      if (source) {
+        return `**Lua error:** ${e.message} (Origin: [[${encodeRef(source)}]])`;
+      }
+    }
+    return `**Lua error:** ${e.message}`;
+  }
+}
+
+/** Evaluate a `${...}`-style expression string and render it as a widget. */
+export async function renderLuaExpression(
+  client: Client,
+  expressionText: string,
+  currentPageMeta?: { name: string } | undefined,
+): Promise<any> {
+  if (expressionText.trim().length === 0) {
+    return "**Error:** Empty Lua expression";
+  }
+  const expr = parseExpressionString(expressionText);
+  return renderLuaWidgetResult(
+    client,
+    (env, sf) => evalExpression(expr, env, sf),
+    expr.ctx,
+    currentPageMeta,
+  );
+}
+
+/** Call a stored Lua render function (e.g. a code widget) and render it. */
+export async function renderLuaCallback(
+  client: Client,
+  fn: ILuaFunction,
+  args: LuaValue[],
+  currentPageMeta?: { name: string } | undefined,
+): Promise<any> {
+  return renderLuaWidgetResult(
+    client,
+    (_env, sf) => fn.call(sf, ...args),
+    {} as ASTCtx,
+    currentPageMeta,
+  );
+}
+
+export type PortableMarkdownResult =
+  | { ok: true; markdown: string }
+  | { ok: false; reason: string };
+
+/**
+ * Evaluate a `${...}`-style expression and produce portable GFM markdown — the
+ * same clean rendering the Copy button uses — or report why it can't be baked.
+ * - nil/empty → ok with empty markdown
+ * - Lua error → not ok (the eval error string)
+ * - widget object: portable only if it exposes a `markdown` rendering;
+ *   html-only widgets are not bakeable
+ * - scalars / tables / arrays / strings → clean GFM
+ */
+export async function expressionToPortableMarkdown(
+  client: Client,
+  expressionText: string,
+  currentPageMeta?: { name: string } | undefined,
+): Promise<PortableMarkdownResult> {
+  const rawResult = await renderLuaExpression(
+    client,
+    expressionText,
+    currentPageMeta,
+  );
+  if (isViewValue(rawResult)) {
+    return { ok: false, reason: "A view has no portable Markdown rendering" };
+  }
+  if (rawResult === null || rawResult === undefined) {
+    return { ok: true, markdown: "" };
+  }
+  // renderLuaExpression returns eval failures as markdown error strings.
+  if (
+    typeof rawResult === "string" &&
+    (rawResult.startsWith("**Lua error:**") ||
+      rawResult.startsWith("**Error:**"))
+  ) {
+    return { ok: false, reason: rawResult };
+  }
+  // Widget objects: portable only when they expose a `markdown` rendering.
+  if (typeof rawResult === "object" && (rawResult as any)._isWidget) {
+    const md = (rawResult as any).markdown;
+    if (typeof md === "string") {
+      return { ok: true, markdown: md.trim() };
+    }
+    return { ok: false, reason: "html-only widget (no markdown rendering)" };
+  }
+  const markdown = await renderResultToCleanMarkdown(
+    rawResult,
+    classifyResult(rawResult),
+  );
+  return { ok: true, markdown };
+}