@ai-matrx/rich-content 0.2.4 → 0.2.6

package/dist/utils/lifted/syntax-themes.js

@@ -0,0 +1,100 @@
+import { normalizeLanguage } from "./languages.js";
+const JSON_SYNTAX_COLORS = {
+  dark: {
+    key: "#7dd3fc",
+    string: "#6ee7b7",
+    number: "#fbbf24",
+    boolean: "#c4b5fd",
+    null: "#a1a1aa",
+    punctuation: "#a1a1aa"
+  },
+  light: {
+    key: "#0369a1",
+    string: "#047857",
+    number: "#b45309",
+    boolean: "#6d28d9",
+    null: "#71717a",
+    punctuation: "#4b5563"
+  }
+};
+function hexForMonaco(color) {
+  return color.replace("#", "").toUpperCase();
+}
+let monacoJsonThemesRegistered = false;
+function registerJsonMonacoThemes(monaco) {
+  if (monacoJsonThemesRegistered) return;
+  monacoJsonThemesRegistered = true;
+  const dark = JSON_SYNTAX_COLORS.dark;
+  const light = JSON_SYNTAX_COLORS.light;
+  monaco.editor.defineTheme("matrx-json-dark", {
+    base: "vs-dark",
+    inherit: true,
+    rules: [
+      { token: "string.key.json", foreground: hexForMonaco(dark.key) },
+      { token: "string.value.json", foreground: hexForMonaco(dark.string) },
+      { token: "number.json", foreground: hexForMonaco(dark.number) },
+      { token: "keyword.json", foreground: hexForMonaco(dark.boolean) },
+      {
+        token: "delimiter.bracket.json",
+        foreground: hexForMonaco(dark.punctuation)
+      },
+      {
+        token: "delimiter.array.json",
+        foreground: hexForMonaco(dark.punctuation)
+      },
+      {
+        token: "delimiter.colon.json",
+        foreground: hexForMonaco(dark.punctuation)
+      },
+      {
+        token: "delimiter.comma.json",
+        foreground: hexForMonaco(dark.punctuation)
+      }
+    ],
+    colors: {}
+  });
+  monaco.editor.defineTheme("matrx-json-light", {
+    base: "vs",
+    inherit: true,
+    rules: [
+      { token: "string.key.json", foreground: hexForMonaco(light.key) },
+      { token: "string.value.json", foreground: hexForMonaco(light.string) },
+      { token: "number.json", foreground: hexForMonaco(light.number) },
+      { token: "keyword.json", foreground: hexForMonaco(light.boolean) },
+      {
+        token: "delimiter.bracket.json",
+        foreground: hexForMonaco(light.punctuation)
+      },
+      {
+        token: "delimiter.array.json",
+        foreground: hexForMonaco(light.punctuation)
+      },
+      {
+        token: "delimiter.colon.json",
+        foreground: hexForMonaco(light.punctuation)
+      },
+      {
+        token: "delimiter.comma.json",
+        foreground: hexForMonaco(light.punctuation)
+      }
+    ],
+    colors: {}
+  });
+}
+function isJsonLanguage(language) {
+  if (!language) return false;
+  const normalized = normalizeLanguage(language).toLowerCase();
+  return normalized === "json" || normalized === "jsonc";
+}
+function resolveMonacoEditorTheme(language, mode) {
+  if (isJsonLanguage(language)) {
+    return mode === "dark" ? "matrx-json-dark" : "matrx-json-light";
+  }
+  return mode === "dark" ? "vs-dark" : "vs";
+}
+export {
+  JSON_SYNTAX_COLORS,
+  isJsonLanguage,
+  registerJsonMonacoThemes,
+  resolveMonacoEditorTheme
+};

package/dist/utils/lifted/url-utm.d.ts

@@ -0,0 +1,24 @@
+/**
+ * URL UTM Management Utility
+ *
+ * Ensures all outgoing links have the correct UTM source parameter
+ * and removes any existing utm_source to prevent conflicts.
+ */
+/**
+ * Adds or replaces utm_source parameter in a URL
+ * @param url - The URL to modify
+ * @param utmSource - The UTM source value (default: 'aimatrx')
+ * @returns The modified URL with the correct utm_source parameter
+ */
+export declare function addUtmSource(url: string, utmSource?: string): string;
+/**
+ * Process multiple URLs in bulk
+ * Useful for batch processing
+ */
+export declare function addUtmSourceToUrls(urls: string[], utmSource?: string): string[];
+/**
+ * The link as its author wrote it: removes the utm_source WE add on render
+ * (`addUtmSource`). Copy uses it — a person copying text never receives a
+ * tracking parameter they did not write (2026-10-05 live walk).
+ */
+export declare function stripOwnUtmSource(url: string, utmSource?: string): string;

package/dist/utils/lifted/url-utm.js

@@ -0,0 +1,66 @@
+function addUtmSource(url, utmSource = "aimatrx") {
+  if (!url || typeof url !== "string") {
+    return url;
+  }
+  try {
+    if (url.startsWith("#") || url.startsWith("/") || url.startsWith("mailto:") || url.startsWith("tel:")) {
+      return url;
+    }
+    const urlObj = new URL(url);
+    const params = urlObj.searchParams;
+    const paramsToRemove = [];
+    params.forEach((value, key) => {
+      if (key.toLowerCase() === "utm_source") {
+        paramsToRemove.push(key);
+      }
+    });
+    paramsToRemove.forEach((param) => params.delete(param));
+    params.set("utm_source", utmSource);
+    return urlObj.toString();
+  } catch (error) {
+    try {
+      if (!url.includes("://") && !url.startsWith("www.")) {
+        return url;
+      }
+      let fixedUrl = url;
+      if (url.startsWith("www.")) {
+        fixedUrl = "https://" + url;
+      }
+      const urlObj = new URL(fixedUrl);
+      const params = urlObj.searchParams;
+      const paramsToRemove = [];
+      params.forEach((value, key) => {
+        if (key.toLowerCase() === "utm_source") {
+          paramsToRemove.push(key);
+        }
+      });
+      paramsToRemove.forEach((param) => params.delete(param));
+      params.set("utm_source", utmSource);
+      return urlObj.toString();
+    } catch (innerError) {
+      console.warn("[addUtmSource] Failed to parse URL:", url, innerError);
+      return url;
+    }
+  }
+}
+function addUtmSourceToUrls(urls, utmSource = "aimatrx") {
+  return urls.map((url) => addUtmSource(url, utmSource));
+}
+function stripOwnUtmSource(url, utmSource = "aimatrx") {
+  if (!url || !/[?&]utm_source=/i.test(url)) return url;
+  try {
+    const u = new URL(url);
+    for (const key of [...u.searchParams.keys()]) {
+      if (key.toLowerCase() === "utm_source" && u.searchParams.get(key) === utmSource) u.searchParams.delete(key);
+    }
+    const out = u.toString();
+    return !url.endsWith("/") && out.endsWith("/") && u.pathname === "/" && !u.search && !u.hash ? out.slice(0, -1) : out.replace(/\?$/, "");
+  } catch {
+    return url;
+  }
+}
+export {
+  addUtmSource,
+  addUtmSourceToUrls,
+  stripOwnUtmSource
+};

package/dist/utils/lifted/use-is-mounted.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Hook that returns true after the component has mounted on the client.
+ * Useful for avoiding hydration mismatches with dynamically generated IDs.
+ *
+ * @example
+ * const isMounted = useIsMounted()
+ * if (!isMounted) return null // or a placeholder
+ * return <ComponentWithDynamicIds />
+ */
+export declare function useIsMounted(): boolean;
+/**
+ * True only while this component's effects are ATTACHED: false on the first
+ * render, true after mount, false again while a React `<Activity
+ * mode="hidden">` ancestor has detached its effects (a sleeping board tile,
+ * a hidden tab), true again when it is shown.
+ *
+ * Use it to gate a child that owns an imperative instance created in an
+ * effect and destroyed in that effect's cleanup, but guarded against being
+ * created twice — `@monaco-editor/react`'s `<Editor>` is the case that
+ * forced this: on hide its cleanup disposes the editor, on show its state
+ * still says "ready", so it never creates another and the pane stays blank.
+ * Rendering it only while attached gives it a fresh mount on every show.
+ */
+export declare function useEffectsAttached(): boolean;

package/dist/utils/lifted/use-is-mounted.js

@@ -0,0 +1,21 @@
+"use client";
+import { useState, useEffect } from "react";
+function useIsMounted() {
+  const [isMounted, setIsMounted] = useState(false);
+  useEffect(() => {
+    setIsMounted(true);
+  }, []);
+  return isMounted;
+}
+function useEffectsAttached() {
+  const [attached, setAttached] = useState(false);
+  useEffect(() => {
+    setAttached(true);
+    return () => setAttached(false);
+  }, []);
+  return attached;
+}
+export {
+  useEffectsAttached,
+  useIsMounted
+};

package/dist/utils/lifted/useToastManager.d.ts

@@ -0,0 +1 @@
+export declare function useToastManager(): import("../../host/index.js").RichContentToast;

package/dist/utils/lifted/useToastManager.js

@@ -0,0 +1,7 @@
+import { toast } from "../../host/toast.js";
+function useToastManager() {
+  return toast;
+}
+export {
+  useToastManager
+};

package/dist/utils/report-kind-at-raw-renderer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * THE BOTTOM-LAYER REPORT — a low-level raw renderer (a markdown leaf, the
+ * value grid, a JSON viewer, the JSON code card) was handed kind data. It has
+ * already rendered the data as its kind; this files the CALLER in the Error
+ * Inspector so the screen that skipped the value door is found and fixed
+ * (Arman, 2026-09-30: a `__kind` is never drawn as raw JSON). Checklist C4:
+ * `features/content-ir/docs/KIND_NEVER_RAW_CHECKLIST.md`.
+ *
+ * Once per component + slug per session: a render loop must not flood the
+ * inspector. The owner stack (development builds) names the caller.
+ */
+export declare function reportKindAtRawRenderer(component: string, slug: string | null, ownerStack?: string | null): void;
+/** Test seam: forget what was reported. */
+export declare function resetKindAtRawRendererReports(): void;
+/**
+ * Report from a component's render. The owner stack is read during render
+ * (the only time React has it) and filed after commit.
+ */
+export declare function useReportKindAtRawRenderer(component: string, slug: string | null, active: boolean): void;

package/dist/utils/report-kind-at-raw-renderer.js

@@ -0,0 +1,32 @@
+import { captureOwnerStack, useEffect } from "react";
+import { captureError } from "../host/diagnostics.js";
+const reported = /* @__PURE__ */ new Set();
+function reportKindAtRawRenderer(component, slug, ownerStack) {
+  const key = `${component}:${slug ?? ""}`;
+  if (reported.has(key)) return;
+  reported.add(key);
+  captureError({
+    source: "content-ir",
+    relation: slug ?? void 0,
+    message: `${component} was handed kind data${slug ? ` ("${slug}")` : ""} \u2014 rendered it as its kind instead of raw.`,
+    hint: "The caller should render this value through AnswerValueView (or text through MarkdownStream). The call site is in the stack.",
+    callSite: ownerStack ?? void 0,
+    stack: ownerStack ?? void 0,
+    recoverable: true
+  });
+}
+function resetKindAtRawRendererReports() {
+  reported.clear();
+}
+function useReportKindAtRawRenderer(component, slug, active) {
+  const ownerStack = active && typeof captureOwnerStack === "function" ? captureOwnerStack() : null;
+  useEffect(() => {
+    if (!active) return;
+    reportKindAtRawRenderer(component, slug, ownerStack);
+  }, [component, slug, active]);
+}
+export {
+  reportKindAtRawRenderer,
+  resetKindAtRawRendererReports,
+  useReportKindAtRawRenderer
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-matrx/rich-content",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "The AI Matrx formatted-text engine: the one markdown renderer, streaming markdown, the block splitter and renderer, the generic blocks, <RichContent> levels, the rich-document action registry and menus, copy, and the selection toolbar — as portable React.",
   "type": "module",
   "license": "MIT",
@@ -39,6 +39,18 @@
       "types": "./dist/display/*.d.ts",
       "import": "./dist/display/*.js"
     },
+    "./levels/*": {
+      "types": "./dist/levels/*.d.ts",
+      "import": "./dist/levels/*.js"
+    },
+    "./code-block/*": {
+      "types": "./dist/code-block/*.d.ts",
+      "import": "./dist/code-block/*.js"
+    },
+    "./mermaid/*": {
+      "types": "./dist/mermaid/*.d.ts",
+      "import": "./dist/mermaid/*.js"
+    },
     "./kinds/*": {
       "types": "./dist/kinds/*.d.ts",
       "import": "./dist/kinds/*.js"
@@ -51,21 +63,32 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
+    "@shikijs/stream": "^4.4.3",
+    "@shikijs/themes": "^4.4.3",
+    "@types/dagre": "^0.7.53",
     "@types/hast": "^3.0.4",
     "@types/mdast": "^4.0.4",
     "@types/unist": "^3.0.3",
+    "@xyflow/react": "^12.12.0",
+    "dagre": "^0.8.5",
     "hast-util-from-html": "^2.0.3",
     "hast-util-from-html-isomorphic": "^2.0.0",
     "hast-util-sanitize": "^5.0.2",
     "hast-util-to-string": "^3.0.1",
     "hast-util-to-text": "^4.0.2",
+    "html2canvas": "^1.4.1",
     "katex": "^0.18.9",
     "lucide-react": "^1.48.0",
     "marked": "^18.0.14",
+    "mdast-util-from-markdown": "^2.1.0",
+    "mdast-util-gfm": "^3.1.0",
     "mdast-util-math": "^3.0.0",
+    "micromark-extension-gfm": "^3.0.0",
     "micromark-factory-space": "^2.1.0",
     "micromark-util-character": "^2.1.1",
+    "react-icons": "^5.7.0",
     "react-markdown": "^10.1.0",
+    "recharts": "^3.10.1",
     "rehype-raw": "^7.0.0",
     "rehype-slug": "^6.0.0",
     "remark-breaks": "^4.0.0",
@@ -78,19 +101,25 @@
     "remark-rehype": "^11.1.2",
     "remend": "1.3.1",
     "server-only": "^0.0.1",
+    "shiki": "^4.4.3",
     "smol-toml": "^1.9.0",
     "unified": "^11.0.5",
     "unist-util-visit": "^5.1.0",
     "unist-util-visit-parents": "^6.0.2",
     "yaml": "^2.9.1",
+    "@ai-matrx/agents": "latest",
+    "@ai-matrx/canvas": "latest",
     "@ai-matrx/content-ir": "latest",
     "@ai-matrx/content-ir-react": "latest",
+    "@ai-matrx/data": "latest",
     "@ai-matrx/design-system": "latest",
-    "@ai-matrx/kit": "latest",
+    "@ai-matrx/diff": "latest",
     "@ai-matrx/media": "latest",
     "@ai-matrx/print": "latest",
+    "@ai-matrx/icons": "latest",
     "@ai-matrx/records": "latest",
-    "@ai-matrx/agents": "latest"
+    "@ai-matrx/tap-target": "latest",
+    "@ai-matrx/kit": "latest"
   },
   "peerDependencies": {
     "react": ">=19.0.0",