@silverbulletmd/silverbullet 2.4.1

package/client/space_lua/stdlib/os.ts

@@ -0,0 +1,368 @@
+import { LuaBuiltinFunction, LuaTable } from "../runtime.ts";
+
+const ONE_DAY = 1000 * 60 * 60 * 24;
+const ONE_WEEK = ONE_DAY * 7;
+
+function weekNumber(
+  d: Date,
+  utc: boolean,
+  weekStartDay: number,
+  iso: boolean,
+): number {
+  const year = utc ? d.getUTCFullYear() : d.getFullYear();
+  const month = utc ? d.getUTCMonth() : d.getMonth();
+  const day = utc ? d.getUTCDate() : d.getDate();
+  const date = new Date(Date.UTC(year, month, day));
+
+  if (iso) {
+    const target = new Date(date);
+    target.setUTCDate(
+      target.getUTCDate() + 3 - ((target.getUTCDay() + 6) % 7),
+    );
+
+    const yearStart = new Date(Date.UTC(target.getUTCFullYear(), 0, 4));
+    const weekStart = new Date(yearStart);
+    weekStart.setUTCDate(
+      yearStart.getUTCDate() - ((yearStart.getUTCDay() + 6) % 7),
+    );
+
+    return 1 + Math.floor((target.getTime() - weekStart.getTime()) / ONE_WEEK);
+  }
+
+  const yearStart = new Date(Date.UTC(year, 0, 1));
+  const startDay = yearStart.getUTCDay();
+  const offset = (7 + (startDay - weekStartDay)) % 7;
+  const firstWeekStart = new Date(yearStart);
+
+  firstWeekStart.setUTCDate(yearStart.getUTCDate() + (7 - offset) % 7);
+
+  if (date < firstWeekStart) return 0;
+  return 1 +
+    Math.floor((date.getTime() - firstWeekStart.getTime()) / ONE_WEEK);
+}
+
+function dayOfYear(d: Date, utc: boolean): number {
+  const year = utc ? d.getUTCFullYear() : d.getFullYear();
+  const start = new Date(Date.UTC(year, 0, 0));
+
+  const current = utc
+    ? new Date(
+      Date.UTC(
+        year,
+        d.getUTCMonth(),
+        d.getUTCDate(),
+        d.getUTCHours(),
+        d.getUTCMinutes(),
+        d.getUTCSeconds(),
+      ),
+    )
+    : new Date(
+      Date.UTC(
+        year,
+        d.getMonth(),
+        d.getDate(),
+        d.getHours(),
+        d.getMinutes(),
+        d.getSeconds(),
+      ),
+    );
+
+  return Math.floor((current.getTime() - start.getTime()) / ONE_DAY);
+}
+
+function isoWeekYear(d: Date, utc: boolean): number {
+  const year = utc ? d.getUTCFullYear() : d.getFullYear();
+  const month = utc ? d.getUTCMonth() : d.getMonth();
+  const day = utc ? d.getUTCDate() : d.getDate();
+  const target = new Date(Date.UTC(year, month, day));
+
+  target.setUTCDate(
+    target.getUTCDate() + 3 - ((target.getUTCDay() + 6) % 7),
+  );
+
+  return target.getUTCFullYear();
+}
+
+function isDST(d: Date): boolean {
+  const jan = new Date(d.getFullYear(), 0, 1);
+
+  return d.getTimezoneOffset() < jan.getTimezoneOffset();
+}
+
+function yr(d: Date, utc: boolean): number {
+  return utc ? d.getUTCFullYear() : d.getFullYear();
+}
+
+function mo(d: Date, utc: boolean): number {
+  return utc ? d.getUTCMonth() : d.getMonth();
+}
+
+function da(d: Date, utc: boolean): number {
+  return utc ? d.getUTCDate() : d.getDate();
+}
+
+function hr(d: Date, utc: boolean): number {
+  return utc ? d.getUTCHours() : d.getHours();
+}
+
+function mi(d: Date, utc: boolean): number {
+  return utc ? d.getUTCMinutes() : d.getMinutes();
+}
+
+function sc(d: Date, utc: boolean): number {
+  return utc ? d.getUTCSeconds() : d.getSeconds();
+}
+
+function wd(d: Date, utc: boolean): number {
+  return utc ? d.getUTCDay() : d.getDay();
+}
+
+function pad2(n: number): string {
+  return n.toString().padStart(2, "0");
+}
+
+function pad3(n: number): string {
+  return n.toString().padStart(3, "0");
+}
+
+function dateTable(d: Date, utc: boolean): LuaTable {
+  const tbl = new LuaTable({
+    year: yr(d, utc),
+    month: mo(d, utc) + 1,
+    day: da(d, utc),
+    hour: hr(d, utc),
+    min: mi(d, utc),
+    sec: sc(d, utc),
+    wday: wd(d, utc) + 1,
+    yday: dayOfYear(d, utc),
+  });
+
+  if (!utc) {
+    tbl.rawSet("isdst", isDST(d));
+  }
+
+  return tbl;
+}
+
+// Build the specifier map for a given `Date` and `utc` flag.
+// Returns a record mapping single-char specifier to its output string.
+function buildSpecMap(
+  d: Date,
+  utc: boolean,
+): Record<string, () => string> {
+  const h = () => hr(d, utc);
+  const h12 = () => h() % 12 || 12;
+  const dow = () => wd(d, utc);
+
+  return {
+    // Date
+    "Y": () => yr(d, utc).toString(),
+    "y": () => pad2(yr(d, utc) % 100),
+    "C": () => pad2(Math.floor(yr(d, utc) / 100)),
+    "m": () => pad2(mo(d, utc) + 1),
+    "d": () => pad2(da(d, utc)),
+    "e": () => da(d, utc).toString().padStart(2, " "),
+    "j": () => pad3(dayOfYear(d, utc)),
+
+    // Time
+    "H": () => pad2(h()),
+    "I": () => pad2(h12()),
+    "M": () => pad2(mi(d, utc)),
+    "S": () => pad2(sc(d, utc)),
+    "p": () => h() >= 12 ? "PM" : "AM",
+
+    // Weekday
+    "A": () =>
+      d.toLocaleString("en-US", {
+        weekday: "long",
+        ...(utc ? { timeZone: "UTC" } : {}),
+      }),
+    "a": () =>
+      d.toLocaleString("en-US", {
+        weekday: "short",
+        ...(utc ? { timeZone: "UTC" } : {}),
+      }),
+    "w": () => dow().toString(),
+    "u": () => (dow() === 0 ? 7 : dow()).toString(),
+
+    // Month name
+    "b": () =>
+      d.toLocaleString("en-US", {
+        month: "short",
+        ...(utc ? { timeZone: "UTC" } : {}),
+      }),
+    "h": () =>
+      d.toLocaleString("en-US", {
+        month: "short",
+        ...(utc ? { timeZone: "UTC" } : {}),
+      }),
+    "B": () =>
+      d.toLocaleString("en-US", {
+        month: "long",
+        ...(utc ? { timeZone: "UTC" } : {}),
+      }),
+
+    // Week number
+    "U": () => pad2(weekNumber(d, utc, 0, false)),
+    "W": () => pad2(weekNumber(d, utc, 1, false)),
+    "V": () => pad2(weekNumber(d, utc, 1, true)),
+    "G": () => isoWeekYear(d, utc).toString(),
+    "g": () => pad2(isoWeekYear(d, utc) % 100),
+
+    // Composite specifiers
+    "c": () =>
+      d.toLocaleString("en-US", {
+        ...(utc ? { timeZone: "UTC" } : {}),
+      }),
+    "x": () =>
+      d.toLocaleDateString("en-US", {
+        ...(utc ? { timeZone: "UTC" } : {}),
+      }),
+    "X": () =>
+      d.toLocaleTimeString("en-US", {
+        ...(utc ? { timeZone: "UTC" } : {}),
+      }),
+    "D": () =>
+      `${pad2(mo(d, utc) + 1)}/${pad2(da(d, utc))}/${pad2(yr(d, utc) % 100)}`,
+    "F": () =>
+      `${yr(d, utc).toString()}-${pad2(mo(d, utc) + 1)}-${pad2(da(d, utc))}`,
+    "R": () => `${pad2(h())}:${pad2(mi(d, utc))}`,
+    "T": () => `${pad2(h())}:${pad2(mi(d, utc))}:${pad2(sc(d, utc))}`,
+    "r": () =>
+      `${pad2(h12())}:${pad2(mi(d, utc))}:${pad2(sc(d, utc))} ${
+        h() >= 12 ? "PM" : "AM"
+      }`,
+
+    // Epoch
+    "s": () => Math.floor(d.getTime() / 1000).toString(),
+
+    // Whitespace
+    "n": () => "\n",
+    "t": () => "\t",
+
+    // Timezone
+    "Z": () => {
+      if (utc) return "UTC";
+      const match = d.toTimeString().match(/\((.*)\)/);
+      return match ? match[1] : "";
+    },
+    "z": () => {
+      if (utc) return "+0000";
+      const offset = -d.getTimezoneOffset();
+      const sign = offset >= 0 ? "+" : "-";
+      const abs = Math.abs(offset);
+      return `${sign}${pad2(Math.floor(abs / 60))}${pad2(abs % 60)}`;
+    },
+
+    // Literal
+    "%": () => "%",
+  };
+}
+
+function luaFormatTime(fmt: string, d: Date, utc: boolean): string {
+  const specs = buildSpecMap(d, utc);
+
+  let out = "";
+  let i = 0;
+
+  while (i < fmt.length) {
+    if (fmt[i] !== "%") {
+      out += fmt[i];
+      i++;
+      continue;
+    }
+    i++; // skip '%'
+    if (i >= fmt.length) {
+      throw new Error("invalid conversion specifier '%'");
+    }
+
+    const ch = fmt[i];
+    const fn = specs[ch];
+    if (!fn) {
+      throw new Error(`invalid conversion specifier '%${ch}'`);
+    }
+
+    out += fn();
+    i++;
+  }
+
+  return out;
+}
+
+export const osApi = new LuaTable({
+  time: new LuaBuiltinFunction((_sf, tbl?: LuaTable) => {
+    if (tbl) {
+      if (!tbl.has("year")) {
+        throw new Error("time(): year is required");
+      }
+
+      if (!tbl.has("month")) {
+        throw new Error("time(): month is required");
+      }
+
+      if (!tbl.has("day")) {
+        throw new Error("time(): day is required");
+      }
+
+      const year = tbl.get("year");
+      const month = tbl.get("month");
+      const day = tbl.get("day");
+      const hour = tbl.get("hour") ?? 12;
+      const min = tbl.get("min") ?? 0;
+      const sec = tbl.get("sec") ?? 0;
+      const date = new Date(year, month - 1, day, hour, min, sec);
+
+      return Math.floor(date.getTime() / 1000);
+    }
+
+    return Math.floor(Date.now() / 1000);
+  }),
+
+  // Returns the difference, from time `t1` to time `t2` in seconds
+  // In POSIX and some other systems, this value is exactly $t2-t1$.
+  difftime: new LuaBuiltinFunction((_sf, t2: number, t1: number): number => {
+    return t2 - t1;
+  }),
+
+  // Returns a string or a table containing date and time, formatted
+  // according to the given string format.
+  //
+  // If format starts with '!', the date is formatted in UTC.
+  //
+  // If format is "*t" (or "!*t"), returns a table with fields:
+  //
+  // - `year`,
+  // - `month` (1-12),
+  // - `day` (1-31),
+  // - `hour` (0-23),
+  // - `min` (0-59),
+  // - `sec` (0-61),
+  // - `wday` (1-7, Sunday is 1),
+  // - `yday` (1-366), and
+  // - `isdst` (boolean).
+  //
+  // Otherwise, format specifiers follow ISO C `strftime`.
+  //
+  // If format is absent, it defaults to `%c`.
+  date: new LuaBuiltinFunction(
+    (_sf, format?: string, timestamp?: number) => {
+      let fmt = format ?? "%c";
+      let utc = false;
+
+      if (fmt.startsWith("!")) {
+        utc = true;
+        fmt = fmt.slice(1);
+      }
+
+      const d = timestamp !== undefined && timestamp !== null
+        ? new Date(timestamp * 1000)
+        : new Date();
+
+      if (fmt === "*t") {
+        return dateTable(d, utc);
+      }
+
+      return luaFormatTime(fmt, d, utc);
+    },
+  ),
+});

package/client/space_lua/stdlib/space_lua.ts

@@ -0,0 +1,153 @@
+import { parseExpressionString } from "../parse.ts";
+import type { LuaExpression } from "../ast.ts";
+import { evalExpression } from "../eval.ts";
+import {
+  LuaBuiltinFunction,
+  LuaEnv,
+  LuaRuntimeError,
+  type LuaStackFrame,
+  LuaTable,
+  luaToString,
+  luaValueToJS,
+  singleResult,
+} from "../runtime.ts";
+
+/**
+ * These are Space Lua specific functions that are available to all scripts, but are not part of the standard Lua language.
+ */
+
+/**
+ * Helper function to create an augmented environment
+ */
+function createAugmentedEnv(
+  sf: LuaStackFrame,
+  envAugmentation?: LuaTable,
+): LuaEnv {
+  const globalEnv = sf.threadLocal.get("_GLOBAL");
+  if (!globalEnv) {
+    throw new Error("_GLOBAL not defined");
+  }
+  const env = new LuaEnv(globalEnv);
+  if (envAugmentation) {
+    env.setLocal("_", envAugmentation);
+    for (const key of envAugmentation.keys()) {
+      env.setLocal(key, envAugmentation.rawGet(key));
+    }
+  }
+  return env;
+}
+
+/**
+ * Interpolates a string with lua expressions and returns the result.
+ *
+ * @param sf - The current space_lua state.
+ * @param template - The template string to interpolate.
+ * @param envAugmentation - An optional environment to augment the global environment with.
+ * @returns The interpolated string.
+ */
+export async function interpolateLuaString(
+  sf: LuaStackFrame,
+  template: string,
+  envAugmentation?: LuaTable,
+): Promise<string> {
+  let result = "";
+  let currentIndex = 0;
+
+  while (true) {
+    const startIndex = template.indexOf("${", currentIndex);
+    if (startIndex === -1) {
+      result += template.slice(currentIndex);
+      break;
+    }
+
+    result += template.slice(currentIndex, startIndex);
+
+    // Find matching closing brace by counting nesting
+    let nestLevel = 1;
+    let endIndex = startIndex + 2;
+    while (nestLevel > 0 && endIndex < template.length) {
+      if (template[endIndex] === "{") {
+        nestLevel++;
+      } else if (template[endIndex] === "}") {
+        nestLevel--;
+      }
+      if (nestLevel > 0) {
+        endIndex++;
+      }
+    }
+
+    if (nestLevel > 0) {
+      throw new LuaRuntimeError("Unclosed interpolation expression", sf);
+    }
+
+    const expr = template.slice(startIndex + 2, endIndex);
+    try {
+      const parsedExpr = parseExpressionString(expr);
+      const env = createAugmentedEnv(sf, envAugmentation);
+      // Do `luaToString` before `luaValueToJS` to preserve tagged float
+      // formatting.
+      const luaResult = singleResult(await evalExpression(parsedExpr, env, sf));
+      result += await luaToString(luaResult);
+    } catch (e: any) {
+      throw new LuaRuntimeError(
+        `Error evaluating "${expr}": ${e.message}`,
+        sf,
+      );
+    }
+
+    currentIndex = endIndex + 1;
+  }
+
+  return result;
+}
+
+export const spaceluaApi = new LuaTable({
+  /**
+   * Parses a lua expression and returns the parsed expression.
+   *
+   * @param sf - The current space_lua state.
+   * @param luaExpression - The lua expression to parse.
+   * @returns The parsed expression.
+   */
+  parseExpression: new LuaBuiltinFunction(
+    (_sf, luaExpression: string) => {
+      return parseExpressionString(luaExpression);
+    },
+  ),
+  /**
+   * Evaluates a parsed lua expression and returns the result.
+   *
+   * @param sf - The current space_lua state.
+   * @param parsedExpr - The parsed lua expression to evaluate.
+   * @param envAugmentation - An optional environment to augment the global environment with.
+   * @returns The result of the evaluated expression.
+   */
+  evalExpression: new LuaBuiltinFunction(
+    async (sf, parsedExpr: LuaExpression, envAugmentation?: LuaTable) => {
+      const env = createAugmentedEnv(sf, envAugmentation);
+      return luaValueToJS(await evalExpression(parsedExpr, env, sf), sf);
+    },
+  ),
+  /**
+   * Interpolates a string with lua expressions and returns the result.
+   */
+  interpolate: new LuaBuiltinFunction(
+    (sf, template: string, envAugmentation?: LuaTable) => {
+      return interpolateLuaString(sf, template, envAugmentation);
+    },
+  ),
+  /**
+   * Returns your SilverBullet instance's base URL, or `undefined` when run on the server
+   */
+  baseUrl: new LuaBuiltinFunction(
+    () => {
+      // Deal with Deno
+      if (typeof location === "undefined") {
+        return null;
+      } else {
+        //NOTE: Removing trailing slash to stay compatible with original code: `location.protocol + "//" + location.host;`
+        return document.baseURI.replace(/\/*$/, "");
+      }
+    },
+  ),
+});