vite-plugin-taro 0.6.0 → 0.6.2

package/dist/node/plugins/wx/render/system-js/string-editor.js

@@ -0,0 +1,93 @@
+/**
+ * Records non-overlapping range edits and renders them in one source-order pass.
+ *
+ * Final WX development chunks do not request source maps. RolldownMagicString's repeated relocation of hundreds of hoisted
+ * functions is considerably more expensive than the semantic analysis itself, so this editor keeps the same range operations
+ * while avoiding a mutable chunk graph when no mappings can be observed.
+ */
+export class StringEditor {
+    original;
+    // These journals are the editor's intentionally mutable transaction; rendering reads but never changes them.
+    #insertions = new Map();
+    #replacements = [];
+    constructor(original) {
+        this.original = original;
+    }
+    /** Records a half-open replacement; semantic passes guarantee ranges are nested or disjoint. */
+    overwrite(start, end, content) {
+        this.#replacements.push({ content, end, start });
+    }
+    /** Removes a range and discards insertions that were owned only by that removed source. */
+    remove(start, end) {
+        this.overwrite(start, end, '');
+        // Removed ranges own their boundary insertions; hoisted function text has already rendered those edits separately.
+        for (const position of this.#insertions.keys()) {
+            if (position >= start && position <= end)
+                this.#insertions.delete(position);
+        }
+    }
+    /** Inserts before prior insertions at a boundary, matching MagicString's prependLeft ordering. */
+    prependLeft(position, content) {
+        const insertions = this.#insertionAt(position);
+        insertions.prepend.unshift(content);
+    }
+    /** Inserts after prior insertions at the left side of a boundary. */
+    appendLeft(position, content) {
+        const insertions = this.#insertionAt(position);
+        insertions.append.push(content);
+    }
+    /** Matches the subset of appendRight ordering used by the capsule compiler. */
+    appendRight(position, content) {
+        const insertions = this.#insertionAt(position);
+        insertions.append.push(content);
+    }
+    /** Materializes one source slice without mutating its edit journal, allowing functions to be rendered before relocation. */
+    render(start, end) {
+        const replacements = this.#replacements
+            .filter((replacement) => replacement.start >= start && replacement.end <= end)
+            .sort((left, right) => left.start - right.start || right.end - left.end);
+        // The cursor advances monotonically; outer removals dominate nested edits when hoisted function ranges are removed.
+        let sourcePosition = start;
+        let output = '';
+        for (const replacement of replacements) {
+            if (replacement.end <= sourcePosition)
+                continue;
+            if (replacement.start < sourcePosition) {
+                throw new Error(`Partially overlapping source edits at ${replacement.start}:${replacement.end}`);
+            }
+            output += this.#renderOriginal(sourcePosition, replacement.start, false);
+            output += replacement.content;
+            sourcePosition = replacement.end;
+        }
+        output += this.#renderOriginal(sourcePosition, end, true);
+        return output;
+    }
+    #insertionAt(position) {
+        const existing = this.#insertions.get(position);
+        if (existing)
+            return existing;
+        // Each position owns mutable ordered lists because prependLeft reverses calls while appendRight preserves them.
+        const created = { append: [], prepend: [] };
+        this.#insertions.set(position, created);
+        return created;
+    }
+    #renderOriginal(start, end, includeEnd) {
+        const positions = [...this.#insertions.keys()]
+            .filter((position) => position >= start && (position < end || (includeEnd && position === end)))
+            .sort((left, right) => left - right);
+        // Segment rendering appends immutable source slices around the small ordered insertion set.
+        let sourcePosition = start;
+        let output = '';
+        for (const position of positions) {
+            output += this.original.slice(sourcePosition, position);
+            output += this.#renderInsertions(position);
+            sourcePosition = position;
+        }
+        output += this.original.slice(sourcePosition, end);
+        return output;
+    }
+    #renderInsertions(position) {
+        const insertions = this.#insertions.get(position);
+        return insertions ? `${insertions.prepend.join('')}${insertions.append.join('')}` : '';
+    }
+}

package/dist/node/plugins/wx/render/system-js/system-js.d.ts

@@ -0,0 +1,23 @@
+import { type ExistingRawSourceMap } from 'rolldown';
+export type SystemJsOutputFormat = 'system-register' | 'commonjs-registration';
+export type SystemJsReferenceKind = 'static' | 'dynamic';
+export type TransformSystemJsOptions = Readonly<{
+    /** Final JavaScript emitted by Rolldown with ES module syntax still present. */
+    code: string;
+    filename: string;
+    format: SystemJsOutputFormat;
+    sourcemap: boolean;
+    /** Converts physical Rolldown references into the logical IDs used by the WX capsule registry. */
+    resolveReference(reference: string, kind: SystemJsReferenceKind): string;
+}>;
+export type TransformSystemJsResult = Readonly<{
+    code: string;
+    map: ExistingRawSourceMap | null;
+}>;
+/**
+ * Converts one final Rolldown ES chunk into System.register data without rebuilding its complete AST through Babel.
+ *
+ * The compiler intentionally accepts Rolldown's normalized final-chunk grammar rather than arbitrary source modules. Every
+ * unsupported module declaration fails before source edits begin, so a future Rolldown output change cannot be miscompiled.
+ */
+export declare function transformSystemJs(options: TransformSystemJsOptions): TransformSystemJsResult;