@frontmcp/ui 0.12.2 → 1.0.0-beta.1

package/renderer/charts/index.js

@@ -0,0 +1,367 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/ui/src/renderer/charts/index.ts
+var charts_exports = {};
+__export(charts_exports, {
+  ChartsRenderer: () => ChartsRenderer,
+  chartsRenderer: () => chartsRenderer,
+  isChart: () => isChart
+});
+module.exports = __toCommonJS(charts_exports);
+var import_react3 = __toESM(require("react"));
+var import_Box = __toESM(require("@mui/material/Box"));
+var import_Alert = __toESM(require("@mui/material/Alert"));
+var import_Typography = __toESM(require("@mui/material/Typography"));
+var import_styles2 = require("@mui/material/styles");
+
+// libs/ui/src/renderer/common/lazy-import.ts
+var ESM_SH_BASE = "https://esm.sh/";
+function esmShUrl(pkg, options) {
+  let url = `${ESM_SH_BASE}${pkg}`;
+  if (options?.external?.length) {
+    url += `?external=${options.external.join(",")}`;
+  }
+  return url;
+}
+function runtimeImport(specifier) {
+  const dynamicImport = new Function("s", "return import(s)");
+  return dynamicImport(specifier);
+}
+async function runtimeImportWithFallback(bareSpecifier, fallbackUrl) {
+  try {
+    return await runtimeImport(bareSpecifier);
+  } catch {
+    return runtimeImport(fallbackUrl);
+  }
+}
+function createLazyImport(moduleId, importer) {
+  let state = { status: "idle" };
+  const doImport = importer ?? (async () => {
+    const mod = await runtimeImport(moduleId);
+    return mod["default"] ?? mod;
+  });
+  return {
+    load() {
+      if (state.status === "loaded") return Promise.resolve(state.module);
+      if (state.status === "loading") return state.promise;
+      if (state.status === "error") {
+        state = { status: "idle" };
+      }
+      const promise = doImport().then(
+        (mod) => {
+          state = { status: "loaded", module: mod };
+          return mod;
+        },
+        (err) => {
+          const error = err instanceof Error ? err : new Error(`Failed to load module "${moduleId}": ${String(err)}`);
+          state = { status: "error", error };
+          throw error;
+        }
+      );
+      state = { status: "loading", promise };
+      return promise;
+    },
+    get() {
+      return state.status === "loaded" ? state.module : void 0;
+    },
+    getState() {
+      return state;
+    },
+    reset() {
+      state = { status: "idle" };
+    }
+  };
+}
+
+// libs/ui/src/renderer/common/use-renderer-theme.ts
+var import_react = require("react");
+var import_styles = require("@mui/material/styles");
+function extractThemeValues(theme) {
+  const palette = theme.palette;
+  return {
+    mode: palette.mode,
+    primary: palette.primary.main,
+    secondary: palette.secondary.main,
+    error: palette.error.main,
+    warning: palette.warning.main,
+    success: palette.success.main,
+    info: palette.info.main,
+    background: palette.background.default,
+    paper: palette.background.paper,
+    textPrimary: palette.text.primary,
+    textSecondary: palette.text.secondary,
+    divider: palette.divider,
+    fontFamily: theme.typography.fontFamily ?? "sans-serif",
+    monoFontFamily: theme.typography["monoFontFamily"] ?? '"SF Mono", "Fira Code", "Fira Mono", "Roboto Mono", monospace',
+    fontSize: theme.typography.fontSize ?? 14,
+    borderRadius: typeof theme.shape.borderRadius === "number" ? theme.shape.borderRadius : 4,
+    seriesColors: [
+      palette.primary.main,
+      palette.secondary.main,
+      palette.error.main,
+      palette.warning.main,
+      palette.success.main,
+      palette.info.main
+    ]
+  };
+}
+function useRendererTheme() {
+  const theme = (0, import_styles.useTheme)();
+  return (0, import_react.useMemo)(() => extractThemeValues(theme), [theme]);
+}
+
+// libs/ui/src/renderer/common/use-lazy-module.ts
+var import_react2 = require("react");
+function useLazyModule(lazy) {
+  const [, forceUpdate] = (0, import_react2.useState)(0);
+  (0, import_react2.useEffect)(() => {
+    if (lazy.getState().status === "loaded") {
+      forceUpdate((n) => n + 1);
+      return;
+    }
+    lazy.load().then(
+      () => forceUpdate((n) => n + 1),
+      () => forceUpdate((n) => n + 1)
+    );
+  }, [lazy]);
+  return lazy.get();
+}
+
+// libs/ui/src/renderer/charts/index.ts
+var CHART_TYPE_RE = /"type"\s*:\s*"(?:bar|line|area|pie|scatter|radar|composed)"/;
+function isChart(content) {
+  const trimmed = content.trim();
+  if (trimmed.charCodeAt(0) !== 123) return false;
+  return CHART_TYPE_RE.test(trimmed) && trimmed.includes('"data"');
+}
+var lazyRecharts = createLazyImport("recharts", async () => {
+  const mod = await runtimeImportWithFallback("recharts", esmShUrl("recharts@2", { external: ["react", "react-dom"] }));
+  return mod;
+});
+var ChartRoot = (0, import_styles2.styled)(import_Box.default, {
+  name: "FrontMcpChart",
+  slot: "Root"
+})(({ theme }) => ({
+  width: "100%",
+  padding: theme.spacing(2)
+}));
+function ChartView({ config, className }) {
+  const themeValues = useRendererTheme();
+  const recharts = useLazyModule(lazyRecharts);
+  const colors = (0, import_react3.useMemo)(() => config.colors ?? themeValues.seriesColors, [config.colors, themeValues.seriesColors]);
+  if (!recharts) {
+    return import_react3.default.createElement(import_Alert.default, { severity: "info" }, "Loading chart library...");
+  }
+  const { ResponsiveContainer, Tooltip, Legend, CartesianGrid, XAxis, YAxis } = recharts;
+  const height = config.height ?? 400;
+  const xKey = config.xKey ?? "name";
+  const yKeys = config.yKeys ?? Object.keys(config.data?.[0] ?? {}).filter((k) => k !== xKey);
+  const chartContent = renderChartType(
+    recharts,
+    config.type,
+    config.data,
+    xKey,
+    yKeys,
+    colors,
+    themeValues.borderRadius
+  );
+  return import_react3.default.createElement(
+    ChartRoot,
+    { className },
+    config.title && import_react3.default.createElement(
+      import_Typography.default,
+      { variant: "subtitle1", gutterBottom: true, fontWeight: 600, textAlign: "center" },
+      config.title
+    ),
+    import_react3.default.createElement(ResponsiveContainer, { width: "100%", height }, chartContent)
+  );
+}
+function renderChartType(rc, type, data, xKey, yKeys, colors, borderRadius) {
+  const commonProps = { data };
+  const grid = import_react3.default.createElement(rc.CartesianGrid, { strokeDasharray: "3 3", opacity: 0.3 });
+  const xAxis = import_react3.default.createElement(rc.XAxis, { dataKey: xKey });
+  const yAxis = import_react3.default.createElement(rc.YAxis);
+  const tooltip = import_react3.default.createElement(rc.Tooltip, { contentStyle: { borderRadius } });
+  const legend = import_react3.default.createElement(rc.Legend);
+  switch (type) {
+    case "bar":
+      return import_react3.default.createElement(
+        rc.BarChart,
+        commonProps,
+        grid,
+        xAxis,
+        yAxis,
+        tooltip,
+        legend,
+        ...yKeys.map(
+          (key, i) => import_react3.default.createElement(rc.Bar, {
+            key,
+            dataKey: key,
+            fill: colors[i % colors.length],
+            radius: [borderRadius, borderRadius, 0, 0]
+          })
+        )
+      );
+    case "line":
+      return import_react3.default.createElement(
+        rc.LineChart,
+        commonProps,
+        grid,
+        xAxis,
+        yAxis,
+        tooltip,
+        legend,
+        ...yKeys.map(
+          (key, i) => import_react3.default.createElement(rc.Line, {
+            key,
+            type: "monotone",
+            dataKey: key,
+            stroke: colors[i % colors.length],
+            strokeWidth: 2
+          })
+        )
+      );
+    case "area":
+      return import_react3.default.createElement(
+        rc.AreaChart,
+        commonProps,
+        grid,
+        xAxis,
+        yAxis,
+        tooltip,
+        legend,
+        ...yKeys.map(
+          (key, i) => import_react3.default.createElement(rc.Area, {
+            key,
+            type: "monotone",
+            dataKey: key,
+            stroke: colors[i % colors.length],
+            fill: colors[i % colors.length],
+            fillOpacity: 0.3
+          })
+        )
+      );
+    case "pie":
+      return import_react3.default.createElement(
+        rc.PieChart,
+        {},
+        tooltip,
+        legend,
+        import_react3.default.createElement(
+          rc.Pie,
+          { data, dataKey: yKeys[0] ?? "value", nameKey: xKey, cx: "50%", cy: "50%", outerRadius: "80%", label: true },
+          ...data.map((_, i) => import_react3.default.createElement(rc.Cell, { key: i, fill: colors[i % colors.length] }))
+        )
+      );
+    case "scatter":
+      return import_react3.default.createElement(
+        rc.ScatterChart,
+        {},
+        grid,
+        xAxis,
+        yAxis,
+        tooltip,
+        legend,
+        ...yKeys.map(
+          (key, i) => import_react3.default.createElement(rc.Scatter, { key, name: key, dataKey: key, data, fill: colors[i % colors.length] })
+        )
+      );
+    case "radar":
+      return import_react3.default.createElement(
+        rc.RadarChart,
+        { cx: "50%", cy: "50%", outerRadius: "80%", data },
+        import_react3.default.createElement(rc.PolarGrid),
+        import_react3.default.createElement(rc.PolarAngleAxis, { dataKey: xKey }),
+        import_react3.default.createElement(rc.PolarRadiusAxis),
+        tooltip,
+        legend,
+        ...yKeys.map(
+          (key, i) => import_react3.default.createElement(rc.Radar, {
+            key,
+            name: key,
+            dataKey: key,
+            stroke: colors[i % colors.length],
+            fill: colors[i % colors.length],
+            fillOpacity: 0.3
+          })
+        )
+      );
+    case "composed":
+      return import_react3.default.createElement(
+        rc.ComposedChart,
+        commonProps,
+        grid,
+        xAxis,
+        yAxis,
+        tooltip,
+        legend,
+        ...yKeys.map((key, i) => {
+          if (i % 2 === 0) {
+            return import_react3.default.createElement(rc.Bar, {
+              key,
+              dataKey: key,
+              fill: colors[i % colors.length],
+              radius: [borderRadius, borderRadius, 0, 0]
+            });
+          }
+          return import_react3.default.createElement(rc.Line, {
+            key,
+            type: "monotone",
+            dataKey: key,
+            stroke: colors[i % colors.length],
+            strokeWidth: 2
+          });
+        })
+      );
+    default:
+      return import_react3.default.createElement(rc.BarChart, commonProps, grid, xAxis, yAxis, tooltip, legend);
+  }
+}
+lazyRecharts.load().catch(() => {
+});
+var ChartsRenderer = class {
+  type = "chart";
+  priority = 80;
+  canHandle(content) {
+    return isChart(content);
+  }
+  render(content, options) {
+    try {
+      const config = JSON.parse(content);
+      return import_react3.default.createElement(ChartView, {
+        config,
+        className: options?.className ?? "fmcp-chart-content"
+      });
+    } catch {
+      return import_react3.default.createElement(import_Alert.default, { severity: "error" }, "Invalid chart JSON");
+    }
+  }
+};
+var chartsRenderer = new ChartsRenderer();

package/renderer/common/index.d.ts

@@ -0,0 +1,5 @@
+export { useRendererTheme, extractThemeValues, type RendererThemeValues } from './use-renderer-theme';
+export { injectStylesheet } from './inject-stylesheet';
+export { createLazyImport, runtimeImport, runtimeImportWithFallback, esmShUrl, ESM_SH_BASE, type LazyImport, type LazyImportState, } from './lazy-import';
+export { useLazyModule } from './use-lazy-module';
+//# sourceMappingURL=index.d.ts.map

package/renderer/common/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/renderer/common/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACtG,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,yBAAyB,EACzB,QAAQ,EACR,WAAW,EACX,KAAK,UAAU,EACf,KAAK,eAAe,GACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC"}

package/renderer/common/index.js

@@ -0,0 +1,158 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/ui/src/renderer/common/index.ts
+var common_exports = {};
+__export(common_exports, {
+  ESM_SH_BASE: () => ESM_SH_BASE,
+  createLazyImport: () => createLazyImport,
+  esmShUrl: () => esmShUrl,
+  extractThemeValues: () => extractThemeValues,
+  injectStylesheet: () => injectStylesheet,
+  runtimeImport: () => runtimeImport,
+  runtimeImportWithFallback: () => runtimeImportWithFallback,
+  useLazyModule: () => useLazyModule,
+  useRendererTheme: () => useRendererTheme
+});
+module.exports = __toCommonJS(common_exports);
+
+// libs/ui/src/renderer/common/use-renderer-theme.ts
+var import_react = require("react");
+var import_styles = require("@mui/material/styles");
+function extractThemeValues(theme) {
+  const palette = theme.palette;
+  return {
+    mode: palette.mode,
+    primary: palette.primary.main,
+    secondary: palette.secondary.main,
+    error: palette.error.main,
+    warning: palette.warning.main,
+    success: palette.success.main,
+    info: palette.info.main,
+    background: palette.background.default,
+    paper: palette.background.paper,
+    textPrimary: palette.text.primary,
+    textSecondary: palette.text.secondary,
+    divider: palette.divider,
+    fontFamily: theme.typography.fontFamily ?? "sans-serif",
+    monoFontFamily: theme.typography["monoFontFamily"] ?? '"SF Mono", "Fira Code", "Fira Mono", "Roboto Mono", monospace',
+    fontSize: theme.typography.fontSize ?? 14,
+    borderRadius: typeof theme.shape.borderRadius === "number" ? theme.shape.borderRadius : 4,
+    seriesColors: [
+      palette.primary.main,
+      palette.secondary.main,
+      palette.error.main,
+      palette.warning.main,
+      palette.success.main,
+      palette.info.main
+    ]
+  };
+}
+function useRendererTheme() {
+  const theme = (0, import_styles.useTheme)();
+  return (0, import_react.useMemo)(() => extractThemeValues(theme), [theme]);
+}
+
+// libs/ui/src/renderer/common/inject-stylesheet.ts
+function injectStylesheet(href, id) {
+  if (typeof document === "undefined") return;
+  if (document.getElementById(id)) return;
+  const link = document.createElement("link");
+  link.id = id;
+  link.rel = "stylesheet";
+  link.href = href;
+  link.crossOrigin = "anonymous";
+  document.head.appendChild(link);
+}
+
+// libs/ui/src/renderer/common/lazy-import.ts
+var ESM_SH_BASE = "https://esm.sh/";
+function esmShUrl(pkg, options) {
+  let url = `${ESM_SH_BASE}${pkg}`;
+  if (options?.external?.length) {
+    url += `?external=${options.external.join(",")}`;
+  }
+  return url;
+}
+function runtimeImport(specifier) {
+  const dynamicImport = new Function("s", "return import(s)");
+  return dynamicImport(specifier);
+}
+async function runtimeImportWithFallback(bareSpecifier, fallbackUrl) {
+  try {
+    return await runtimeImport(bareSpecifier);
+  } catch {
+    return runtimeImport(fallbackUrl);
+  }
+}
+function createLazyImport(moduleId, importer) {
+  let state = { status: "idle" };
+  const doImport = importer ?? (async () => {
+    const mod = await runtimeImport(moduleId);
+    return mod["default"] ?? mod;
+  });
+  return {
+    load() {
+      if (state.status === "loaded") return Promise.resolve(state.module);
+      if (state.status === "loading") return state.promise;
+      if (state.status === "error") {
+        state = { status: "idle" };
+      }
+      const promise = doImport().then(
+        (mod) => {
+          state = { status: "loaded", module: mod };
+          return mod;
+        },
+        (err) => {
+          const error = err instanceof Error ? err : new Error(`Failed to load module "${moduleId}": ${String(err)}`);
+          state = { status: "error", error };
+          throw error;
+        }
+      );
+      state = { status: "loading", promise };
+      return promise;
+    },
+    get() {
+      return state.status === "loaded" ? state.module : void 0;
+    },
+    getState() {
+      return state;
+    },
+    reset() {
+      state = { status: "idle" };
+    }
+  };
+}
+
+// libs/ui/src/renderer/common/use-lazy-module.ts
+var import_react2 = require("react");
+function useLazyModule(lazy) {
+  const [, forceUpdate] = (0, import_react2.useState)(0);
+  (0, import_react2.useEffect)(() => {
+    if (lazy.getState().status === "loaded") {
+      forceUpdate((n) => n + 1);
+      return;
+    }
+    lazy.load().then(
+      () => forceUpdate((n) => n + 1),
+      () => forceUpdate((n) => n + 1)
+    );
+  }, [lazy]);
+  return lazy.get();
+}

package/renderer/common/inject-stylesheet.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Inject a CSS stylesheet link into the document head.
+ * No-ops if the stylesheet is already loaded or if running outside a browser.
+ *
+ * @param href - URL of the stylesheet
+ * @param id - Unique ID for the link element (prevents duplicates)
+ */
+export declare function injectStylesheet(href: string, id: string): void;
+//# sourceMappingURL=inject-stylesheet.d.ts.map

package/renderer/common/inject-stylesheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-stylesheet.d.ts","sourceRoot":"","sources":["../../../src/renderer/common/inject-stylesheet.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAU/D"}

package/renderer/common/lazy-import.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Lazy module import helper.
+ *
+ * Creates a lazy-loading wrapper for peer dependencies that are externalized
+ * and loaded via esm.sh. Follows the state machine pattern from babel-runtime.ts.
+ *
+ * @packageDocumentation
+ */
+/** Base URL for esm.sh CDN. */
+export declare const ESM_SH_BASE = "https://esm.sh/";
+/**
+ * Build an esm.sh CDN URL for a package.
+ *
+ * @param pkg - Package specifier with version (e.g., 'recharts@2', 'mermaid@11')
+ * @param options - Optional configuration
+ * @param options.external - Packages to externalize (e.g., ['react', 'react-dom'])
+ *
+ * @example
+ * ```typescript
+ * esmShUrl('mermaid@11');
+ * // => 'https://esm.sh/mermaid@11'
+ *
+ * esmShUrl('recharts@2', { external: ['react', 'react-dom'] });
+ * // => 'https://esm.sh/recharts@2?external=react,react-dom'
+ * ```
+ */
+export declare function esmShUrl(pkg: string, options?: {
+    external?: string[];
+}): string;
+/** Loading state for a lazy-imported module. */
+export type LazyImportState<T> = {
+    status: 'idle';
+} | {
+    status: 'loading';
+    promise: Promise<T>;
+} | {
+    status: 'loaded';
+    module: T;
+} | {
+    status: 'error';
+    error: Error;
+};
+export interface LazyImport<T> {
+    /** Load the module (cached after first call). */
+    load(): Promise<T>;
+    /** Get the module if already loaded, or undefined. */
+    get(): T | undefined;
+    /** Check current loading status. */
+    getState(): LazyImportState<T>;
+    /** Reset state (for testing). */
+    reset(): void;
+}
+/**
+ * Runtime dynamic import that avoids TS2307 for uninstalled optional peer deps.
+ * Uses Function constructor so TypeScript doesn't try to resolve the module.
+ */
+export declare function runtimeImport(specifier: string): Promise<Record<string, unknown>>;
+/**
+ * Try importing a bare specifier first (works in bundled environments),
+ * then fall back to an esm.sh URL (works in raw browser environments).
+ *
+ * This is the primary import strategy for optional peer dependencies.
+ * In Vite dev mode, bare specifiers resolve via `optimizeDeps.include`.
+ * In production or unbundled environments, the esm.sh CDN URL is used.
+ *
+ * @param bareSpecifier - The npm package name (e.g., 'recharts', 'mermaid')
+ * @param fallbackUrl - The esm.sh URL to use if bare import fails
+ *
+ * @example
+ * ```typescript
+ * const mod = await runtimeImportWithFallback(
+ *   'recharts',
+ *   esmShUrl('recharts@2', { external: ['react', 'react-dom'] }),
+ * );
+ * ```
+ */
+export declare function runtimeImportWithFallback(bareSpecifier: string, fallbackUrl: string): Promise<Record<string, unknown>>;
+/**
+ * Create a lazy-loading wrapper for an external module.
+ *
+ * @param moduleId - The module specifier (e.g., 'recharts', 'mermaid')
+ * @param importer - Optional custom import function. Defaults to dynamic import().
+ */
+export declare function createLazyImport<T>(moduleId: string, importer?: () => Promise<T>): LazyImport<T>;
+//# sourceMappingURL=lazy-import.d.ts.map

package/renderer/common/lazy-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-import.d.ts","sourceRoot":"","sources":["../../../src/renderer/common/lazy-import.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,+BAA+B;AAC/B,eAAO,MAAM,WAAW,oBAAoB,CAAC;AAE7C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,MAAM,CAM/E;AAMD,gDAAgD;AAChD,MAAM,MAAM,eAAe,CAAC,CAAC,IACzB;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAClB;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;CAAE,GAC1C;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,GAC/B;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;AAEtC,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,iDAAiD;IACjD,IAAI,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;IACnB,sDAAsD;IACtD,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;IACrB,oCAAoC;IACpC,QAAQ,IAAI,eAAe,CAAC,CAAC,CAAC,CAAC;IAC/B,iCAAiC;IACjC,KAAK,IAAI,IAAI,CAAC;CACf;AAMD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAIjF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,yBAAyB,CAC7C,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAMlC;AAMD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAgDhG"}

package/renderer/common/use-lazy-module.d.ts

@@ -0,0 +1,13 @@
+import type { LazyImport } from './lazy-import';
+/**
+ * React hook that loads a lazy module and triggers a re-render when it finishes.
+ *
+ * Without this hook, components that call `lazyX.get()` synchronously will render
+ * once (returning undefined), show a "Loading..." fallback, and never re-render
+ * because nothing triggers an update when the module finishes loading.
+ *
+ * @param lazy - A lazy import handle created by `createLazyImport`.
+ * @returns The loaded module, or `undefined` while still loading.
+ */
+export declare function useLazyModule<T>(lazy: LazyImport<T>): T | undefined;
+//# sourceMappingURL=use-lazy-module.d.ts.map

package/renderer/common/use-lazy-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-lazy-module.d.ts","sourceRoot":"","sources":["../../../src/renderer/common/use-lazy-module.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,CAkBnE"}

package/renderer/common/use-renderer-theme.d.ts

@@ -0,0 +1,35 @@
+import { type Theme } from '@mui/material/styles';
+/**
+ * Flat theme values extracted from MUI theme for non-MUI libraries.
+ * Used by Recharts, Mermaid, Leaflet, KaTeX, ReactFlow, etc.
+ */
+export interface RendererThemeValues {
+    mode: 'light' | 'dark';
+    primary: string;
+    secondary: string;
+    error: string;
+    warning: string;
+    success: string;
+    info: string;
+    background: string;
+    paper: string;
+    textPrimary: string;
+    textSecondary: string;
+    divider: string;
+    fontFamily: string;
+    monoFontFamily: string;
+    fontSize: number;
+    borderRadius: number;
+    /** Ordered palette colors for data series */
+    seriesColors: string[];
+}
+/**
+ * Extract flat theme values from MUI theme for use in non-MUI renderers.
+ */
+export declare function extractThemeValues(theme: Theme): RendererThemeValues;
+/**
+ * React hook that extracts MUI theme values into a flat object
+ * for use by non-MUI rendering libraries (Recharts, Mermaid, etc.).
+ */
+export declare function useRendererTheme(): RendererThemeValues;
+//# sourceMappingURL=use-renderer-theme.d.ts.map