@boperators/webpack-loader 0.3.0 → 0.3.1

package/dist/toRawSourceMap.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRawSourceMap = toRawSourceMap;
+/**
+ * Convert boperators EditRecord[] into a V3 RawSourceMap.
+ *
+ * Generates line-level mappings: unchanged regions map 1:1, and edit
+ * boundaries map back to the start of the original edit region.
+ */
+function toRawSourceMap(edits, originalText, transformedText, fileName) {
+    const origLineStarts = buildLineStarts(originalText);
+    const transLineStarts = buildLineStarts(transformedText);
+    // Each segment is [transCol, sourceIndex, origLine, origCol]
+    // We only have one source (index 0), so sourceIndex is always 0.
+    const mappingLines = [];
+    const transLineCount = transLineStarts.length;
+    // Initialise empty lines
+    for (let i = 0; i < transLineCount; i++) {
+        mappingLines.push([]);
+    }
+    // For positions outside any edit, the mapping is identity + accumulated delta.
+    // For positions inside an edit's transformed region, map to the original edit start.
+    // We generate one segment per transformed line start.
+    for (let transLine = 0; transLine < transLineCount; transLine++) {
+        const transOffset = transLineStarts[transLine];
+        const origOffset = transformedToOriginal(edits, transOffset);
+        const { line: origLine, col: origCol } = offsetToLineCol(origLineStarts, origOffset);
+        mappingLines[transLine].push([0, 0, origLine, origCol]);
+    }
+    return {
+        version: 3,
+        file: fileName,
+        sources: [fileName],
+        sourcesContent: [originalText],
+        names: [],
+        mappings: encodeMappings(mappingLines),
+    };
+}
+/** Map a transformed-source offset back to the original source. */
+function transformedToOriginal(edits, pos) {
+    let delta = 0;
+    for (const edit of edits) {
+        if (pos < edit.transStart) {
+            break;
+        }
+        if (pos < edit.transEnd) {
+            return edit.origStart;
+        }
+        delta = edit.origEnd - edit.transEnd;
+    }
+    return pos + delta;
+}
+/** Build an array where index i is the character offset of line i. */
+function buildLineStarts(text) {
+    const starts = [0];
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === "\n") {
+            starts.push(i + 1);
+        }
+    }
+    return starts;
+}
+/** Convert a character offset to 0-based line and column. */
+function offsetToLineCol(lineStarts, offset) {
+    // Binary search for the line containing this offset
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >>> 1;
+        if (lineStarts[mid] <= offset) {
+            lo = mid;
+        }
+        else {
+            hi = mid - 1;
+        }
+    }
+    return { line: lo, col: offset - lineStarts[lo] };
+}
+/** Encode segment arrays into a VLQ mappings string. */
+function encodeMappings(lines) {
+    let prevTransCol = 0;
+    let prevOrigLine = 0;
+    let prevOrigCol = 0;
+    let prevSourceIdx = 0;
+    const lineStrings = [];
+    for (const segments of lines) {
+        prevTransCol = 0; // reset column tracking per line
+        const segStrings = [];
+        for (const seg of segments) {
+            const [transCol, sourceIdx, origLine, origCol] = seg;
+            segStrings.push(encodeVLQ(transCol - prevTransCol) +
+                encodeVLQ(sourceIdx - prevSourceIdx) +
+                encodeVLQ(origLine - prevOrigLine) +
+                encodeVLQ(origCol - prevOrigCol));
+            prevTransCol = transCol;
+            prevSourceIdx = sourceIdx;
+            prevOrigLine = origLine;
+            prevOrigCol = origCol;
+        }
+        lineStrings.push(segStrings.join(","));
+    }
+    return lineStrings.join(";");
+}
+const VLQ_BASE = 32;
+const VLQ_BASE_MASK = VLQ_BASE - 1;
+const VLQ_CONTINUATION = VLQ_BASE;
+const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/** Encode a single integer as a VLQ base64 string. */
+function encodeVLQ(value) {
+    let vlq = value < 0 ? (-value << 1) | 1 : value << 1;
+    let result = "";
+    do {
+        let digit = vlq & VLQ_BASE_MASK;
+        vlq >>>= 5;
+        if (vlq > 0) {
+            digit |= VLQ_CONTINUATION;
+        }
+        result += BASE64_CHARS[digit];
+    } while (vlq > 0);
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@boperators/webpack-loader",
-	"version": "0.3.0",
+	"version": "0.3.1",
 	"license": "MIT",
 	"description": "webpack loader for boperators",
 	"repository": {
@@ -37,7 +37,7 @@
 		"dist"
 	],
 	"peerDependencies": {
-		"boperators": "0.3.0",
+		"boperators": "0.3.1",
 		"typescript": ">=5.0.0 <5.10.0"
 	},
 	"devDependencies": {