@volar/source-map 1.0.0-beta.0 → 1.0.0-beta.2

package/out/index.d.ts

@@ -1,80 +1,22 @@
-export interface Range {
-    start: number;
-    end: number;
-}
-export declare enum Mode {
-    /**
-     * @case1
-     * 123456 -> abcdef
-     * ^    ^    ^    ^
-     * @case2
-     * 123456 -> abcdef
-     *  ^  ^      ^  ^
-     * @case3
-     * 123456 -> abcdef
-     *   ^^        ^^
-     */
-    Offset = 1,
-    /**
-     * @case1
-     * 123456 -> abcdef
-     * ^    ^    ^    ^
-     * @case2
-     * 123456 -> abcdef
-     *  ^  ^     NOT_MATCH
-     * @case3
-     * 123456 -> abcdef
-     *   ^^      NOT_MATCH
-     */
-    Totally = 2,
-    /**
-     * @case1
-     * 123456 -> abcdef
-     * ^    ^    ^    ^
-     * @case2
-     * 123456 -> abcdef
-     *  ^  ^     ^    ^
-     * @case3
-     * 123456 -> abcdef
-     *   ^^      ^    ^
-     */
-    Expand = 3
-}
-export type MappingBase = {
-    mode: Mode;
-    sourceRange: Range;
-    mappedRange: Range;
-};
-export type Mapping<T> = MappingBase & {
+import { SegmentWithData, SegmentWithoutData } from 'muggle-string';
+export * from 'muggle-string';
+export interface Mapping<T = any> {
+    source?: string;
+    sourceRange: [number, number];
+    generatedRange: [number, number];
     data: T;
-    additional?: MappingBase[];
-};
+}
 export declare class SourceMapBase<Data = undefined> {
-    private __mappings;
-    private __memo;
-    get mappings(): Mapping<Data>[];
-    set mappings(value: Mapping<Data>[]);
-    constructor(_mappings?: Mapping<Data>[]);
-    getSourceRange(start: number, end?: number, filter?: (data: Data) => boolean): [{
-        start: number;
-        end: number;
-    }, Data] | undefined;
-    getMappedRange(start: number, end?: number, filter?: (data: Data) => boolean): [{
-        start: number;
-        end: number;
-    }, Data] | undefined;
-    getSourceRanges(start: number, end?: number, filter?: (data: Data) => boolean): Generator<[{
-        start: number;
-        end: number;
-    }, Data], void, unknown>;
-    getMappedRanges(start: number, end?: number, filter?: (data: Data) => boolean): Generator<[{
-        start: number;
-        end: number;
-    }, Data], void, unknown>;
-    getRanges(startOffset: number, endOffset: number, sourceToTarget: boolean, filter?: (data: Data) => boolean): Generator<[{
-        start: number;
-        end: number;
-    }, Data], void, unknown>;
+    readonly mappings: Mapping<Data>[];
+    private _memo;
+    private get memo();
+    constructor(mappings: Mapping<Data>[]);
+    toSourceOffset(start: number): readonly [number, Mapping<Data>] | undefined;
+    toGeneratedOffset(start: number): readonly [number, Mapping<Data>] | undefined;
+    toSourceOffsets(start: number): Generator<readonly [number, Mapping<Data>], void, unknown>;
+    toGeneratedOffsets(start: number): Generator<readonly [number, Mapping<Data>], void, unknown>;
+    matcing(startOffset: number, from: 'sourceRange' | 'generatedRange', to: 'sourceRange' | 'generatedRange'): Generator<readonly [number, Mapping<Data>], void, unknown>;
+    matchOffset(start: number, mappedFromRange: [number, number], mappedToRange: [number, number]): number | undefined;
     private binarySearchMemo;
-    private getRange;
 }
+export declare function buildMappings<T>(chunks: SegmentWithoutData[] | SegmentWithData<T>[]): Mapping<T>[];

package/out/index.js

@@ -1,90 +1,42 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SourceMapBase = exports.Mode = void 0;
-const reactivity_1 = require("@vue/reactivity");
-var Mode;
-(function (Mode) {
-    /**
-     * @case1
-     * 123456 -> abcdef
-     * ^    ^    ^    ^
-     * @case2
-     * 123456 -> abcdef
-     *  ^  ^      ^  ^
-     * @case3
-     * 123456 -> abcdef
-     *   ^^        ^^
-     */
-    Mode[Mode["Offset"] = 1] = "Offset";
-    /**
-     * @case1
-     * 123456 -> abcdef
-     * ^    ^    ^    ^
-     * @case2
-     * 123456 -> abcdef
-     *  ^  ^     NOT_MATCH
-     * @case3
-     * 123456 -> abcdef
-     *   ^^      NOT_MATCH
-     */
-    Mode[Mode["Totally"] = 2] = "Totally";
-    /**
-     * @case1
-     * 123456 -> abcdef
-     * ^    ^    ^    ^
-     * @case2
-     * 123456 -> abcdef
-     *  ^  ^     ^    ^
-     * @case3
-     * 123456 -> abcdef
-     *   ^^      ^    ^
-     */
-    Mode[Mode["Expand"] = 3] = "Expand";
-})(Mode = exports.Mode || (exports.Mode = {}));
+exports.buildMappings = exports.SourceMapBase = void 0;
+__exportStar(require("muggle-string"), exports);
+;
 class SourceMapBase {
-    get mappings() {
-        return this.__mappings.value;
-    }
-    set mappings(value) {
-        this.__mappings.value = value;
-    }
-    constructor(_mappings) {
-        this.__mappings = (0, reactivity_1.shallowRef)([]);
-        this.__memo = (0, reactivity_1.computed)(() => {
+    get memo() {
+        if (!this._memo) {
             const self = this;
-            const source = createMemo('sourceRange');
-            const mapped = createMemo('mappedRange');
-            return {
-                source,
-                mapped,
+            this._memo = {
+                sourceRange: createMemo('sourceRange'),
+                generatedRange: createMemo('generatedRange'),
             };
             function createMemo(key) {
                 const offsets = new Set();
                 for (const mapping of self.mappings) {
-                    offsets.add(mapping[key].start);
-                    offsets.add(mapping[key].end);
-                    if (mapping.additional) {
-                        for (const addition of mapping.additional) {
-                            offsets.add(addition[key].start);
-                            offsets.add(addition[key].end);
-                        }
-                    }
+                    offsets.add(mapping[key][0]);
+                    offsets.add(mapping[key][1]);
                 }
                 const arr = [...offsets].sort((a, b) => a - b).map(offset => ({ offset, mappings: new Set() }));
                 for (const mapping of self.mappings) {
-                    const startIndex = binarySearch(mapping[key].start);
-                    const endIndex = binarySearch(mapping[key].end);
+                    const startIndex = binarySearch(mapping[key][0]);
+                    const endIndex = binarySearch(mapping[key][1]);
                     for (let i = startIndex; i <= endIndex; i++) {
                         arr[i].mappings.add(mapping);
                     }
-                    if (mapping.additional) {
-                        for (const addition of mapping.additional) {
-                            const startIndex = binarySearch(addition[key].start);
-                            const endIndex = binarySearch(addition[key].end);
-                            for (let i = startIndex; i <= endIndex; i++) {
-                                arr[i].mappings.add(mapping);
-                            }
-                        }
-                    }
                 }
                 return arr;
                 function binarySearch(start) {
@@ -105,59 +57,52 @@ class SourceMapBase {
                     }
                 }
             }
-        });
-        this.mappings = _mappings !== null && _mappings !== void 0 ? _mappings : [];
+        }
+        return this._memo;
+    }
+    constructor(mappings) {
+        this.mappings = mappings;
     }
-    getSourceRange(start, end, filter) {
-        for (const mapped of this.getRanges(start, end !== null && end !== void 0 ? end : start, false, filter)) {
+    toSourceOffset(start) {
+        for (const mapped of this.matcing(start, 'generatedRange', 'sourceRange')) {
             return mapped;
         }
     }
-    getMappedRange(start, end, filter) {
-        for (const mapped of this.getRanges(start, end !== null && end !== void 0 ? end : start, true, filter)) {
+    toGeneratedOffset(start) {
+        for (const mapped of this.matcing(start, 'sourceRange', 'generatedRange')) {
             return mapped;
         }
     }
-    getSourceRanges(start, end, filter) {
-        return this.getRanges(start, end !== null && end !== void 0 ? end : start, false, filter);
+    toSourceOffsets(start) {
+        return this.matcing(start, 'generatedRange', 'sourceRange');
     }
-    getMappedRanges(start, end, filter) {
-        return this.getRanges(start, end !== null && end !== void 0 ? end : start, true, filter);
+    toGeneratedOffsets(start) {
+        return this.matcing(start, 'sourceRange', 'generatedRange');
     }
-    *getRanges(startOffset, endOffset, sourceToTarget, filter) {
-        const memo = this.__memo.value;
-        const _memo = sourceToTarget ? memo.source : memo.mapped;
-        if (_memo.length === 0)
+    *matcing(startOffset, from, to) {
+        const memo = this.memo[from];
+        if (memo.length === 0)
             return;
-        const { low: start, high: end, } = startOffset === endOffset ? this.binarySearchMemo(_memo, startOffset) : {
-            low: this.binarySearchMemo(_memo, startOffset).low,
-            high: this.binarySearchMemo(_memo, endOffset).high,
-        };
+        const { low: start, high: end, } = this.binarySearchMemo(memo, startOffset);
         const skip = new Set();
         for (let i = start; i <= end; i++) {
-            for (const mapping of _memo[i].mappings) {
+            for (const mapping of memo[i].mappings) {
                 if (skip.has(mapping)) {
                     continue;
                 }
                 skip.add(mapping);
-                if (filter && !filter(mapping.data))
-                    continue;
-                const mapped = this.getRange(startOffset, endOffset, sourceToTarget, mapping.mode, mapping.sourceRange, mapping.mappedRange, mapping.data);
+                const mapped = this.matchOffset(startOffset, mapping[from], mapping[to]);
                 if (mapped) {
-                    yield mapped;
-                }
-                else if (mapping.additional) {
-                    for (const other of mapping.additional) {
-                        const mapped = this.getRange(startOffset, endOffset, sourceToTarget, other.mode, other.sourceRange, other.mappedRange, mapping.data);
-                        if (mapped) {
-                            yield mapped;
-                            break; // only return first match additional range
-                        }
-                    }
+                    yield [mapped, mapping];
                 }
             }
         }
     }
+    matchOffset(start, mappedFromRange, mappedToRange) {
+        if (start >= mappedFromRange[0] && start <= mappedFromRange[1]) {
+            return mappedToRange[0] + start - mappedFromRange[0];
+        }
+    }
     binarySearchMemo(array, start) {
         let low = 0;
         let high = array.length - 1;
@@ -181,40 +126,27 @@ class SourceMapBase {
             high: Math.min(Math.max(low, high, 0), array.length - 1),
         };
     }
-    getRange(start, end, sourceToTarget, mode, sourceRange, targetRange, data) {
-        const mappedToRange = sourceToTarget ? targetRange : sourceRange;
-        const mappedFromRange = sourceToTarget ? sourceRange : targetRange;
-        if (mode === Mode.Totally) {
-            if (start === mappedFromRange.start && end === mappedFromRange.end) {
-                const _start = mappedToRange.start;
-                const _end = mappedToRange.end;
-                return [{
-                        start: Math.min(_start, _end),
-                        end: Math.max(_start, _end),
-                    }, data];
-            }
-        }
-        else if (mode === Mode.Offset) {
-            if (start >= mappedFromRange.start && end <= mappedFromRange.end) {
-                const _start = mappedToRange.start + start - mappedFromRange.start;
-                const _end = mappedToRange.end + end - mappedFromRange.end;
-                return [{
-                        start: Math.min(_start, _end),
-                        end: Math.max(_start, _end),
-                    }, data];
-            }
+}
+exports.SourceMapBase = SourceMapBase;
+function buildMappings(chunks) {
+    let length = 0;
+    const mappings = [];
+    for (const segment of chunks) {
+        if (typeof segment === 'string') {
+            length += segment.length;
         }
-        else if (mode === Mode.Expand) {
-            if (start >= mappedFromRange.start && end <= mappedFromRange.end) {
-                const _start = mappedToRange.start;
-                const _end = mappedToRange.end;
-                return [{
-                        start: Math.min(_start, _end),
-                        end: Math.max(_start, _end),
-                    }, data];
-            }
+        else {
+            mappings.push({
+                generatedRange: [length, length + segment[0].length],
+                source: segment[1],
+                sourceRange: typeof segment[2] === 'number' ? [segment[2], segment[2] + segment[0].length] : segment[2],
+                // @ts-ignore
+                data: segment[3],
+            });
+            length += segment[0].length;
         }
     }
+    return mappings;
 }
-exports.SourceMapBase = SourceMapBase;
+exports.buildMappings = buildMappings;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/source-map",
-	"version": "1.0.0-beta.0",
+	"version": "1.0.0-beta.2",
 	"main": "out/index.js",
 	"license": "MIT",
 	"files": [
@@ -13,7 +13,7 @@
 		"directory": "packages/source-map"
 	},
 	"dependencies": {
-		"@vue/reactivity": "^3.2.38"
+		"muggle-string": "^0.1.0"
 	},
-	"gitHead": "e93a2cf6e614f6c8fa9b8a61e314c123cbe9a95a"
+	"gitHead": "a523013ad349e28c9d0a7d9ad3f0c0834e0067e7"
 }