rayo-editor 0.0.1

package/dist/types/diff.types.d.ts

@@ -0,0 +1,84 @@
+export interface DiffRange {
+    from: number;
+    to: number;
+}
+export interface DiffRect {
+    top: number;
+    left: number;
+    width: number;
+    bottom: number;
+    right: number;
+}
+export interface DiffPair {
+    redRange?: DiffRange;
+    greenRange?: DiffRange;
+    rect: DiffRect;
+    lastGreenRect: DiffRect;
+    isTextOnly?: boolean;
+    isImageDeletion?: boolean;
+    isImageInsertion?: boolean;
+    isImageReplacement?: boolean;
+    isTableDeletion?: boolean;
+    isTableInsertion?: boolean;
+    isTableReplacement?: boolean;
+    isCodeBlockDeletion?: boolean;
+    isCodeBlockInsertion?: boolean;
+    isCodeBlockReplacement?: boolean;
+    includesImageDeletion?: boolean;
+    includesImageInsertion?: boolean;
+    isImageReplacedByText?: boolean;
+    isTextReplacedByImage?: boolean;
+    includesTableDeletion?: boolean;
+    includesTableInsertion?: boolean;
+    isTableReplacedByText?: boolean;
+    isTextReplacedByTable?: boolean;
+    tableIsBeforeText?: boolean;
+    includesCodeBlockDeletion?: boolean;
+    includesCodeBlockInsertion?: boolean;
+    isCodeBlockReplacedByText?: boolean;
+    isTextReplacedByCode?: boolean;
+    codeBlockIsBeforeText?: boolean;
+    includesTextInsertion?: boolean;
+    imageIsLastInPair?: boolean;
+    firstGreenBlockEnd?: number;
+    newImagesCount?: number;
+}
+export interface DiffMarker {
+    type: 'insertion' | 'deletion' | 'highlight';
+    color?: string;
+    from?: number;
+    to?: number;
+}
+export interface DiffMarkerResult {
+    hasDiffs: boolean;
+    markers: DiffMarker[];
+}
+export interface ImageOperation {
+    pos: number;
+    nodeSize: number;
+    rect: DiffRect;
+    pendingDelete?: boolean;
+    pendingInsert?: boolean;
+}
+export interface TableOperation {
+    pos: number;
+    nodeSize: number;
+    rect: DiffRect;
+    pendingDelete?: boolean;
+    pendingInsert?: boolean;
+}
+export interface CodeBlockOperation {
+    pos: number;
+    nodeSize: number;
+    rect: DiffRect;
+    language?: string;
+    pendingDelete?: boolean;
+    pendingInsert?: boolean;
+}
+export interface HighlightInfo {
+    from: number;
+    to: number;
+    color: '#c7f0d6ff' | '#fecaca';
+    rect: DiffRect;
+}
+//# sourceMappingURL=diff.types.d.ts.map

package/dist/types/diff.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.types.d.ts","sourceRoot":"","sources":["../../src/types/diff.types.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,QAAQ;IAEvB,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,UAAU,CAAC,EAAE,SAAS,CAAC;IAGvB,IAAI,EAAE,QAAQ,CAAC;IACf,aAAa,EAAE,QAAQ,CAAC;IAGxB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAGjC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAG5B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,WAAW,CAAC;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,QAAQ,CAAC;CAChB"}

package/dist/types/editor.types.d.ts

@@ -0,0 +1,59 @@
+import { RefObject } from 'react';
+import { DiffRange, DiffPair } from './diff.types';
+type Editor = any;
+export interface BlogSimpleEditorRef {
+    getEditor: () => Editor | null;
+}
+export interface RayoEditorProps {
+    content: string;
+    title: string;
+    onChange: (content: string) => void;
+    onTitleChange?: (title: string) => void;
+    isLoading: boolean;
+    isStreaming?: boolean;
+    isAgentThinking?: boolean;
+    readOnly?: boolean;
+    focusMode?: boolean;
+    pendingChanges?: boolean;
+    showDiffs?: boolean;
+    hideReviewUI?: boolean;
+    editedLinesCount?: number;
+    onAcceptChanges?: () => void;
+    onRejectChanges?: () => void;
+    onAcceptSingleChange?: (greenRange: DiffRange, redRange?: DiffRange) => void;
+    onRejectSingleChange?: (greenRange: DiffRange, redRange?: DiffRange) => void;
+    onDiffPairsChange?: (diffPairs: DiffPair[]) => void;
+    featuredImageUrl?: string;
+    onEditFeaturedImage?: () => void;
+    isGeneratingImage?: boolean;
+    editorRef: RefObject<BlogSimpleEditorRef>;
+    onAriScoreChange?: (score: number) => void;
+    disableAutoScroll?: boolean;
+    onUserScrollChange?: (isScrolledUp: boolean) => void;
+    showToolbarAnimation?: boolean;
+    streamingPhase?: string;
+}
+export interface TitleTextareaProps {
+    title: string;
+    onTitleChange?: (title: string) => void;
+    readOnly?: boolean;
+}
+export interface DiffOverlayProps {
+    diffPairs: DiffPair[];
+    overlayHoleRect: {
+        top: number;
+        bottom: number;
+    } | null;
+    onPairHover?: (index: number) => void;
+    onPairClick?: (index: number) => void;
+}
+export interface ReviewButtonsProps {
+    onAccept: () => void;
+    onReject: () => void;
+    position: {
+        top: number;
+        left: number;
+    };
+}
+export {};
+//# sourceMappingURL=editor.types.d.ts.map

package/dist/types/editor.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor.types.d.ts","sourceRoot":"","sources":["../../src/types/editor.types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAClC,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAGnD,KAAK,MAAM,GAAG,GAAG,CAAC;AAElB,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,eAAe;IAE9B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAGxC,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IAGpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B,oBAAoB,CAAC,EAAE,CAAC,UAAU,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,SAAS,KAAK,IAAI,CAAC;IAC7E,oBAAoB,CAAC,EAAE,CAAC,UAAU,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,SAAS,KAAK,IAAI,CAAC;IAC7E,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,KAAK,IAAI,CAAC;IAGpD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mBAAmB,CAAC,EAAE,MAAM,IAAI,CAAC;IACjC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAG5B,SAAS,EAAE,SAAS,CAAC,mBAAmB,CAAC,CAAC;IAC1C,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,CAAC,YAAY,EAAE,OAAO,KAAK,IAAI,CAAC;IACrD,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,eAAe,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACxD,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,QAAQ,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CACzC"}

package/dist/utils/contentProcessing.d.ts

@@ -0,0 +1,81 @@
+import { DiffRange } from '../types/diff.types';
+/**
+ * Merges consecutive or overlapping ranges into single ranges
+ *
+ * Sorts ranges by start position and combines any that touch or overlap.
+ * Useful for consolidating multiple small diffs into larger blocks.
+ *
+ * @param ranges - Array of DiffRange objects to merge
+ * @returns Array of merged DiffRange objects (sorted by position)
+ *
+ * @example
+ * ```tsx
+ * const ranges = [
+ *   { from: 0, to: 5 },
+ *   { from: 5, to: 10 },  // consecutive
+ *   { from: 8, to: 15 }   // overlapping
+ * ];
+ * const merged = mergeConsecutiveRanges(ranges);
+ * // Returns: [{ from: 0, to: 15 }]
+ * ```
+ *
+ * @example
+ * Optimize diff highlighting:
+ * ```tsx
+ * const diffRanges = detectAndExtractDiffs(content);
+ * const optimized = mergeConsecutiveRanges(diffRanges);
+ * renderHighlights(optimized);
+ * ```
+ */
+export declare function mergeConsecutiveRanges(ranges: DiffRange[]): DiffRange[];
+/**
+ * Extracts text content from a given range within a string
+ *
+ * Simple substring extraction based on position range.
+ * Returns empty string if range is invalid or out of bounds.
+ *
+ * @param content - The full text content
+ * @param range - The range defining start and end positions
+ * @returns The extracted text substring
+ *
+ * @example
+ * ```tsx
+ * const text = 'Hello World';
+ * const range = { from: 0, to: 5 };
+ * extractTextContent(text, range); // 'Hello'
+ * ```
+ */
+export declare function extractTextContent(content: string, range: DiffRange): string;
+/**
+ * Optimizes ranges by merging consecutive ranges and filtering out empty ranges
+ *
+ * Performs two optimizations:
+ * 1. Filters out empty ranges where from === to
+ * 2. Merges all consecutive/overlapping ranges
+ *
+ * Use before rendering to ensure efficient diff highlighting.
+ *
+ * @param ranges - Array of DiffRange objects to optimize
+ * @returns Array of optimized DiffRange objects (minimal, non-overlapping)
+ *
+ * @example
+ * ```tsx
+ * const ranges = [
+ *   { from: 0, to: 0 },   // empty - filtered
+ *   { from: 5, to: 10 },
+ *   { from: 10, to: 15 }  // consecutive - merged
+ * ];
+ * const optimized = optimizeRanges(ranges);
+ * // Returns: [{ from: 5, to: 15 }]
+ * ```
+ *
+ * @example
+ * Before rendering highlights:
+ * ```tsx
+ * const detected = extractDiffRanges(content);
+ * const optimized = optimizeRanges(detected);
+ * return <DiffOverlay ranges={optimized} />;
+ * ```
+ */
+export declare function optimizeRanges(ranges: DiffRange[]): DiffRange[];
+//# sourceMappingURL=contentProcessing.d.ts.map

package/dist/utils/contentProcessing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentProcessing.d.ts","sourceRoot":"","sources":["../../src/utils/contentProcessing.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CA6BvE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAE5E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAM/D"}

package/dist/utils/diffDetection.d.ts

@@ -0,0 +1,85 @@
+import { DiffMarkerResult } from '../types/diff.types';
+/**
+ * Detect diff markers in HTML content
+ *
+ * Identifies insertions, deletions, and highlights using multiple detection methods:
+ * - <ins> and <del> HTML tags
+ * - data-color attributes for green (#c7f0d6ff) and red (#fecaca) highlights
+ * - data-pending-insert and data-pending-delete attributes
+ *
+ * @param content - HTML content to scan for diff markers
+ * @returns Result object with hasDiffs flag and array of markers found
+ *
+ * @example
+ * ```tsx
+ * const content = '<ins>new text</ins> and <del>old text</del>';
+ * const { hasDiffs, markers } = detectDiffMarkers(content);
+ * console.log(hasDiffs); // true
+ * console.log(markers.length); // 2
+ * ```
+ *
+ * @example
+ * Check for specific highlight colors:
+ * ```tsx
+ * const { hasDiffs, markers } = detectDiffMarkers(content);
+ * const greenMarkers = markers.filter(m => m.color === '#c7f0d6ff');
+ * const redMarkers = markers.filter(m => m.color === '#fecaca');
+ * ```
+ */
+export declare const detectDiffMarkers: (content: string) => DiffMarkerResult;
+/**
+ * Normalize diff text for consistent comparison
+ *
+ * Performs Unicode normalization and standardization:
+ * - Removes diacritics (é → e, ñ → n)
+ * - Normalizes dash variants (em-dash, en-dash → hyphen)
+ * - Standardizes whitespace (non-breaking space, em-space → regular space)
+ * - Normalizes quote variants (curly quotes → straight quotes)
+ * - Removes zero-width characters
+ * - Collapses multiple spaces into single space
+ *
+ * @param text - Text to normalize
+ * @returns Normalized text suitable for comparison
+ *
+ * @example
+ * ```tsx
+ * const text = 'Café — hello\u00A0world';
+ * const normalized = normalizeDiffText(text);
+ * console.log(normalized); // 'Cafe - hello world'
+ * ```
+ *
+ * @example
+ * Compare diff texts reliably:
+ * ```tsx
+ * const oldText = 'Résumé – 2026';
+ * const newText = 'Resume - 2026';
+ * normalizeDiffText(oldText) === normalizeDiffText(newText); // true
+ * ```
+ */
+export declare const normalizeDiffText: (text: string) => string;
+/**
+ * Extract diff ranges from HTML content
+ *
+ * Parses content to find all diff ranges and returns them as position pairs.
+ * Can filter by type to get only insertions, deletions, or all changes.
+ *
+ * @param _content - HTML content to extract ranges from
+ * @param _type - Optional filter: 'all' (default), 'green' (additions), 'red' (deletions)
+ * @returns Array of {from, to} ranges indicating diff locations
+ *
+ * @example
+ * ```tsx
+ * const content = '<ins>new</ins> text <del>old</del>';
+ * const ranges = extractDiffRanges(content);
+ * // Returns positions of insertions and deletions
+ * ```
+ *
+ * @example
+ * Filter by type:
+ * ```tsx
+ * const additions = extractDiffRanges(content, 'green');
+ * const deletions = extractDiffRanges(content, 'red');
+ * ```
+ */
+export declare const extractDiffRanges: (_content: string) => never[];
+//# sourceMappingURL=diffDetection.d.ts.map

package/dist/utils/diffDetection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diffDetection.d.ts","sourceRoot":"","sources":["../../src/utils/diffDetection.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,iBAAiB,GAAI,SAAS,MAAM,KAAG,gBA2DnD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,KAAG,MAsBhD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,YAGjD,CAAC"}

package/dist/utils/errorHandling.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Custom error class for diff processing failures
+ *
+ * Extends Error with additional context information for better debugging.
+ * Useful for distinguishing diff processing errors from other exceptions.
+ *
+ * @example
+ * ```tsx
+ * try {
+ *   processComplexDiff(content);
+ * } catch (error) {
+ *   if (error instanceof DiffProcessingError) {
+ *     console.error('Diff error:', error.message);
+ *     console.error('Context:', error.context);
+ *   }
+ * }
+ * ```
+ */
+export declare class DiffProcessingError extends Error {
+    context?: any | undefined;
+    /**
+     * Create a new DiffProcessingError
+     * @param message - Error message
+     * @param context - Additional context object for debugging
+     */
+    constructor(message: string, context?: any | undefined);
+}
+/**
+ * Safely execute a function with error handling and fallback
+ *
+ * Wraps function execution in try-catch and returns fallback value on error.
+ * Logs warnings but doesn't throw, making it safe for non-critical operations.
+ *
+ * @template T - The return type of the function
+ * @param fn - Function to execute safely
+ * @param fallback - Fallback value if function throws
+ * @returns Result of fn() or fallback value
+ *
+ * @example
+ * ```tsx
+ * const result = safeExecute(
+ *   () => expensiveOperation(data),
+ *   defaultValue
+ * );
+ * ```
+ *
+ * @example
+ * Safe diff detection:
+ * ```tsx
+ * const markers = safeExecute(
+ *   () => detectDiffMarkers(content),
+ *   { hasDiffs: false, markers: [] }
+ * );
+ * ```
+ */
+export declare const safeExecute: <T>(fn: () => T, fallback: T) => T;
+//# sourceMappingURL=errorHandling.d.ts.map

package/dist/utils/errorHandling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorHandling.d.ts","sourceRoot":"","sources":["../../src/utils/errorHandling.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAMR,OAAO,CAAC,EAAE,GAAG;IALjD;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAS,OAAO,CAAC,EAAE,GAAG,YAAA;CAIlD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,IAAI,MAAM,CAAC,EAAE,UAAU,CAAC,KAAG,CAOzD,CAAC"}

package/dist/utils/imageHandling.d.ts

@@ -0,0 +1,52 @@
+import { ImageOperation, DiffPair } from '../types/diff.types';
+/**
+ * Group consecutive images in content
+ *
+ * Identifies images that appear consecutively in content and groups them together.
+ * Useful for batch processing image changes or detecting image sequences.
+ *
+ * @param images - Array of ImageOperation objects
+ * @returns Array of groups, where each group contains consecutive images
+ *
+ * @example
+ * ```tsx
+ * const images = [
+ *   { pos: 0, nodeSize: 10, rect: {...} },
+ *   { pos: 10, nodeSize: 12, rect: {...} },  // consecutive
+ *   { pos: 25, nodeSize: 10, rect: {...} }   // separate group
+ * ];
+ * const groups = groupConsecutiveImages(images);
+ * // Returns: [[image1, image2], [image3]]
+ * ```
+ */
+export declare const groupConsecutiveImages: (images: ImageOperation[]) => ImageOperation[][];
+/**
+ * Match image replacements in diff pairs
+ *
+ * Identifies images that were deleted and replaced with new images.
+ * Matches insertions immediately following deletions as replacements.
+ * Handles multiple image replacements in sequence.
+ *
+ * @param deletions - Array of deleted ImageOperation objects
+ * @param insertions - Array of inserted ImageOperation objects
+ * @returns Array of DiffPair objects representing image changes
+ *
+ * @example
+ * ```tsx
+ * const deleted = [{ pos: 0, nodeSize: 10, rect: {...} }];
+ * const inserted = [{ pos: 10, nodeSize: 12, rect: {...} }];
+ * const pairs = matchImageReplacements(deleted, inserted);
+ * // Returns: [{ redRange, greenRange, isImageReplacement: true }]
+ * ```
+ *
+ * @example
+ * Handle image deletion without replacement:
+ * ```tsx
+ * const deleted = [{ pos: 0, nodeSize: 10, rect: {...} }];
+ * const inserted: ImageOperation[] = [];
+ * const pairs = matchImageReplacements(deleted, inserted);
+ * // Returns: [{ redRange, greenRange: undefined, isImageDeletion: true }]
+ * ```
+ */
+export declare const matchImageReplacements: (deletions: ImageOperation[], insertions: ImageOperation[]) => DiffPair[];
+//# sourceMappingURL=imageHandling.d.ts.map

package/dist/utils/imageHandling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageHandling.d.ts","sourceRoot":"","sources":["../../src/utils/imageHandling.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,cAAc,EAAE,KAAG,cAAc,EAAE,EA0BjF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,sBAAsB,GACjC,WAAW,cAAc,EAAE,EAC3B,YAAY,cAAc,EAAE,KAC3B,QAAQ,EA4CV,CAAC"}

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+export { detectDiffMarkers, normalizeDiffText, extractDiffRanges } from './diffDetection';
+export { mergeConsecutiveRanges, extractTextContent, optimizeRanges } from './contentProcessing';
+export { groupConsecutiveImages, matchImageReplacements } from './imageHandling';
+export { calculateProximity, findOwnerTextPair, groupConsecutiveItems } from './proximityMatching';
+export { DiffProcessingError, safeExecute } from './errorHandling';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAC1F,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACjG,OAAO,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AACjF,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACnG,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/utils/proximityMatching.d.ts

@@ -0,0 +1,80 @@
+import { DiffRange, DiffPair } from '../types/diff.types';
+/**
+ * Calculate proximity score between two text ranges
+ *
+ * Calculates the minimum distance between two ranges in characters.
+ * Returns 0 if ranges are adjacent or overlapping, larger values indicate
+ * greater distance.
+ *
+ * @param range1 - First text range
+ * @param range2 - Second text range
+ * @returns Distance in characters (0 means adjacent/overlapping)
+ *
+ * @example
+ * ```tsx
+ * const range1 = { from: 0, to: 10 };
+ * const range2 = { from: 10, to: 20 };
+ * calculateProximity(range1, range2); // 0 - adjacent
+ *
+ * const range3 = { from: 100, to: 110 };
+ * calculateProximity(range1, range3); // 90 - far apart
+ * ```
+ */
+export declare const calculateProximity: (range1: DiffRange, range2: DiffRange) => number;
+/**
+ * Find the best matching diff pair for a given block position
+ *
+ * Searches for the diff pair closest to the specified block position.
+ * Useful for associating non-text blocks (images, tables) with their
+ * corresponding text changes.
+ *
+ * @param blockPos - Position of the block to match
+ * @param _blockEndPos - End position of the block (unused)
+ * @param textPairs - Array of DiffPair objects to search
+ * @returns The closest DiffPair or null if none found
+ *
+ * @example
+ * ```tsx
+ * const pairs = [
+ *   { redRange: { from: 0, to: 10 }, greenRange: { from: 0, to: 15 } },
+ *   { redRange: { from: 50, to: 60 }, greenRange: { from: 50, to: 65 } }
+ * ];
+ * const imagePos = 52;
+ * const owner = findOwnerTextPair(imagePos, 62, pairs);
+ * // Returns the second pair as it's closest to imagePos
+ * ```
+ */
+export declare const findOwnerTextPair: (blockPos: number, _blockEndPos: number, textPairs: DiffPair[]) => DiffPair | null;
+/**
+ * Group consecutive items by position
+ *
+ * Groups items that appear consecutively in content based on pos and nodeSize.
+ * Items are consecutive if: item.pos === previous.pos + previous.nodeSize
+ *
+ * @template T - Item type (must have pos and nodeSize properties)
+ * @param items - Array of items to group
+ * @returns Array of groups, each containing consecutive items
+ *
+ * @example
+ * ```tsx
+ * const items = [
+ *   { pos: 0, nodeSize: 10 },
+ *   { pos: 10, nodeSize: 5 },   // consecutive
+ *   { pos: 20, nodeSize: 10 }   // separate group
+ * ];
+ * const groups = groupConsecutiveItems(items);
+ * // Returns: [[item1, item2], [item3]]
+ * ```
+ *
+ * @example
+ * Group items by position:
+ * ```typescript
+ * const items = [{ pos: 5, nodeSize: 20 }, { pos: 25, nodeSize: 15 }];
+ * const groups = groupConsecutiveItems(items);
+ * ```
+ */
+export declare const groupConsecutiveItems: <T extends {
+    pos: number;
+    nodeSize: number;
+}>(items: T[]) => T[][];
+//# sourceMappingURL=proximityMatching.d.ts.map

package/dist/utils/proximityMatching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proximityMatching.d.ts","sourceRoot":"","sources":["../../src/utils/proximityMatching.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,SAAS,EAAE,QAAQ,SAAS,KAAG,MAIzE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,iBAAiB,GAC5B,UAAU,MAAM,EAChB,cAAc,MAAM,EACpB,WAAW,QAAQ,EAAE,KACpB,QAAQ,GAAG,IAqBb,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAC/E,OAAO,CAAC,EAAE,KACT,CAAC,EAAE,EAqBL,CAAC"}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "rayo-editor",
+  "version": "0.0.1",
+  "description": "Standalone npm module for Rayo Blog Editor",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.umd.js"
+    },
+    "./dist/styles.css": "./dist/styles.css"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build && node scripts/copy-styles.js",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage",
+    "lint": "eslint src --ext .ts,.tsx",
+    "type-check": "tsc --noEmit"
+  },
+  "keywords": [
+    "rayo",
+    "editor",
+    "blog",
+    "rich-text"
+  ],
+  "author": "Rayo Team",
+  "license": "MIT",
+  "dependencies": {
+    "@tiptap/react": "^3.20.1"
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "^6.0.0",
+    "@testing-library/react": "^14.0.0",
+    "@types/node": "^20.0.0",
+    "@types/react": "^18.0.0",
+    "@types/react-dom": "^18.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "@vitejs/plugin-react": "^4.0.0",
+    "@vitest/coverage-v8": "^0.34.6",
+    "@vitest/ui": "^0.34.0",
+    "eslint": "^8.0.0",
+    "jsdom": "^28.1.0",
+    "typescript": "^5.0.0",
+    "vite": "^4.0.0",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^0.34.0"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": false
+    },
+    "react-dom": {
+      "optional": false
+    }
+  }
+}