@changerawr/markdown 1.0.0

package/dist/react/index.d.ts

@@ -0,0 +1,264 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React, { ReactNode } from 'react';
+
+interface MarkdownToken {
+    type: string;
+    content: string;
+    raw: string;
+    attributes?: Record<string, string>;
+}
+interface ParseRule {
+    name: string;
+    pattern: RegExp;
+    render: (match: RegExpMatchArray) => MarkdownToken;
+}
+interface RenderRule {
+    type: string;
+    render: (token: MarkdownToken) => string;
+}
+interface Extension {
+    name: string;
+    parseRules: ParseRule[];
+    renderRules: RenderRule[];
+}
+type OutputFormat = 'html' | 'tailwind' | 'json';
+interface RendererConfig {
+    format: OutputFormat;
+    sanitize?: boolean;
+    allowUnsafeHtml?: boolean;
+    customClasses?: Record<string, string>;
+    debugMode?: boolean;
+}
+interface ParserConfig {
+    debugMode?: boolean;
+    maxIterations?: number;
+    validateMarkdown?: boolean;
+}
+interface EngineConfig {
+    parser?: ParserConfig;
+    renderer?: RendererConfig;
+    extensions?: Extension[];
+}
+interface DebugInfo {
+    warnings: string[];
+    parseTime: number;
+    renderTime: number;
+    tokenCount: number;
+    iterationCount: number;
+}
+interface PerformanceMetrics {
+    parseTime: number;
+    renderTime: number;
+    totalTime: number;
+    tokenCount: number;
+    memoryUsed?: number;
+}
+interface ExtensionRegistration {
+    success: boolean;
+    extensionName: string;
+    error?: string;
+    conflictingRules?: string[];
+}
+
+/**
+ * Props for the MarkdownRenderer component
+ */
+interface MarkdownRendererProps {
+    /** Markdown content to render */
+    content: string;
+    /** Additional CSS classes to apply to the wrapper */
+    className?: string;
+    /** Engine configuration */
+    config?: EngineConfig;
+    /** Output format (defaults to 'tailwind') */
+    format?: OutputFormat;
+    /** Custom wrapper element (defaults to 'div') */
+    as?: keyof JSX.IntrinsicElements;
+    /** Additional HTML attributes for the wrapper */
+    wrapperProps?: React.HTMLAttributes<HTMLElement>;
+    /** Enable debug mode */
+    debug?: boolean;
+    /** Custom error fallback component */
+    errorFallback?: (error: Error) => ReactNode;
+    /** Loading component while processing */
+    loading?: ReactNode;
+    /** Callback when rendering completes */
+    onRender?: (html: string, tokens: MarkdownToken[]) => void;
+    /** Callback when an error occurs */
+    onError?: (error: Error) => void;
+    /** Custom extensions to register */
+    extensions?: Extension[];
+    /** Whether to sanitize HTML output */
+    sanitize?: boolean;
+    /** Allow unsafe HTML (use with caution) */
+    allowUnsafeHtml?: boolean;
+}
+/**
+ * Options for useMarkdown hook
+ */
+interface UseMarkdownOptions {
+    /** Engine configuration */
+    config?: EngineConfig;
+    /** Output format */
+    format?: OutputFormat;
+    /** Enable debug mode */
+    debug?: boolean;
+    /** Custom extensions */
+    extensions?: Extension[];
+    /** Debounce delay in milliseconds */
+    debounceMs?: number;
+    /** Whether to memoize results */
+    memoize?: boolean;
+}
+/**
+ * Return type for useMarkdown hook
+ */
+interface UseMarkdownResult {
+    /** Rendered HTML */
+    html: string;
+    /** Parsed tokens */
+    tokens: MarkdownToken[];
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Debug information */
+    debug: MarkdownDebugInfo | null;
+    /** Re-render with new content */
+    render: (content: string) => void;
+    /** Clear current state */
+    clear: () => void;
+}
+/**
+ * Options for useMarkdownEngine hook
+ */
+interface MarkdownEngineHookOptions {
+    /** Initial engine configuration */
+    config?: EngineConfig;
+    /** Auto-register built-in extensions */
+    autoRegisterExtensions?: boolean;
+}
+/**
+ * Debug information for React components - extends the core DebugInfo
+ */
+interface MarkdownDebugInfo {
+    /** Core debug info from engine */
+    core: DebugInfo | null;
+    /** Performance metrics */
+    performance: PerformanceMetrics | null;
+    /** Render timestamp */
+    renderedAt: Date;
+    /** Input content length */
+    contentLength: number;
+    /** Output HTML length */
+    htmlLength: number;
+    /** Extensions used */
+    extensionsUsed: string[];
+}
+
+/**
+ * MarkdownRenderer - Main React component for rendering markdown
+ *
+ * @example
+ * ```tsx
+ * <MarkdownRenderer
+ *   content="# Hello **World**!"
+ *   className="prose"
+ * />
+ * ```
+ */
+declare function MarkdownRenderer({ content, className, config, format, as: Component, wrapperProps, debug, errorFallback, loading, onRender, onError, extensions, sanitize, allowUnsafeHtml, ...restProps }: MarkdownRendererProps): react_jsx_runtime.JSX.Element;
+declare namespace MarkdownRenderer {
+    var displayName: string;
+}
+
+declare class ChangerawrMarkdown {
+    private parser;
+    private renderer;
+    private extensions;
+    constructor(config?: EngineConfig);
+    /**
+     * Register a custom extension
+     */
+    registerExtension(extension: Extension): ExtensionRegistration;
+    /**
+     * Unregister an extension
+     */
+    unregisterExtension(name: string): boolean;
+    /**
+     * Parse markdown content into tokens
+     */
+    parse(markdown: string): MarkdownToken[];
+    /**
+     * Render tokens to HTML
+     */
+    render(tokens: MarkdownToken[]): string;
+    /**
+     * Parse and render markdown to HTML in one step
+     */
+    toHtml(markdown: string): string;
+    /**
+     * Get list of registered extensions
+     */
+    getExtensions(): string[];
+    /**
+     * Check if extension is registered
+     */
+    hasExtension(name: string): boolean;
+    /**
+     * Get parser warnings
+     */
+    getWarnings(): string[];
+    /**
+     * Get debug information from last render
+     */
+    getDebugInfo(): DebugInfo | null;
+    /**
+     * Get performance metrics for the last operation
+     */
+    getPerformanceMetrics(): PerformanceMetrics | null;
+    /**
+     * Register built-in extensions
+     */
+    private registerBuiltInExtensions;
+    /**
+     * Rebuild parser and renderer with current extensions
+     */
+    private rebuildParserAndRenderer;
+}
+
+/**
+ * Main hook for rendering markdown content
+ */
+declare function useMarkdown(initialContent?: string, options?: UseMarkdownOptions): UseMarkdownResult;
+/**
+ * Hook for managing a markdown engine instance
+ */
+declare function useMarkdownEngine(options?: MarkdownEngineHookOptions): {
+    engine: ChangerawrMarkdown;
+    toHtml: (content: string) => string;
+    parse: (content: string) => MarkdownToken[];
+    render: (tokens: MarkdownToken[]) => string;
+    getExtensions: () => string[];
+    hasExtension: (name: string) => boolean;
+    registerExtension: (extension: Parameters<ChangerawrMarkdown["registerExtension"]>[0]) => ExtensionRegistration;
+    unregisterExtension: (name: string) => boolean;
+    getWarnings: () => string[];
+    getDebugInfo: () => DebugInfo | null;
+    getPerformanceMetrics: () => PerformanceMetrics | null;
+};
+/**
+ * Debug hook for markdown processing
+ */
+declare function useMarkdownDebug(content: string): {
+    html: string;
+    tokens: MarkdownToken[];
+    debug: MarkdownDebugInfo | null;
+    stats: {
+        tokenCount: number;
+        htmlLength: number;
+        contentLength: number;
+    };
+};
+
+export { type EngineConfig, type Extension, type MarkdownDebugInfo, type MarkdownEngineHookOptions, MarkdownRenderer, type MarkdownRendererProps, type MarkdownToken, type OutputFormat, type UseMarkdownOptions, type UseMarkdownResult, useMarkdown, useMarkdownDebug, useMarkdownEngine };