@silverbulletmd/silverbullet 2.4.2 → 2.6.1

package/client/space_lua/query_env.ts

@@ -0,0 +1,26 @@
+import { LuaEnv, luaGet, luaKeys, type LuaStackFrame } from "./runtime.ts";
+
+/**
+ * Build an environment for evaluating per-item expressions in queries.
+ * Extracted to its own module to avoid circular imports between
+ * query_collection.ts and aggregates.ts.
+ */
+export function buildItemEnv(
+  objectVariable: string | undefined,
+  item: any,
+  env: LuaEnv,
+  sf: LuaStackFrame,
+): LuaEnv {
+  const itemEnv = new LuaEnv(env);
+  if (!objectVariable) {
+    // Inject all item keys as variables
+    for (const key of luaKeys(item)) {
+      itemEnv.setLocal(key, luaGet(item, key, sf.astCtx ?? null, sf));
+    }
+    // As well as _
+    itemEnv.setLocal("_", item);
+  } else {
+    itemEnv.setLocal(objectVariable, item);
+  }
+  return itemEnv;
+}

package/client/space_lua/render_lua_markdown.ts

@@ -0,0 +1,369 @@
+import {
+  defaultTransformer,
+  escapeRegularPipes,
+  jsonToMDTable,
+} from "../markdown_renderer/result_render.ts";
+import { isSqlNull } from "../space_lua/liq_null.ts";
+import { isTaggedFloat } from "../space_lua/numeric.ts";
+import { LuaTable, luaFormatNumber } from "../space_lua/runtime.ts";
+
+/**
+ * Applies some heuristics to figure out if a string should be rendered
+ * as a markdown block or inline markdown.
+ */
+export function isBlockMarkdown(s: string) {
+  if (s.includes("\n")) {
+    return true;
+  }
+  return !!s.match(/[-*]\s+/);
+}
+
+function isEmpty(v: any): boolean {
+  return v === undefined || v === null || isSqlNull(v);
+}
+
+function isPlainObject(v: any): v is Record<string, any> {
+  return (
+    typeof v === "object" &&
+    v !== null &&
+    !Array.isArray(v) &&
+    v.constructor === Object
+  );
+}
+
+function formatScalar(v: any): string {
+  if (isEmpty(v)) return "";
+  if (isTaggedFloat(v)) return luaFormatNumber(v.value, "float");
+  if (typeof v === "number") return luaFormatNumber(v);
+  if (typeof v === "boolean") return v ? "true" : "false";
+  return `${v}`.trim();
+}
+
+const emptyTable = "<table data-table-empty></table>";
+
+/**
+ * Build an HTML table from string headers and a row accessor.
+ * Each row is rendered by calling `getCell(rowIndex, header)`.
+ */
+function buildHtmlTable(
+  headers: string[],
+  rowCount: number,
+  getCell: (rowIndex: number, header: string) => any,
+): string {
+  if (headers.length === 0) return emptyTable;
+  const parts: string[] = ["<table><thead><tr>"];
+  for (const h of headers) parts.push(`<th>${h}</th>`);
+  parts.push("</tr></thead><tbody>");
+  for (let i = 0; i < rowCount; i++) {
+    parts.push("<tr>");
+    for (const h of headers) parts.push(renderTd(getCell(i, h)));
+    parts.push("</tr>");
+  }
+  parts.push("</tbody></table>");
+  return parts.join("");
+}
+
+/** Collect the union of string keys across items. */
+function collectHeaders<T>(
+  items: T[],
+  getKeys: (item: T) => Iterable<string>,
+): string[] {
+  const set = new Set<string>();
+  for (const item of items) {
+    for (const k of getKeys(item)) set.add(k);
+  }
+  return [...set];
+}
+
+/**
+ * Classification of a JS/Lua value that drives both the HTML and the
+ * clean-markdown renderers. Keeping this in one place ensures the two
+ * output paths stay in lock-step when new cases are added.
+ */
+export type Classified =
+  | { kind: "nil"; dataType: "nil" }
+  | {
+      kind: "scalar";
+      text: string;
+      dataType: "string" | "number" | "boolean";
+    }
+  | { kind: "emptyTable"; dataType: "table" }
+  | {
+      kind: "record";
+      headers: string[];
+      getCell: (header: string) => any;
+      dataType: "table";
+    }
+  | {
+      kind: "recordArray";
+      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.
+      dataType: "table" | "list";
+    }
+  | { kind: "scalarArray"; items: any[]; dataType: "list" };
+
+export function classifyResult(result: any): Classified {
+  if (isEmpty(result)) return { kind: "nil", dataType: "nil" };
+  if (typeof result === "string") {
+    return { kind: "scalar", text: result, dataType: "string" };
+  }
+  if (isTaggedFloat(result)) {
+    return {
+      kind: "scalar",
+      text: luaFormatNumber(result.value, "float"),
+      dataType: "number",
+    };
+  }
+  if (typeof result === "number") {
+    return {
+      kind: "scalar",
+      text: luaFormatNumber(result),
+      dataType: "number",
+    };
+  }
+  if (typeof result === "boolean") {
+    return {
+      kind: "scalar",
+      text: result ? "true" : "false",
+      dataType: "boolean",
+    };
+  }
+
+  if (result instanceof LuaTable) {
+    if (result.empty()) return { kind: "emptyTable", dataType: "table" };
+    const keys = result.keys();
+    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));
+      if (elements.every((el) => el instanceof LuaTable)) {
+        const tables = elements as LuaTable[];
+        const headers = collectHeaders(tables, (t) => t.keys().map(String));
+        if (headers.length === 0) {
+          return { kind: "emptyTable", dataType: "table" };
+        }
+        return {
+          kind: "recordArray",
+          headers,
+          rowCount: tables.length,
+          getCell: (i, h) => {
+            const key = /^\d+$/.test(h) ? Number(h) : h;
+            return tables[i].rawGet(key);
+          },
+          dataType: "list",
+        };
+      }
+      return { kind: "scalarArray", items: elements, dataType: "list" };
+    }
+
+    // Has string keys (record or mixed) — single-row table
+    const headers = keys.map(String);
+    return {
+      kind: "record",
+      headers,
+      getCell: (h) => {
+        const key = keys[headers.indexOf(h)];
+        return result.rawGet(key);
+      },
+      dataType: "table",
+    };
+  }
+
+  if (Array.isArray(result)) {
+    if (result.length === 0) return { kind: "emptyTable", dataType: "table" };
+    if (result.every(isPlainObject)) {
+      const headers = collectHeaders(result, Object.keys);
+      return {
+        kind: "recordArray",
+        headers,
+        rowCount: result.length,
+        getCell: (i, h) => result[i][h],
+        dataType: "table",
+      };
+    }
+    return { kind: "scalarArray", items: result, dataType: "list" };
+  }
+
+  if (isPlainObject(result)) {
+    if (Object.keys(result).length === 0) {
+      return { kind: "emptyTable", dataType: "table" };
+    }
+    const headers = Object.keys(result);
+    return {
+      kind: "record",
+      headers,
+      getCell: (h) => result[h],
+      dataType: "table",
+    };
+  }
+
+  return { kind: "scalar", text: `${result}`, dataType: "string" };
+}
+
+/**
+ * Render any Lua/JS value to a markdown string (with embedded HTML
+ * for structured data like tables).
+ *
+ * Scalar lists are rendered as plain lines. Tables use HTML for
+ * full nesting support.
+ *
+ * The returned markdown can be fed through the markdown parser and
+ * renderer to produce final HTML, getting wiki links, hashtags,
+ * formatting etc. for free.
+ */
+export function renderResultToMarkdown(
+  result: any,
+  classified: Classified = classifyResult(result),
+): {
+  markdown: string;
+  dataType: string;
+} {
+  switch (classified.kind) {
+    case "nil":
+      return { markdown: "", dataType: "nil" };
+    case "scalar":
+      return { markdown: classified.text, dataType: classified.dataType };
+    case "emptyTable":
+      return { markdown: emptyTable, dataType: "table" };
+    case "record":
+      return {
+        markdown: buildHtmlTable(classified.headers, 1, (_i, h) =>
+          classified.getCell(h),
+        ),
+        dataType: "table",
+      };
+    case "recordArray":
+      return {
+        markdown: buildHtmlTable(
+          classified.headers,
+          classified.rowCount,
+          classified.getCell,
+        ),
+        dataType: classified.dataType,
+      };
+    case "scalarArray":
+      return {
+        markdown: renderArrayToMarkdown(classified.items),
+        dataType: "list",
+      };
+  }
+}
+
+/**
+ * Render any Lua/JS value as "clean" GFM-style markdown suitable for
+ * the Copy button. Tables render as pipe tables, scalar arrays as
+ * newline-joined lines, scalars as their plain text.
+ *
+ * Nested structures inside a table cell degrade to their Lua literal
+ * form (via `LuaTable.toStringAsync()` in `defaultTransformer`), since
+ * GFM table cells cannot contain block-level content.
+ */
+/**
+ * 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),
+ *  - everything else via `defaultTransformer` (which Lua-encodes nested
+ *    tables and escapes pipes for scalars).
+ */
+function cleanCellTransformer(v: any, k: string): Promise<string> {
+  if (k === "ref") return Promise.resolve(`[[${v}]]`);
+  const c = classifyResult(v);
+  if (c.kind === "scalarArray") {
+    return Promise.resolve(
+      c.items
+        .map(formatScalar)
+        .map((s) => escapeRegularPipes(s.replaceAll("\n", " ")))
+        .join("<br/>"),
+    );
+  }
+  return defaultTransformer(v, k);
+}
+
+export async function renderResultToCleanMarkdown(
+  result: any,
+  classified: Classified = classifyResult(result),
+): Promise<string> {
+  switch (classified.kind) {
+    case "nil":
+      return "";
+    case "scalar":
+      return classified.text;
+    case "emptyTable":
+      return "*(empty table)*";
+    case "record": {
+      const row: Record<string, any> = {};
+      for (const h of classified.headers) row[h] = classified.getCell(h);
+      return jsonToMDTable([row], cleanCellTransformer);
+    }
+    case "recordArray": {
+      const rows: Record<string, any>[] = [];
+      for (let i = 0; i < classified.rowCount; i++) {
+        const row: Record<string, any> = {};
+        for (const h of classified.headers) row[h] = classified.getCell(i, h);
+        rows.push(row);
+      }
+      return jsonToMDTable(rows, cleanCellTransformer);
+    }
+    case "scalarArray":
+      return classified.items.map(formatScalar).join("\n");
+  }
+}
+
+function luaTypeName(v: any): string | undefined {
+  if (isEmpty(v)) return undefined;
+  if (typeof v === "number" || isTaggedFloat(v)) return "number";
+  if (typeof v === "string") return "string";
+  if (typeof v === "boolean") return "boolean";
+  if (v instanceof LuaTable) {
+    return v.keys().some((k) => typeof k === "string") ? "table" : "array";
+  }
+  if (Array.isArray(v)) return "array";
+  if (isPlainObject(v)) return "table";
+  return "string";
+}
+
+function renderTd(v: any): string {
+  if (isEmpty(v)) return "<td data-table-cell-empty></td>";
+  const type = luaTypeName(v);
+  const attr = type ? ` data-table-cell-type="${type}"` : "";
+  return `<td${attr}>${renderCellContent(v)}</td>`;
+}
+
+function renderArrayToMarkdown(items: any[]): string {
+  return items.map((item) => renderCellContent(item)).join("\n");
+}
+
+function renderArrayToHtmlLines(items: any[]): string {
+  return items.map((item) => renderCellContent(item)).join("<br/>");
+}
+
+/**
+ * Render a value as cell content. Used inside HTML contexts (table
+ * cells, nested structures) where markdown block syntax won't be
+ * parsed, so scalar arrays are joined with `<br/>` rather than newlines.
+ */
+function renderCellContent(v: any): string {
+  const c = classifyResult(v);
+  switch (c.kind) {
+    case "nil":
+      return "";
+    case "scalar":
+      return c.text;
+    case "emptyTable":
+      return emptyTable;
+    case "record":
+      return buildHtmlTable(c.headers, 1, (_i, h) => c.getCell(h));
+    case "recordArray":
+      return buildHtmlTable(c.headers, c.rowCount, c.getCell);
+    case "scalarArray":
+      return renderArrayToHtmlLines(c.items);
+  }
+}

package/client/space_lua/rp.ts

@@ -2,11 +2,12 @@
 
 export type RP<T> = T | Promise<T>;
 
-// Returns true when v is a Promise or a has a then function.
+// Returns true when v is a Promise or has a then function.
+// Optimized: skip the property access for primitives (number, string, boolean, null, undefined).
 export function isPromise<T>(v: RP<T>): v is Promise<T> {
-  return v !== null &&
-    (typeof v === "object" || typeof v === "function") &&
-    typeof (v as any).then === "function";
+  return (
+    typeof v === "object" && v !== null && typeof (v as any).then === "function"
+  );
 }
 
 export function rpThen<A, B>(v: RP<A>, f: (a: A) => RP<B>): RP<B> {