@fulcro/transform-core 0.8.1 → 0.10.0

package/dist/rewrite/languageService/index.js

@@ -0,0 +1,286 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLanguageServicePlugin = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const fixpoint_1 = require("../fixpoint/index.js");
+/**
+ * A file name as the program spells it: forward slashes on every platform.
+ * `tsserver` and a host may hand either spelling over, and a map keyed by one
+ * would never be found by the other.
+ *
+ * @param fileName File name in either spelling.
+ * @returns The program's spelling.
+ */
+const normalized = (fileName) => fileName.replace(/\\/g, '/');
+/** The map of a file the rewrite did not touch: every offset is itself. */
+const UNCHANGED = {
+    text: '',
+    toOriginal: (generated) => generated,
+    toGenerated: (original) => original,
+};
+/**
+ * Maps a span of the rewritten text back to the original.
+ *
+ * @param span Span in the rewritten text.
+ * @param map Map of the file.
+ * @returns The span in the original text.
+ */
+const spanToOriginal = (span, map) => {
+    const start = map.toOriginal(span.start);
+    if (span.length === 0)
+        return { start, length: 0 };
+    // The end is exclusive, so it can sit exactly where a copied piece stops
+    // and synthesized text begins, and would map to the start of the rewritten
+    // node. The last character of the span is inside the span; mapping it and
+    // stepping one past lands where the span really ends.
+    const end = map.toOriginal(span.start + span.length - 1) + 1;
+    return { start, length: Math.max(0, end - start) };
+};
+/**
+ * Removes the namespace the rewrite imports from text shown to the reader.
+ *
+ * The checker names a type by the shortest path it can reach it through, and
+ * in a rewritten file that is often the namespace import the rewrite added —
+ * `__fulcroTypes.SignedInteger<32>`, a name the author never wrote.
+ *
+ * @param namespace Local name of the import.
+ * @returns The cleaner.
+ */
+const withoutNamespace = (namespace) => (text) => text.split(`${namespace}.`).join('');
+/**
+ * Builds the shadow of a language service: the same project, every file read
+ * through the rewrite.
+ *
+ * @param info What `tsserver` handed the plugin.
+ * @param rewriter What to rewrite.
+ * @returns The shadow, and the rewrite it is currently built on.
+ */
+const createShadow = (info, rewriter) => {
+    const base = info.languageServiceHost;
+    const texts = new Map();
+    // Bumped on every text handed back, so the shadow re-reads exactly the
+    // files the rewrite changed.
+    let generation = 0;
+    const host = Object.create(base, {
+        getScriptSnapshot: {
+            value: (fileName) => {
+                const text = texts.get(normalized(fileName));
+                return text === undefined
+                    ? base.getScriptSnapshot(fileName)
+                    : typescript_1.default.ScriptSnapshot.fromString(text);
+            },
+        },
+        getScriptVersion: {
+            value: (fileName) => texts.has(normalized(fileName))
+                ? `${base.getScriptVersion(fileName)}:rewritten:${generation}`
+                : base.getScriptVersion(fileName),
+        },
+        getProjectVersion: {
+            value: () => `${base.getProjectVersion?.() ?? ''}:${generation}`,
+        },
+    });
+    const service = typescript_1.default.createLanguageService(host, typescript_1.default.createDocumentRegistry());
+    let settledFor;
+    let current;
+    /**
+     * The rewrite for the project as it stands, recomputed only when the
+     * original project changed.
+     *
+     * @returns The rewrite.
+     */
+    const rewrite = () => {
+        const version = base.getProjectVersion?.() ??
+            base
+                .getScriptFileNames()
+                .map((fileName) => base.getScriptVersion(fileName))
+                .join('|');
+        if (current !== undefined && settledFor === version)
+            return current;
+        texts.clear();
+        generation++;
+        current = (0, fixpoint_1.rewriteToFixpoint)({
+            program: () => {
+                const program = service.getProgram();
+                if (program === undefined) {
+                    throw new Error('The shadow language service produced no program.');
+                }
+                return program;
+            },
+            update: (fileName, text) => {
+                texts.set(normalized(fileName), text);
+                generation++;
+            },
+        }, rewriter);
+        settledFor = version;
+        return current;
+    };
+    return { service, rewrite };
+};
+/**
+ * Builds the `tsserver` plugin of a rewriter.
+ *
+ * @param rewriter What to rewrite.
+ * @returns The plugin module, as `tsserver` loads it.
+ */
+const createLanguageServicePlugin = (rewriter) => () => ({
+    create: (info) => {
+        const original = info.languageService;
+        const shadow = createShadow(info, rewriter);
+        /**
+         * The map of a file, when the rewrite touched it.
+         *
+         * @param fileName File being asked about.
+         * @returns Its map, or `undefined` when it reads as written.
+         */
+        const mapOf = (fileName) => shadow.rewrite().files.get(normalized(fileName));
+        const clean = withoutNamespace(rewriter.namespace);
+        /**
+         * Removes the rewrite's namespace from the parts of a display.
+         *
+         * @param parts Display parts, when there are any.
+         * @returns The same parts, cleaned.
+         */
+        const cleanParts = (parts) => 
+        // A display names the namespace as a part of its own, followed by
+        // a `.` part; both go, and any text naming it inline is cleaned.
+        parts
+            ?.filter((part, index) => !(part.text === rewriter.namespace &&
+            parts[index + 1]?.text === '.') &&
+            !(part.text === '.' &&
+                parts[index - 1]?.text === rewriter.namespace))
+            .map((part) => ({ ...part, text: clean(part.text) }));
+        /**
+         * Removes the rewrite's namespace from a diagnostic message, however
+         * deeply it is chained.
+         *
+         * @param message The message.
+         * @returns The message, cleaned.
+         */
+        const cleanMessage = (message) => typeof message === 'string'
+            ? clean(message)
+            : {
+                ...message,
+                messageText: clean(message.messageText),
+                next: message.next?.map((next) => cleanMessage(next)),
+            };
+        /**
+         * Maps the diagnostics of one file back to its original text.
+         *
+         * @param fileName File the diagnostics are about.
+         * @param diagnostics Diagnostics from the shadow.
+         * @returns The same diagnostics, in the original's positions.
+         */
+        const mapDiagnostics = (fileName, diagnostics) => {
+            const map = mapOf(fileName);
+            const sourceFile = original
+                .getProgram()
+                ?.getSourceFile(fileName);
+            return diagnostics.map((diagnostic) => {
+                const messageText = cleanMessage(diagnostic.messageText);
+                if (map === undefined || diagnostic.start === undefined) {
+                    return {
+                        ...diagnostic,
+                        messageText,
+                        file: sourceFile ?? diagnostic.file,
+                    };
+                }
+                const span = spanToOriginal({ start: diagnostic.start, length: diagnostic.length ?? 0 }, map);
+                return {
+                    ...diagnostic,
+                    messageText,
+                    file: sourceFile ?? diagnostic.file,
+                    start: span.start,
+                    length: span.length,
+                };
+            });
+        };
+        /**
+         * Maps a position into the shadow, asks it, and maps the answer back.
+         *
+         * @param fileName File asked about.
+         * @param position Position in the original text.
+         * @param ask The question, put to the shadow at the mapped position.
+         * @param fromShadow Maps what the shadow answered back.
+         * @returns The mapped answer.
+         */
+        const atPosition = (fileName, position, ask, fromShadow) => {
+            // A file the rewrite left alone still gets its answer mapped: a
+            // definition it points to may sit in a file that was rewritten.
+            const map = mapOf(fileName) ?? UNCHANGED;
+            return fromShadow(ask(shadow.service, map.toGenerated(position)), map);
+        };
+        /**
+         * Maps a definition back when it points into a rewritten file.
+         *
+         * @param definition A definition or a reference.
+         * @returns The same, in original positions.
+         */
+        const mapLocation = (definition) => {
+            const map = mapOf(definition.fileName);
+            return map === undefined
+                ? definition
+                : {
+                    ...definition,
+                    textSpan: spanToOriginal(definition.textSpan, map),
+                };
+        };
+        const proxy = Object.create(original);
+        // The rewrite is brought up to date before the shadow is asked, so the
+        // shadow answers about the rewritten text and not the one before it.
+        proxy.getSemanticDiagnostics = (fileName) => {
+            shadow.rewrite();
+            return mapDiagnostics(fileName, shadow.service.getSemanticDiagnostics(fileName));
+        };
+        proxy.getSuggestionDiagnostics = (fileName) => {
+            shadow.rewrite();
+            return mapDiagnostics(fileName, shadow.service.getSuggestionDiagnostics(fileName));
+        };
+        proxy.getQuickInfoAtPosition = (fileName, position, ...rest) => atPosition(fileName, position, (service, at) => service.getQuickInfoAtPosition(fileName, at, ...rest), (answer, map) => answer === undefined
+            ? answer
+            : {
+                ...answer,
+                textSpan: spanToOriginal(answer.textSpan, map),
+                displayParts: cleanParts(answer.displayParts),
+                documentation: cleanParts(answer.documentation),
+            });
+        proxy.getCompletionsAtPosition = (fileName, position, ...rest) => atPosition(fileName, position, (service, at) => service.getCompletionsAtPosition(fileName, at, ...rest), (answer, map) => answer === undefined
+            ? answer
+            : {
+                ...answer,
+                optionalReplacementSpan: answer.optionalReplacementSpan === undefined
+                    ? undefined
+                    : spanToOriginal(answer.optionalReplacementSpan, map),
+                entries: answer.entries.map((entry) => entry.replacementSpan === undefined
+                    ? entry
+                    : {
+                        ...entry,
+                        replacementSpan: spanToOriginal(entry.replacementSpan, map),
+                    }),
+            });
+        proxy.getCompletionEntryDetails = (fileName, position, ...rest) => atPosition(fileName, position, (service, at) => service.getCompletionEntryDetails(fileName, at, ...rest), (answer) => answer === undefined
+            ? answer
+            : {
+                ...answer,
+                displayParts: cleanParts(answer.displayParts) ?? [],
+            });
+        proxy.getSignatureHelpItems = (fileName, position, ...rest) => atPosition(fileName, position, (service, at) => service.getSignatureHelpItems(fileName, at, ...rest), (answer, map) => answer === undefined
+            ? answer
+            : {
+                ...answer,
+                applicableSpan: spanToOriginal(answer.applicableSpan, map),
+            });
+        proxy.getDefinitionAtPosition = (fileName, position, ...rest) => atPosition(fileName, position, (service, at) => service.getDefinitionAtPosition(fileName, at, ...rest), (answer) => answer?.map(mapLocation));
+        proxy.getDefinitionAndBoundSpan = (fileName, position) => atPosition(fileName, position, (service, at) => service.getDefinitionAndBoundSpan(fileName, at), (answer, map) => answer === undefined
+            ? answer
+            : {
+                textSpan: spanToOriginal(answer.textSpan, map),
+                definitions: answer.definitions?.map(mapLocation),
+            });
+        proxy.getTypeDefinitionAtPosition = (fileName, position) => atPosition(fileName, position, (service, at) => service.getTypeDefinitionAtPosition(fileName, at), (answer) => answer?.map(mapLocation));
+        return proxy;
+    },
+});
+exports.createLanguageServicePlugin = createLanguageServicePlugin;

package/dist/rewrite/programTransformer/index.d.ts

@@ -0,0 +1,44 @@
+import typescript from 'typescript';
+import { type ExpressionRewriter } from '../file/index.js';
+import { type ProgramRewrite } from '../fixpoint/index.js';
+/**
+ * The `tsc` integration of a rewrite that has to happen before type checking.
+ *
+ * `ts-patch` offers two kinds of plugin. The ordinary one, a `before`
+ * transformer, runs on a program that has already been type checked, which is
+ * too late: `decimal * decimal` has been reported as an error by then. The other
+ * — `"transformProgram": true` in the tsconfig entry — is handed the program as
+ * it is created and returns the one `tsc` goes on to check and emit. That is
+ * where this runs: it rewrites the program to a fixed point and returns the
+ * rewritten one, so what gets checked is what the rewrite produced.
+ *
+ * ```json
+ * { "plugins": [{ "transform": "@fulcro/types/transformer", "transformProgram": true }] }
+ * ```
+ */
+/** The shape `ts-patch` expects from a program transformer. */
+export type ProgramTransformer = (program: typescript.Program, host?: typescript.CompilerHost, config?: unknown, extras?: unknown) => typescript.Program;
+/**
+ * Rewrites an existing program, returning the rewritten program with what the
+ * rewrite did.
+ *
+ * @param program Program to rewrite.
+ * @param host Host it was created with; a default one when not given.
+ * @param rewriter What to rewrite.
+ * @returns The rewritten program, and the rewrite.
+ */
+export declare const rewriteProgram: (program: typescript.Program, host: typescript.CompilerHost | undefined, rewriter: ExpressionRewriter) => {
+    readonly program: typescript.Program;
+    readonly rewrite: ProgramRewrite;
+};
+/**
+ * Builds the program transformer of a rewriter.
+ *
+ * Guarded against itself: the new program is made with `createProgram`, which
+ * `ts-patch` has patched to run program transformers, so without the guard the
+ * transformer would be invoked on its own output, recursively.
+ *
+ * @param rewriter What to rewrite.
+ * @returns The program transformer, as `ts-patch` expects it.
+ */
+export declare const createProgramTransformer: (rewriter: ExpressionRewriter) => ProgramTransformer;

package/dist/rewrite/programTransformer/index.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProgramTransformer = exports.rewriteProgram = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const fixpoint_1 = require("../fixpoint/index.js");
+/**
+ * Serves the rewritten texts in place of the files on disk, and parses each
+ * once per text.
+ *
+ * @param base Host the program was created with.
+ * @param texts Rewritten texts by file name.
+ * @param languageVersion Target the files are parsed for.
+ * @param seed Program whose files are reused as they are.
+ * @returns A host reading through the rewrite.
+ */
+const overlayHost = (base, texts, languageVersion, seed) => {
+    const parsed = new Map();
+    // Every file the rewrite did not touch is handed back as the same object on
+    // every pass. `createProgram` reuses an old program's file only when the
+    // host returns the identical object, so a host that parsed the standard
+    // library afresh each time would make every pass re-check it from nothing.
+    const unchanged = new Map(seed.getSourceFiles().map((file) => [file.fileName, file]));
+    return {
+        ...base,
+        getSourceFile: (fileName, options, onError, shouldCreate) => {
+            const text = texts.get(fileName);
+            if (text === undefined) {
+                if (!unchanged.has(fileName)) {
+                    unchanged.set(fileName, base.getSourceFile(fileName, options, onError, shouldCreate));
+                }
+                return unchanged.get(fileName);
+            }
+            const cached = parsed.get(fileName);
+            if (cached !== undefined && cached.text === text)
+                return cached;
+            const sourceFile = typescript_1.default.createSourceFile(fileName, text, typeof options === 'object' ? options : languageVersion, true);
+            parsed.set(fileName, sourceFile);
+            return sourceFile;
+        },
+        readFile: (fileName) => texts.get(fileName) ?? base.readFile(fileName),
+        fileExists: (fileName) => texts.has(fileName) || base.fileExists(fileName),
+    };
+};
+/**
+ * Rewrites an existing program, returning the rewritten program with what the
+ * rewrite did.
+ *
+ * @param program Program to rewrite.
+ * @param host Host it was created with; a default one when not given.
+ * @param rewriter What to rewrite.
+ * @returns The rewritten program, and the rewrite.
+ */
+const rewriteProgram = (program, host, rewriter) => {
+    const options = program.getCompilerOptions();
+    const base = host ?? typescript_1.default.createCompilerHost(options, true);
+    const texts = new Map();
+    const overlay = overlayHost(base, texts, options.target ?? typescript_1.default.ScriptTarget.ES2022, program);
+    let current = program;
+    let stale = false;
+    const rewrite = (0, fixpoint_1.rewriteToFixpoint)({
+        program: () => {
+            if (stale) {
+                current = typescript_1.default.createProgram({
+                    rootNames: program.getRootFileNames(),
+                    options,
+                    host: overlay,
+                    oldProgram: current,
+                    projectReferences: program.getProjectReferences(),
+                });
+                stale = false;
+            }
+            return current;
+        },
+        update: (fileName, text) => {
+            texts.set(fileName, text);
+            stale = true;
+        },
+    }, rewriter);
+    return { program: current, rewrite };
+};
+exports.rewriteProgram = rewriteProgram;
+/**
+ * Builds the program transformer of a rewriter.
+ *
+ * Guarded against itself: the new program is made with `createProgram`, which
+ * `ts-patch` has patched to run program transformers, so without the guard the
+ * transformer would be invoked on its own output, recursively.
+ *
+ * @param rewriter What to rewrite.
+ * @returns The program transformer, as `ts-patch` expects it.
+ */
+const createProgramTransformer = (rewriter) => {
+    let running = false;
+    return (program, host) => {
+        if (running)
+            return program;
+        running = true;
+        try {
+            return (0, exports.rewriteProgram)(program, host, rewriter).program;
+        }
+        finally {
+            running = false;
+        }
+    };
+};
+exports.createProgramTransformer = createProgramTransformer;

package/dist/rewrite/text/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * 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.
+ */
+/** A rewritten text and the two directions of its position map. */
+export interface RewrittenText {
+    /** The rewritten text. */
+    readonly text: string;
+    /**
+     * Maps an offset in the rewritten text to the original.
+     *
+     * @param generated Offset in {@link RewrittenText.text}.
+     * @returns The offset in the original text it came from.
+     */
+    readonly toOriginal: (generated: number) => number;
+    /**
+     * Maps an offset in the original text to the rewritten one.
+     *
+     * @param original Offset in the original text.
+     * @returns The offset in {@link RewrittenText.text} it went to.
+     */
+    readonly toGenerated: (original: number) => number;
+}
+/** Accumulates the output of a rewrite and its map. */
+export interface TextBuilder {
+    /** Copies a span of the original text verbatim. */
+    readonly copy: (start: number, end: number) => void;
+    /** Writes synthesized text, which maps to the enclosing region. */
+    readonly write: (text: string) => void;
+    /** Opens the region of a rewritten node; returns the handle to close it. */
+    readonly open: (originalStart: number, originalEnd: number) => () => void;
+    /** Whether any region was opened, which is whether anything was rewritten. */
+    readonly rewrote: () => boolean;
+    /** Finishes the text. */
+    readonly build: () => RewrittenText;
+}
+/**
+ * Starts the output of a rewrite over an original text.
+ *
+ * @param original The text being rewritten.
+ * @returns The builder.
+ */
+export declare const createTextBuilder: (original: string) => TextBuilder;
+/**
+ * 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.
+ */
+export declare const composeRewrites: (first: RewrittenText, second: RewrittenText) => RewrittenText;

package/dist/rewrite/text/index.js

@@ -0,0 +1,161 @@
+"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;

package/dist/unplugin/index.d.mts

@@ -1,5 +1,6 @@
 import { type UnpluginFactory, type UnpluginInstance } from 'unplugin';
 import { type TransformCoreOptions } from '../program/index.js';
+import { type ExpressionRewriter } from '../rewrite/file/index.js';
 import { type CallRewriter } from '../shared/index.js';
 /**
  * Bundler adapters for the Fulcro transformers.
@@ -54,4 +55,14 @@ export interface TransformerUnplugin {
  * @returns Every adapter `unplugin` can produce.
  */
 export declare const createTransformerUnplugin: (rewriters: readonly CallRewriter[], name: string) => TransformerUnplugin;
+/**
+ * Builds the bundler adapters for a rewrite that happens before type checking
+ * — one whose output is what the checker would read, such as the operators of
+ * `@fulcro/types`.
+ *
+ * @param rewriter Rewriter of the package publishing the plugin.
+ * @param name Name the plugin reports to the bundler.
+ * @returns Every adapter `unplugin` can produce.
+ */
+export declare const createRewriterUnplugin: (rewriter: ExpressionRewriter, name: string) => TransformerUnplugin;
 export {};