@silverbulletmd/silverbullet 2.9.0 → 2.10.0

package/plug-api/ui/panel_styles.ts

@@ -15,9 +15,10 @@ export type PanelStylesOptions = {
  * Order: components first (base), then space styles (so user theming wins),
  * leaving any plug-specific CSS you append afterwards highest-precedence.
  */
-export async function panelStyles(
-  { components = true, spaceStyles = true }: PanelStylesOptions = {},
-): Promise<string> {
+export async function panelStyles({
+  components = true,
+  spaceStyles = true,
+}: PanelStylesOptions = {}): Promise<string> {
   let out = "";
   if (components) {
     out += `<link rel="stylesheet" href=".client/components.css">`;

package/plug-api/ui/slugify.ts

@@ -0,0 +1,44 @@
+/**
+ * Lower-cased, filesystem- and URL-safe version of a space name, used to
+ * derive its default folder and URL prefix.
+ *
+ * Mirrors the server's `slug::slugify`, so a prefix typed into the Space
+ * Manager, the first-run wizard, or the desktop app's space form all reach the
+ * server in the same shape.
+ */
+export function slugify(name: string): string {
+  return name
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+/**
+ * The default URL prefix for a space called `name`, as an absolute path.
+ *
+ * The leading slash is part of the value, not decoration: a binding prefix is
+ * a path, the server stores and validates it that way, and showing it in the
+ * field is what makes the assembled URL in `UrlPrefixInput` read correctly. An
+ * empty name yields `""` rather than a bare `"/"`, which would bind the space
+ * to the server root.
+ */
+export function prefixFromName(name: string): string {
+  const slug = slugify(name);
+  return slug ? `/${slug}` : "";
+}
+
+/**
+ * Force a user-typed prefix into the shape the server accepts: exactly one
+ * leading slash, and a slugified body.
+ *
+ * Callers that hand a prefix straight to an API need this because a value
+ * already starting with `/` is taken as-is by the desktop app's
+ * `provision_space` command — it only slugifies input that lacks the slash, so
+ * `/My Space!` would otherwise be sent through verbatim. Returns `""` for an
+ * empty or slash-only input, the server's spelling of a root binding.
+ */
+export function normalizePrefix(raw: string): string {
+  const slug = slugify(raw.replace(/^\/+/, ""));
+  return slug ? `/${slug}` : "";
+}

package/client/plugos/syscalls/lua.ts

@@ -1,81 +0,0 @@
-import type { SysCallMapping } from "../system.ts";
-import { evalExpression } from "../../space_lua/eval.ts";
-import { parseBlock, parseExpressionString } from "../../space_lua/parse.ts";
-import {
-  type PrintOptions,
-  prettyPrintBlock,
-  prettyPrintExpression,
-} from "../../space_lua/pretty_print.ts";
-import {
-  LuaStackFrame,
-  luaToString,
-  luaValueToJS,
-} from "../../space_lua/runtime.ts";
-import { buildThreadLocalEnv } from "../../space_lua_api.ts";
-import { isSendable } from "../util.ts";
-import type { LuaBlock, LuaExpression } from "../../space_lua/ast.ts";
-import type { ClientSystem } from "../../client_system.ts";
-
-export function luaSyscalls(clientSystem: ClientSystem): SysCallMapping {
-  return {
-    "lua.parseBlock": (_ctx, code: string): LuaBlock => {
-      return parseBlock(code);
-    },
-    // Deprecated alias for `lua.parseBlock`, kept for backwards compatibility.
-    "lua.parse": (_ctx, code: string): LuaBlock => {
-      return parseBlock(code);
-    },
-    "lua.parseExpression": (_ctx, expression: string): LuaExpression => {
-      return parseExpressionString(expression);
-    },
-    "lua.prettyPrintBlock": (
-      _ctx,
-      block: LuaBlock,
-      opts?: PrintOptions,
-    ): string => {
-      return prettyPrintBlock(block, opts);
-    },
-    "lua.prettyPrintExpression": (
-      _ctx,
-      expression: LuaExpression,
-      opts?: PrintOptions,
-    ): string => {
-      return prettyPrintExpression(expression, opts);
-    },
-    /**
-     * Evaluates a Lua expression and returns the result as a JavaScript value
-     * @param _ctx
-     * @param expression
-     * @returns
-     */
-    "lua.evalExpression": async (_ctx, expression: string) => {
-      try {
-        const ast = parseExpressionString(expression);
-        const env = await buildThreadLocalEnv(
-          clientSystem.system,
-          clientSystem.spaceLuaEnv.env,
-        );
-        const sf = new LuaStackFrame(env, null);
-        const luaResult = await evalExpression(
-          ast,
-          clientSystem.spaceLuaEnv.env,
-          sf,
-        );
-        const jsResult = luaValueToJS(luaResult, sf);
-        if (isSendable(jsResult)) {
-          return jsResult;
-        } else {
-          // This may evaluate to e.g. a function, which is not sendable, in this case we'll console.warn and return a stringified version of the result
-          console.warn(
-            "Lua eval result is not sendable, returning stringified version",
-            jsResult,
-          );
-          return luaToString(luaResult);
-        }
-      } catch (e: any) {
-        console.error("Lua eval error: ", e.message, e.sf?.astCtx);
-        throw e;
-      }
-    },
-  };
-}