@fulcro/transform-core 0.10.0 → 0.11.0

package/dist/rewrite/text/index.js

@@ -1,161 +0,0 @@
-"use strict";
-/**
- * Text produced by rewriting a source file, with the map back to the original.
- *
- * A rewrite that happens before type checking changes the text the checker,
- * the emitter and the editor all read, and every one of them reports positions
- * in it. For those positions to mean anything to the person who wrote the
- * original, the rewrite keeps a record of where each piece of its output came
- * from — the same idea as a source map, kept as offsets rather than lines,
- * because the language service speaks in offsets.
- *
- * The output is made of two kinds of piece. A **copy** is original text moved
- * verbatim, and maps offset for offset. A **region** is the output of one
- * rewritten node; any position inside it that is not also inside a copy — the
- * synthesized `T.add(` around two operands — maps to the start of the node it
- * replaced, which is where an error about it belongs.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.composeRewrites = exports.createTextBuilder = void 0;
-/**
- * Finds the last entry whose start is at or before an offset.
- *
- * @param entries Entries sorted by the key.
- * @param key The start of an entry.
- * @param offset Offset looked up.
- * @returns The index, or -1.
- */
-const floorIndex = (entries, key, offset) => {
-    let low = 0;
-    let high = entries.length - 1;
-    let found = -1;
-    while (low <= high) {
-        const middle = (low + high) >> 1;
-        if (key(entries[middle]) <= offset) {
-            found = middle;
-            low = middle + 1;
-        }
-        else {
-            high = middle - 1;
-        }
-    }
-    return found;
-};
-/**
- * Starts the output of a rewrite over an original text.
- *
- * @param original The text being rewritten.
- * @returns The builder.
- */
-const createTextBuilder = (original) => {
-    const pieces = [];
-    const copies = [];
-    const regions = [];
-    let position = 0;
-    const copy = (start, end) => {
-        if (end <= start)
-            return;
-        copies.push({
-            originalStart: start,
-            generatedStart: position,
-            length: end - start,
-        });
-        pieces.push(original.slice(start, end));
-        position += end - start;
-    };
-    const write = (text) => {
-        pieces.push(text);
-        position += text.length;
-    };
-    const open = (originalStart, originalEnd) => {
-        const generatedStart = position;
-        return () => {
-            regions.push({
-                originalStart,
-                originalEnd,
-                generatedStart,
-                generatedEnd: position,
-            });
-        };
-    };
-    const build = () => {
-        const text = pieces.join('');
-        // A region closes after the regions nested in it, so sorting by start —
-        // and, at equal starts, the wider first — puts the innermost last among
-        // those containing any given offset.
-        const byGenerated = [...regions].sort((left, right) => left.generatedStart - right.generatedStart ||
-            right.generatedEnd - left.generatedEnd);
-        const byOriginal = [...regions].sort((left, right) => left.originalStart - right.originalStart ||
-            right.originalEnd - left.originalEnd);
-        const innermost = (sorted, start, end, offset) => {
-            let best;
-            for (const region of sorted) {
-                if (start(region) > offset)
-                    break;
-                if (offset < end(region))
-                    best = region;
-            }
-            return best;
-        };
-        const toOriginal = (generated) => {
-            const index = floorIndex(copies, (entry) => entry.generatedStart, generated);
-            const candidate = copies[index];
-            if (candidate !== undefined &&
-                generated < candidate.generatedStart + candidate.length) {
-                return candidate.originalStart + (generated - candidate.generatedStart);
-            }
-            const region = innermost(byGenerated, (entry) => entry.generatedStart, (entry) => entry.generatedEnd, generated);
-            if (region !== undefined)
-                return region.originalStart;
-            // Past the last copy, or inside text written outside any region:
-            // the end of the copy before it is the nearest original position.
-            return candidate === undefined
-                ? 0
-                : candidate.originalStart + candidate.length;
-        };
-        const toGenerated = (originalOffset) => {
-            // Copies are in output order, so the first one holding the offset is
-            // the earliest in the output — which is the one that counts when a
-            // node was written twice, as the target of a compound assignment is.
-            //
-            // A copy that contains the offset wins over one that merely ends at
-            // it: the start of an operand is also the end of the copy before its
-            // operator, and answering with that copy's end would land on the
-            // synthesized text in front of the operand rather than on the operand.
-            // Only when nothing contains it — the position just after the last
-            // word of a file — does a copy ending there count.
-            const holder = copies.find((entry) => entry.originalStart <= originalOffset &&
-                originalOffset < entry.originalStart + entry.length) ??
-                copies.find((entry) => entry.originalStart <= originalOffset &&
-                    originalOffset === entry.originalStart + entry.length);
-            if (holder !== undefined) {
-                return holder.generatedStart + (originalOffset - holder.originalStart);
-            }
-            const region = innermost(byOriginal, (entry) => entry.originalStart, (entry) => entry.originalEnd, originalOffset);
-            return region === undefined ? originalOffset : region.generatedStart;
-        };
-        return { text, toOriginal, toGenerated };
-    };
-    return {
-        copy,
-        write,
-        open,
-        rewrote: () => regions.length > 0,
-        build,
-    };
-};
-exports.createTextBuilder = createTextBuilder;
-/**
- * Chains two rewrites of the same file, the second applied to the output of the
- * first, into one map from the last text back to the original.
- *
- * @param first The earlier rewrite.
- * @param second The later one, over the earlier one's text.
- * @returns The combined rewrite.
- */
-const composeRewrites = (first, second) => ({
-    text: second.text,
-    toOriginal: (generated) => first.toOriginal(second.toOriginal(generated)),
-    toGenerated: (original) => second.toGenerated(first.toGenerated(original)),
-});
-exports.composeRewrites = composeRewrites;