@mintlify/common 1.0.710 → 1.0.712

package/dist/editor/computeStringSimilarity.d.ts

@@ -0,0 +1,11 @@
+export declare function computeLevenshteinDistance(a: string, b: string): number;
+export declare function computeStringSimilarity(a: string, b: string): number;
+export interface BestMatchResult {
+    similarity: number;
+    startIndex: number;
+    endIndex: number;
+}
+export declare function findBestMatch(content: string, target: string, options?: {
+    minSimilarity?: number;
+    windowSize?: number;
+}): BestMatchResult | null;

package/dist/editor/computeStringSimilarity.js

@@ -0,0 +1,56 @@
+export function computeLevenshteinDistance(a, b) {
+    if (a.length === 0)
+        return b.length;
+    if (b.length === 0)
+        return a.length;
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++) {
+        matrix[i] = [i];
+    }
+    for (let j = 0; j <= a.length; j++) {
+        matrix[0][j] = j;
+    }
+    for (let i = 1; i <= b.length; i++) {
+        for (let j = 1; j <= a.length; j++) {
+            if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            }
+            else {
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+            }
+        }
+    }
+    return matrix[b.length][a.length];
+}
+export function computeStringSimilarity(a, b) {
+    if (a.length === 0 && b.length === 0)
+        return 1;
+    if (a.length === 0 || b.length === 0)
+        return 0;
+    const distance = computeLevenshteinDistance(a, b);
+    const maxLength = Math.max(a.length, b.length);
+    return 1 - distance / maxLength;
+}
+export function findBestMatch(content, target, options) {
+    var _a, _b;
+    const minSimilarity = (_a = options === null || options === void 0 ? void 0 : options.minSimilarity) !== null && _a !== void 0 ? _a : 0.85;
+    const windowSize = (_b = options === null || options === void 0 ? void 0 : options.windowSize) !== null && _b !== void 0 ? _b : Math.ceil(target.length * 1.5);
+    if (content.length === 0 || target.length === 0)
+        return null;
+    let bestMatch = null;
+    const minLen = Math.ceil(target.length * 0.5);
+    for (let i = 0; i <= content.length - minLen; i++) {
+        for (let len = minLen; len <= Math.min(windowSize, content.length - i); len++) {
+            const candidate = content.slice(i, i + len);
+            const similarity = computeStringSimilarity(candidate, target);
+            if (similarity >= minSimilarity && (!bestMatch || similarity > bestMatch.similarity)) {
+                bestMatch = {
+                    similarity,
+                    startIndex: i,
+                    endIndex: i + len,
+                };
+            }
+        }
+    }
+    return bestMatch;
+}

package/dist/editor/findTextInContent.d.ts

@@ -0,0 +1,2 @@
+import type { CommentAnchor, TextSearchResult } from './types.js';
+export declare function findOriginalTextInContent(content: string, anchor: CommentAnchor): TextSearchResult;

package/dist/editor/findTextInContent.js

@@ -0,0 +1,45 @@
+export function findOriginalTextInContent(content, anchor) {
+    var _a, _b;
+    const exactIndex = content.indexOf(anchor.originalText);
+    if (exactIndex !== -1) {
+        return {
+            found: true,
+            startIndex: exactIndex,
+            endIndex: exactIndex + anchor.originalText.length,
+        };
+    }
+    const contextPattern = anchor.contextBefore + anchor.originalText + anchor.contextAfter;
+    const contextIndex = content.indexOf(contextPattern);
+    if (contextIndex !== -1) {
+        const startIndex = contextIndex + anchor.contextBefore.length;
+        return {
+            found: true,
+            startIndex,
+            endIndex: startIndex + anchor.originalText.length,
+        };
+    }
+    const lines = content.split('\n');
+    if (anchor.line <= lines.length) {
+        const targetLine = lines[anchor.line - 1];
+        if (targetLine) {
+            const lineIndex = targetLine.indexOf(anchor.originalText);
+            if (lineIndex !== -1) {
+                let startIndex = 0;
+                for (let i = 0; i < anchor.line - 1; i++) {
+                    startIndex += ((_b = (_a = lines[i]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) + 1;
+                }
+                startIndex += lineIndex;
+                return {
+                    found: true,
+                    startIndex,
+                    endIndex: startIndex + anchor.originalText.length,
+                };
+            }
+        }
+    }
+    return {
+        found: false,
+        startIndex: -1,
+        endIndex: -1,
+    };
+}

package/dist/editor/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './computeStringSimilarity.js';
+export * from './findTextInContent.js';
+export * from './resolveAnchor.js';
+export * from './resolveAnchors.js';

package/dist/editor/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './computeStringSimilarity.js';
+export * from './findTextInContent.js';
+export * from './resolveAnchor.js';
+export * from './resolveAnchors.js';

package/dist/editor/resolveAnchor.d.ts

@@ -0,0 +1,2 @@
+import type { CommentAnchor, AnchorResolutionResult, ResolveAnchorOptions } from './types.js';
+export declare function resolveAnchor(content: string, anchor: CommentAnchor, options?: ResolveAnchorOptions): AnchorResolutionResult;

package/dist/editor/resolveAnchor.js

@@ -0,0 +1,49 @@
+import { findBestMatch } from './computeStringSimilarity.js';
+import { findOriginalTextInContent } from './findTextInContent.js';
+const DEFAULT_SIMILARITY_THRESHOLD = 0.85;
+export function resolveAnchor(content, anchor, options) {
+    var _a;
+    const similarityThreshold = (_a = options === null || options === void 0 ? void 0 : options.similarityThreshold) !== null && _a !== void 0 ? _a : DEFAULT_SIMILARITY_THRESHOLD;
+    if ((options === null || options === void 0 ? void 0 : options.currentCommit) && options.currentCommit === anchor.anchorCommit) {
+        const lines = content.split('\n');
+        let startIndex = 0;
+        for (let i = 0; i < anchor.line - 1 && i < lines.length; i++) {
+            startIndex += lines[i].length + 1;
+        }
+        startIndex += anchor.startCol;
+        return {
+            status: 'found',
+            range: {
+                startIndex,
+                endIndex: startIndex + anchor.originalText.length,
+            },
+        };
+    }
+    const searchResult = findOriginalTextInContent(content, anchor);
+    if (searchResult.found) {
+        return {
+            status: 'found',
+            range: {
+                startIndex: searchResult.startIndex,
+                endIndex: searchResult.endIndex,
+            },
+        };
+    }
+    const fuzzyMatch = findBestMatch(content, anchor.originalText, {
+        minSimilarity: similarityThreshold,
+    });
+    if (fuzzyMatch) {
+        return {
+            status: 'stale',
+            range: {
+                startIndex: fuzzyMatch.startIndex,
+                endIndex: fuzzyMatch.endIndex,
+            },
+            similarity: fuzzyMatch.similarity,
+        };
+    }
+    return {
+        status: 'orphan',
+        range: null,
+    };
+}

package/dist/editor/resolveAnchors.d.ts

@@ -0,0 +1,2 @@
+import type { ThreadResolutionInput, ThreadResolutionResult, ResolveAnchorOptions } from './types.js';
+export declare function resolveAnchors<T = unknown>(content: string, threads: ThreadResolutionInput<T>[], options?: ResolveAnchorOptions): ThreadResolutionResult<T>[];

package/dist/editor/resolveAnchors.js

@@ -0,0 +1,59 @@
+import { resolveAnchor } from './resolveAnchor.js';
+function computeLineAndCol(content, startIndex, endIndex) {
+    const lines = content.split('\n');
+    let charCount = 0;
+    let line = 1;
+    for (let i = 0; i < lines.length; i++) {
+        const lineLength = lines[i].length + 1;
+        if (charCount + lineLength > startIndex) {
+            line = i + 1;
+            break;
+        }
+        charCount += lineLength;
+    }
+    const startCol = startIndex - charCount;
+    const lineContent = lines[line - 1] || '';
+    const contextBeforeStart = Math.max(0, startCol - 50);
+    const contextBefore = lineContent.slice(contextBeforeStart, startCol);
+    let endCharCount = 0;
+    let endLine = 1;
+    for (let i = 0; i < lines.length; i++) {
+        const lineLength = lines[i].length + 1;
+        if (endCharCount + lineLength > endIndex) {
+            endLine = i + 1;
+            break;
+        }
+        endCharCount += lineLength;
+    }
+    const endCol = endIndex - endCharCount;
+    const endLineContent = lines[endLine - 1] || '';
+    const contextAfter = endLineContent.slice(endCol, endCol + 50);
+    return { line, startCol, endCol, contextBefore, contextAfter };
+}
+export function resolveAnchors(content, threads, options) {
+    return threads.map((thread) => {
+        const resolution = resolveAnchor(content, thread.anchor, options);
+        let updatedAnchor;
+        if (resolution.range && resolution.status !== 'orphan') {
+            const { line, startCol, endCol, contextBefore, contextAfter } = computeLineAndCol(content, resolution.range.startIndex, resolution.range.endIndex);
+            const originalText = content.slice(resolution.range.startIndex, resolution.range.endIndex);
+            const positionChanged = line !== thread.anchor.line ||
+                startCol !== thread.anchor.startCol ||
+                originalText !== thread.anchor.originalText;
+            if (positionChanged) {
+                updatedAnchor = Object.assign(Object.assign({}, thread.anchor), { line,
+                    startCol,
+                    endCol,
+                    originalText,
+                    contextBefore,
+                    contextAfter, anchorCommit: (options === null || options === void 0 ? void 0 : options.currentCommit) || thread.anchor.anchorCommit });
+            }
+        }
+        return {
+            threadId: thread.threadId,
+            resolution,
+            updatedAnchor,
+            metadata: thread.metadata,
+        };
+    });
+}

package/dist/editor/types.d.ts

@@ -0,0 +1,41 @@
+export interface CommentAnchor {
+    anchorCommit: string;
+    line: number;
+    startCol: number;
+    endCol: number;
+    originalText: string;
+    contextBefore: string;
+    contextAfter: string;
+    createdAt: Date;
+    createdBy: string;
+}
+export type AnchorResolutionStatus = 'found' | 'stale' | 'orphan';
+export interface TextRange {
+    startIndex: number;
+    endIndex: number;
+}
+export interface AnchorResolutionResult {
+    status: AnchorResolutionStatus;
+    range: TextRange | null;
+    similarity?: number;
+}
+export interface ThreadResolutionInput<T = unknown> {
+    threadId: string;
+    anchor: CommentAnchor;
+    metadata?: T;
+}
+export interface ThreadResolutionResult<T = unknown> {
+    threadId: string;
+    resolution: AnchorResolutionResult;
+    updatedAnchor?: CommentAnchor;
+    metadata?: T;
+}
+export interface ResolveAnchorOptions {
+    currentCommit?: string;
+    similarityThreshold?: number;
+}
+export interface TextSearchResult {
+    found: boolean;
+    startIndex: number;
+    endIndex: number;
+}

package/dist/editor/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -28,3 +28,4 @@ export * from './api-reference/parseApiTargetFromMetadata.js';
 export * from './mintIgnore.js';
 export * from './getDisplayDomain.js';
 export * from './exponentialBackoff.js';
+export * from './editor/index.js';

package/dist/index.js

@@ -28,3 +28,4 @@ export * from './api-reference/parseApiTargetFromMetadata.js';
 export * from './mintIgnore.js';
 export * from './getDisplayDomain.js';
 export * from './exponentialBackoff.js';
+export * from './editor/index.js';