@frontmcp/ui 0.6.1 → 0.6.2

package/esm/renderers/react.adapter.d.ts

@@ -1,70 +0,0 @@
-/**
- * React Renderer Adapter
- *
- * Client-side adapter for rendering React components.
- * Handles hydration, client-side rendering, and updates.
- *
- * @packageDocumentation
- */
-import type { RendererAdapter, RenderContext, RenderOptions, RenderResult } from '@frontmcp/uipack/runtime';
-import type { UIType } from '@frontmcp/uipack/types';
-/**
- * React Renderer Adapter.
- *
- * Renders React components to the DOM with support for:
- * - Server-side rendering (SSR)
- * - Client-side hydration
- * - Dynamic updates when data changes
- */
-export declare class ReactRendererAdapter implements RendererAdapter {
-    readonly type: UIType;
-    private react;
-    private reactDOM;
-    private loadPromise;
-    /**
-     * Check if this adapter can handle the given content.
-     */
-    canHandle(content: string | unknown): boolean;
-    /**
-     * Render React component to a string.
-     * This is a client-side fallback - SSR should be done at build time.
-     */
-    render(content: string, context: RenderContext, _options?: RenderOptions): Promise<string>;
-    /**
-     * Render React component directly to the DOM.
-     */
-    renderToDOM(content: string, target: HTMLElement, context: RenderContext, options?: RenderOptions): Promise<RenderResult>;
-    /**
-     * Hydrate existing SSR content with React.
-     */
-    hydrate(target: HTMLElement, context: RenderContext, options?: RenderOptions): Promise<RenderResult>;
-    /**
-     * Update rendered React component with new data.
-     */
-    update(target: HTMLElement, context: RenderContext): Promise<RenderResult>;
-    /**
-     * Clean up React root.
-     */
-    destroy(target: HTMLElement): void;
-    /**
-     * Ensure React is loaded.
-     */
-    private ensureReactLoaded;
-    /**
-     * Load React runtime.
-     */
-    private loadReact;
-    /**
-     * Get a React component by name or from content.
-     */
-    private getComponent;
-}
-/**
- * Create a new React renderer adapter.
- */
-export declare function createReactAdapter(): ReactRendererAdapter;
-/**
- * Adapter loader for lazy loading.
- */
-export declare function loadReactAdapter(): Promise<RendererAdapter>;
-//# sourceMappingURL=react.adapter.d.ts.map

package/esm/renderers/react.adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react.adapter.d.ts","sourceRoot":"","sources":["../../../src/renderers/react.adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC5G,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAsDrD;;;;;;;GAOG;AACH,qBAAa,oBAAqB,YAAW,eAAe;IAC1D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAW;IAGhC,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,WAAW,CAA8B;IAEjD;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO;IAqB7C;;;OAGG;IACG,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;IAMhG;;OAEG;IACG,WAAW,CACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,aAAa,EACtB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,YAAY,CAAC;IA4DxB;;OAEG;IACG,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAI1G;;OAEG;IACG,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAsChF;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAQlC;;OAEG;YACW,iBAAiB;IAa/B;;OAEG;YACW,SAAS;IAmCvB;;OAEG;IACH,OAAO,CAAC,YAAY;CAsBrB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,oBAAoB,CAEzD;AAED;;GAEG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,eAAe,CAAC,CAEjE"}

package/esm/renderers/react.renderer.d.ts

@@ -1,96 +0,0 @@
-/**
- * React Renderer
- *
- * Handles React component templates:
- * - Imported React components (already transpiled)
- * - JSX string templates (transpiled at runtime with SWC)
- *
- * Uses react-dom/server for SSR to HTML.
- */
-import type { TemplateContext } from '@frontmcp/uipack/runtime';
-import type { PlatformCapabilities } from '@frontmcp/uipack/theme';
-import type { UIRenderer, TranspileResult, TranspileOptions, RenderOptions, RuntimeScripts, ToolUIProps } from '@frontmcp/uipack/renderers';
-/**
- * Types this renderer can handle.
- */
-type ReactTemplate<In = unknown, Out = unknown> = ((props: ToolUIProps<In, Out>) => unknown) | string;
-/**
- * React Renderer Implementation.
- *
- * Handles:
- * - Imported React components (FC or class)
- * - JSX string templates (transpiled with SWC at runtime)
- *
- * Renders to HTML using react-dom/server's renderToString.
- *
- * @example Imported component
- * ```typescript
- * import { MyWidget } from './my-widget.tsx';
- *
- * @Tool({
- *   ui: { template: MyWidget }
- * })
- * ```
- *
- * @example JSX string (runtime transpilation)
- * ```typescript
- * @Tool({
- *   ui: {
- *     template: `
- *       function Widget({ output }) {
- *         return <div>{output.name}</div>;
- *       }
- *     `
- *   }
- * })
- * ```
- */
-export declare class ReactRenderer implements UIRenderer<ReactTemplate> {
-    readonly type: "react";
-    readonly priority = 20;
-    /**
-     * Lazy-loaded React modules.
-     */
-    private React;
-    private ReactDOMServer;
-    /**
-     * Check if this renderer can handle the given template.
-     *
-     * Accepts:
-     * - React component functions (imported, already transpiled)
-     * - Strings containing JSX syntax
-     */
-    canHandle(template: unknown): template is ReactTemplate;
-    /**
-     * Transpile the template if needed.
-     *
-     * For imported React components, no transpilation is needed.
-     * For JSX strings, SWC transpilation is performed.
-     */
-    transpile(template: ReactTemplate, options?: TranspileOptions): Promise<TranspileResult>;
-    /**
-     * Render the template to HTML string using react-dom/server.
-     */
-    render<In, Out>(template: ReactTemplate<In, Out>, context: TemplateContext<In, Out>, options?: RenderOptions): Promise<string>;
-    /**
-     * Get runtime scripts for client-side functionality.
-     */
-    getRuntimeScripts(platform: PlatformCapabilities): RuntimeScripts;
-    /**
-     * Load React and ReactDOMServer modules.
-     */
-    private loadReact;
-}
-/**
- * Singleton instance of the React renderer.
- */
-export declare const reactRenderer: ReactRenderer;
-/**
- * Build React hydration script for client-side interactivity.
- *
- * This script finds elements with data-hydrate attributes and
- * hydrates them with the corresponding React component.
- */
-export declare function buildHydrationScript(): string;
-export {};
-//# sourceMappingURL=react.renderer.d.ts.map

package/esm/renderers/react.renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react.renderer.d.ts","sourceRoot":"","sources":["../../../src/renderers/react.renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,WAAW,EACZ,MAAM,4BAA4B,CAAC;AAUpC;;GAEG;AACH,KAAK,aAAa,CAAC,EAAE,GAAG,OAAO,EAAE,GAAG,GAAG,OAAO,IAC1C,CAAC,CAAC,KAAK,EAAE,WAAW,CAAC,EAAE,EAAE,GAAG,CAAC,KAAK,OAAO,CAAC,GAC1C,MAAM,CAAC;AAqBX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,aAAc,YAAW,UAAU,CAAC,aAAa,CAAC;IAC7D,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAU;IACjC,QAAQ,CAAC,QAAQ,MAAM;IAEvB;;OAEG;IAEH,OAAO,CAAC,KAAK,CAAa;IAE1B,OAAO,CAAC,cAAc,CAAa;IAEnC;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,aAAa;IAcvD;;;;;OAKG;IACG,SAAS,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAsB9F;;OAEG;IACG,MAAM,CAAC,EAAE,EAAE,GAAG,EAClB,QAAQ,EAAE,aAAa,CAAC,EAAE,EAAE,GAAG,CAAC,EAChC,OAAO,EAAE,eAAe,CAAC,EAAE,EAAE,GAAG,CAAC,EACjC,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,MAAM,CAAC;IAkElB;;OAEG;IACH,iBAAiB,CAAC,QAAQ,EAAE,oBAAoB,GAAG,cAAc;IAoBjE;;OAEG;YACW,SAAS;CAYxB;AAED;;GAEG;AACH,eAAO,MAAM,aAAa,eAAsB,CAAC;AAEjD;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CA+B7C"}

package/esm/universal/UniversalApp.d.ts

@@ -1,108 +0,0 @@
-/**
- * Universal App Component
- *
- * Main entry point for the universal renderer.
- * Handles loading states, error boundaries, and auto-detection.
- */
-import React from 'react';
-import type { UniversalAppProps, FrontMCPState } from './types';
-/**
- * Default loading spinner component.
- */
-declare function LoadingSpinner(): React.ReactElement;
-/**
- * Default error display component.
- */
-declare function ErrorDisplay({ error }: {
-    error: string;
-}): React.ReactElement;
-/**
- * Default empty state component.
- */
-declare function EmptyState(): React.ReactElement;
-/**
- * Universal App component.
- *
- * Main entry point for the universal renderer. Handles:
- * - Loading states
- * - Error display
- * - Content auto-detection
- * - Custom component injection
- *
- * @example Basic usage
- * ```tsx
- * function App() {
- *   return (
- *     <FrontMCPProvider>
- *       <UniversalApp />
- *     </FrontMCPProvider>
- *   );
- * }
- * ```
- *
- * @example With custom content
- * ```tsx
- * const content: UniversalContent = {
- *   type: 'markdown',
- *   source: '# Hello World',
- * };
- *
- * function App() {
- *   return (
- *     <FrontMCPProvider>
- *       <UniversalApp content={content} />
- *     </FrontMCPProvider>
- *   );
- * }
- * ```
- *
- * @example With custom components
- * ```tsx
- * const components = {
- *   WeatherCard: ({ temp }) => <div>{temp}°F</div>,
- * };
- *
- * function App() {
- *   return (
- *     <FrontMCPProvider>
- *       <UniversalApp components={components} />
- *     </FrontMCPProvider>
- *   );
- * }
- * ```
- */
-export declare function UniversalApp({ content: contentOverride, components, fallback, errorFallback: ErrorFallback, }: UniversalAppProps): React.ReactElement;
-/**
- * Props for the standalone UniversalAppWithProvider.
- */
-interface StandaloneAppProps extends UniversalAppProps {
-    /** Initial store state */
-    initialState?: Partial<FrontMCPState>;
-}
-/**
- * Standalone Universal App with built-in provider.
- *
- * Use this when you need a self-contained universal renderer
- * without manually setting up the provider.
- *
- * @example
- * ```tsx
- * function App() {
- *   return (
- *     <UniversalAppWithProvider
- *       initialState={{
- *         toolName: 'get_weather',
- *         output: { temperature: 72 },
- *       }}
- *       content={{
- *         type: 'markdown',
- *         source: '# Weather: {output.temperature}°F',
- *       }}
- *     />
- *   );
- * }
- * ```
- */
-export declare function UniversalAppWithProvider({ initialState, components, ...appProps }: StandaloneAppProps): React.ReactElement;
-export { LoadingSpinner, ErrorDisplay, EmptyState };
-//# sourceMappingURL=UniversalApp.d.ts.map

package/esm/universal/UniversalApp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"UniversalApp.d.ts","sourceRoot":"","sources":["../../../src/universal/UniversalApp.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,iBAAiB,EAAmC,aAAa,EAAE,MAAM,SAAS,CAAC;AAUjG;;GAEG;AACH,iBAAS,cAAc,IAAI,KAAK,CAAC,YAAY,CAQ5C;AAMD;;GAEG;AACH,iBAAS,YAAY,CAAC,EAAE,KAAK,EAAE,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,KAAK,CAAC,YAAY,CAWtE;AAMD;;GAEG;AACH,iBAAS,UAAU,IAAI,KAAK,CAAC,YAAY,CAQxC;AAuCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,YAAY,CAAC,EAC3B,OAAO,EAAE,eAAe,EACxB,UAAU,EACV,QAAQ,EACR,aAAa,EAAE,aAA4B,GAC5C,EAAE,iBAAiB,GAAG,KAAK,CAAC,YAAY,CA+BxC;AAMD;;GAEG;AACH,UAAU,kBAAmB,SAAQ,iBAAiB;IACpD,0BAA0B;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,wBAAwB,CAAC,EACvC,YAAY,EACZ,UAAU,EACV,GAAG,QAAQ,EACZ,EAAE,kBAAkB,GAAG,KAAK,CAAC,YAAY,CAQzC;AAMD,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,UAAU,EAAE,CAAC"}

package/esm/universal/cached-runtime.d.ts

@@ -1,115 +0,0 @@
-/**
- * Cached Runtime Builder
- *
- * Optimizes bundling by pre-building and caching the static runtime code.
- * Separates "vendor" (static runtime) from "app" (user component) chunks.
- *
- * Benefits:
- * - Runtime is built once and cached globally
- * - Only user components need transpilation per request
- * - Significantly reduces build time for repeated builds
- */
-import type { CDNType, ContentSecurityOptions } from './types';
-/**
- * Runtime cache configuration.
- */
-interface RuntimeCacheConfig {
-    /** Maximum cache entries */
-    maxEntries?: number;
-    /** TTL in milliseconds (0 = forever) */
-    ttl?: number;
-}
-/**
- * Placeholders for dynamic content injection.
- * These are replaced at build time with actual content.
- */
-export declare const RUNTIME_PLACEHOLDERS: {
-    /** Placeholder for transpiled component code */
-    readonly COMPONENT_CODE: "/*__FRONTMCP_COMPONENT_CODE__*/";
-    /** Placeholder for data injection */
-    readonly DATA_INJECTION: "/*__FRONTMCP_DATA_INJECTION__*/";
-    /** Placeholder for custom components */
-    readonly CUSTOM_COMPONENTS: "/*__FRONTMCP_CUSTOM_COMPONENTS__*/";
-};
-/**
- * Options for cached runtime.
- */
-export interface CachedRuntimeOptions {
-    /** CDN type (esm or umd) */
-    cdnType: CDNType;
-    /** Include markdown renderer */
-    includeMarkdown?: boolean;
-    /** Include MDX renderer */
-    includeMdx?: boolean;
-    /** Minify output */
-    minify?: boolean;
-    /** Content security / XSS protection options */
-    contentSecurity?: ContentSecurityOptions;
-}
-/**
- * Result from getting cached runtime.
- */
-export interface CachedRuntimeResult {
-    /** Pre-built vendor script (static runtime) */
-    vendorScript: string;
-    /** Template for app script (with placeholders) */
-    appTemplate: string;
-    /** CDN imports for head */
-    cdnImports: string;
-    /** Total size of vendor script */
-    vendorSize: number;
-    /** Whether this was from cache */
-    cached: boolean;
-    /** Cache key used */
-    cacheKey: string;
-}
-/**
- * Get or build cached runtime.
- *
- * @param options - Runtime options
- * @param config - Cache configuration
- * @returns Cached runtime result
- *
- * @example
- * ```typescript
- * const runtime = getCachedRuntime({ cdnType: 'umd', includeMarkdown: true });
- *
- * // Replace placeholders with actual content
- * const appScript = runtime.appTemplate
- *   .replace(RUNTIME_PLACEHOLDERS.COMPONENT_CODE, transpiledCode)
- *   .replace(RUNTIME_PLACEHOLDERS.DATA_INJECTION, dataScript);
- * ```
- */
-export declare function getCachedRuntime(options: CachedRuntimeOptions, config?: RuntimeCacheConfig): CachedRuntimeResult;
-/**
- * Clear the runtime cache.
- */
-export declare function clearRuntimeCache(): void;
-/**
- * Get cache statistics.
- */
-export declare function getRuntimeCacheStats(): {
-    entries: number;
-    totalSize: number;
-    keys: string[];
-};
-/**
- * Build the complete app script by replacing placeholders.
- *
- * @param appTemplate - Template with placeholders
- * @param componentCode - Transpiled component code (or empty string)
- * @param dataInjection - Data injection script
- * @param customComponents - Custom components script (or empty string)
- * @returns Complete app script
- */
-export declare function buildAppScript(appTemplate: string, componentCode: string, dataInjection: string, customComponents?: string): string;
-/**
- * Build data injection code for the app script.
- */
-export declare function buildDataInjectionCode(toolName: string, input: unknown, output: unknown, structuredContent: unknown, contentType: string, source: string | null, hasComponent: boolean): string;
-/**
- * Build component wrapper code.
- */
-export declare function buildComponentCode(transpiledCode: string): string;
-export {};
-//# sourceMappingURL=cached-runtime.d.ts.map

package/esm/universal/cached-runtime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cached-runtime.d.ts","sourceRoot":"","sources":["../../../src/universal/cached-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAuB/D;;GAEG;AACH,UAAU,kBAAkB;IAC1B,4BAA4B;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wCAAwC;IACxC,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAMD;;;GAGG;AACH,eAAO,MAAM,oBAAoB;IAC/B,gDAAgD;;IAEhD,qCAAqC;;IAErC,wCAAwC;;CAEhC,CAAC;AAiDX;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,4BAA4B;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,gCAAgC;IAChC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,2BAA2B;IAC3B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oBAAoB;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,gDAAgD;IAChD,eAAe,CAAC,EAAE,sBAAsB,CAAC;CAC1C;AAkgBD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,+CAA+C;IAC/C,YAAY,EAAE,MAAM,CAAC;IACrB,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAC;IACpB,2BAA2B;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,MAAM,EAAE,OAAO,CAAC;IAChB,qBAAqB;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,EAAE,MAAM,GAAE,kBAAuB,GAAG,mBAAmB,CAyEpH;AAqBD;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAcA;AAMD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,EACrB,gBAAgB,SAAK,GACpB,MAAM,CAKR;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,OAAO,EACf,iBAAiB,EAAE,OAAO,EAC1B,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,YAAY,EAAE,OAAO,GACpB,MAAM,CAsCR;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAWjE"}

package/esm/universal/context.d.ts

@@ -1,122 +0,0 @@
-/**
- * FrontMCP Context Provider
- *
- * React context for providing the FrontMCP store to child components.
- * Supports custom store injection and auto-initialization from window.
- */
-import React from 'react';
-import type { FrontMCPStore, FrontMCPProviderProps, FrontMCPState } from './types';
-/**
- * FrontMCP Provider component.
- *
- * Provides the FrontMCP store to child components and optionally
- * initializes from window.__frontmcp data.
- *
- * @example
- * ```tsx
- * function App() {
- *   return (
- *     <FrontMCPProvider>
- *       <MyWidget />
- *     </FrontMCPProvider>
- *   );
- * }
- * ```
- *
- * @example Custom store
- * ```tsx
- * const store = createFrontMCPStore({ toolName: 'test' });
- *
- * function App() {
- *   return (
- *     <FrontMCPProvider store={store}>
- *       <MyWidget />
- *     </FrontMCPProvider>
- *   );
- * }
- * ```
- */
-export declare function FrontMCPProvider({ store, initialState, children }: FrontMCPProviderProps): React.ReactElement;
-/**
- * Props for the ComponentsProvider.
- */
-export interface ComponentsProviderProps {
-    /** Custom components to make available */
-    components: Record<string, React.ComponentType<any>>;
-    /** Children to render (optional when using React.createElement) */
-    children?: React.ReactNode;
-}
-/**
- * Provide custom components to renderers.
- *
- * @example
- * ```tsx
- * const components = {
- *   WeatherCard: ({ temp }) => <div>{temp}°F</div>,
- *   Badge: ({ type }) => <span className={type}>Badge</span>,
- * };
- *
- * function App() {
- *   return (
- *     <ComponentsProvider components={components}>
- *       <UniversalRenderer content={mdxContent} />
- *     </ComponentsProvider>
- *   );
- * }
- * ```
- */
-export declare function ComponentsProvider({ components, children }: ComponentsProviderProps): React.ReactElement;
-/**
- * Hook to access the FrontMCP store from context.
- *
- * @throws Error if used outside of FrontMCPProvider
- * @returns Store instance
- */
-export declare function useFrontMCPContext(): FrontMCPStore;
-/**
- * Hook to access custom components from context.
- *
- * @returns Components record
- */
-export declare function useComponents(): Record<string, React.ComponentType<any>>;
-/**
- * Hook to safely access the FrontMCP store (returns null outside provider).
- *
- * @returns Store instance or null
- */
-export declare function useFrontMCPContextSafe(): FrontMCPStore | null;
-/**
- * Props for the combined UniversalProvider.
- */
-export interface UniversalProviderProps extends FrontMCPProviderProps {
-    /** Custom components to make available */
-    components?: Record<string, React.ComponentType<any>>;
-}
-/**
- * Combined provider for FrontMCP store and custom components.
- *
- * @example
- * ```tsx
- * function App() {
- *   return (
- *     <UniversalProvider
- *       initialState={{ toolName: 'get_weather' }}
- *       components={{ WeatherCard: MyWeatherCard }}
- *     >
- *       <UniversalApp />
- *     </UniversalProvider>
- *   );
- * }
- * ```
- */
-export declare function UniversalProvider({ store, initialState, components, children, }: UniversalProviderProps): React.ReactElement;
-/**
- * Higher-order component to inject FrontMCP store as props.
- *
- * @param Component - Component to wrap
- * @returns Wrapped component with store props
- */
-export declare function withFrontMCP<P extends {
-    state?: FrontMCPState;
-}>(Component: React.ComponentType<P>): React.FC<Omit<P, 'state'>>;
-//# sourceMappingURL=context.d.ts.map

package/esm/universal/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/universal/context.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAgE,MAAM,OAAO,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAsBnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,EAAE,qBAAqB,GAAG,KAAK,CAAC,YAAY,CAkB7G;AAMD;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,0CAA0C;IAE1C,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;IACrD,mEAAmE;IACnE,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,uBAAuB,GAAG,KAAK,CAAC,YAAY,CAYxG;AAMD;;;;;GAKG;AACH,wBAAgB,kBAAkB,IAAI,aAAa,CAQlD;AAED;;;;GAIG;AAEH,wBAAgB,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAExE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,aAAa,GAAG,IAAI,CAE7D;AAMD;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,qBAAqB;IACnE,0CAA0C;IAE1C,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;CACvD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,KAAK,EACL,YAAY,EACZ,UAAe,EACf,QAAQ,GACT,EAAE,sBAAsB,GAAG,KAAK,CAAC,YAAY,CAM7C;AAMD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS;IAAE,KAAK,CAAC,EAAE,aAAa,CAAA;CAAE,EAC9D,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,GAChC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAU5B"}

package/esm/universal/index.d.ts

@@ -1,57 +0,0 @@
-/**
- * Universal Renderer Module
- *
- * Multi-format client-side rendering system for FrontMCP widgets.
- * Supports HTML, Markdown, React, and MDX content with auto-detection.
- *
- * @module @frontmcp/ui/universal
- *
- * @example Basic usage
- * ```tsx
- * import { UniversalAppWithProvider } from '@frontmcp/ui/universal';
- *
- * function App() {
- *   return (
- *     <UniversalAppWithProvider
- *       initialState={{
- *         toolName: 'get_weather',
- *         output: { temperature: 72 },
- *       }}
- *       content={{
- *         type: 'markdown',
- *         source: '# Weather: {output.temperature}°F',
- *       }}
- *     />
- *   );
- * }
- * ```
- *
- * @example Custom components
- * ```tsx
- * const components = {
- *   WeatherCard: ({ temp }) => <div>{temp}°F</div>,
- * };
- *
- * function App() {
- *   return (
- *     <UniversalAppWithProvider
- *       components={components}
- *       content={{
- *         type: 'markdown',
- *         source: '# Weather\n\n<WeatherCard temp={72} />',
- *       }}
- *     />
- *   );
- * }
- * ```
- */
-export type { ContentType, UniversalContent, FrontMCPState, FrontMCPStore, RenderContext, ClientRenderer, UniversalAppProps, FrontMCPProviderProps, CDNType, UniversalRuntimeOptions, UniversalRuntimeResult, ContentSecurityOptions, } from './types';
-export { DEFAULT_FRONTMCP_STATE, UNIVERSAL_CDN, detectContentType } from './types';
-export { createFrontMCPStore, getGlobalStore, setGlobalStore, resetGlobalStore, useFrontMCPStore, useToolOutput, useToolInput, useContent, useToolName, useLoadingState, initializeStoreFromWindow, createStoreSelector, } from './store';
-export { FrontMCPProvider, ComponentsProvider, UniversalProvider, useFrontMCPContext, useComponents, useFrontMCPContextSafe, withFrontMCP, } from './context';
-export type { ComponentsProviderProps, UniversalProviderProps } from './context';
-export { RendererRegistry, rendererRegistry, detectRenderer, renderContent, createContent, htmlRenderer, safeHtmlRenderer, markdownRenderer, createMarkdownRenderer, reactRenderer, isReactComponent, mdxRenderer, isMdxSupported, createMdxRenderer, } from './renderers';
-export { UniversalApp, UniversalAppWithProvider, LoadingSpinner, ErrorDisplay, EmptyState } from './UniversalApp';
-export { buildUniversalRuntime, buildMinimalRuntime } from './runtime-builder';
-export { getCachedRuntime, clearRuntimeCache, getRuntimeCacheStats, buildAppScript, buildDataInjectionCode, buildComponentCode, RUNTIME_PLACEHOLDERS, type CachedRuntimeOptions, type CachedRuntimeResult, } from './cached-runtime';
-//# sourceMappingURL=index.d.ts.map

package/esm/universal/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/universal/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAMH,YAAY,EACV,WAAW,EACX,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,qBAAqB,EACrB,OAAO,EACP,uBAAuB,EACvB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,sBAAsB,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAMnF,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,UAAU,EACV,WAAW,EACX,eAAe,EACf,yBAAyB,EACzB,mBAAmB,GACpB,MAAM,SAAS,CAAC;AAMjB,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,sBAAsB,EACtB,YAAY,GACb,MAAM,WAAW,CAAC;AAEnB,YAAY,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAMjF,OAAO,EAEL,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,aAAa,EAEb,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,sBAAsB,EACtB,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,iBAAiB,GAClB,MAAM,aAAa,CAAC;AAMrB,OAAO,EAAE,YAAY,EAAE,wBAAwB,EAAE,cAAc,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAMlH,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAM/E,OAAO,EAEL,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EAEpB,cAAc,EACd,sBAAsB,EACtB,kBAAkB,EAElB,oBAAoB,EAEpB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,GACzB,MAAM,kBAAkB,CAAC"}

package/esm/universal/renderers/html.renderer.d.ts

@@ -1,37 +0,0 @@
-/**
- * HTML Renderer
- *
- * Renders raw HTML strings using dangerouslySetInnerHTML.
- * Used for pre-rendered or server-side generated HTML content.
- */
-import type { ClientRenderer } from '../types';
-/**
- * HTML renderer implementation.
- *
- * Renders HTML strings directly to the DOM using dangerouslySetInnerHTML.
- * This is the lowest priority renderer (fallback).
- *
- * @example
- * ```tsx
- * const content: UniversalContent = {
- *   type: 'html',
- *   source: '<div class="card"><h1>Hello</h1></div>',
- * };
- *
- * // Renders: <div class="card"><h1>Hello</h1></div>
- * ```
- */
-export declare const htmlRenderer: ClientRenderer;
-/**
- * Sanitize HTML string (basic XSS protection).
- * For production use, consider using a library like DOMPurify.
- *
- * @param html - HTML string to sanitize
- * @returns Sanitized HTML string
- */
-export declare function sanitizeHtml(html: string): string;
-/**
- * Create a safe HTML renderer that sanitizes content.
- */
-export declare const safeHtmlRenderer: ClientRenderer;
-//# sourceMappingURL=html.renderer.d.ts.map

package/esm/universal/renderers/html.renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"html.renderer.d.ts","sourceRoot":"","sources":["../../../../src/universal/renderers/html.renderer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAmC,MAAM,UAAU,CAAC;AAEhF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,EAAE,cAsB1B,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAYjD;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAsB9B,CAAC"}