@shwfed/config 2.10.7 → 2.10.9

package/dist/runtime/components/ui/markdown/Markdown.vue

@@ -1,4 +1,5 @@
 <script>
+import { useRuntimeConfig } from "#app";
 import { computed, defineComponent, h } from "vue";
 import { md } from "../../../utils/markdown";
 import { TRIGGER_CLASS } from "../../../utils/markdown-tooltip";
@@ -16,20 +17,20 @@ const tokenAttrs = (tok) => {
   for (const [name, value] of tok.attrs) out[name] = value;
   return out;
 };
-const renderTooltip = (tok) => {
+const renderTooltip = (tok, env) => {
   const meta = tok.meta;
   return h(Tooltip, { delayDuration: 180 }, () => [
     h(TooltipTrigger, { asChild: true }, () => h("span", {
       class: TRIGGER_CLASS,
-      innerHTML: md.renderInline(meta.trigger)
+      innerHTML: md.renderInline(meta.trigger, env)
     })),
     h(TooltipContent, { class: "max-w-xs text-xs" }, () => h("span", {
       class: "prose prose-zinc text-xs",
-      innerHTML: md.render(meta.content)
+      innerHTML: md.render(meta.content, env)
     }))
   ]);
 };
-const renderInlineChildren = (children) => {
+const renderInlineChildren = (children, env) => {
   const vnodes = [];
   let bufferStart = 0;
   for (let i = 0; i <= children.length; i++) {
@@ -38,11 +39,11 @@ const renderInlineChildren = (children) => {
     if (!tok || isTooltip) {
       if (i > bufferStart) {
         const run = children.slice(bufferStart, i);
-        const html = md.renderer.render(run, md.options, {});
+        const html = md.renderer.render(run, md.options, env);
         vnodes.push(h("span", { innerHTML: html }));
       }
       if (tok && isTooltip) {
-        vnodes.push(renderTooltip(tok));
+        vnodes.push(renderTooltip(tok, env));
         bufferStart = i + 1;
       }
     }
@@ -61,7 +62,7 @@ const findMatchingClose = (tokens, openIdx) => {
   }
   return tokens.length;
 };
-const renderBlockTokens = (tokens) => {
+const renderBlockTokens = (tokens, env) => {
   const vnodes = [];
   let i = 0;
   while (i < tokens.length) {
@@ -69,13 +70,13 @@ const renderBlockTokens = (tokens) => {
     if (tok.nesting === 1) {
       const closeIdx = findMatchingClose(tokens, i);
       const children = tokens.slice(i + 1, closeIdx);
-      vnodes.push(h(tok.tag || "div", tokenAttrs(tok), renderBlockTokens(children)));
+      vnodes.push(h(tok.tag || "div", tokenAttrs(tok), renderBlockTokens(children, env)));
       i = closeIdx + 1;
     } else if (tok.type === "inline") {
-      vnodes.push(...renderInlineChildren(tok.children ?? []));
+      vnodes.push(...renderInlineChildren(tok.children ?? [], env));
       i++;
     } else {
-      const html = md.renderer.render([tok], md.options, {});
+      const html = md.renderer.render([tok], md.options, env);
       vnodes.push(h("span", { innerHTML: html }));
       i++;
     }
@@ -89,15 +90,17 @@ export default defineComponent({
     block: { type: Boolean, default: false }
   },
   setup(props) {
+    const base = useRuntimeConfig().app.baseURL || "/";
+    const env = { base };
     const rendered = computed(() => {
       if (props.block) {
-        const tokens = md.parse(props.source, {});
-        if (!hasTooltip(tokens)) return { fast: md.render(props.source) };
-        return { vnodes: renderBlockTokens(tokens) };
+        const tokens = md.parse(props.source, env);
+        if (!hasTooltip(tokens)) return { fast: md.render(props.source, env) };
+        return { vnodes: renderBlockTokens(tokens, env) };
       }
-      const children = md.parseInline(props.source, {})[0]?.children ?? [];
-      if (!hasTooltip(children)) return { fast: md.renderInline(props.source) };
-      return { vnodes: renderInlineChildren(children) };
+      const children = md.parseInline(props.source, env)[0]?.children ?? [];
+      if (!hasTooltip(children)) return { fast: md.renderInline(props.source, env) };
+      return { vnodes: renderInlineChildren(children, env) };
     });
     return () => {
       const r = rendered.value;

package/dist/runtime/utils/markdown.d.ts

@@ -1,5 +1,8 @@
 import MarkdownIt from 'markdown-it';
 export declare const md: MarkdownIt;
-export declare function renderMarkdown(source: string, options?: {
+export interface RenderMarkdownOptions {
     block?: boolean;
-}): string;
+    /** App base URL (`app.baseURL`) used to rewrite root-relative link hrefs. */
+    base?: string;
+}
+export declare function renderMarkdown(source: string, options?: RenderMarkdownOptions): string;

package/dist/runtime/utils/markdown.js

@@ -1,6 +1,27 @@
 import MarkdownIt from "markdown-it";
 import tooltipPlugin from "./markdown-tooltip.js";
 export const md = new MarkdownIt({ html: true, linkify: false, breaks: true }).use(tooltipPlugin);
+function withBase(path, base) {
+  const b = base.endsWith("/") ? base.slice(0, -1) : base;
+  if (!b) return path;
+  if (path === b || path.startsWith(`${b}/`)) return path;
+  return b + path;
+}
+function isRootRelative(href) {
+  return href.startsWith("/") && !href.startsWith("//");
+}
+const renderToken = (tokens, idx, options, _env, self) => self.renderToken(tokens, idx, options);
+const baseLinkOpen = md.renderer.rules.link_open ?? renderToken;
+md.renderer.rules.link_open = (tokens, idx, options, env, self) => {
+  const base = env?.base;
+  if (base) {
+    const token = tokens[idx];
+    const href = token.attrGet("href");
+    if (href && isRootRelative(href)) token.attrSet("href", withBase(href, base));
+  }
+  return baseLinkOpen(tokens, idx, options, env, self);
+};
 export function renderMarkdown(source, options) {
-  return options?.block ? md.render(source) : md.renderInline(source);
+  const env = options?.base ? { base: options.base } : {};
+  return options?.block ? md.render(source, env) : md.renderInline(source, env);
 }

package/dist/runtime/vendor/cel-js/CLAUDE.md

@@ -69,6 +69,7 @@ import { Environment, ParseError, TypeError, EvaluationError } from './lib/index
   - `.check(expr)` — Returns `Either<string, ParseError | TypeError>` (success = type name string)
   - `.evaluate<T>(expr, ctx?)` — Returns `Effect<T, ParseError | TypeError | EvaluationError>`
   - `.registerVariable(name, type, options?)`
+  - `.deleteVariable(name)` — Remove a previously-registered variable (no-op if absent). Lets a narrower scope override an inherited declaration with a different type (e.g. the table cell-style scope's per-row `selected: bool` vs. an enclosing toolbar's `selected: list<dyn>`), since `registerVariable` throws on a duplicate name.
   - `.registerConstant(name, type, value)`
   - `.registerFunction(signature, handler, options?)`
   - `.registerOperator(signature, handler)`

package/dist/runtime/vendor/cel-js/lib/evaluator.d.ts

@@ -26,6 +26,7 @@ declare class Environment {
     registerOperator(signature: string, handler?: (...args: unknown[]) => unknown, opts?: unknown): this;
     registerType(typename: string, constructor: unknown): this;
     registerVariable(name: string, type?: unknown, opts?: unknown): this;
+    deleteVariable(name: string): this;
     registerConstant(name: string, type: unknown, value: unknown): this;
     getDefinitions(): ReturnType<Registry['getDefinitions']>;
     check(expression: string): Either.Either<string, ParseError | TypeError>;

package/dist/runtime/vendor/cel-js/lib/evaluator.js

@@ -54,6 +54,10 @@ class Environment {
     this.#registry.registerVariable(name, type, opts);
     return this;
   }
+  deleteVariable(name) {
+    this.#registry.deleteVariable(name);
+    return this;
+  }
   registerConstant(name, type, value) {
     this.#registry.registerConstant(name, type, value);
     return this;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shwfed/config",
-  "version": "2.10.7",
+  "version": "2.10.9",
   "description": "Configurable UI for SHWFED",
   "type": "module",
   "publishConfig": {