artifactuse 0.1.0

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

@@ -0,0 +1,62 @@
+declare namespace _default {
+    export { imageProcessor as image };
+    export { videoProcessor as video };
+    export { audioProcessor as audio };
+    export { mapProcessor as map };
+    export { socialProcessor as social };
+    export { documentProcessor as document };
+    export { codeEmbedProcessor as codeEmbed };
+    export { dataVizProcessor as dataViz };
+    export { designProcessor as design };
+    export { interactiveProcessor as interactive };
+    export { mermaidProcessor as mermaid };
+    export { tableProcessor as table };
+    export { mathProcessor as math };
+    export let processImages: typeof import("./image.js").processImages;
+    export let processVideos: typeof import("./video.js").processVideos;
+    export let processAudio: typeof import("./audio.js").processAudio;
+    export let processMaps: typeof import("./map.js").processMaps;
+    export let processSocialEmbeds: typeof import("./social.js").processSocialEmbeds;
+    export let processPdfs: typeof import("./document.js").processPdfs;
+    export let processGoogleDocs: typeof import("./document.js").processGoogleDocs;
+    export let processOfficeDocuments: typeof import("./document.js").processOfficeDocuments;
+    export let processCodeEmbeds: typeof import("./codeEmbed.js").processCodeEmbeds;
+    export let processDataViz: typeof import("./dataViz.js").processDataViz;
+    export let process3DEmbeds: typeof import("./design.js").process3DEmbeds;
+    export let processInteractiveEmbeds: typeof import("./interactive.js").processInteractiveEmbeds;
+    export let processMermaid: typeof import("./mermaid.js").processMermaid;
+    export let processTables: typeof import("./table.js").processTables;
+    export let processMath: typeof import("./math.js").processMath;
+    export let initializeMermaid: typeof import("./mermaid.js").initializeMermaid;
+    export let initializeTables: typeof import("./table.js").initializeTables;
+    export let initializeMath: typeof import("./math.js").initializeMath;
+    export let renderImageHtml: typeof import("./image.js").renderImageHtml;
+}
+export default _default;
+import imageProcessor from './image.js';
+import videoProcessor from './video.js';
+import audioProcessor from './audio.js';
+import mapProcessor from './map.js';
+import socialProcessor from './social.js';
+import documentProcessor from './document.js';
+import codeEmbedProcessor from './codeEmbed.js';
+import dataVizProcessor from './dataViz.js';
+import designProcessor from './design.js';
+import interactiveProcessor from './interactive.js';
+import mermaidProcessor from './mermaid.js';
+import tableProcessor from './table.js';
+import mathProcessor from './math.js';
+export { processImages, renderImageHtml, processImageGalleries, createImageGallery } from "./image.js";
+export { processVideos, isVideoUrl, renderVideoHtml, createVideoPlayer, processVideoGalleries, createVideoGallery, createVideoWithPreview, createYouTubeEmbed, createVimeoEmbed, createLoomEmbed, createDailymotionEmbed } from "./video.js";
+export { processAudio, createAudioPlayer, createSoundCloudEmbed, createSpotifyEmbed, createAppleMusicEmbed } from "./audio.js";
+export { initializeAudioPlayers, destroyAllPlayers } from "./audioPlayer.js";
+export { processMaps, createGoogleMapEmbed, createGoogleMapEmbedCoords, createOSMEmbed } from "./map.js";
+export { processSocialEmbeds, createTwitterEmbed, createInstagramEmbed, createInstagramReelEmbed, createTikTokEmbed, createLinkedInEmbed, createRedditEmbed, createFacebookEmbed, createPinterestEmbed } from "./social.js";
+export { processPdfs, createPdfEmbed, processGoogleDocs, createGoogleDocEmbed, createGoogleFormEmbed, processOfficeDocuments, createOfficeEmbed } from "./document.js";
+export { processCodeEmbeds, createGistEmbed, createCodePenEmbed, createCodeSandboxEmbed, createJSFiddleEmbed, createStackBlitzEmbed, createReplitEmbed } from "./codeEmbed.js";
+export { processDataViz, createTableauEmbed, createFlourishEmbed, createDatawrapperEmbed, createInfogramEmbed } from "./dataViz.js";
+export { process3DEmbeds, createSketchfabEmbed, createFigmaEmbed, createFigmaPrototypeEmbed, createCanvaEmbed, createDribbbleEmbed, createBehanceEmbed } from "./design.js";
+export { processInteractiveEmbeds, createTypeformEmbed, createCalendlyEmbed, createGoogleCalendarEmbed, createCalcomEmbed, createNotionEmbed, createAirtableEmbed, createMiroEmbed } from "./interactive.js";
+export { processMermaid, createMermaidBlock, initializeMermaid, loadMermaid, resetMermaidLoadState, isMermaidAvailable, hasMermaidLoadFailed, processMermaidInElement, rerenderMermaid, updateMermaidDiagram } from "./mermaid.js";
+export { processTables, createEnhancedTable, tableToCSV, downloadCSV, copyTableToClipboard, sortTable, filterTable, initializeTables } from "./table.js";
+export { processMath, createMathBlock, initializeMath, loadKaTeX, resetKaTeXLoadState, isKaTeXAvailable, hasKaTeXLoadFailed, processMathInElement, mathPatterns } from "./math.js";

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

@@ -0,0 +1,57 @@
+/**
+ * Process all interactive tool URLs in HTML
+ * @param {string} html - HTML content to process
+ * @param {object} options - Processing options
+ * @param {string} options.theme - Theme: 'dark' | 'light'
+ */
+export function processInteractiveEmbeds(html: string, options?: {
+    theme: string;
+}): string;
+/**
+ * Create Typeform embed
+ * Note: Typeform embed doesn't support theme parameter via URL
+ */
+export function createTypeformEmbed(formId: any): string;
+/**
+ * Create Calendly embed
+ * Note: Calendly embed doesn't support theme parameter via URL
+ */
+export function createCalendlyEmbed(username: any, eventType?: string): string;
+/**
+ * Create Google Calendar Appointments embed
+ * Note: Google Calendar embed doesn't support theme parameter
+ */
+export function createGoogleCalendarEmbed(scheduleId: any): string;
+/**
+ * Create Cal.com embed
+ * @param {string} username - Cal.com username
+ * @param {string} eventType - Event type (optional)
+ * @param {string} theme - 'dark' | 'light'
+ */
+export function createCalcomEmbed(username: string, eventType?: string, theme?: string): string;
+/**
+ * Create Notion embed
+ * Note: Notion embed doesn't support theme parameter
+ */
+export function createNotionEmbed(pageId: any): string;
+/**
+ * Create Airtable embed
+ * Note: Airtable embed doesn't support theme parameter
+ */
+export function createAirtableEmbed(baseId: any, viewId: any): string;
+/**
+ * Create Miro embed
+ * Note: Miro embed doesn't support theme parameter
+ */
+export function createMiroEmbed(boardId: any): string;
+declare namespace _default {
+    export { processInteractiveEmbeds };
+    export { createTypeformEmbed };
+    export { createCalendlyEmbed };
+    export { createGoogleCalendarEmbed };
+    export { createCalcomEmbed };
+    export { createNotionEmbed };
+    export { createAirtableEmbed };
+    export { createMiroEmbed };
+}
+export default _default;

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

@@ -0,0 +1,29 @@
+/**
+ * Process all map URLs in HTML
+ */
+export function processMaps(html: any): any;
+/**
+ * Create Google Maps embed from direct embed URL
+ * Extracts coordinates from the pb parameter and creates a standard embed
+ */
+export function createGoogleMapEmbedDirect(embedUrl: any): string;
+/**
+ * Create Google Maps embed from place name/query
+ */
+export function createGoogleMapEmbed(query: any): string;
+/**
+ * Create Google Maps embed from coordinates
+ */
+export function createGoogleMapEmbedCoords(lat: any, lng: any, zoom: any): string;
+/**
+ * Create OpenStreetMap embed
+ */
+export function createOSMEmbed(lat: any, lon: any, zoom?: number): string;
+declare namespace _default {
+    export { processMaps };
+    export { createGoogleMapEmbedDirect };
+    export { createGoogleMapEmbed };
+    export { createGoogleMapEmbedCoords };
+    export { createOSMEmbed };
+}
+export default _default;

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

@@ -0,0 +1,75 @@
+/**
+ * Process all math expressions in HTML
+ * Supports:
+ * - Display math: $$ ... $$ or \[ ... \]
+ * - Inline math: $ ... $ or \( ... \)
+ * - Code blocks with language "math" or "latex"
+ */
+export function processMath(html: any): any;
+/**
+ * Create math block HTML with KaTeX rendering
+ */
+export function createMathBlock(tex: any, isDisplay?: boolean): string;
+/**
+ * Initialize KaTeX rendering (call after DOM is ready)
+ * Requires KaTeX library to be loaded
+ */
+export function initializeMath(): any;
+/**
+ * Dynamically load KaTeX library
+ */
+export function loadKaTeX(): any;
+/**
+ * Reset the KaTeX loading state (useful for testing)
+ */
+export function resetKaTeXLoadState(): void;
+/**
+ * Check if KaTeX is currently available
+ */
+export function isKaTeXAvailable(): boolean;
+/**
+ * Check if KaTeX loading has failed
+ */
+export function hasKaTeXLoadFailed(): boolean;
+/**
+ * Process and render math in a specific element
+ */
+export function processMathInElement(element: any): any;
+export namespace mathPatterns {
+    function fraction(num: any, den: any): string;
+    function sqrt(expr: any, n?: any): string;
+    function power(base: any, exp: any): string;
+    function subscript(base: any, sub: any): string;
+    let alpha: string;
+    let beta: string;
+    let gamma: string;
+    let delta: string;
+    let theta: string;
+    let lambda: string;
+    let pi: string;
+    let sigma: string;
+    let omega: string;
+    function sum(lower: any, upper: any, expr: any): string;
+    function product(lower: any, upper: any, expr: any): string;
+    function integral(lower: any, upper: any, expr: any): string;
+    function limit(variable: any, to: any, expr: any): string;
+    function matrix(rows: any): string;
+    function determinant(rows: any): string;
+    let quadratic: string;
+    let pythagorean: string;
+    let euler: string;
+    function derivative(f: any, x: any): string;
+    function partialDerivative(f: any, x: any): string;
+}
+declare namespace _default {
+    export { processMath };
+    export { createMathBlock };
+    export { initializeMath };
+    export { loadKaTeX };
+    export { resetKaTeXLoadState };
+    export { isKaTeXAvailable };
+    export { hasKaTeXLoadFailed };
+    export { processMathInElement };
+    export { mathPatterns };
+}
+export default _default;

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

@@ -0,0 +1,72 @@
+/**
+ * Process mermaid code blocks in HTML
+ */
+export function processMermaid(html: any): any;
+/**
+ * Create mermaid diagram placeholder
+ */
+export function createMermaidBlock(diagram: any): string;
+/**
+ * Initialize Mermaid rendering (call after DOM is ready)
+ * @param {object} config - Mermaid configuration options
+ * @param {string} config.theme - Theme: 'dark' | 'light'
+ */
+export function initializeMermaid(config?: {
+    theme: string;
+}): any;
+/**
+ * Dynamically load Mermaid library
+ */
+export function loadMermaid(): any;
+/**
+ * Reset the Mermaid loading state (useful for testing)
+ */
+export function resetMermaidLoadState(): void;
+/**
+ * Check if Mermaid is currently available
+ */
+export function isMermaidAvailable(): boolean;
+/**
+ * Check if Mermaid loading has failed
+ */
+export function hasMermaidLoadFailed(): boolean;
+/**
+ * Process and render mermaid in a specific element
+ * @param {HTMLElement} element - Element to process
+ * @param {object} config - Mermaid configuration options
+ * @param {string} config.theme - Theme: 'dark' | 'light'
+ */
+export function processMermaidInElement(element: HTMLElement, config?: {
+    theme: string;
+}): any;
+/**
+ * Re-render a specific mermaid container
+ */
+export function rerenderMermaid(containerId: any): Promise<void>;
+/**
+ * Update diagram content and re-render
+ */
+export function updateMermaidDiagram(containerId: any, newDiagram: any): Promise<void>;
+/**
+ * Re-initialize Mermaid with new theme
+ * Call this when theme changes to re-render diagrams
+ * @param {object} config - Configuration options
+ * @param {string} config.theme - Theme: 'dark' | 'light'
+ */
+export function reinitializeMermaid(config?: {
+    theme: string;
+}): Promise<any>;
+declare namespace _default {
+    export { processMermaid };
+    export { createMermaidBlock };
+    export { initializeMermaid };
+    export { loadMermaid };
+    export { resetMermaidLoadState };
+    export { isMermaidAvailable };
+    export { hasMermaidLoadFailed };
+    export { processMermaidInElement };
+    export { rerenderMermaid };
+    export { updateMermaidDiagram };
+    export { reinitializeMermaid };
+}
+export default _default;

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

@@ -0,0 +1,63 @@
+/**
+ * Process all social media URLs in HTML
+ * @param {string} html - HTML content to process
+ * @param {object} options - Processing options
+ * @param {string} options.theme - Theme: 'dark' | 'light'
+ */
+export function processSocialEmbeds(html: string, options?: {
+    theme: string;
+}): string;
+/**
+ * Create Twitter/X embed
+ * @param {string} username - Twitter username
+ * @param {string} tweetId - Tweet ID
+ * @param {string} theme - 'dark' | 'light'
+ */
+export function createTwitterEmbed(username: string, tweetId: string, theme?: string): string;
+/**
+ * Create Instagram post embed
+ * Note: Instagram embed doesn't support theme parameter
+ */
+export function createInstagramEmbed(postId: any): string;
+/**
+ * Create Instagram reel embed
+ * Note: Instagram embed doesn't support theme parameter
+ */
+export function createInstagramReelEmbed(reelId: any): string;
+/**
+ * Create TikTok embed
+ * Note: TikTok embed doesn't support theme parameter
+ */
+export function createTikTokEmbed(videoId: any): string;
+/**
+ * Create LinkedIn embed
+ * Note: LinkedIn embed doesn't support theme parameter
+ */
+export function createLinkedInEmbed(postId: any, originalUrl: any): string;
+/**
+ * Create Reddit embed
+ * Note: Reddit embed doesn't support theme parameter
+ */
+export function createRedditEmbed(subreddit: any, postId: any, originalUrl: any): string;
+/**
+ * Create Facebook embed
+ * Note: Facebook embed doesn't support theme parameter
+ */
+export function createFacebookEmbed(url: any): string;
+/**
+ * Create Pinterest embed
+ * Note: Pinterest embed doesn't support theme parameter
+ */
+export function createPinterestEmbed(pinId: any): string;
+declare namespace _default {
+    export { processSocialEmbeds };
+    export { createTwitterEmbed };
+    export { createInstagramEmbed };
+    export { createInstagramReelEmbed };
+    export { createTikTokEmbed };
+    export { createLinkedInEmbed };
+    export { createRedditEmbed };
+    export { createFacebookEmbed };
+    export { createPinterestEmbed };
+}
+export default _default;

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

@@ -0,0 +1,43 @@
+/**
+ * Process all tables in HTML to add enhanced functionality
+ */
+export function processTables(html: any): any;
+/**
+ * Create enhanced table wrapper with controls
+ */
+export function createEnhancedTable(tableId: any, attrs: any, content: any): string;
+/**
+ * Generate CSV from table data
+ */
+export function tableToCSV(tableElement: any): string;
+/**
+ * Download CSV file
+ */
+export function downloadCSV(csv: any, filename?: string): void;
+/**
+ * Copy table data to clipboard as tab-separated values
+ */
+export function copyTableToClipboard(tableElement: any): string;
+/**
+ * Sort table by column
+ */
+export function sortTable(tableElement: any, colIndex: any, ascending?: boolean): void;
+/**
+ * Filter table rows by search term
+ */
+export function filterTable(tableElement: any, searchTerm: any): number;
+/**
+ * Initialize table interactivity (call this after DOM is ready)
+ */
+export function initializeTables(): void;
+declare namespace _default {
+    export { processTables };
+    export { createEnhancedTable };
+    export { tableToCSV };
+    export { downloadCSV };
+    export { copyTableToClipboard };
+    export { sortTable };
+    export { filterTable };
+    export { initializeTables };
+}
+export default _default;

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

@@ -0,0 +1,69 @@
+/**
+ * Check if a URL is a video URL (direct file or platform embed)
+ * @param {string} url - URL to check
+ * @returns {boolean} - True if URL is a video
+ */
+export function isVideoUrl(url: string): boolean;
+/**
+ * Render video HTML from URL (used by marked renderer)
+ * Similar to renderImageHtml for images
+ * @param {string} url - Video URL
+ * @returns {string} - HTML string
+ */
+export function renderVideoHtml(url: string): string;
+/**
+ * Process all video URLs in HTML
+ */
+export function processVideos(html: any): any;
+/**
+ * Create HTML5 video player
+ */
+export function createVideoPlayer(videoUrl: any): string;
+/**
+ * Create video with preview image (Pexels style)
+ */
+export function createVideoWithPreview(title: any, videoUrl: any, previewImage: any, alt: any): string;
+/**
+ * Create lazy-loaded YouTube embed with thumbnail preview
+ */
+export function createYouTubeEmbed(videoId: any): string;
+/**
+ * Create lazy-loaded Vimeo embed with thumbnail preview
+ */
+export function createVimeoEmbed(videoId: any): string;
+/**
+ * Create lazy-loaded Loom embed with thumbnail preview
+ */
+export function createLoomEmbed(videoId: any): string;
+/**
+ * Create lazy-loaded Dailymotion embed with thumbnail preview
+ */
+export function createDailymotionEmbed(videoId: any): string;
+/**
+ * Process HTML to group consecutive videos into galleries
+ * Uses regex-based approach to handle single-line HTML
+ */
+export function processVideoGalleries(html: any): any;
+/**
+ * Create a gallery wrapper for multiple videos with captions
+ */
+export function createVideoGallery(videoDataArray: any): string;
+/**
+ * Initialize video facades - attach click handlers for lazy loading
+ */
+export function initializeVideoFacades(container?: Document): void;
+declare namespace _default {
+    export { isVideoUrl };
+    export { renderVideoHtml };
+    export { processVideos };
+    export { processVideoGalleries };
+    export { createVideoPlayer };
+    export { createVideoWithPreview };
+    export { createVideoGallery };
+    export { createYouTubeEmbed };
+    export { createVimeoEmbed };
+    export { createLoomEmbed };
+    export { createDailymotionEmbed };
+    export { initializeVideoFacades };
+}
+export default _default;

package/dist/core/state.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Create state manager
+ */
+export function createState(): {
+    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;
+};
+/**
+ * Create a reactive state (for frameworks that need reactivity)
+ */
+export function createReactiveState(reactivityFn: any): any;
+declare namespace _default {
+    export { createState };
+    export { createReactiveState };
+}
+export default _default;

package/dist/core/theme.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Convert hex color to RGB string
+ * Accepts: '#rgb', '#rrggbb', 'rgb', 'rrggbb'
+ * Returns: 'r, g, b' string for CSS variables
+ */
+export function hexToRgb(hex: any): string;
+/**
+ * Convert RGB string to hex
+ * Accepts: 'r, g, b' or 'r,g,b'
+ * Returns: '#rrggbb'
+ */
+export function rgbToHex(rgb: any): string;
+/**
+ * Normalize color to RGB string
+ * Accepts hex or RGB, returns RGB string
+ */
+export function normalizeColor(color: any): string;
+/**
+ * Create theme manager
+ *
+ * @param {string} initialTheme - 'dark' | 'light' | 'auto'
+ * @param {object} customColors - Custom colors (hex or RGB format accepted)
+ *
+ * @example
+ * // Both formats work:
+ * createTheme('dark', { primary: '#6366f1' })
+ * createTheme('dark', { primary: '99, 102, 241' })
+ */
+export function createTheme(initialTheme?: string, customColors?: object): {
+    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;
+};
+/**
+ * Inject theme CSS into document
+ */
+export function injectThemeCSS(theme: any): void;
+export namespace DEFAULT_COLORS {
+    namespace dark {
+        let primary: string;
+        let primaryHover: string;
+        let background: string;
+        let surface: string;
+        let surfaceHover: string;
+        let text: string;
+        let textSecondary: string;
+        let textMuted: string;
+        let border: string;
+        let borderLight: string;
+        let success: string;
+        let warning: string;
+        let error: string;
+        let info: string;
+        let gradient: string;
+        let gradientOpacity: string;
+    }
+    namespace light {
+        let primary_1: string;
+        export { primary_1 as primary };
+        let primaryHover_1: string;
+        export { primaryHover_1 as primaryHover };
+        let background_1: string;
+        export { background_1 as background };
+        let surface_1: string;
+        export { surface_1 as surface };
+        let surfaceHover_1: string;
+        export { surfaceHover_1 as surfaceHover };
+        let text_1: string;
+        export { text_1 as text };
+        let textSecondary_1: string;
+        export { textSecondary_1 as textSecondary };
+        let textMuted_1: string;
+        export { textMuted_1 as textMuted };
+        let border_1: string;
+        export { border_1 as border };
+        let borderLight_1: string;
+        export { borderLight_1 as borderLight };
+        let success_1: string;
+        export { success_1 as success };
+        let warning_1: string;
+        export { warning_1 as warning };
+        let error_1: string;
+        export { error_1 as error };
+        let info_1: string;
+        export { info_1 as info };
+        let gradient_1: string;
+        export { gradient_1 as gradient };
+        let gradientOpacity_1: string;
+        export { gradientOpacity_1 as gradientOpacity };
+    }
+}
+declare namespace _default {
+    export { DEFAULT_COLORS };
+    export { createTheme };
+    export { injectThemeCSS };
+    export { hexToRgb };
+    export { rgbToHex };
+    export { normalizeColor };
+}
+export default _default;