@frontmcp/ui 0.6.0 → 0.6.2

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/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"}

package/renderers/types.d.ts

@@ -1,342 +0,0 @@
-/**
- * Renderer System Types
- *
- * Core interfaces for the multi-framework rendering system.
- * Supports HTML, React, and MDX templates with auto-detection.
- */
-import type { TemplateContext, TemplateHelpers, TemplateBuilderFn } from '../runtime/types';
-import type { PlatformCapabilities } from '../theme';
-/**
- * Supported renderer types for template processing.
- * - 'html': Plain HTML string or template function
- * - 'react': React functional component
- * - 'mdx': MDX content string
- */
-export type RendererType = 'html' | 'react' | 'mdx';
-/**
- * Props passed to React components used as templates.
- *
- * For SSR (server-side rendering), `output` is always available.
- * For client-side hydration with the bridge, use `HydratedToolUIProps`.
- */
-export interface ToolUIProps<In = unknown, Out = unknown> {
-    /** Tool input arguments */
-    input: In;
-    /** Tool output result */
-    output: Out;
-    /** Structured content parsed from output */
-    structuredContent?: unknown;
-    /** Helper functions for rendering */
-    helpers: TemplateHelpers;
-}
-/**
- * Props for client-side hydrated components using the Platform Bridge.
- *
- * These props include loading/error state for reactive rendering.
- * Use with `useSyncExternalStore` from React 18+:
- *
- * @example
- * ```tsx
- * import { useSyncExternalStore } from 'react';
- *
- * function useToolBridge<T>(): HydratedToolUIProps<T> {
- *   const state = useSyncExternalStore(
- *     window.__frontmcp.bridge.subscribe,
- *     window.__frontmcp.bridge.getSnapshot,
- *     window.__frontmcp.bridge.getServerSnapshot
- *   );
- *   return {
- *     data: state.data as T,
- *     loading: state.loading,
- *     error: state.error,
- *   };
- * }
- *
- * function MyWidget() {
- *   const { data, loading, error } = useToolBridge<WeatherData>();
- *
- *   if (loading) return <Spinner />;
- *   if (error) return <Error message={error} />;
- *   if (!data) return <Empty />;
- *
- *   return <WeatherCard {...data} />;
- * }
- * ```
- */
-export interface HydratedToolUIProps<Out = unknown> {
-    /** Tool output data (null when loading or no data) */
-    data: Out | null;
-    /** Whether the bridge is waiting for data */
-    loading: boolean;
-    /** Error message if data loading failed */
-    error: string | null;
-}
-/**
- * Result of transpiling a template.
- */
-export interface TranspileResult {
-    /** Transpiled JavaScript code */
-    code: string;
-    /** Content hash for caching */
-    hash: string;
-    /** Whether result was retrieved from cache */
-    cached: boolean;
-    /** Source map for debugging (optional) */
-    sourceMap?: string;
-}
-/**
- * Options for transpilation.
- */
-export interface TranspileOptions {
-    /** Enable source maps */
-    sourceMaps?: boolean;
-    /** Development mode (more detailed errors) */
-    development?: boolean;
-}
-/**
- * Options for rendering a template.
- */
-export interface RenderOptions {
-    /** Target platform capabilities */
-    platform?: PlatformCapabilities;
-    /** Enable client-side hydration */
-    hydrate?: boolean;
-    /** Custom MDX components */
-    mdxComponents?: Record<string, unknown>;
-}
-/**
- * Runtime scripts to inject for client-side functionality.
- */
-export interface RuntimeScripts {
-    /** Scripts to include in <head> */
-    headScripts: string;
-    /** Inline script content (for blocked-network platforms) */
-    inlineScripts?: string;
-    /** Whether scripts are inline or external */
-    isInline: boolean;
-}
-/**
- * Result of rendering a template.
- */
-export interface RenderResult {
-    /** Rendered HTML content (body only) */
-    html: string;
-    /** Renderer type that was used */
-    rendererType: RendererType;
-    /** Whether transpilation was cached */
-    transpileCached: boolean;
-    /** Runtime scripts needed for this template */
-    runtimeScripts: RuntimeScripts;
-}
-/**
- * Abstract renderer interface for processing templates.
- *
- * Each renderer handles a specific template type (HTML, React, MDX)
- * and provides:
- * - Template type detection
- * - Transpilation (if needed)
- * - HTML rendering
- * - Client runtime script generation
- */
-export interface UIRenderer<T = unknown> {
-    /**
-     * Unique renderer type identifier.
-     */
-    readonly type: RendererType;
-    /**
-     * Priority for auto-detection.
-     * Higher values are checked first.
-     * - React: 20
-     * - MDX: 10
-     * - HTML: 0 (fallback)
-     */
-    readonly priority: number;
-    /**
-     * Check if this renderer can handle the given template.
-     *
-     * @param template - The template to check
-     * @returns True if this renderer can process the template
-     */
-    canHandle(template: unknown): template is T;
-    /**
-     * Transpile the template to executable JavaScript (if needed).
-     *
-     * For React components from imports, no transpilation is needed.
-     * For JSX strings, SWC transpilation is performed.
-     * Results are cached by content hash.
-     *
-     * @param template - Template to transpile
-     * @param options - Transpilation options
-     * @returns Transpiled result with caching metadata
-     */
-    transpile(template: T, options?: TranspileOptions): Promise<TranspileResult>;
-    /**
-     * Render the template to HTML string.
-     *
-     * @param template - Template to render
-     * @param context - Template context with input/output/helpers
-     * @param options - Render options (platform, hydration, etc.)
-     * @returns Rendered HTML string
-     */
-    render<In, Out>(template: T, context: TemplateContext<In, Out>, options?: RenderOptions): Promise<string>;
-    /**
-     * Get runtime scripts needed for client-side functionality.
-     *
-     * @param platform - Target platform capabilities
-     * @returns Scripts to inject (CDN or inline based on platform)
-     */
-    getRuntimeScripts(platform: PlatformCapabilities): RuntimeScripts;
-}
-/**
- * Options for the renderer registry.
- */
-export interface RendererRegistryOptions {
-    /** Maximum cache size for transpiled results */
-    maxCacheSize?: number;
-    /** Enable debug logging */
-    debug?: boolean;
-}
-/**
- * Result of detecting a template's renderer type.
- */
-export interface DetectionResult {
-    /** The detected renderer */
-    renderer: UIRenderer;
-    /** Confidence level (0-1) */
-    confidence: number;
-    /** Detection reason for debugging */
-    reason: string;
-}
-/**
- * React component type for Tool UI templates.
- *
- * This is a generic function type that accepts props and returns JSX.
- * We use a loose type here to avoid requiring React types at compile time.
- */
-export type ReactComponentType<In = unknown, Out = unknown> = (props: ToolUIProps<In, Out>) => any;
-/**
- * All possible template types.
- * Auto-detected at runtime.
- */
-export type ToolUITemplate<In = unknown, Out = unknown> = TemplateBuilderFn<In, Out> | string | ReactComponentType<In, Out>;
-/**
- * Context passed to custom wrapper functions.
- */
-export interface WrapperContext {
-    /** Tool name */
-    toolName: string;
-    /** Rendered content HTML */
-    content: string;
-    /** Detected renderer type */
-    rendererType: RendererType;
-    /** Target platform */
-    platform: PlatformCapabilities;
-    /** Runtime scripts to inject */
-    runtimeScripts: RuntimeScripts;
-}
-/**
- * Extended Tool UI configuration with multi-framework support.
- *
- * The template type is auto-detected - no need to specify a renderer!
- *
- * @example React component
- * ```typescript
- * import { UserCard } from './components/user-card.tsx';
- *
- * @Tool({
- *   ui: {
- *     template: UserCard, // Auto-detected as React
- *     hydrate: true,      // Enable client-side interactivity
- *   }
- * })
- * ```
- *
- * @example MDX template
- * ```typescript
- * @Tool({
- *   ui: {
- *     template: `
- *       # Welcome
- *       <UserCard name={output.name} />
- *     `,
- *     mdxComponents: { UserCard },
- *   }
- * })
- * ```
- *
- * @example HTML template (unchanged)
- * ```typescript
- * @Tool({
- *   ui: {
- *     template: (ctx) => `<div>${ctx.output.name}</div>`,
- *   }
- * })
- * ```
- */
-export interface ExtendedToolUIConfig<In = unknown, Out = unknown> {
-    /**
-     * Template for rendering the UI.
-     *
-     * Can be:
-     * - React component: `({ input, output }) => <div>...</div>`
-     * - MDX string: `# Title\n<Component />`
-     * - HTML function: `(ctx) => \`<div>...</div>\``
-     * - Static HTML string
-     *
-     * Type is auto-detected at runtime.
-     */
-    template: ToolUITemplate<In, Out>;
-    /**
-     * Enable client-side hydration for React components.
-     * When true, the React runtime is included and components
-     * become interactive in the browser.
-     *
-     * @default false
-     */
-    hydrate?: boolean;
-    /**
-     * Custom wrapper function to override the default HTML document wrapper.
-     * Useful for completely custom document structures.
-     *
-     * @param content - Rendered template HTML
-     * @param ctx - Wrapper context with metadata
-     * @returns Complete HTML document string
-     */
-    wrapper?: (content: string, ctx: WrapperContext) => string;
-    /**
-     * Custom MDX components available in MDX templates.
-     * These components can be used directly in MDX content.
-     *
-     * @example
-     * ```typescript
-     * mdxComponents: {
-     *   UserCard: ({ name }) => <div>{name}</div>,
-     *   Badge: ({ type }) => <span className={type}>...</span>,
-     * }
-     * ```
-     */
-    mdxComponents?: Record<string, (props: any) => any>;
-    /** Content Security Policy for the sandboxed widget. */
-    csp?: {
-        connectDomains?: string[];
-        resourceDomains?: string[];
-    };
-    /** Whether the widget can invoke tools via the MCP bridge. */
-    widgetAccessible?: boolean;
-    /** Preferred display mode for the widget. */
-    displayMode?: 'inline' | 'fullscreen' | 'pip';
-    /** Human-readable description shown to users about what the widget does. */
-    widgetDescription?: string;
-    /** Status messages shown during tool invocation. */
-    invocationStatus?: {
-        invoking?: string;
-        invoked?: string;
-    };
-    /** How the widget HTML should be served to the client. */
-    servingMode?: 'inline' | 'static' | 'hybrid' | 'direct-url' | 'custom-url';
-    /** Custom URL for widget serving when `servingMode: 'custom-url'`. */
-    customWidgetUrl?: string;
-    /** Path for direct URL serving when `servingMode: 'direct-url'`. */
-    directPath?: string;
-}
-//# sourceMappingURL=types.d.ts.map

package/renderers/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/renderers/types.ts"],"names":[],"mappings":"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"}