@pancake-apps/web 0.0.0-snapshot-20260125200133

package/dist/index-CpXDfXKD.d.ts

@@ -0,0 +1,395 @@
+import { d as ContentBlock, j as TeardownHandler, H as HostPlatform, l as UnifiedAdaptor, T as Theme, D as DisplayMode, S as SafeAreaInsets, P as Platform, a as DeviceType, C as ContainerSize, I as InputCapabilities, c as CallToolResult, f as ResourceReadResult, L as LogLevel } from './adaptor-interface-BYbH9PpT.js';
+import { N as ToolInputParams, Q as ToolInputPartialParams, K as ToolCancelledParams, H as HostContext, g as HostCapabilities, h as HostInfo } from './types-B_O3kZYh.js';
+
+/**
+ * View Class
+ *
+ * A unified, platform-agnostic API for building Pancake apps.
+ * Works seamlessly with both MCP Apps and ChatGPT Apps.
+ *
+ * @example
+ * ```typescript
+ * import { View } from '@pancake-apps/web';
+ *
+ * const view = new View({
+ *   appInfo: { name: "MyApp", version: "1.0.0" },
+ * });
+ *
+ * view.ontoolinput = (params) => {
+ *   console.log("Tool input:", params.arguments);
+ * };
+ *
+ * await view.connect();
+ *
+ * // Actions
+ * await view.callTool("my-tool", { arg: "value" });
+ * view.sendMessage("Hello!");
+ * ```
+ */
+
+/**
+ * App information for initialization
+ */
+interface ViewAppInfo {
+    name: string;
+    version: string;
+}
+/**
+ * Options for creating a View
+ */
+interface ViewOptions {
+    /**
+     * Application information (used for MCP initialization)
+     */
+    appInfo?: ViewAppInfo;
+    /**
+     * Force a specific platform instead of auto-detecting
+     */
+    platform?: HostPlatform;
+    /**
+     * Custom capabilities to send during MCP initialization
+     */
+    capabilities?: Record<string, unknown>;
+}
+/**
+ * Tool result notification params
+ */
+interface ToolResultParams {
+    content: ContentBlock[];
+    structuredContent?: unknown;
+    isError?: boolean;
+    _meta?: Record<string, unknown>;
+}
+declare class View {
+    private adaptor;
+    private options;
+    private _isConnected;
+    private cleanupFns;
+    private _hostContext;
+    private _hostCapabilities;
+    private _hostInfo;
+    /**
+     * Called when tool input is received (complete input)
+     */
+    ontoolinput?: (params: ToolInputParams) => void;
+    /**
+     * Called during streaming when partial tool input is received (MCP only)
+     */
+    ontoolinputpartial?: (params: ToolInputPartialParams) => void;
+    /**
+     * Called when tool result is received
+     */
+    ontoolresult?: (params: ToolResultParams) => void;
+    /**
+     * Called when tool execution is cancelled
+     */
+    ontoolcancelled?: (params: ToolCancelledParams) => void;
+    /**
+     * Called when host context changes (theme, display mode, etc.)
+     */
+    onhostcontextchanged?: (context: HostContext) => void;
+    /**
+     * Called when the host requests teardown
+     */
+    onteardown?: TeardownHandler;
+    /**
+     * Called when an error occurs
+     */
+    onerror?: (error: Error) => void;
+    /**
+     * Called when the connection is closed
+     */
+    onclose?: () => void;
+    constructor(options?: ViewOptions);
+    /**
+     * Get the current host context (MCP-specific)
+     */
+    getHostContext(): HostContext | undefined;
+    /**
+     * Get host capabilities (MCP-specific)
+     */
+    getHostCapabilities(): HostCapabilities | undefined;
+    /**
+     * Get host info (MCP-specific)
+     */
+    getHostInfo(): HostInfo | undefined;
+    /**
+     * Check if the view is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get the current platform
+     */
+    getPlatform(): HostPlatform;
+    /**
+     * Get the underlying adaptor for advanced use cases
+     */
+    getAdaptor(): UnifiedAdaptor;
+    /**
+     * Get the current theme
+     */
+    getTheme(): Theme;
+    /**
+     * Get the current locale
+     */
+    getLocale(): string;
+    /**
+     * Get the current display mode
+     */
+    getDisplayMode(): DisplayMode;
+    /**
+     * Get the max height constraint
+     */
+    getMaxHeight(): number;
+    /**
+     * Get safe area insets
+     */
+    getSafeArea(): SafeAreaInsets;
+    /**
+     * Get the normalized platform
+     */
+    getNormalizedPlatform(): Platform;
+    /**
+     * Get the device type
+     */
+    getDeviceType(): DeviceType;
+    /**
+     * Get container size
+     */
+    getContainerSize(): ContainerSize;
+    /**
+     * Get input capabilities
+     */
+    getInputCapabilities(): InputCapabilities;
+    /**
+     * Get the current tool input
+     */
+    getToolInput<T>(): T | undefined;
+    /**
+     * Get partial tool input during streaming (MCP only)
+     */
+    getToolInputPartial<T>(): Partial<T> | undefined;
+    /**
+     * Get the current tool output
+     */
+    getToolOutput<T>(): T | undefined;
+    /**
+     * Connect to the host platform.
+     * For MCP, this performs the initialization handshake.
+     * For Apps SDK, this is a no-op (already connected).
+     */
+    connect(): Promise<void>;
+    private connectMcp;
+    private connectAppsSdk;
+    /**
+     * Close the view and cleanup resources
+     */
+    close(): void;
+    /**
+     * Call a server tool
+     */
+    callTool<TInput = Record<string, unknown>, TOutput = unknown>(name: string, args?: TInput): Promise<CallToolResult<TOutput>>;
+    /**
+     * Send a message to the chat
+     */
+    sendMessage(content: string | ContentBlock[]): Promise<void>;
+    /**
+     * Open a link in the browser
+     */
+    openLink(url: string): Promise<void>;
+    /**
+     * Request a display mode change
+     */
+    requestDisplayMode(mode: DisplayMode): Promise<DisplayMode>;
+    /**
+     * Update the model context (MCP only)
+     */
+    updateModelContext(content?: ContentBlock[], structured?: Record<string, unknown>): Promise<void>;
+    /**
+     * Read a resource (MCP only)
+     */
+    readResource(uri: string): Promise<ResourceReadResult>;
+    /**
+     * Notify the host of size changes
+     */
+    notifySizeChanged(width: number, height: number): void;
+    /**
+     * Setup automatic size reporting
+     */
+    setupAutoSizeReporting(element?: HTMLElement): () => void;
+    /**
+     * Log a message to the host
+     */
+    log(level: LogLevel, data: unknown, logger?: string): void;
+    /**
+     * Ping the host (MCP only)
+     */
+    ping(): Promise<void>;
+    private ensureConnected;
+}
+/**
+ * Create and optionally connect a View
+ *
+ * @example
+ * ```typescript
+ * const view = await createView({
+ *   appInfo: { name: "MyApp", version: "1.0.0" },
+ *   autoConnect: true,
+ * });
+ * ```
+ */
+declare function createView(options?: ViewOptions & {
+    autoConnect?: boolean;
+}): Promise<View>;
+
+/**
+ * useView Hook
+ *
+ * React hook for creating and managing a View instance.
+ *
+ * @example
+ * ```tsx
+ * const { view, isConnected, error } = useView({
+ *   appInfo: { name: "MyApp", version: "1.0.0" },
+ *   onViewCreated: (view) => {
+ *     view.ontoolinput = handleToolInput;
+ *   },
+ * });
+ * ```
+ */
+
+interface UseViewOptions extends ViewOptions {
+    /**
+     * Whether to auto-connect on mount (default: true)
+     */
+    autoConnect?: boolean;
+    /**
+     * Callback when the view is created (before connecting)
+     * Use this to set up event handlers
+     */
+    onViewCreated?: (view: View) => void;
+    /**
+     * Callback when successfully connected
+     */
+    onConnected?: (view: View) => void;
+    /**
+     * Callback when connection fails
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Callback when the view is closed
+     */
+    onClose?: () => void;
+}
+interface UseViewResult {
+    /**
+     * The View instance
+     */
+    view: View | null;
+    /**
+     * Whether the view is connected
+     */
+    isConnected: boolean;
+    /**
+     * Whether the view is currently connecting
+     */
+    isConnecting: boolean;
+    /**
+     * Any error that occurred during connection
+     */
+    error: Error | null;
+    /**
+     * Manually connect the view
+     */
+    connect: () => Promise<void>;
+    /**
+     * Manually disconnect/close the view
+     */
+    disconnect: () => void;
+}
+/**
+ * Create and manage a View instance
+ */
+declare function useView(options?: UseViewOptions): UseViewResult;
+
+/**
+ * useHostStyles Hook
+ *
+ * React hook for applying host-provided styles to the document.
+ *
+ * @example
+ * ```tsx
+ * const { view, isConnected } = useView({ ... });
+ *
+ * // Apply host styles when connected
+ * useHostStyles(view?.getHostContext());
+ * ```
+ */
+
+interface UseHostStylesOptions {
+    /**
+     * Whether to apply theme (default: true)
+     */
+    applyTheme?: boolean;
+    /**
+     * Whether to apply CSS variables (default: true)
+     */
+    applyVariables?: boolean;
+    /**
+     * Whether to apply fonts (default: true)
+     */
+    applyFonts?: boolean;
+    /**
+     * Whether to apply safe area insets (default: true)
+     */
+    applySafeArea?: boolean;
+    /**
+     * Whether to clear styles on unmount (default: true)
+     */
+    clearOnUnmount?: boolean;
+}
+/**
+ * Apply host-provided styles to the document
+ */
+declare function useHostStyles(context: HostContext | undefined, options?: UseHostStylesOptions): void;
+/**
+ * Apply only the theme from host context
+ */
+declare function useHostTheme(context: HostContext | undefined): void;
+/**
+ * Apply only CSS variables from host context
+ */
+declare function useHostVariables(context: HostContext | undefined): void;
+/**
+ * Apply only fonts from host context
+ */
+declare function useHostFontsHook(context: HostContext | undefined): void;
+
+/**
+ * useDocumentTheme Hook
+ *
+ * React hook for reactive document theme detection.
+ *
+ * @example
+ * ```tsx
+ * const theme = useDocumentTheme();
+ * console.log(theme); // 'light' or 'dark'
+ * ```
+ */
+
+/**
+ * Get the current document theme reactively
+ * Updates when the theme changes (via class, data-theme, or system preference)
+ */
+declare function useDocumentTheme(): Theme;
+/**
+ * Alternative hook using useState/useEffect pattern
+ * @deprecated Use useDocumentTheme() instead
+ */
+declare function useDocumentThemeState(): Theme;
+/**
+ * Get the system color scheme preference (ignores document classes)
+ */
+declare function useSystemColorScheme(): Theme;
+
+export { type ToolResultParams as T, type UseHostStylesOptions as U, View as V, type UseViewOptions as a, type UseViewResult as b, type ViewAppInfo as c, type ViewOptions as d, createView as e, useDocumentThemeState as f, useHostFontsHook as g, useHostStyles as h, useHostTheme as i, useHostVariables as j, useSystemColorScheme as k, useView as l, useDocumentTheme as u };