artifactuse 0.1.0

package/dist/core/bridge.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Create bridge for panel iframe communication
+ */
+export function createBridge(cdnUrl: any): {
+    setIframe: (iframe: any) => void;
+    send: (action: any, data: any, requestId?: any) => any;
+    request: (action: any, data: any, timeout?: number) => Promise<any>;
+    on: (action: any, callback: any) => () => void;
+    off: (action: any, callback: any) => void;
+    loadArtifact: (artifact: any) => any;
+    updateArtifact: (artifactId: any, updates: any) => any;
+    requestSave: () => Promise<any>;
+    requestExport: (format?: string) => Promise<any>;
+    sendAIResponse: (response: any, requestId: any) => any;
+    destroy: () => void;
+    readonly isReady: boolean;
+    readonly iframe: any;
+};
+/**
+ * Create bridge receiver (for use inside panel iframes)
+ */
+export function createBridgeReceiver(allowedOrigins?: any[]): {
+    on: (action: any, callback: any) => () => void;
+    off: (action: any, callback: any) => void;
+    send: (action: any, data: any) => void;
+    respond: (action: any, data: any, requestId: any) => void;
+    ready: () => void;
+    requestAI: (prompt: any, context?: {}) => string;
+    requestSave: (data: any) => void;
+    notifyExportComplete: (data: any) => void;
+    destroy: () => void;
+};
+declare namespace _default {
+    export { createBridge };
+    export { createBridgeReceiver };
+}
+export default _default;

package/dist/core/detector.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Generate unique artifact ID
+ */
+export function generateArtifactId(prefix?: string): string;
+/**
+ * Check if language/type supports preview
+ */
+export function isPreviewable(language: any): boolean;
+/**
+ * Check if language/type should open in panel by default
+ */
+export function isPanelArtifact(language: any): boolean;
+/**
+ * Check if platform is supported for social previews
+ */
+export function isSupportedSocialPlatform(platform: any): boolean;
+/**
+ * Get display name for language/type
+ */
+export function getLanguageDisplayName(language: any): any;
+/**
+ * Get file extension for language/type
+ */
+export function getFileExtension(language: any): any;
+/**
+ * Get language/type icon SVG path
+ */
+export function getLanguageIcon(language: any): any;
+/**
+ * Format bytes to human readable string
+ */
+export function formatBytes(bytes: any): string;
+/**
+ * Decode HTML entities
+ */
+export function decodeHtml(encoded: any): any;
+/**
+ * Encode HTML for safe embedding
+ */
+export function encodeHtml(code: any): any;
+/**
+ * Encode JSON for safe embedding in HTML attributes using Base64
+ */
+export function encodeJsonForAttribute(obj: any): string;
+/**
+ * Decode JSON from a Base64-encoded HTML attribute value
+ */
+export function decodeJsonFromAttribute(encoded: any): any;
+/**
+ * Extract title from code content
+ */
+export function extractArtifactTitle(code: any, language: any): any;
+/**
+ * Determine if form should render inline or in panel
+ * Parses JSON from code to check complexity
+ */
+export function shouldFormBeInline(code: any): boolean;
+/**
+ * Determine if artifact should be inline based on language
+ */
+export function getIsInline(language: any, code: any): boolean;
+/**
+ * Parse artifacts from rendered HTML (simple detection, no replacement)
+ */
+export function parseArtifacts(html: any, messageId: any): {
+    id: string;
+    messageId: string;
+    type: string;
+    language: string;
+    title: any;
+    code: string;
+    isInline: boolean;
+    isPreviewable: boolean;
+    isPanelArtifact: boolean;
+    size: number;
+    lineCount: number;
+    createdAt: string;
+}[];
+/**
+ * Extract code blocks and replace with placeholders
+ * Handles all artifact types: code, form, social
+ */
+export function extractCodeBlockArtifacts(html: any, messageId: any, options?: {}): {
+    artifacts: any[];
+    html: any;
+};
+export namespace ARTIFACT_TYPES {
+    let CODE: string;
+    let FORM: string;
+    let SOCIAL: string;
+    let IMAGE: string;
+    let VIDEO: string;
+    let AUDIO: string;
+    let DOCUMENT: string;
+    let EMBED: string;
+    let MAP: string;
+    let CHART: string;
+}
+/**
+ * Supported social platforms
+ */
+export const SOCIAL_PLATFORMS: string[];
+/**
+ * Languages/types that support live preview
+ */
+export const PREVIEWABLE_LANGUAGES: string[];
+/**
+ * Languages/types that open in panel (vs inline)
+ */
+export const PANEL_LANGUAGES: string[];
+declare namespace _default {
+    export { ARTIFACT_TYPES };
+    export { PREVIEWABLE_LANGUAGES };
+    export { PANEL_LANGUAGES };
+    export { SOCIAL_PLATFORMS };
+    export { generateArtifactId };
+    export { isPreviewable };
+    export { isPanelArtifact };
+    export { isSupportedSocialPlatform };
+    export { getLanguageDisplayName };
+    export { getFileExtension };
+    export { getLanguageIcon };
+    export { getIsInline };
+    export { formatBytes };
+    export { decodeHtml };
+    export { encodeHtml };
+    export { encodeJsonForAttribute };
+    export { decodeJsonFromAttribute };
+    export { extractArtifactTitle };
+    export { parseArtifacts };
+    export { extractCodeBlockArtifacts };
+    export { shouldFormBeInline };
+}
+export default _default;

package/dist/core/highlight.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Check if Prism is available
+ */
+export function isPrismAvailable(): any;
+/**
+ * Highlight all code blocks in a container
+ * @param {HTMLElement|string} container - Container element or selector
+ */
+export function highlightAll(container: HTMLElement | string): void;
+/**
+ * Highlight a single code block
+ * @param {HTMLElement} element - Code element to highlight
+ * @param {string} language - Language identifier
+ */
+export function highlightElement(element: HTMLElement, language: string): void;
+/**
+ * Highlight code string and return HTML
+ * @param {string} code - Code to highlight
+ * @param {string} language - Language identifier
+ * @returns {string} - Highlighted HTML
+ */
+export function highlightCode(code: string, language: string): string;
+/**
+ * Detect language from element classes
+ * @param {HTMLElement} element - Code element
+ * @returns {string|null} - Detected language or null
+ */
+export function detectLanguage(element: HTMLElement): string | null;
+/**
+ * Normalize language identifier to Prism-compatible name
+ */
+export function normalizeLanguage(lang: any): any;
+/**
+ * Create a mutation observer to auto-highlight new code blocks
+ * @param {HTMLElement} container - Container to observe
+ * @returns {MutationObserver} - Observer instance
+ */
+export function createAutoHighlighter(container: HTMLElement): MutationObserver;
+/**
+ * Get list of supported languages (if Prism is available)
+ */
+export function getSupportedLanguages(): string[];
+declare namespace _default {
+    export { isPrismAvailable };
+    export { highlightAll };
+    export { highlightElement };
+    export { highlightCode };
+    export { detectLanguage };
+    export { normalizeLanguage };
+    export { createAutoHighlighter };
+    export { getSupportedLanguages };
+}
+export default _default;

package/dist/core/index.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Create Artifactuse instance
+ */
+export function createArtifactuse(userConfig?: {}): {
+    config: any;
+    state: {
+        getState: () => {
+            artifacts: any[];
+            activeArtifactId: any;
+            isPanelOpen: boolean;
+            viewMode: string;
+            isFullscreen: boolean;
+        };
+        subscribe: (callback: any) => () => void;
+        addArtifact: (artifact: any) => void;
+        addArtifacts: (artifacts: any) => void;
+        removeArtifact: (artifactId: any) => void;
+        getArtifact: (artifactId: any) => any;
+        getActiveArtifact: () => any;
+        getArtifactsByMessageId: (messageId: any) => any[];
+        getArtifactsByType: (type: any) => any[];
+        getArtifactCount: () => number;
+        setActiveArtifact: (artifactId: any) => void;
+        clearActiveArtifact: () => void;
+        setPanelOpen: (isOpen: any) => void;
+        setViewMode: (mode: any) => void;
+        setFullscreen: (isFullscreen: any) => void;
+        clear: () => void;
+        batch: (updateFn: any) => void;
+    };
+    getState: () => {
+        artifacts: any[];
+        activeArtifactId: any;
+        isPanelOpen: boolean;
+        viewMode: string;
+        isFullscreen: boolean;
+    };
+    subscribe: (callback: any) => () => void;
+    processMessage: (content: any, messageId: any) => {
+        html: string | Promise<string>;
+        artifacts: any[];
+    };
+    initializeContent: (container?: Document) => Promise<void>;
+    openArtifact: (artifact: any) => void;
+    closePanel: () => void;
+    togglePanel: () => void;
+    toggleFullscreen: () => void;
+    setViewMode: (mode: any) => void;
+    getPanelUrl: (artifact: any, options?: {}) => any;
+    sendToPanel: (action: any, data: any) => void;
+    hasPanel: (artifact: any) => any;
+    registerPanel: (typesOrLang: string | string[], panel: string | object) => void;
+    unregisterPanel: (typesOrLang: string | string[]) => void;
+    getPanelTypes: () => any;
+    panelResolver: any;
+    theme: {
+        readonly current: string;
+        readonly resolved: string;
+        readonly colors: any;
+        getResolvedTheme: () => string;
+        getColors: () => any;
+        getCSSVariables: () => string;
+        getCSS: () => string;
+        apply: (container?: HTMLElement) => void;
+        set: (theme: any) => void;
+        toggle: () => void;
+        setColors: (newColors: any, theme?: any) => void;
+        watchSystemTheme: (callback: any) => () => void;
+    };
+    applyTheme: () => void;
+    setTheme: (newTheme: any) => void;
+    getTheme: () => string;
+    on: (event: any, callback: any) => () => void;
+    off: (event: any, callback: any) => void;
+    emit: (event: any, data: any) => void;
+    bridge: {
+        setIframe: (iframe: any) => void;
+        send: (action: any, data: any, requestId?: any) => any;
+        request: (action: any, data: any, timeout?: number) => Promise<any>;
+        on: (action: any, callback: any) => () => void;
+        off: (action: any, callback: any) => void;
+        loadArtifact: (artifact: any) => any;
+        updateArtifact: (artifactId: any, updates: any) => any;
+        requestSave: () => Promise<any>;
+        requestExport: (format?: string) => Promise<any>;
+        sendAIResponse: (response: any, requestId: any) => any;
+        destroy: () => void;
+        readonly isReady: boolean;
+        readonly iframe: any;
+    };
+    destroy: () => void;
+};
+export * from "./processors/index.js";
+export * from "./highlight.js";
+export { createState } from "./state.js";
+export { createBridge } from "./bridge.js";
+export { createTheme } from "./theme.js";
+export default createArtifactuse;
+export namespace DEFAULT_PANELS {
+    let form: string;
+    let video: string;
+    let videoeditor: string;
+    let timeline: string;
+    let canvas: string;
+    let whiteboard: string;
+    let drawing: string;
+    let json: string;
+    let svg: string;
+    let diff: string;
+    let patch: string;
+    let javascript: string;
+    let js: string;
+    let python: string;
+    let py: string;
+    let jsx: string;
+    let react: string;
+    let vue: string;
+    let html: string;
+    let htm: string;
+    let markdown: string;
+    let md: string;
+    let mermaid: string;
+}
+export { parseArtifacts, extractCodeBlockArtifacts, getIsInline as isInlineArtifact } from "./detector.js";

package/dist/core/processors/audio.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Process all audio URLs in HTML
+ * @param {string} html - HTML content to process
+ * @param {object} options - Processing options
+ * @param {string} options.theme - Theme: 'dark' | 'light'
+ */
+export function processAudio(html: string, options?: {
+    theme: string;
+}): string;
+/**
+ * Create custom waveform audio player
+ */
+export function createAudioPlayer(audioUrl: any): string;
+/**
+ * Create SoundCloud embed
+ */
+export function createSoundCloudEmbed(url: any): string;
+/**
+ * Create Spotify embed
+ * @param {string} type - track, album, playlist, artist, episode, show
+ * @param {string} id - Spotify ID
+ * @param {string} theme - 'dark' | 'light'
+ */
+export function createSpotifyEmbed(type: string, id: string, theme?: string): string;
+/**
+ * Create Apple Music embed
+ */
+export function createAppleMusicEmbed(country: any, type: any, id: any): string;
+declare namespace _default {
+    export { processAudio };
+    export { createAudioPlayer };
+    export { createSoundCloudEmbed };
+    export { createSpotifyEmbed };
+    export { createAppleMusicEmbed };
+}
+export default _default;

package/dist/core/processors/audioPlayer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Initialize all audio players in the document
+ * Call this after DOM is ready
+ */
+export function initializeAudioPlayers(container?: Document): void;
+/**
+ * Play audio
+ */
+export function playAudio(playerId: any): void;
+/**
+ * Pause audio
+ */
+export function pauseAudio(playerId: any): void;
+/**
+ * Stop all players
+ */
+export function stopAllPlayers(): void;
+/**
+ * Get player state
+ */
+export function getPlayerState(playerId: any): any;
+/**
+ * Destroy a player instance
+ */
+export function destroyPlayer(playerId: any): void;
+/**
+ * Destroy all players
+ */
+export function destroyAllPlayers(): void;
+declare namespace _default {
+    export { initializeAudioPlayers };
+    export { playAudio };
+    export { pauseAudio };
+    export { stopAllPlayers };
+    export { getPlayerState };
+    export { destroyPlayer };
+    export { destroyAllPlayers };
+}
+export default _default;

package/dist/core/processors/codeEmbed.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Process all code platform URLs in HTML
+ * @param {string} html - HTML content to process
+ * @param {object} options - Processing options
+ * @param {string} options.theme - Theme: 'dark' | 'light'
+ */
+export function processCodeEmbeds(html: string, options?: {
+    theme: string;
+}): string;
+/**
+ * Create GitHub Gist embed
+ * Note: Gist doesn't support theme parameter, it uses user's GitHub preference
+ */
+export function createGistEmbed(user: any, gistId: any): string;
+/**
+ * Create CodePen embed
+ * @param {string} user - CodePen username
+ * @param {string} penId - Pen ID
+ * @param {string} theme - 'dark' | 'light'
+ */
+export function createCodePenEmbed(user: string, penId: string, theme?: string): string;
+/**
+ * Create CodeSandbox embed
+ * @param {string} sandboxId - Sandbox ID
+ * @param {string} theme - 'dark' | 'light'
+ */
+export function createCodeSandboxEmbed(sandboxId: string, theme?: string): string;
+/**
+ * Create JSFiddle embed
+ * @param {string} user - JSFiddle username
+ * @param {string} fiddleId - Fiddle ID
+ * @param {string} theme - 'dark' | 'light'
+ */
+export function createJSFiddleEmbed(user: string, fiddleId: string, theme?: string): string;
+/**
+ * Create StackBlitz embed
+ * @param {string} projectId - Project ID
+ * @param {string} theme - 'dark' | 'light'
+ */
+export function createStackBlitzEmbed(projectId: string, theme?: string): string;
+/**
+ * Create Replit embed
+ * Note: Replit uses system/user preference for theme, parameter included for consistency
+ * @param {string} user - Replit username
+ * @param {string} replName - Repl name
+ * @param {string} theme - 'dark' | 'light' (may not be honored by Replit)
+ */
+export function createReplitEmbed(user: string, replName: string, theme?: string): string;
+declare namespace _default {
+    export { processCodeEmbeds };
+    export { createGistEmbed };
+    export { createCodePenEmbed };
+    export { createCodeSandboxEmbed };
+    export { createJSFiddleEmbed };
+    export { createStackBlitzEmbed };
+    export { createReplitEmbed };
+}
+export default _default;

package/dist/core/processors/dataViz.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Process all data visualization URLs in HTML
+ */
+export function processDataViz(html: any): any;
+/**
+ * Create Tableau Public embed
+ */
+export function createTableauEmbed(vizPath: any): string;
+/**
+ * Create Flourish embed
+ */
+export function createFlourishEmbed(vizId: any): string;
+/**
+ * Create Datawrapper embed
+ */
+export function createDatawrapperEmbed(chartId: any): string;
+/**
+ * Create Infogram embed
+ */
+export function createInfogramEmbed(chartId: any): string;
+declare namespace _default {
+    export { processDataViz };
+    export { createTableauEmbed };
+    export { createFlourishEmbed };
+    export { createDatawrapperEmbed };
+    export { createInfogramEmbed };
+}
+export default _default;

package/dist/core/processors/design.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Process all 3D and design URLs in HTML
+ * @param {string} html - HTML content to process
+ * @param {object} options - Processing options
+ * @param {string} options.theme - Theme: 'dark' | 'light'
+ */
+export function process3DEmbeds(html: string, options?: {
+    theme: string;
+}): string;
+/**
+ * Create Sketchfab 3D model embed
+ * @param {string} modelId - Sketchfab model ID
+ * @param {string} theme - 'dark' | 'light'
+ */
+export function createSketchfabEmbed(modelId: string, theme?: string): string;
+/**
+ * Create Figma file embed
+ * Note: Figma embed doesn't support theme parameter
+ */
+export function createFigmaEmbed(fileKey: any, nodeId: any): string;
+/**
+ * Create Figma prototype embed
+ * Note: Figma embed doesn't support theme parameter
+ */
+export function createFigmaPrototypeEmbed(fileKey: any, originalUrl: any): string;
+/**
+ * Create Canva embed (placeholder with link - Canva doesn't support direct embeds)
+ * Note: Canva doesn't support direct embedding with theme parameter
+ */
+export function createCanvaEmbed(designId: any, originalUrl: any): string;
+/**
+ * Create Dribbble shot embed
+ * Note: Dribbble embed doesn't support theme parameter
+ */
+export function createDribbbleEmbed(shotId: any): string;
+/**
+ * Create Behance project embed
+ * Note: Behance embed doesn't support theme parameter
+ */
+export function createBehanceEmbed(projectId: any, originalUrl: any): string;
+declare namespace _default {
+    export { process3DEmbeds };
+    export { createSketchfabEmbed };
+    export { createFigmaEmbed };
+    export { createFigmaPrototypeEmbed };
+    export { createCanvaEmbed };
+    export { createDribbbleEmbed };
+    export { createBehanceEmbed };
+}
+export default _default;

package/dist/core/processors/document.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Process PDF URLs in HTML
+ */
+export function processPdfs(html: any): any;
+/**
+ * Create PDF embed
+ */
+export function createPdfEmbed(url: any): string;
+/**
+ * Process Google Docs/Sheets/Slides/Forms URLs
+ */
+export function processGoogleDocs(html: any): any;
+/**
+ * Create Google Doc/Sheet/Slides embed
+ */
+export function createGoogleDocEmbed(docId: any, type: any): string;
+/**
+ * Create Google Form embed
+ */
+export function createGoogleFormEmbed(formId: any): string;
+/**
+ * Process Office document URLs
+ */
+export function processOfficeDocuments(html: any): any;
+/**
+ * Create Office document embed (Word, Excel, PowerPoint)
+ */
+export function createOfficeEmbed(fileUrl: any): string;
+declare namespace _default {
+    export { processPdfs };
+    export { createPdfEmbed };
+    export { processGoogleDocs };
+    export { createGoogleDocEmbed };
+    export { createGoogleFormEmbed };
+    export { processOfficeDocuments };
+    export { createOfficeEmbed };
+}
+export default _default;

package/dist/core/processors/image.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Process all image URLs in HTML (linkified and raw)
+ */
+export function processImages(html: any): any;
+/**
+ * Render a single image with lightbox support
+ */
+export function renderImageHtml(src: any, title: any, alt: any): string;
+/**
+ * Process HTML to group consecutive images into galleries
+ */
+export function processImageGalleries(html: any): string;
+/**
+ * Create a gallery wrapper for multiple images
+ */
+export function createImageGallery(imageContainers: any): string;
+declare namespace _default {
+    export { processImages };
+    export { renderImageHtml };
+    export { processImageGalleries };
+    export { createImageGallery };
+}
+export default _default;