@orangecatai/adgen-canvas 0.0.1 → 0.0.2

package/dist/types/excalidraw/components/ai-chat/agentLoop.d.ts

@@ -0,0 +1,60 @@
+import { type ToolExecutionContext, type ToolResult } from "./canvasTools";
+type ContentPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "image_url";
+    image_url: {
+        url: string;
+    };
+};
+export type AgentMessage = {
+    role: "system";
+    content: string;
+} | {
+    role: "user";
+    content: string | ContentPart[];
+} | {
+    role: "assistant";
+    content: string | null;
+    tool_calls?: ToolCall[];
+} | {
+    role: "tool";
+    tool_call_id: string;
+    content: string;
+};
+export type ToolCall = {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+export type ToolAction = {
+    toolName: string;
+    args: Record<string, unknown>;
+    result: ToolResult;
+};
+export type AgentUpdate = {
+    type: "status" | "tool_start" | "tool_done" | "final";
+    message: string;
+    toolAction?: ToolAction;
+};
+export type AgentResult = {
+    reply: string;
+    toolActions: ToolAction[];
+};
+export declare function runAgentLoop(opts: {
+    userMessages: Array<{
+        role: "user" | "assistant";
+        content: string;
+    }>;
+    elementContext?: string;
+    frameScreenshot?: string;
+    apiKey: string;
+    toolCtx: ToolExecutionContext;
+    onUpdate: (update: AgentUpdate) => void;
+    signal?: AbortSignal;
+}): Promise<AgentResult>;
+export {};

package/dist/types/excalidraw/components/ai-chat/canvasTools.d.ts

@@ -0,0 +1,288 @@
+import type { ExcalidrawElement } from "@orangecatai/element/types";
+import type { ExcalidrawImperativeAPI } from "../../types";
+export declare const CANVAS_TOOLS: readonly [{
+    readonly type: "function";
+    readonly function: {
+        readonly name: "create_frame";
+        readonly description: "Create a new frame on the canvas. Frames act as artboards that clip their children. Default size is 512x512.";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly width: {
+                    readonly type: "number";
+                    readonly description: "Frame width in pixels (default 512)";
+                };
+                readonly height: {
+                    readonly type: "number";
+                    readonly description: "Frame height in pixels (default 512)";
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Optional display name for the frame";
+                };
+            };
+            readonly required: readonly [];
+            readonly additionalProperties: false;
+        };
+    };
+}, {
+    readonly type: "function";
+    readonly function: {
+        readonly name: "add_rectangle";
+        readonly description: "Add a filled rectangle inside a frame. Commonly used for solid background fills behind images and text.";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly frameId: {
+                    readonly type: "string";
+                    readonly description: "ID of the parent frame";
+                };
+                readonly x: {
+                    readonly type: "number";
+                    readonly description: "X position relative to canvas (use the frame's x for full coverage)";
+                };
+                readonly y: {
+                    readonly type: "number";
+                    readonly description: "Y position relative to canvas (use the frame's y for full coverage)";
+                };
+                readonly width: {
+                    readonly type: "number";
+                    readonly description: "Rectangle width in pixels";
+                };
+                readonly height: {
+                    readonly type: "number";
+                    readonly description: "Rectangle height in pixels";
+                };
+                readonly backgroundColor: {
+                    readonly type: "string";
+                    readonly description: "Fill color as hex string e.g. \"#1a1a2e\". Use \"transparent\" for no fill.";
+                };
+                readonly fillStyle: {
+                    readonly type: "string";
+                    readonly enum: readonly ["solid", "hachure", "cross-hatch"];
+                    readonly description: "Fill style (default \"solid\")";
+                };
+                readonly strokeColor: {
+                    readonly type: "string";
+                    readonly description: "Stroke/border color as hex (default \"transparent\")";
+                };
+                readonly strokeWidth: {
+                    readonly type: "number";
+                    readonly description: "Stroke width in pixels (default 0)";
+                };
+                readonly opacity: {
+                    readonly type: "number";
+                    readonly description: "Opacity 0-100 (default 100)";
+                };
+            };
+            readonly required: readonly ["frameId", "x", "y", "width", "height", "backgroundColor"];
+            readonly additionalProperties: false;
+        };
+    };
+}, {
+    readonly type: "function";
+    readonly function: {
+        readonly name: "add_text";
+        readonly description: "Add a text element inside a frame. Use for headlines, subheads, body copy, CTAs etc.";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly frameId: {
+                    readonly type: "string";
+                    readonly description: "ID of the parent frame";
+                };
+                readonly x: {
+                    readonly type: "number";
+                    readonly description: "X position (canvas coordinates)";
+                };
+                readonly y: {
+                    readonly type: "number";
+                    readonly description: "Y position (canvas coordinates)";
+                };
+                readonly text: {
+                    readonly type: "string";
+                    readonly description: "The text content";
+                };
+                readonly fontSize: {
+                    readonly type: "number";
+                    readonly description: "Font size in pixels (default 20)";
+                };
+                readonly fontFamily: {
+                    readonly type: "number";
+                    readonly enum: readonly [1, 2, 3, 4, 5];
+                    readonly description: "Font family: 1=Excalifont(hand), 2=Nunito(sans), 3=Comic Shanns(code), 4=Liberation Sans(clean sans), 5=cascadia(code). Default 2.";
+                };
+                readonly strokeColor: {
+                    readonly type: "string";
+                    readonly description: "Text color as hex string (default \"#000000\")";
+                };
+                readonly textAlign: {
+                    readonly type: "string";
+                    readonly enum: readonly ["left", "center", "right"];
+                    readonly description: "Horizontal alignment (default left)";
+                };
+                readonly width: {
+                    readonly type: "number";
+                    readonly description: "Optional fixed width for text wrapping";
+                };
+            };
+            readonly required: readonly ["frameId", "x", "y", "text"];
+            readonly additionalProperties: false;
+        };
+    };
+}, {
+    readonly type: "function";
+    readonly function: {
+        readonly name: "generate_image";
+        readonly description: "Generate an image using AI (Gemini) from a text prompt and place it inside a frame. Use for hero images, product shots, backgrounds, illustrations etc.";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly frameId: {
+                    readonly type: "string";
+                    readonly description: "ID of the parent frame to insert the image into";
+                };
+                readonly prompt: {
+                    readonly type: "string";
+                    readonly description: "Detailed image generation prompt describing what to create";
+                };
+                readonly x: {
+                    readonly type: "number";
+                    readonly description: "X position for the image (canvas coordinates)";
+                };
+                readonly y: {
+                    readonly type: "number";
+                    readonly description: "Y position for the image (canvas coordinates)";
+                };
+                readonly width: {
+                    readonly type: "number";
+                    readonly description: "Image width in pixels";
+                };
+                readonly height: {
+                    readonly type: "number";
+                    readonly description: "Image height in pixels";
+                };
+            };
+            readonly required: readonly ["frameId", "prompt", "x", "y", "width", "height"];
+            readonly additionalProperties: false;
+        };
+    };
+}, {
+    readonly type: "function";
+    readonly function: {
+        readonly name: "update_element";
+        readonly description: "Update properties of an existing element (move, resize, recolor, change text, etc.)";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly elementId: {
+                    readonly type: "string";
+                    readonly description: "ID of the element to update";
+                };
+                readonly x: {
+                    readonly type: "number";
+                    readonly description: "New X position";
+                };
+                readonly y: {
+                    readonly type: "number";
+                    readonly description: "New Y position";
+                };
+                readonly width: {
+                    readonly type: "number";
+                    readonly description: "New width";
+                };
+                readonly height: {
+                    readonly type: "number";
+                    readonly description: "New height";
+                };
+                readonly backgroundColor: {
+                    readonly type: "string";
+                    readonly description: "New background/fill color";
+                };
+                readonly strokeColor: {
+                    readonly type: "string";
+                    readonly description: "New stroke/text color";
+                };
+                readonly opacity: {
+                    readonly type: "number";
+                    readonly description: "New opacity 0-100";
+                };
+                readonly fontSize: {
+                    readonly type: "number";
+                    readonly description: "New font size (text elements only)";
+                };
+                readonly text: {
+                    readonly type: "string";
+                    readonly description: "New text content (text elements only)";
+                };
+                readonly fillStyle: {
+                    readonly type: "string";
+                    readonly enum: readonly ["solid", "hachure", "cross-hatch"];
+                    readonly description: "New fill style";
+                };
+            };
+            readonly required: readonly ["elementId"];
+            readonly additionalProperties: false;
+        };
+    };
+}, {
+    readonly type: "function";
+    readonly function: {
+        readonly name: "delete_element";
+        readonly description: "Delete an element from the canvas";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly elementId: {
+                    readonly type: "string";
+                    readonly description: "ID of the element to delete";
+                };
+            };
+            readonly required: readonly ["elementId"];
+            readonly additionalProperties: false;
+        };
+    };
+}, {
+    readonly type: "function";
+    readonly function: {
+        readonly name: "get_frame_elements";
+        readonly description: "Get all child elements inside a frame. Returns their IDs, types, positions, sizes, colors, and text content. Use this to understand the current layout before making changes.";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly frameId: {
+                    readonly type: "string";
+                    readonly description: "ID of the frame to inspect";
+                };
+            };
+            readonly required: readonly ["frameId"];
+            readonly additionalProperties: false;
+        };
+    };
+}];
+export declare function serializeElements(elements: readonly ExcalidrawElement[]): Record<string, unknown>[];
+export type FrameInfo = {
+    id: string;
+    name: string;
+    width: number;
+    height: number;
+    childCount: number;
+};
+export declare function listFrames(api: ExcalidrawImperativeAPI): FrameInfo[];
+export declare function captureFrameScreenshot(api: ExcalidrawImperativeAPI, frameId: string): Promise<string | null>;
+export declare function getFrameContext(api: ExcalidrawImperativeAPI, frameId: string): {
+    serialized: string;
+    frameInfo: FrameInfo;
+} | null;
+export type ToolExecutionContext = {
+    excalidrawAPI: ExcalidrawImperativeAPI;
+    geminiApiKey: string;
+    signal?: AbortSignal;
+};
+export type ToolResult = {
+    success: boolean;
+    data?: Record<string, unknown>;
+    error?: string;
+    statusMessage: string;
+};
+export declare function executeCanvasTool(toolName: string, rawArgs: string, ctx: ToolExecutionContext): Promise<ToolResult>;

package/dist/types/excalidraw/components/image-generation/pendingGenerations.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pending image generation state — shared across ImageGeneratorPanel and
+ * ImageQuickEditPanel so generation survives panel unmount/remount.
+ *
+ * Flow:
+ * 1. User clicks Generate → startPendingGeneration(id, prompt, settings, controller)
+ *    Stores prompt, model/ratio/resolution, and AbortController. Request continues
+ *    even if user clicks away (no unmount-abort).
+ * 2. Panel subscribes via subscribeGenerationDone(id, cb). If generation already
+ *    finished while unmounted, cb is invoked immediately with finishedError.
+ * 3. On success/error → finishPendingGeneration(id, error) notifies subscribers.
+ * 4. On success only → clearGenerationState(id) removes the entry so reselecting
+ *    the frame/image shows a clean prompt instead of the old one.
+ * 5. Stop button → abortPendingGeneration(id) aborts the controller.
+ */
+export type GenerationDoneCallback = (error: string | null) => void;
+export interface GenerationSettings {
+    model: string;
+    ratio: string;
+    resolution: string;
+}
+export declare function startPendingGeneration(elementId: string, prompt: string, settings: GenerationSettings, controller: AbortController): void;
+export declare function finishPendingGeneration(elementId: string, error: string | null): void;
+export declare function subscribeGenerationDone(elementId: string, fn: GenerationDoneCallback): boolean;
+export declare function unsubscribeGenerationDone(elementId: string, fn: GenerationDoneCallback): void;
+export declare function clearGenerationState(elementId: string): void;
+export declare function abortPendingGeneration(elementId: string): void;
+export declare function getPendingPrompt(elementId: string): string;
+export declare function getPendingSettings(elementId: string): GenerationSettings | null;
+export declare function hasPendingGeneration(elementId: string): boolean;

package/dist/types/excalidraw/components/ui/avatar.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+declare const Avatar: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Avatar, AvatarImage, AvatarFallback };

package/dist/types/excalidraw/components/ui/button.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "outline" | "destructive" | "secondary" | "ghost" | null | undefined;
+    size?: "icon" | "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

package/dist/types/excalidraw/components/ui/chat-container.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+export type ChatContainerRootProps = {
+    children: React.ReactNode;
+    className?: string;
+} & React.HTMLAttributes<HTMLDivElement>;
+export type ChatContainerContentProps = {
+    children: React.ReactNode;
+    className?: string;
+} & React.HTMLAttributes<HTMLDivElement>;
+export type ChatContainerScrollAnchorProps = {
+    className?: string;
+    ref?: React.RefObject<HTMLDivElement>;
+} & React.HTMLAttributes<HTMLDivElement>;
+declare function ChatContainerRoot({ children, className, ...props }: ChatContainerRootProps): import("react/jsx-runtime").JSX.Element;
+declare function ChatContainerContent({ children, className, ...props }: ChatContainerContentProps): import("react/jsx-runtime").JSX.Element;
+declare function ChatContainerScrollAnchor({ className, ...props }: ChatContainerScrollAnchorProps): import("react/jsx-runtime").JSX.Element;
+export { ChatContainerRoot, ChatContainerContent, ChatContainerScrollAnchor };

package/dist/types/excalidraw/components/ui/code-block.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+export type CodeBlockProps = {
+    children?: React.ReactNode;
+    className?: string;
+} & React.HTMLProps<HTMLDivElement>;
+declare function CodeBlock({ children, className, ...props }: CodeBlockProps): import("react/jsx-runtime").JSX.Element;
+export type CodeBlockCodeProps = {
+    code: string;
+    language?: string;
+    theme?: string;
+    className?: string;
+} & React.HTMLProps<HTMLDivElement>;
+declare function CodeBlockCode({ code, language, theme, className, ...props }: CodeBlockCodeProps): import("react/jsx-runtime").JSX.Element;
+export type CodeBlockGroupProps = React.HTMLAttributes<HTMLDivElement>;
+declare function CodeBlockGroup({ children, className, ...props }: CodeBlockGroupProps): import("react/jsx-runtime").JSX.Element;
+export { CodeBlockGroup, CodeBlockCode, CodeBlock };

package/dist/types/excalidraw/components/ui/markdown.d.ts

@@ -0,0 +1,10 @@
+import type { Components } from "react-markdown";
+export type MarkdownProps = {
+    children: string;
+    id?: string;
+    className?: string;
+    components?: Partial<Components>;
+};
+declare function MarkdownComponent({ children, id, className, components, }: MarkdownProps): import("react/jsx-runtime").JSX.Element;
+declare const Markdown: import("react").MemoExoticComponent<typeof MarkdownComponent>;
+export { Markdown };

package/dist/types/excalidraw/components/ui/message.d.ts

@@ -0,0 +1,35 @@
+import * as React from "react";
+import { Markdown } from "./markdown";
+import { Tooltip } from "@/components/ui/tooltip";
+export type MessageProps = {
+    children: React.ReactNode;
+    className?: string;
+} & React.HTMLProps<HTMLDivElement>;
+declare const Message: ({ children, className, ...props }: MessageProps) => import("react/jsx-runtime").JSX.Element;
+export type MessageAvatarProps = {
+    src: string;
+    alt: string;
+    fallback?: string;
+    delayMs?: number;
+    className?: string;
+};
+declare const MessageAvatar: ({ src, alt, fallback, delayMs, className, }: MessageAvatarProps) => import("react/jsx-runtime").JSX.Element;
+export type MessageContentProps = {
+    children: React.ReactNode;
+    markdown?: boolean;
+    className?: string;
+} & React.ComponentProps<typeof Markdown> & React.HTMLProps<HTMLDivElement>;
+declare const MessageContent: ({ children, markdown, className, ...props }: MessageContentProps) => import("react/jsx-runtime").JSX.Element;
+export type MessageActionsProps = {
+    children: React.ReactNode;
+    className?: string;
+} & React.HTMLProps<HTMLDivElement>;
+declare const MessageActions: ({ children, className, ...props }: MessageActionsProps) => import("react/jsx-runtime").JSX.Element;
+export type MessageActionProps = {
+    className?: string;
+    tooltip: React.ReactNode;
+    children: React.ReactNode;
+    side?: "top" | "bottom" | "left" | "right";
+} & React.ComponentProps<typeof Tooltip>;
+declare const MessageAction: ({ tooltip, children, className, side, ...props }: MessageActionProps) => import("react/jsx-runtime").JSX.Element;
+export { Message, MessageAvatar, MessageContent, MessageActions, MessageAction, };

package/dist/types/excalidraw/components/ui/prompt-input.d.ts

@@ -0,0 +1,28 @@
+import React from "react";
+import { Textarea } from "./textarea";
+import { Tooltip } from "./tooltip";
+export type PromptInputProps = {
+    isLoading?: boolean;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    maxHeight?: number | string;
+    onSubmit?: () => void;
+    children: React.ReactNode;
+    className?: string;
+    disabled?: boolean;
+} & React.ComponentProps<"div">;
+declare function PromptInput({ className, isLoading, maxHeight, value, onValueChange, onSubmit, children, disabled, onClick, ...props }: PromptInputProps): import("react/jsx-runtime").JSX.Element;
+export type PromptInputTextareaProps = {
+    disableAutosize?: boolean;
+} & React.ComponentProps<typeof Textarea>;
+declare function PromptInputTextarea({ className, onKeyDown, disableAutosize, ...props }: PromptInputTextareaProps): import("react/jsx-runtime").JSX.Element;
+export type PromptInputActionsProps = React.HTMLAttributes<HTMLDivElement>;
+declare function PromptInputActions({ children, className, ...props }: PromptInputActionsProps): import("react/jsx-runtime").JSX.Element;
+export type PromptInputActionProps = {
+    className?: string;
+    tooltip: React.ReactNode;
+    children: React.ReactNode;
+    side?: "top" | "bottom" | "left" | "right";
+} & React.ComponentProps<typeof Tooltip>;
+declare function PromptInputAction({ tooltip, children, className, side, ...props }: PromptInputActionProps): import("react/jsx-runtime").JSX.Element;
+export { PromptInput, PromptInputTextarea, PromptInputActions, PromptInputAction, };

package/dist/types/excalidraw/components/ui/scroll-button.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+import type { buttonVariants } from "@/components/ui/button";
+export type ScrollButtonProps = {
+    className?: string;
+    variant?: VariantProps<typeof buttonVariants>["variant"];
+    size?: VariantProps<typeof buttonVariants>["size"];
+} & React.ButtonHTMLAttributes<HTMLButtonElement>;
+declare function ScrollButton({ className, variant, size, ...props }: ScrollButtonProps): import("react/jsx-runtime").JSX.Element;
+export { ScrollButton };

package/dist/types/excalidraw/components/ui/select.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };

package/dist/types/excalidraw/components/ui/textarea.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Textarea: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/dist/types/excalidraw/components/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/types/excalidraw/data/blob.d.ts

@@ -1,6 +1,6 @@
 import { IMAGE_MIME_TYPES, MIME_TYPES } from "@orangecatai/common";
-import type { ValueOf } from "@orangecatai/common/utility-types";
 import type { ExcalidrawElement, FileId } from "@orangecatai/element/types";
+import type { ValueOf } from "@orangecatai/common/utility-types";
 import type { AppState, DataURL, LibraryItem } from "../types";
 import type { FileSystemHandle } from "browser-fs-access";
 import type { ImportedLibraryData } from "./types";
@@ -21,14 +21,6 @@ fileHandle?: FileSystemHandle | null) => Promise<{
     data: {
         elements: import("@orangecatai/element/types").OrderedExcalidrawElement[];
         appState: {
-            viewBackgroundColor: string;
-            theme: import("@orangecatai/element/types").Theme;
-            frameRendering: {
-                enabled: boolean;
-                name: boolean;
-                outline: boolean;
-                clip: boolean;
-            };
             name: string | null;
             zoom: import("../types").Zoom;
             scrollX: number;
@@ -52,6 +44,7 @@ fileHandle?: FileSystemHandle | null) => Promise<{
                 [id: string]: true;
             }>;
             frameToHighlight: import("@orangecatai/element/types").NonDeleted<import("@orangecatai/element/types").ExcalidrawFrameLikeElement> | null;
+            theme: import("@orangecatai/element/types").Theme;
             activeTool: {
                 lastActiveTool: import("../types").ActiveTool | null;
                 locked: boolean;
@@ -89,6 +82,12 @@ fileHandle?: FileSystemHandle | null) => Promise<{
             hoveredElementIds: Readonly<{
                 [id: string]: true;
             }>;
+            frameRendering: {
+                enabled: boolean;
+                name: boolean;
+                outline: boolean;
+                clip: boolean;
+            };
             shouldCacheIgnoreZoom: boolean;
             exportScale: number;
             currentItemArrowType: "sharp" | "round" | "elbow";
@@ -128,6 +127,7 @@ fileHandle?: FileSystemHandle | null) => Promise<{
             currentItemEndArrowhead: import("@orangecatai/element/types").Arrowhead | null;
             currentHoveredFontFamily: import("@orangecatai/element/types").FontFamilyValues | null;
             currentItemRoundness: import("@orangecatai/element/types").StrokeRoundness;
+            viewBackgroundColor: string;
             cursorButton: "up" | "down";
             scrolledOutside: boolean;
             isResizing: boolean;
@@ -188,14 +188,6 @@ localAppState: AppState | null, localElements: readonly ExcalidrawElement[] | nu
 fileHandle?: FileSystemHandle | null) => Promise<{
     elements: import("@orangecatai/element/types").OrderedExcalidrawElement[];
     appState: {
-        viewBackgroundColor: string;
-        theme: import("@orangecatai/element/types").Theme;
-        frameRendering: {
-            enabled: boolean;
-            name: boolean;
-            outline: boolean;
-            clip: boolean;
-        };
         name: string | null;
         zoom: import("../types").Zoom;
         scrollX: number;
@@ -219,6 +211,7 @@ fileHandle?: FileSystemHandle | null) => Promise<{
             [id: string]: true;
         }>;
         frameToHighlight: import("@orangecatai/element/types").NonDeleted<import("@orangecatai/element/types").ExcalidrawFrameLikeElement> | null;
+        theme: import("@orangecatai/element/types").Theme;
         activeTool: {
             lastActiveTool: import("../types").ActiveTool | null;
             locked: boolean;
@@ -256,6 +249,12 @@ fileHandle?: FileSystemHandle | null) => Promise<{
         hoveredElementIds: Readonly<{
             [id: string]: true;
         }>;
+        frameRendering: {
+            enabled: boolean;
+            name: boolean;
+            outline: boolean;
+            clip: boolean;
+        };
         shouldCacheIgnoreZoom: boolean;
         exportScale: number;
         currentItemArrowType: "sharp" | "round" | "elbow";
@@ -295,6 +294,7 @@ fileHandle?: FileSystemHandle | null) => Promise<{
         currentItemEndArrowhead: import("@orangecatai/element/types").Arrowhead | null;
         currentHoveredFontFamily: import("@orangecatai/element/types").FontFamilyValues | null;
         currentItemRoundness: import("@orangecatai/element/types").StrokeRoundness;
+        viewBackgroundColor: string;
         cursorButton: "up" | "down";
         scrolledOutside: boolean;
         isResizing: boolean;
@@ -353,6 +353,8 @@ export declare const generateIdFromFile: (file: File) => Promise<FileId>;
 /** async. For sync variant, use getDataURL_sync */
 export declare const getDataURL: (file: Blob | File) => Promise<DataURL>;
 export declare const getDataURL_sync: (data: string | Uint8Array | ArrayBuffer, mimeType: ValueOf<typeof MIME_TYPES>) => DataURL;
+/** Parses MIME type from a data URL (e.g. data:image/webp;base64,...). */
+export declare const getMimeTypeFromDataURL: (dataURL: string) => string;
 export declare const dataURLToFile: (dataURL: DataURL, filename?: string) => File;
 export declare const dataURLToString: (dataURL: DataURL) => string;
 export declare const resizeImageFile: (file: File, opts: {