@vscode/diff 0.0.2-0 → 0.0.2-2

package/dist/index.d.ts

@@ -219,5 +219,233 @@ interface CreateDiffComputerOptions {
 }
 declare function createDiffComputer(options?: CreateDiffComputerOptions): Promise<IDiffComputer>;
 
-export { AnnotatedStringEdit, AnnotatedStringReplacement, DiffAnnotation, DiffResult, Move, OffsetRange, OffsetRangeMapping, StringEdit, StringReplacement, createDiffComputer };
-export type { CreateDiffComputerOptions, DiffOptions, IDiffComputer, IEditData };
+/**
+ * Main-thread client for the diff worker. Exposes an async `IAsyncDiffComputer`.
+ *
+ * Inputs travel as `string[]` via structured-clone postMessage. The response
+ * is a small JSON-friendly `WireLinesDiff`; the main thread reconstructs the
+ * full `LinesDiff` and runs `_adaptLinesDiff` locally (it already has the
+ * input strings).
+ */
+
+interface IAsyncDiffComputer {
+    computeDiff(original: string, modified: string, options?: DiffOptions): Promise<DiffResult>;
+    dispose(): void;
+}
+interface CreateWorkerDiffComputerOptions {
+    /** Use the WASM backend inside the worker. Default: false (TS). */
+    useWasm?: boolean;
+    /**
+     * Override worker construction. Defaults to
+     * `new Worker(new URL('./worker.ts?esm', import.meta.url), { type: 'module' })`.
+     *
+     * The `?esm` marker is recognized by `@vscode/rollup-plugin-esm-url`,
+     * `@vscode/esbuild-plugin-esm-url`, and `@vscode/esm-url-webpack-plugin`,
+     * which auto-discover sibling worker entries when bundling consumer apps.
+     * After bundling, the URL resolves to a sibling `worker.js`. Override this
+     * only when your toolchain needs a non-default discovery mechanism.
+     */
+    workerFactory?: () => Worker;
+}
+declare function createWorkerDiffComputer(opts?: CreateWorkerDiffComputerOptions): Promise<IAsyncDiffComputer>;
+
+/**
+ * Represents a range in terms of lines and columns.
+ */
+interface IRange {
+    readonly startLineNumber: number;
+    readonly startColumn: number;
+    readonly endLineNumber: number;
+    readonly endColumn: number;
+}
+declare class Range implements IRange {
+    readonly startLineNumber: number;
+    readonly startColumn: number;
+    readonly endLineNumber: number;
+    readonly endColumn: number;
+    constructor(startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number);
+    static fromPositions(start: Position, end: Position): Range;
+}
+declare class Position {
+    readonly lineNumber: number;
+    readonly column: number;
+    constructor(lineNumber: number, column: number);
+    isBefore(other: Position): boolean;
+}
+
+/**
+ * A range of lines (1-based, end is exclusive).
+ */
+declare class LineRange {
+    readonly startLineNumber: number;
+    readonly endLineNumberExclusive: number;
+    constructor(startLineNumber: number, endLineNumberExclusive: number);
+    get isEmpty(): boolean;
+    get length(): number;
+    join(other: LineRange): LineRange;
+    intersectsOrTouches(other: LineRange): boolean;
+    toOffsetRange(): OffsetRange;
+    toString(): string;
+}
+/**
+ * A mapping between two ranges.
+ */
+declare class RangeMapping {
+    readonly originalRange: Range;
+    readonly modifiedRange: Range;
+    constructor(originalRange: Range, modifiedRange: Range);
+    toString(): string;
+    static assertSorted(rangeMappings: RangeMapping[]): void;
+}
+/**
+ * A mapping between two line ranges.
+ */
+declare class LineRangeMapping {
+    readonly original: LineRange;
+    readonly modified: LineRange;
+    constructor(original: LineRange, modified: LineRange);
+    toString(): string;
+    /**
+     * This method assumes that the LineRangeMapping describes a valid diff!
+     * I.e. if one range is empty, the other range cannot be the entire document.
+     * It avoids various problems when the line range points to non-existing line-numbers.
+    */
+    toRangeMapping2(originalLines: string[], modifiedLines: string[]): RangeMapping;
+}
+/**
+ * A detailed mapping between two line ranges, including inner changes.
+ */
+declare class DetailedLineRangeMapping extends LineRangeMapping {
+    readonly innerChanges: RangeMapping[] | undefined;
+    constructor(original: LineRange, modified: LineRange, innerChanges: RangeMapping[] | undefined);
+}
+/**
+ * Result of a lines diff computation.
+ */
+declare class LinesDiff {
+    readonly changes: DetailedLineRangeMapping[];
+    readonly moves: MovedText[];
+    readonly hitTimeout: boolean;
+    constructor(changes: DetailedLineRangeMapping[], moves: MovedText[], hitTimeout: boolean);
+}
+/**
+ * Represents text that was moved from one location to another.
+ */
+declare class MovedText {
+    readonly lineRangeMapping: LineRangeMapping;
+    readonly changes: DetailedLineRangeMapping[];
+    constructor(lineRangeMapping: LineRangeMapping, changes: DetailedLineRangeMapping[]);
+}
+
+/**
+ * Options for the lines diff computer.
+ */
+interface ILinesDiffComputerOptions {
+    /**
+     * Maximum computation time in milliseconds. 0 means no timeout.
+     */
+    maxComputationTimeMs: number;
+    /**
+     * Whether to ignore leading and trailing whitespace.
+     */
+    ignoreTrimWhitespace: boolean;
+    /**
+     * Whether to compute moved text detection.
+     */
+    computeMoves: boolean;
+    /**
+     * Whether to extend diffs to subword boundaries.
+     */
+    extendToSubwords: boolean;
+}
+/**
+ * The main diff computer that computes detailed line diffs.
+ */
+declare class DefaultLinesDiffComputer {
+    private readonly _dynamicProgrammingDiffing;
+    private readonly _myersDiffingAlgorithm;
+    computeDiff(originalLines: string[], modifiedLines: string[], options: ILinesDiffComputerOptions): LinesDiff;
+    private _refineDiff;
+}
+
+/**
+ * Types for WASM interop, matching the Rust WasmLinesDiff structure.
+ */
+/**
+ * A line range in the diff result.
+ */
+interface WasmLineRange {
+    startLineNumber: number;
+    endLineNumberExclusive: number;
+}
+/**
+ * A character-level range mapping between original and modified.
+ */
+interface WasmRangeMapping {
+    originalStartLine: number;
+    originalStartColumn: number;
+    originalEndLine: number;
+    originalEndColumn: number;
+    modifiedStartLine: number;
+    modifiedStartColumn: number;
+    modifiedEndLine: number;
+    modifiedEndColumn: number;
+}
+/**
+ * A detailed mapping between line ranges with optional inner character changes.
+ */
+interface WasmDetailedLineRangeMapping {
+    original: WasmLineRange;
+    modified: WasmLineRange;
+    innerChanges: WasmRangeMapping[] | null;
+}
+/**
+ * Result of a WASM diff computation.
+ */
+interface WasmLinesDiff {
+    changes: WasmDetailedLineRangeMapping[];
+    hitTimeout: boolean;
+}
+/**
+ * Options for the WASM diff computation.
+ */
+interface WasmDiffOptions {
+    maxComputationTimeMs?: number;
+    ignoreTrimWhitespace?: boolean;
+    computeMoves?: boolean;
+    extendToSubwords?: boolean;
+}
+/**
+ * WASM module exports interface.
+ */
+interface WasmModule {
+    computeDiff(original: string, modified: string, options: WasmDiffOptions | undefined): WasmLinesDiff;
+    computeDiffLines(originalLines: string[], modifiedLines: string[], options: WasmDiffOptions | undefined): WasmLinesDiff;
+    init(): void;
+}
+
+/**
+ * WASM module loader.
+ *
+ * Handles async initialization of the WASM module.
+ */
+
+/**
+ * Initialize the WASM module.
+ *
+ * This must be called before using any WASM-based diff functions.
+ * It's safe to call multiple times — subsequent calls are no-ops.
+ *
+ * @returns Promise that resolves when WASM is ready
+ */
+declare function initWasm(): Promise<WasmModule>;
+/**
+ * Get the WASM module synchronously.
+ *
+ * @throws Error if WASM hasn't been initialized yet
+ * @returns The WASM module
+ */
+declare function getWasm(): WasmModule;
+
+export { AnnotatedStringEdit, AnnotatedStringReplacement, DiffAnnotation, DiffResult, Move, OffsetRange, OffsetRangeMapping, StringEdit, StringReplacement, DefaultLinesDiffComputer as _DefaultLinesDiffComputer, DetailedLineRangeMapping as _DetailedLineRangeMapping, LineRange as _LineRange, LineRangeMapping as _LineRangeMapping, LinesDiff as _LinesDiff, RangeMapping as _RangeMapping, getWasm as _getWasm, initWasm as _initWasm, createDiffComputer, createWorkerDiffComputer };
+export type { CreateDiffComputerOptions, CreateWorkerDiffComputerOptions, DiffOptions, IAsyncDiffComputer, IDiffComputer, IEditData };