@frontmcp/ui 0.6.0 → 0.6.1

package/renderers/html.renderer.d.ts

@@ -1,123 +0,0 @@
-/**
- * HTML Renderer
- *
- * Handles plain HTML templates:
- * - Static HTML strings
- * - Template builder functions: (ctx) => string
- * - Handlebars-enhanced templates: HTML with {{variable}} syntax
- *
- * This is the default fallback renderer with the lowest priority.
- */
-import type { TemplateContext } from '../runtime/types';
-import type { PlatformCapabilities } from '../theme';
-import type { UIRenderer, TranspileResult, TranspileOptions, RenderOptions, RuntimeScripts } from './types';
-/**
- * Template builder function type.
- */
-type TemplateBuilderFn<In, Out> = (ctx: TemplateContext<In, Out>) => string;
-/**
- * Types this renderer can handle.
- */
-type HtmlTemplate<In = unknown, Out = unknown> = string | TemplateBuilderFn<In, Out>;
-/**
- * Check if a template contains Handlebars syntax.
- * Non-async version for canHandle check.
- */
-declare function containsHandlebars(template: string): boolean;
-/**
- * HTML Renderer Implementation.
- *
- * Handles:
- * - Static HTML strings (passed through directly)
- * - Template builder functions that return HTML strings
- * - Handlebars-enhanced templates (detected by {{...}} syntax)
- *
- * When Handlebars syntax is detected, the template is processed
- * with the HandlebarsRenderer for variable interpolation, conditionals,
- * and loops.
- *
- * @example Static HTML
- * ```typescript
- * const template = '<div class="card">Hello World</div>';
- * await htmlRenderer.render(template, context);
- * ```
- *
- * @example Template function
- * ```typescript
- * const template = (ctx) => `<div>${ctx.helpers.escapeHtml(ctx.output.name)}</div>`;
- * await htmlRenderer.render(template, context);
- * ```
- *
- * @example Handlebars template
- * ```typescript
- * const template = `
- *   <div class="card">
- *     <h2>{{escapeHtml output.title}}</h2>
- *     {{#if output.items}}
- *       <ul>
- *         {{#each output.items}}
- *           <li>{{this.name}}</li>
- *         {{/each}}
- *       </ul>
- *     {{/if}}
- *   </div>
- * `;
- * await htmlRenderer.render(template, context);
- * ```
- */
-export declare class HtmlRenderer implements UIRenderer<HtmlTemplate> {
-    readonly type: "html";
-    readonly priority = 0;
-    /**
-     * Check if this renderer can handle the given template.
-     *
-     * Accepts:
-     * - Any string (assumed to be HTML, with or without Handlebars)
-     * - Functions that are template builders (not React components)
-     */
-    canHandle(template: unknown): template is HtmlTemplate;
-    /**
-     * Check if a template uses Handlebars syntax.
-     *
-     * @param template - Template string to check
-     * @returns true if template contains {{...}} syntax
-     */
-    usesHandlebars(template: string): boolean;
-    /**
-     * Transpile the template.
-     *
-     * For HTML templates, no transpilation is needed.
-     * This method returns a dummy result for consistency.
-     */
-    transpile(template: HtmlTemplate, _options?: TranspileOptions): Promise<TranspileResult>;
-    /**
-     * Render the template to HTML string.
-     *
-     * For static strings without Handlebars, returns the string directly.
-     * For strings with Handlebars syntax, processes with HandlebarsRenderer.
-     * For functions, calls the function with the context.
-     */
-    render<In, Out>(template: HtmlTemplate<In, Out>, context: TemplateContext<In, Out>, _options?: RenderOptions): Promise<string>;
-    /**
-     * Render Handlebars template with context.
-     */
-    private renderHandlebars;
-    /**
-     * Get runtime scripts for client-side functionality.
-     *
-     * HTML templates don't need additional runtime scripts.
-     */
-    getRuntimeScripts(_platform: PlatformCapabilities): RuntimeScripts;
-}
-/**
- * Singleton instance of the HTML renderer.
- */
-export declare const htmlRenderer: HtmlRenderer;
-/**
- * Check if a template string contains Handlebars syntax.
- *
- * @param template - Template string
- * @returns true if contains {{...}}
- */
-export { containsHandlebars };
-//# sourceMappingURL=html.renderer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"html.renderer.d.ts","sourceRoot":"","sources":["../../src/renderers/html.renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,gBAAgB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAI5G;;GAEG;AACH,KAAK,iBAAiB,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,eAAe,CAAC,EAAE,EAAE,GAAG,CAAC,KAAK,MAAM,CAAC;AAE5E;;GAEG;AACH,KAAK,YAAY,CAAC,EAAE,GAAG,OAAO,EAAE,GAAG,GAAG,OAAO,IAAI,MAAM,GAAG,iBAAiB,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;AA0CrF;;;GAGG;AACH,iBAAS,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGrD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,YAAa,YAAW,UAAU,CAAC,YAAY,CAAC;IAC3D,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAU;IAChC,QAAQ,CAAC,QAAQ,KAAK;IAEtB;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY;IActD;;;;;OAKG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIzC;;;;;OAKG;IACG,SAAS,CAAC,QAAQ,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAW9F;;;;;;OAMG;IACG,MAAM,CAAC,EAAE,EAAE,GAAG,EAClB,QAAQ,EAAE,YAAY,CAAC,EAAE,EAAE,GAAG,CAAC,EAC/B,OAAO,EAAE,eAAe,CAAC,EAAE,EAAE,GAAG,CAAC,EACjC,QAAQ,CAAC,EAAE,aAAa,GACvB,OAAO,CAAC,MAAM,CAAC;IAwBlB;;OAEG;YACW,gBAAgB;IAmB9B;;;;OAIG;IACH,iBAAiB,CAAC,SAAS,EAAE,oBAAoB,GAAG,cAAc;CAMnE;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,cAAqB,CAAC;AAE/C;;;;;GAKG;AACH,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/renderers/mdx.renderer.d.ts

@@ -1,120 +0,0 @@
-/**
- * MDX Renderer
- *
- * Handles MDX templates - Markdown with embedded JSX components.
- * Uses @mdx-js/mdx for compilation and react-dom/server for SSR.
- *
- * MDX allows mixing Markdown with React components:
- * - Markdown headings, lists, code blocks
- * - JSX component tags: `<Card />`
- * - JS expressions: `{output.items.map(...)}`
- * - Frontmatter for metadata
- */
-import type { TemplateContext } from '../runtime/types';
-import type { PlatformCapabilities } from '../theme';
-import type { UIRenderer, TranspileResult, TranspileOptions, RenderOptions, RuntimeScripts } from './types';
-/**
- * Types this renderer can handle - MDX strings.
- */
-type MdxTemplate = string;
-/**
- * MDX Renderer Implementation.
- *
- * Compiles MDX (Markdown + JSX) to React components using @mdx-js/mdx,
- * then renders to HTML using react-dom/server.
- *
- * @example Basic MDX template
- * ```typescript
- * @Tool({
- *   ui: {
- *     template: `
- * # User Profile
- *
- * <UserCard name={output.name} email={output.email} />
- *
- * ## Recent Activity
- * {output.items.map(item => <ActivityItem key={item.id} {...item} />)}
- *     `,
- *     mdxComponents: { UserCard, ActivityItem }
- *   }
- * })
- * ```
- *
- * @example MDX with frontmatter
- * ```typescript
- * @Tool({
- *   ui: {
- *     template: `
- * ---
- * title: Dashboard
- * ---
- *
- * # {frontmatter.title}
- *
- * <Dashboard data={output} />
- *     `
- *   }
- * })
- * ```
- */
-export declare class MdxRenderer implements UIRenderer<MdxTemplate> {
-    readonly type: "mdx";
-    readonly priority = 10;
-    /**
-     * Lazy-loaded modules.
-     */
-    private React;
-    private ReactDOMServer;
-    private jsxRuntime;
-    private mdxEvaluate;
-    /**
-     * Check if this renderer can handle the given template.
-     *
-     * Accepts strings containing MDX syntax (Markdown + JSX).
-     */
-    canHandle(template: unknown): template is MdxTemplate;
-    /**
-     * Transpile MDX to executable JavaScript.
-     *
-     * Uses @mdx-js/mdx to compile MDX source to a module.
-     * Note: For MDX, we use evaluate() which combines compile + run,
-     * so this method just returns the source hash for caching purposes.
-     */
-    transpile(template: MdxTemplate, _options?: TranspileOptions): Promise<TranspileResult>;
-    /**
-     * Render MDX template to HTML string.
-     *
-     * Uses @mdx-js/mdx's evaluate() for clean compilation + execution,
-     * then renders the resulting React component to HTML via SSR.
-     */
-    render<In, Out>(template: MdxTemplate, 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;
-    /**
-     * Load @mdx-js/mdx evaluate function.
-     *
-     * evaluate() is the cleanest way to run MDX - it combines
-     * compile and run in a single step, handling all the runtime
-     * injection automatically.
-     */
-    private loadMdx;
-}
-/**
- * Singleton instance of the MDX renderer.
- */
-export declare const mdxRenderer: MdxRenderer;
-/**
- * Build MDX hydration script for client-side interactivity.
- *
- * Note: MDX hydration is more complex than React hydration
- * because it needs the MDX runtime and component definitions.
- */
-export declare function buildMdxHydrationScript(): string;
-export {};
-//# sourceMappingURL=mdx.renderer.d.ts.map

package/renderers/mdx.renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mdx.renderer.d.ts","sourceRoot":"","sources":["../../src/renderers/mdx.renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,cAAc,EAEf,MAAM,SAAS,CAAC;AAKjB;;GAEG;AACH,KAAK,WAAW,GAAG,MAAM,CAAC;AAmB1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,qBAAa,WAAY,YAAW,UAAU,CAAC,WAAW,CAAC;IACzD,QAAQ,CAAC,IAAI,EAAG,KAAK,CAAU;IAC/B,QAAQ,CAAC,QAAQ,MAAM;IAEvB;;OAEG;IAEH,OAAO,CAAC,KAAK,CAAa;IAE1B,OAAO,CAAC,cAAc,CAAa;IAEnC,OAAO,CAAC,UAAU,CAAa;IAE/B,OAAO,CAAC,WAAW,CAAiF;IAEpG;;;;OAIG;IACH,SAAS,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,WAAW;IAQrD;;;;;;OAMG;IACG,SAAS,CAAC,QAAQ,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAsB7F;;;;;OAKG;IACG,MAAM,CAAC,EAAE,EAAE,GAAG,EAClB,QAAQ,EAAE,WAAW,EACrB,OAAO,EAAE,eAAe,CAAC,EAAE,EAAE,GAAG,CAAC,EACjC,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,MAAM,CAAC;IAkFlB;;OAEG;IACH,iBAAiB,CAAC,QAAQ,EAAE,oBAAoB,GAAG,cAAc;IAoBjE;;OAEG;YACW,SAAS;IAoBvB;;;;;;OAMG;YACW,OAAO;CAgBtB;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,aAAoB,CAAC;AAE7C;;;;;GAKG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CA+BhD"}

package/renderers/registry.d.ts

@@ -1,134 +0,0 @@
-/**
- * Renderer Registry
- *
- * Global registry for template renderers with auto-detection.
- * Manages registration, detection, and rendering of templates.
- */
-import type { TemplateContext } from '../runtime/types';
-import type { UIRenderer, RendererType, RendererRegistryOptions, DetectionResult, RenderResult, RenderOptions } from './types';
-/**
- * Renderer Registry.
- *
- * Manages a collection of renderers and provides:
- * - Registration of custom renderers
- * - Auto-detection of template types
- * - Unified rendering interface
- *
- * @example
- * ```typescript
- * // Register a custom renderer
- * registry.register(myCustomRenderer);
- *
- * // Auto-detect and render
- * const result = await registry.render(template, context);
- * ```
- */
-export declare class RendererRegistry {
-    private renderers;
-    private sortedRenderers;
-    private defaultRenderer;
-    private debug;
-    constructor(options?: RendererRegistryOptions);
-    /**
-     * Register a renderer.
-     *
-     * Renderers are sorted by priority (highest first) for detection.
-     *
-     * @param renderer - Renderer to register
-     */
-    register(renderer: UIRenderer): void;
-    /**
-     * Unregister a renderer.
-     *
-     * @param type - Type of renderer to remove
-     * @returns True if renderer was removed
-     */
-    unregister(type: RendererType): boolean;
-    /**
-     * Get a renderer by type.
-     *
-     * @param type - Renderer type
-     * @returns Renderer or undefined if not found
-     */
-    get(type: RendererType): UIRenderer | undefined;
-    /**
-     * Check if a renderer type is registered.
-     *
-     * @param type - Renderer type
-     * @returns True if registered
-     */
-    has(type: RendererType): boolean;
-    /**
-     * Get all registered renderer types.
-     *
-     * @returns Array of renderer types
-     */
-    getTypes(): RendererType[];
-    /**
-     * Auto-detect the renderer for a template.
-     *
-     * Checks renderers in priority order (highest first).
-     * Returns HTML renderer as fallback.
-     *
-     * @param template - Template to detect
-     * @returns Detection result with renderer and confidence
-     */
-    detect(template: unknown): DetectionResult;
-    /**
-     * Render a template with auto-detection.
-     *
-     * @param template - Template to render (React, MDX, or HTML)
-     * @param context - Template context with input/output
-     * @param options - Render options
-     * @returns Rendered result with HTML and metadata
-     */
-    render<In, Out>(template: unknown, context: TemplateContext<In, Out>, options?: RenderOptions): Promise<RenderResult>;
-    /**
-     * Render with a specific renderer type.
-     *
-     * @param type - Renderer type to use
-     * @param template - Template to render
-     * @param context - Template context
-     * @param options - Render options
-     * @returns Rendered result
-     */
-    renderWith<In, Out>(type: RendererType, template: unknown, context: TemplateContext<In, Out>, options?: RenderOptions): Promise<RenderResult>;
-    /**
-     * Update the sorted renderer list by priority.
-     */
-    private updateSortedList;
-    /**
-     * Set the default renderer type.
-     *
-     * @param type - Renderer type to use as default
-     */
-    setDefault(type: RendererType): void;
-    /**
-     * Get registry statistics.
-     */
-    getStats(): {
-        registeredRenderers: RendererType[];
-        defaultRenderer: RendererType;
-        priorityOrder: Array<{
-            type: RendererType;
-            priority: number;
-        }>;
-    };
-}
-/**
- * Global renderer registry instance.
- *
- * Pre-configured with the HTML renderer.
- * React and MDX renderers can be added:
- *
- * ```typescript
- * import { rendererRegistry } from '@frontmcp/ui';
- * import { reactRenderer } from '@frontmcp/ui';
- * import { mdxRenderer } from '@frontmcp/ui';
- *
- * rendererRegistry.register(reactRenderer);
- * rendererRegistry.register(mdxRenderer);
- * ```
- */
-export declare const rendererRegistry: RendererRegistry;
-//# sourceMappingURL=registry.d.ts.map

package/renderers/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/renderers/registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGxD,OAAO,KAAK,EACV,UAAU,EACV,YAAY,EACZ,uBAAuB,EACvB,eAAe,EACf,YAAY,EACZ,aAAa,EACd,MAAM,SAAS,CAAC;AAGjB;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,SAAS,CAAuC;IACxD,OAAO,CAAC,eAAe,CAAoB;IAC3C,OAAO,CAAC,eAAe,CAAwB;IAC/C,OAAO,CAAC,KAAK,CAAU;gBAEX,OAAO,GAAE,uBAA4B;IAOjD;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,IAAI;IASpC;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO;IAQvC;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,YAAY,GAAG,UAAU,GAAG,SAAS;IAI/C;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO;IAIhC;;;;OAIG;IACH,QAAQ,IAAI,YAAY,EAAE;IAI1B;;;;;;;;OAQG;IACH,MAAM,CAAC,QAAQ,EAAE,OAAO,GAAG,eAAe;IA+B1C;;;;;;;OAOG;IACG,MAAM,CAAC,EAAE,EAAE,GAAG,EAClB,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,eAAe,CAAC,EAAE,EAAE,GAAG,CAAC,EACjC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC;IA4BxB;;;;;;;;OAQG;IACG,UAAU,CAAC,EAAE,EAAE,GAAG,EACtB,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,eAAe,CAAC,EAAE,EAAE,GAAG,CAAC,EACjC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC;IAyBxB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;;;OAIG;IACH,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI;IAOpC;;OAEG;IACH,QAAQ,IAAI;QACV,mBAAmB,EAAE,YAAY,EAAE,CAAC;QACpC,eAAe,EAAE,YAAY,CAAC;QAC9B,aAAa,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,YAAY,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAChE;CAUF;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,kBAAyB,CAAC"}