@vertesia/ui 1.5.0-dev.20260722.120446Z → 1.5.0-dev.20260725.083715Z

package/src/widgets/markdown/textDiff.ts

@@ -0,0 +1,399 @@
+export interface TextDiffSegment {
+    type: 'equal' | 'added' | 'removed';
+    text: string;
+}
+
+// Above this token count the LCS table gets expensive; fall back to a whole-text replace.
+const MAX_LCS_TOKENS = 600;
+
+function tokenize(text: string): string[] {
+    return text.split(/(\s+)/).filter((token) => token.length > 0);
+}
+
+function pushSegment(segments: TextDiffSegment[], type: TextDiffSegment['type'], text: string): void {
+    if (!text) return;
+    const last = segments[segments.length - 1];
+    if (last && last.type === type) {
+        last.text += text;
+    } else {
+        segments.push({ type, text });
+    }
+}
+
+function lcsSegments(before: string[], after: string[], segments: TextDiffSegment[]): void {
+    // lengths[i][j] = LCS length of before[i..] and after[j..]
+    const rows = before.length + 1;
+    const cols = after.length + 1;
+    const lengths = new Uint32Array(rows * cols);
+    for (let i = before.length - 1; i >= 0; i--) {
+        for (let j = after.length - 1; j >= 0; j--) {
+            lengths[i * cols + j] =
+                before[i] === after[j]
+                    ? lengths[(i + 1) * cols + j + 1] + 1
+                    : Math.max(lengths[(i + 1) * cols + j], lengths[i * cols + j + 1]);
+        }
+    }
+
+    let i = 0;
+    let j = 0;
+    while (i < before.length && j < after.length) {
+        if (before[i] === after[j]) {
+            pushSegment(segments, 'equal', before[i]);
+            i++;
+            j++;
+        } else if (lengths[(i + 1) * cols + j] >= lengths[i * cols + j + 1]) {
+            pushSegment(segments, 'removed', before[i]);
+            i++;
+        } else {
+            pushSegment(segments, 'added', after[j]);
+            j++;
+        }
+    }
+    pushSegment(segments, 'removed', before.slice(i).join(''));
+    pushSegment(segments, 'added', after.slice(j).join(''));
+}
+
+/**
+ * Word-level diff of two texts, returned as ordered segments suitable for
+ * rendering a unified inline diff. Whitespace is kept in the segments so the
+ * concatenation of `equal` + `removed` segments equals `before`, and
+ * `equal` + `added` segments equals `after`.
+ */
+export function diffWordSegments(before: string, after: string): TextDiffSegment[] {
+    if (before === after) {
+        return before ? [{ type: 'equal', text: before }] : [];
+    }
+
+    const beforeTokens = tokenize(before);
+    const afterTokens = tokenize(after);
+
+    // Trim the common prefix and suffix so the quadratic LCS only runs on the changed middle.
+    let start = 0;
+    while (start < beforeTokens.length && start < afterTokens.length && beforeTokens[start] === afterTokens[start]) {
+        start++;
+    }
+    let beforeEnd = beforeTokens.length;
+    let afterEnd = afterTokens.length;
+    while (beforeEnd > start && afterEnd > start && beforeTokens[beforeEnd - 1] === afterTokens[afterEnd - 1]) {
+        beforeEnd--;
+        afterEnd--;
+    }
+
+    const segments: TextDiffSegment[] = [];
+    pushSegment(segments, 'equal', beforeTokens.slice(0, start).join(''));
+
+    const beforeMiddle = beforeTokens.slice(start, beforeEnd);
+    const afterMiddle = afterTokens.slice(start, afterEnd);
+    if (beforeMiddle.length * afterMiddle.length > MAX_LCS_TOKENS * MAX_LCS_TOKENS) {
+        pushSegment(segments, 'removed', beforeMiddle.join(''));
+        pushSegment(segments, 'added', afterMiddle.join(''));
+    } else {
+        lcsSegments(beforeMiddle, afterMiddle, segments);
+    }
+
+    pushSegment(segments, 'equal', beforeTokens.slice(beforeEnd).join(''));
+    return segments;
+}
+
+interface LineOp {
+    type: 'equal' | 'removed' | 'added';
+    line: string;
+}
+
+function lcsLineOps(before: string[], after: string[]): LineOp[] {
+    const ops: LineOp[] = [];
+
+    let start = 0;
+    while (start < before.length && start < after.length && before[start] === after[start]) {
+        ops.push({ type: 'equal', line: before[start] });
+        start++;
+    }
+    let beforeEnd = before.length;
+    let afterEnd = after.length;
+    const tail: LineOp[] = [];
+    while (beforeEnd > start && afterEnd > start && before[beforeEnd - 1] === after[afterEnd - 1]) {
+        beforeEnd--;
+        afterEnd--;
+        tail.unshift({ type: 'equal', line: before[beforeEnd] });
+    }
+
+    const beforeMiddle = before.slice(start, beforeEnd);
+    const afterMiddle = after.slice(start, afterEnd);
+    if (beforeMiddle.length * afterMiddle.length > MAX_LCS_TOKENS * MAX_LCS_TOKENS) {
+        for (const line of beforeMiddle) ops.push({ type: 'removed', line });
+        for (const line of afterMiddle) ops.push({ type: 'added', line });
+        return [...ops, ...tail];
+    }
+
+    const rows = beforeMiddle.length + 1;
+    const cols = afterMiddle.length + 1;
+    const lengths = new Uint32Array(rows * cols);
+    for (let i = beforeMiddle.length - 1; i >= 0; i--) {
+        for (let j = afterMiddle.length - 1; j >= 0; j--) {
+            lengths[i * cols + j] =
+                beforeMiddle[i] === afterMiddle[j]
+                    ? lengths[(i + 1) * cols + j + 1] + 1
+                    : Math.max(lengths[(i + 1) * cols + j], lengths[i * cols + j + 1]);
+        }
+    }
+    let i = 0;
+    let j = 0;
+    while (i < beforeMiddle.length && j < afterMiddle.length) {
+        if (beforeMiddle[i] === afterMiddle[j]) {
+            ops.push({ type: 'equal', line: beforeMiddle[i] });
+            i++;
+            j++;
+        } else if (lengths[(i + 1) * cols + j] >= lengths[i * cols + j + 1]) {
+            ops.push({ type: 'removed', line: beforeMiddle[i] });
+            i++;
+        } else {
+            ops.push({ type: 'added', line: afterMiddle[j] });
+            j++;
+        }
+    }
+    while (i < beforeMiddle.length) ops.push({ type: 'removed', line: beforeMiddle[i++] });
+    while (j < afterMiddle.length) ops.push({ type: 'added', line: afterMiddle[j++] });
+    return [...ops, ...tail];
+}
+
+function splitLinesWithEndings(text: string): string[] {
+    return text.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+}
+
+/**
+ * Document-scale text diff. Exact lines are aligned first, then word-level
+ * highlighting is applied only inside each changed line hunk. This avoids the
+ * word diff's bounded-LCS fallback turning a large document middle into one
+ * wholesale removal and addition.
+ */
+export function diffTextSegments(before: string, after: string): TextDiffSegment[] {
+    if (!before.includes('\n') && !after.includes('\n')) return diffWordSegments(before, after);
+    if (before === after) return before ? [{ type: 'equal', text: before }] : [];
+
+    const segments: TextDiffSegment[] = [];
+    const ops = lcsLineOps(splitLinesWithEndings(before), splitLinesWithEndings(after));
+    let index = 0;
+    while (index < ops.length) {
+        const op = ops[index];
+        if (op.type === 'equal') {
+            pushSegment(segments, 'equal', op.line);
+            index++;
+            continue;
+        }
+
+        let removed = '';
+        let added = '';
+        while (index < ops.length && ops[index].type !== 'equal') {
+            const changed = ops[index++];
+            if (changed.type === 'removed') removed += changed.line;
+            if (changed.type === 'added') added += changed.line;
+        }
+        for (const segment of diffWordSegments(removed, added)) {
+            pushSegment(segments, segment.type, segment.text);
+        }
+    }
+    return segments;
+}
+
+export interface TextLineChangeRegion {
+    /** Zero-based line in the current document where the change starts. */
+    startLine: number;
+    /** Inclusive zero-based line in the current document where the change ends. */
+    endLine: number;
+}
+
+/** Returns distinct current-document line hunks for a change minimap. */
+export function getTextLineChangeRegions(before: string, after: string): TextLineChangeRegion[] {
+    if (before === after) return [];
+
+    const regions: TextLineChangeRegion[] = [];
+    const ops = lcsLineOps(before.split('\n'), after.split('\n'));
+    let currentLine = 0;
+    let startLine: number | undefined;
+
+    const closeRegion = () => {
+        if (startLine === undefined) return;
+        regions.push({ startLine, endLine: Math.max(startLine, currentLine - 1) });
+        startLine = undefined;
+    };
+
+    for (const op of ops) {
+        if (op.type === 'equal') {
+            closeRegion();
+            currentLine++;
+            continue;
+        }
+        startLine ??= currentLine;
+        if (op.type === 'added') currentLine++;
+    }
+    closeRegion();
+    return regions;
+}
+
+interface LineChange {
+    /** Inclusive start and exclusive end in base-document line coordinates. */
+    start: number;
+    end: number;
+    replacement: string[];
+}
+
+export type TextRebaseResult = { status: 'rebased'; content: string } | { status: 'conflict'; content: string };
+
+function lineChanges(base: string[], changed: string[]): LineChange[] {
+    const changes: LineChange[] = [];
+    const ops = lcsLineOps(base, changed);
+    let baseIndex = 0;
+    let index = 0;
+    while (index < ops.length) {
+        if (ops[index].type === 'equal') {
+            baseIndex++;
+            index++;
+            continue;
+        }
+
+        const start = baseIndex;
+        const replacement: string[] = [];
+        while (index < ops.length && ops[index].type !== 'equal') {
+            const op = ops[index++];
+            if (op.type === 'removed') baseIndex++;
+            if (op.type === 'added') replacement.push(op.line);
+        }
+        changes.push({ start, end: baseIndex, replacement });
+    }
+    return changes;
+}
+
+function sameLineChange(left: LineChange, right: LineChange): boolean {
+    return (
+        left.start === right.start &&
+        left.end === right.end &&
+        left.replacement.length === right.replacement.length &&
+        left.replacement.every((line, index) => line === right.replacement[index])
+    );
+}
+
+function lineChangesOverlap(left: LineChange, right: LineChange): boolean {
+    const leftInsertion = left.start === left.end;
+    const rightInsertion = right.start === right.end;
+    if (leftInsertion && rightInsertion) return left.start === right.start;
+    if (leftInsertion) return left.start >= right.start && left.start <= right.end;
+    if (rightInsertion) return right.start >= left.start && right.start <= left.end;
+    return left.start < right.end && right.start < left.end;
+}
+
+/**
+ * Conservatively reapplies local line edits onto a concurrently changed document.
+ * Identical edits are deduplicated. Any overlapping base ranges return a conflict
+ * and preserve `local` unchanged for recovery by the caller.
+ */
+export function rebaseTextChanges(base: string, local: string, remote: string): TextRebaseResult {
+    if (local === remote) return { status: 'rebased', content: local };
+    if (local === base) return { status: 'rebased', content: remote };
+    if (remote === base) return { status: 'rebased', content: local };
+
+    const baseLines = base.split('\n');
+    const localChanges = lineChanges(baseLines, local.split('\n'));
+    const remoteChanges = lineChanges(baseLines, remote.split('\n'));
+    const uniqueLocalChanges: LineChange[] = [];
+
+    for (const localChange of localChanges) {
+        let duplicate = false;
+        for (const remoteChange of remoteChanges) {
+            if (sameLineChange(localChange, remoteChange)) {
+                duplicate = true;
+                break;
+            }
+            if (lineChangesOverlap(localChange, remoteChange)) {
+                return { status: 'conflict', content: local };
+            }
+        }
+        if (!duplicate) uniqueLocalChanges.push(localChange);
+    }
+
+    const combined = [...remoteChanges, ...uniqueLocalChanges].sort(
+        (left, right) => left.start - right.start || left.end - right.end,
+    );
+    const merged: string[] = [];
+    let cursor = 0;
+    for (const change of combined) {
+        merged.push(...baseLines.slice(cursor, change.start), ...change.replacement);
+        cursor = change.end;
+    }
+    merged.push(...baseLines.slice(cursor));
+    return { status: 'rebased', content: merged.join('\n') };
+}
+
+export interface UnifiedLineDiffOptions {
+    /** Unchanged lines shown around each change (default 2). */
+    context?: number;
+    /** When set, returns undefined if the formatted diff would exceed this length. */
+    maxChars?: number;
+}
+
+/**
+ * Line-level unified diff (`@@ -a,b +c,d @@` hunks with `-`/`+`/space prefixes)
+ * of two texts. Returns undefined when the texts are identical, or when the
+ * formatted diff exceeds `maxChars` — callers fall back to a non-diff summary.
+ */
+export function createUnifiedLineDiff(
+    before: string,
+    after: string,
+    options: UnifiedLineDiffOptions = {},
+): string | undefined {
+    if (before === after) return undefined;
+    const context = options.context ?? 2;
+
+    const ops = lcsLineOps(before.split('\n'), after.split('\n'));
+
+    // Group changed ops into hunks, merging hunks whose context would overlap.
+    const changed: Array<{ start: number; end: number }> = [];
+    for (let index = 0; index < ops.length; index++) {
+        if (ops[index].type === 'equal') continue;
+        const previous = changed[changed.length - 1];
+        if (previous && index - previous.end <= context * 2) {
+            previous.end = index + 1;
+        } else {
+            changed.push({ start: index, end: index + 1 });
+        }
+    }
+    if (changed.length === 0) return undefined;
+
+    const lines: string[] = [];
+    let beforeLine = 1;
+    let afterLine = 1;
+    let cursor = 0;
+    for (const hunk of changed) {
+        const start = Math.max(hunk.start - context, cursor === 0 ? 0 : cursor);
+        for (; cursor < start; cursor++) {
+            if (ops[cursor].type !== 'added') beforeLine++;
+            if (ops[cursor].type !== 'removed') afterLine++;
+        }
+        const end = Math.min(hunk.end + context, ops.length);
+        let beforeCount = 0;
+        let afterCount = 0;
+        const body: string[] = [];
+        for (let index = start; index < end; index++) {
+            const op = ops[index];
+            if (op.type === 'equal') {
+                body.push(` ${op.line}`);
+                beforeCount++;
+                afterCount++;
+            } else if (op.type === 'removed') {
+                body.push(`-${op.line}`);
+                beforeCount++;
+            } else {
+                body.push(`+${op.line}`);
+                afterCount++;
+            }
+        }
+        lines.push(`@@ -${beforeLine},${beforeCount} +${afterLine},${afterCount} @@`, ...body);
+        for (; cursor < end; cursor++) {
+            if (ops[cursor].type !== 'added') beforeLine++;
+            if (ops[cursor].type !== 'removed') afterLine++;
+        }
+    }
+
+    const formatted = lines.join('\n');
+    if (options.maxChars !== undefined && formatted.length > options.maxChars) return undefined;
+    return formatted;
+}

package/src/widgets/markdown/useArtifactContent.ts

@@ -1,5 +1,5 @@
 /**
- * useArtifactContent - Hook to fetch artifact content from GCS
+ * useArtifactContent - Hook to fetch artifact content from blob storage
  *
  * Used by expand:* code blocks to fetch and render artifact content inline.
  */
@@ -19,6 +19,8 @@ export interface ArtifactContentState<T = unknown> {
     error: string | undefined;
     /** Detected content type */
     contentType: 'json' | 'text' | 'binary' | undefined;
+    /** Storage ETag when exposed by the signed artifact response. */
+    etag: string | undefined;
     /** Retry the fetch */
     retry: () => void;
 }
@@ -59,8 +61,8 @@ function detectContentType(path: string): 'json' | 'text' | 'binary' {
 }
 
 /**
- * Hook to fetch artifact content from GCS.
- * Handles caching, loading states, and error handling.
+ * Hook to fetch artifact content from blob storage.
+ * Handles signed-URL caching, loading states, and error handling.
  *
  * @example
  * ```tsx
@@ -90,6 +92,7 @@ export function useArtifactContent<T = unknown>({
         isLoading: boolean;
         error: string | undefined;
         contentType: 'json' | 'text' | 'binary' | undefined;
+        etag?: string;
     }>({
         data: undefined,
         rawContent: undefined,
@@ -156,6 +159,7 @@ export function useArtifactContent<T = unknown>({
                     isLoading: false,
                     error: undefined,
                     contentType,
+                    etag: response.headers.get('etag')?.replace(/^"(.*)"$/, '$1'),
                 });
                 return;
             }
@@ -181,6 +185,7 @@ export function useArtifactContent<T = unknown>({
                 isLoading: false,
                 error: undefined,
                 contentType,
+                etag: response.headers.get('etag')?.replace(/^"(.*)"$/, '$1'),
             });
         } catch (err) {
             const errorMessage = err instanceof Error ? err.message : 'Failed to fetch artifact';
@@ -216,6 +221,7 @@ export function useArtifactContent<T = unknown>({
         isLoading: state.isLoading,
         error: state.error,
         contentType: state.contentType,
+        etag: state.etag,
         retry,
     };
 }

package/src/widgets/markdown/useResolvedUrl.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { mapSchemeToRoute, parseUrlScheme } from './useResolvedUrl';
+import { parseUrlScheme } from './useResolvedUrl';
 
 describe('parseUrlScheme', () => {
     it('should parse artifact: URLs', () => {
@@ -50,9 +50,29 @@ describe('parseUrlScheme', () => {
         expect(result.path).toBe('doc-id-123');
     });
 
-    it('should map collection:// through to a single-slash route', () => {
+    it('should normalize collection:// to its resource id', () => {
         const { scheme, path } = parseUrlScheme('collection://my-collection');
-        expect(mapSchemeToRoute(scheme, path)).toBe('/store/collections/my-collection');
+        expect(scheme).toBe('collection');
+        expect(path).toBe('my-collection');
+    });
+
+    it.each([
+        ['interaction:int-1', 'interaction', 'int-1'],
+        ['prompt:prm-1', 'prompt', 'prm-1'],
+        ['agent:agt-1', 'agent', 'agt-1'],
+        ['workflow:wf-1', 'workflow', 'wf-1'],
+        ['process:proc-1', 'process', 'proc-1'],
+        ['run:run-1', 'run', 'run-1'],
+    ])('should parse %s as a route scheme', (raw, scheme, path) => {
+        const result = parseUrlScheme(raw);
+        expect(result.scheme).toBe(scheme);
+        expect(result.path).toBe(path);
+    });
+
+    it('should strip the // authority from interaction:// URLs', () => {
+        const result = parseUrlScheme('interaction://int-1');
+        expect(result.scheme).toBe('interaction');
+        expect(result.path).toBe('int-1');
     });
 
     it('should parse standard URLs', () => {
@@ -61,6 +81,12 @@ describe('parseUrlScheme', () => {
         expect(result.path).toBe('https://example.com/page');
     });
 
+    it('should treat an unknown scheme as standard', () => {
+        const result = parseUrlScheme('mailto:user@example.com');
+        expect(result.scheme).toBe('standard');
+        expect(result.path).toBe('mailto:user@example.com');
+    });
+
     it('should parse relative URLs as standard', () => {
         const result = parseUrlScheme('/path/to/page');
         expect(result.scheme).toBe('standard');
@@ -78,40 +104,3 @@ describe('parseUrlScheme', () => {
         expect(result.path).toBe('');
     });
 });
-
-describe('mapSchemeToRoute', () => {
-    it('should map store: to /store/objects/', () => {
-        const result = mapSchemeToRoute('store', 'abc123');
-        expect(result).toBe('/store/objects/abc123');
-    });
-
-    it('should map document: to /store/objects/', () => {
-        const result = mapSchemeToRoute('document', 'doc-id');
-        expect(result).toBe('/store/objects/doc-id');
-    });
-
-    it('should map collection: to /store/collections/', () => {
-        const result = mapSchemeToRoute('collection', 'my-collection');
-        expect(result).toBe('/store/collections/my-collection');
-    });
-
-    it('should return null for artifact: scheme', () => {
-        const result = mapSchemeToRoute('artifact', 'path/to/file');
-        expect(result).toBeNull();
-    });
-
-    it('should return null for image: scheme', () => {
-        const result = mapSchemeToRoute('image', 'path/to/image');
-        expect(result).toBeNull();
-    });
-
-    it('should return null for standard scheme', () => {
-        const result = mapSchemeToRoute('standard', 'https://example.com');
-        expect(result).toBeNull();
-    });
-
-    it('should return null for empty path', () => {
-        const result = mapSchemeToRoute('store', '');
-        expect(result).toBeNull();
-    });
-});

package/src/widgets/markdown/useResolvedUrl.ts

@@ -7,7 +7,31 @@ import {
     useArtifactUrlCache,
 } from '../../features/agent/chat/useArtifactUrlCache';
 
-export type UrlScheme = 'artifact' | 'image' | 'store' | 'document' | 'collection' | 'standard';
+export type UrlScheme =
+    | 'artifact'
+    | 'image'
+    | 'store'
+    | 'document'
+    | 'collection'
+    | 'interaction'
+    | 'prompt'
+    | 'agent'
+    | 'workflow'
+    | 'process'
+    | 'run'
+    | 'standard';
+
+const AGENT_RESOURCE_SCHEMES = new Set<UrlScheme>([
+    'store',
+    'document',
+    'collection',
+    'interaction',
+    'prompt',
+    'agent',
+    'workflow',
+    'process',
+    'run',
+]);
 
 export interface ResolvedUrlState {
     /** The resolved URL, or undefined if not yet resolved */
@@ -49,34 +73,16 @@ export function parseUrlScheme(rawUrl: string): { scheme: UrlScheme; path: strin
     if (rawUrl.startsWith('image:')) {
         return { scheme: 'image', path: rawUrl.slice(6).trim() };
     }
-    if (rawUrl.startsWith('store:')) {
-        return { scheme: 'store', path: stripSchemePath(rawUrl.slice(6)) };
-    }
-    if (rawUrl.startsWith('document:')) {
-        return { scheme: 'document', path: stripSchemePath(rawUrl.slice(9)) };
-    }
-    if (rawUrl.startsWith('collection:')) {
-        return { scheme: 'collection', path: stripSchemePath(rawUrl.slice(11)) };
+    const colonIndex = rawUrl.indexOf(':');
+    if (colonIndex > 0) {
+        const scheme = rawUrl.slice(0, colonIndex);
+        if (AGENT_RESOURCE_SCHEMES.has(scheme as UrlScheme)) {
+            return { scheme: scheme as UrlScheme, path: stripSchemePath(rawUrl.slice(colonIndex + 1)) };
+        }
     }
     return { scheme: 'standard', path: rawUrl };
 }
 
-/**
- * Maps internal URL schemes to application routes
- */
-export function mapSchemeToRoute(scheme: UrlScheme, path: string): string | null {
-    switch (scheme) {
-        case 'store':
-            return path ? `/store/objects/${path}` : null;
-        case 'document':
-            return path ? `/store/objects/${path}` : null;
-        case 'collection':
-            return path ? `/store/collections/${path}` : null;
-        default:
-            return null;
-    }
-}
-
 /**
  * Hook to resolve custom URL schemes (artifact:, image:, etc.) to actual URLs.
  * Handles caching, loading states, and error handling.
@@ -95,19 +101,11 @@ export function useResolvedUrl({
     urlCacheRef.current = urlCache;
     const { scheme, path } = parseUrlScheme(rawUrl);
 
-    // For schemes that map to routes, resolve immediately
-    const mappedRoute = mapSchemeToRoute(scheme, path);
-
     const [state, setState] = useState<{
         url: string | undefined;
         isLoading: boolean;
         error: string | undefined;
     }>(() => {
-        // If it's a mapped route, use that immediately
-        if (mappedRoute) {
-            return { url: mappedRoute, isLoading: false, error: undefined };
-        }
-
         // If it's a standard URL, use as-is
         if (scheme === 'standard') {
             return { url: rawUrl, isLoading: false, error: undefined };
@@ -133,7 +131,7 @@ export function useResolvedUrl({
 
     const fetchUrl = useCallback(async () => {
         // Skip if already resolved or standard URL
-        if (mappedRoute || scheme === 'standard') {
+        if (scheme === 'standard') {
             return;
         }
 
@@ -203,7 +201,7 @@ export function useResolvedUrl({
             console.error('Failed to resolve URL:', path, err);
             setState({ url: undefined, isLoading: false, error: errorMessage });
         }
-    }, [scheme, path, artifactRunId, disposition, mappedRoute]);
+    }, [scheme, path, artifactRunId, disposition]);
 
     useEffect(() => {
         // Skip if already resolved

package/src/widgets/xml-viewer/hooks/useXMLViewer.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+import { parseXML } from './useXMLViewer';
+
+describe('parseXML', () => {
+    it('parses valid XML', () => {
+        const result = parseXML('<root><item id="1">value</item></root>');
+
+        expect(result.valid).toBe(true);
+        expect(result.json).not.toBeNull();
+    });
+
+    it('allows parsererror elements in valid XML content', () => {
+        const result = parseXML('<root><parsererror>expected content</parsererror></root>');
+
+        expect(result.valid).toBe(true);
+        expect(result.json).not.toBeNull();
+    });
+
+    it('rejects invalid XML', () => {
+        const result = parseXML('<root><item></root>');
+
+        expect(result.valid).toBe(false);
+        expect(result.json).toBeNull();
+        expect(result.errorMessage).toContain('Fail to parse:');
+    });
+});