@openrewrite/rewrite 8.66.0-SNAPSHOT → 8.66.1

package/dist/javascript/templating.js

@@ -1,1069 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Template = exports.MatchResult = exports.Pattern = exports._ = void 0;
-exports.capture = capture;
-exports.pattern = pattern;
-exports.template = template;
-exports.rewrite = rewrite;
-/*
- * Copyright 2025 the original author or authors.
- * <p>
- * Licensed under the Moderne Source Available License (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * <p>
- * https://docs.moderne.io/licensing/moderne-source-available-license
- * <p>
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-const _1 = require(".");
-const parser_1 = require("./parser");
-const visitor_1 = require("./visitor");
-const __1 = require("..");
-const java_1 = require("../java");
-const immer_1 = require("immer");
-const comparator_1 = require("./comparator");
-const dependency_workspace_1 = require("./dependency-workspace");
-const uuid_1 = require("../uuid");
-/**
- * Cache for compiled templates and patterns.
- * Stores parsed ASTs to avoid expensive re-parsing and dependency resolution.
- */
-class TemplateCache {
-    constructor() {
-        this.cache = new Map();
-    }
-    /**
-     * Generates a cache key from template string, captures, and options.
-     */
-    generateKey(templateString, captures, imports, dependencies) {
-        // Use the actual template string (with placeholders) as the primary key
-        const templateKey = templateString;
-        // Capture names
-        const capturesKey = captures.map(c => c.name).join(',');
-        // Imports
-        const importsKey = imports.join(';');
-        // Dependencies
-        const depsKey = JSON.stringify(dependencies || {});
-        return `${templateKey}::${capturesKey}::${importsKey}::${depsKey}`;
-    }
-    /**
-     * Gets a cached compilation unit or creates and caches a new one.
-     */
-    getOrParse(templateString, captures, imports, dependencies) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const key = this.generateKey(templateString, captures, imports, dependencies);
-            let cu = this.cache.get(key);
-            if (cu) {
-                return cu;
-            }
-            // Create workspace if dependencies are provided
-            // DependencyWorkspace has its own cache, so multiple templates with
-            // the same dependencies will automatically share the same workspace
-            let workspaceDir;
-            if (dependencies && Object.keys(dependencies).length > 0) {
-                workspaceDir = yield dependency_workspace_1.DependencyWorkspace.getOrCreateWorkspace(dependencies);
-            }
-            // Prepend imports for type attribution context
-            const fullTemplateString = imports.length > 0
-                ? imports.join('\n') + '\n' + templateString
-                : templateString;
-            // Parse and cache (workspace only needed during parsing)
-            const parser = new parser_1.JavaScriptParser({ relativeTo: workspaceDir });
-            const parseGenerator = parser.parse({ text: fullTemplateString, sourcePath: 'template.ts' });
-            cu = (yield parseGenerator.next()).value;
-            this.cache.set(key, cu);
-            return cu;
-        });
-    }
-    /**
-     * Clears the cache.
-     */
-    clear() {
-        this.cache.clear();
-    }
-}
-// Global cache instance
-const templateCache = new TemplateCache();
-/**
- * Marker that stores capture metadata on pattern AST nodes.
- * This avoids the need to parse capture names from identifiers during matching.
- */
-class CaptureMarker {
-    constructor(captureName) {
-        this.captureName = captureName;
-        this.kind = 'org.openrewrite.javascript.CaptureMarker';
-        this.id = (0, uuid_1.randomId)();
-    }
-}
-class CaptureImpl {
-    constructor(name) {
-        this.name = name;
-    }
-}
-/**
- * Creates a capture specification for use in template patterns.
- *
- * @param name Optional name for the capture. If not provided, an auto-generated name is used.
- * @returns A Capture object
- *
- * @example
- * // Named inline captures
- * const pattern = pattern`${capture('left')} + ${capture('right')}`;
- *
- * // Unnamed captures
- * const {left, right} = {left: capture(), right: capture()};
- * const pattern = pattern`${left} + ${right}`;
- *
- * // Repeated patterns using the same capture
- * const expr = capture('expr');
- * const redundantOr = pattern`${expr} || ${expr}`;
- */
-function capture(name) {
-    if (name) {
-        return new CaptureImpl(name);
-    }
-    return new CaptureImpl(`unnamed_${capture.nextUnnamedId++}`);
-}
-// Static counter for generating unique IDs for unnamed captures
-capture.nextUnnamedId = 1;
-/**
- * Concise alias for `capture`. Works well for inline captures in patterns and templates.
- *
- * @param name Optional name for the capture. If not provided, an auto-generated name is used.
- * @returns A Capture object
- *
- * @example
- * // Inline captures with _ alias
- * pattern`isDate(${_('dateArg')})`
- * template`${_('dateArg')} instanceof Date`
- */
-exports._ = capture;
-/**
- * Represents a pattern that can be matched against AST nodes.
- */
-class Pattern {
-    /**
-     * Gets the configuration options for this pattern.
-     * @readonly
-     */
-    get options() {
-        return this._options;
-    }
-    /**
-     * Creates a new pattern from template parts and captures.
-     *
-     * @param templateParts The string parts of the template
-     * @param captures The captures between the string parts
-     */
-    constructor(templateParts, captures) {
-        this.templateParts = templateParts;
-        this.captures = captures;
-        this._options = {};
-    }
-    /**
-     * Configures this pattern with additional options.
-     *
-     * @param options Configuration options
-     * @returns This pattern for method chaining
-     *
-     * @example
-     * pattern`isDate(${capture('date')})`
-     *     .configure({
-     *         imports: ['import { isDate } from "util"'],
-     *         dependencies: { 'util': '^1.0.0' }
-     *     })
-     */
-    configure(options) {
-        this._options = Object.assign(Object.assign({}, this._options), options);
-        return this;
-    }
-    /**
-     * Creates a matcher for this pattern against a specific AST node.
-     *
-     * @param ast The AST node to match against
-     * @returns A Matcher object
-     */
-    match(ast) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const matcher = new Matcher(this, ast);
-            const success = yield matcher.matches();
-            return success ? new MatchResult(matcher.getAll()) : undefined;
-        });
-    }
-}
-exports.Pattern = Pattern;
-class MatchResult {
-    constructor(bindings = new Map()) {
-        this.bindings = bindings;
-    }
-    get(capture) {
-        const name = typeof capture === "string" ? capture : capture.name;
-        return this.bindings.get(name);
-    }
-}
-exports.MatchResult = MatchResult;
-/**
- * A comparator visitor that checks semantic equality including type attribution.
- * This ensures that patterns only match code with compatible types, not just
- * structurally similar code.
- */
-class JavaScriptTemplateSemanticallyEqualVisitor extends comparator_1.JavaScriptComparatorVisitor {
-    /**
-     * Checks if two types are semantically equal.
-     * For method types, this checks that the declaring type and method name match.
-     */
-    isOfType(target, source) {
-        if (!target || !source) {
-            return target === source;
-        }
-        if (target.kind !== source.kind) {
-            return false;
-        }
-        // For method types, check declaring type
-        // Note: We don't check the name field because it might not be fully resolved in patterns
-        // The method invocation visitor already checks that simple names match
-        if (target.kind === java_1.Type.Kind.Method && source.kind === java_1.Type.Kind.Method) {
-            const targetMethod = target;
-            const sourceMethod = source;
-            // Only check that declaring types match
-            return this.isOfType(targetMethod.declaringType, sourceMethod.declaringType);
-        }
-        // For fully qualified types, check the fully qualified name
-        if (java_1.Type.isFullyQualified(target) && java_1.Type.isFullyQualified(source)) {
-            return java_1.Type.FullyQualified.getFullyQualifiedName(target) ===
-                java_1.Type.FullyQualified.getFullyQualifiedName(source);
-        }
-        // Default: types are equal if they're the same kind
-        return true;
-    }
-    /**
-     * Override method invocation comparison to include type attribution checking.
-     * When types match semantically, we allow matching even if one has a receiver
-     * and the other doesn't (e.g., `isDate(x)` vs `util.isDate(x)`).
-     */
-    visitMethodInvocation(method, other) {
-        const _super = Object.create(null, {
-            visitMethodInvocation: { get: () => super.visitMethodInvocation }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            if (other.kind !== java_1.J.Kind.MethodInvocation) {
-                return method;
-            }
-            const otherMethod = other;
-            // Check basic structural equality first
-            if (method.name.simpleName !== otherMethod.name.simpleName ||
-                method.arguments.elements.length !== otherMethod.arguments.elements.length) {
-                this.abort();
-                return method;
-            }
-            // Check type attribution
-            // Both must have method types for semantic equality
-            if (!method.methodType || !otherMethod.methodType) {
-                // If template has type but target doesn't, they don't match
-                if (method.methodType || otherMethod.methodType) {
-                    this.abort();
-                    return method;
-                }
-                // If neither has type, fall through to structural comparison
-                return _super.visitMethodInvocation.call(this, method, other);
-            }
-            // Both have types - check they match semantically
-            const typesMatch = this.isOfType(method.methodType, otherMethod.methodType);
-            if (!typesMatch) {
-                // Types don't match - abort comparison
-                this.abort();
-                return method;
-            }
-            // Types match! Now we can ignore receiver differences and just compare arguments.
-            // This allows pattern `isDate(x)` to match both `isDate(x)` and `util.isDate(x)`
-            // when they have the same type attribution.
-            // Compare type parameters
-            if ((method.typeParameters === undefined) !== (otherMethod.typeParameters === undefined)) {
-                this.abort();
-                return method;
-            }
-            if (method.typeParameters && otherMethod.typeParameters) {
-                if (method.typeParameters.elements.length !== otherMethod.typeParameters.elements.length) {
-                    this.abort();
-                    return method;
-                }
-                for (let i = 0; i < method.typeParameters.elements.length; i++) {
-                    yield this.visit(method.typeParameters.elements[i].element, otherMethod.typeParameters.elements[i].element);
-                    if (!this.match)
-                        return method;
-                }
-            }
-            // Compare name (already checked simpleName above, but visit for markers/prefix)
-            yield this.visit(method.name, otherMethod.name);
-            if (!this.match)
-                return method;
-            // Compare arguments
-            for (let i = 0; i < method.arguments.elements.length; i++) {
-                yield this.visit(method.arguments.elements[i].element, otherMethod.arguments.elements[i].element);
-                if (!this.match)
-                    return method;
-            }
-            return method;
-        });
-    }
-    /**
-     * Override identifier comparison to include type checking for field access.
-     */
-    visitIdentifier(identifier, other) {
-        const _super = Object.create(null, {
-            visitIdentifier: { get: () => super.visitIdentifier }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            if (other.kind !== java_1.J.Kind.Identifier) {
-                return identifier;
-            }
-            const otherIdentifier = other;
-            // Check name matches
-            if (identifier.simpleName !== otherIdentifier.simpleName) {
-                return identifier;
-            }
-            // For identifiers with field types, check type attribution
-            if (identifier.fieldType && otherIdentifier.fieldType) {
-                if (!this.isOfType(identifier.fieldType, otherIdentifier.fieldType)) {
-                    this.abort();
-                    return identifier;
-                }
-            }
-            else if (identifier.fieldType || otherIdentifier.fieldType) {
-                // If only one has a type, they don't match
-                this.abort();
-                return identifier;
-            }
-            return _super.visitIdentifier.call(this, identifier, other);
-        });
-    }
-}
-/**
- * Matcher for checking if a pattern matches an AST node and extracting captured nodes.
- */
-class Matcher {
-    /**
-     * Creates a new matcher for a pattern against an AST node.
-     *
-     * @param pattern The pattern to match
-     * @param ast The AST node to match against
-     */
-    constructor(pattern, ast) {
-        this.pattern = pattern;
-        this.ast = ast;
-        this.bindings = new Map();
-    }
-    /**
-     * Checks if the pattern matches the AST node.
-     *
-     * @returns true if the pattern matches, false otherwise
-     */
-    matches() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.patternAst) {
-                const templateProcessor = new TemplateProcessor(this.pattern.templateParts, this.pattern.captures, this.pattern.options.imports || [], this.pattern.options.dependencies || {});
-                this.patternAst = yield templateProcessor.toAstPattern();
-            }
-            return this.matchNode(this.patternAst, this.ast);
-        });
-    }
-    /**
-     * Gets all captured nodes.
-     *
-     * @returns A map of capture names to captured nodes
-     */
-    getAll() {
-        return new Map(this.bindings);
-    }
-    /**
-     * Matches a pattern node against a target node.
-     *
-     * @param pattern The pattern node
-     * @param target The target node
-     * @returns true if the pattern matches the target, false otherwise
-     */
-    matchNode(pattern, target) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Check if pattern is a capture placeholder
-            if (PlaceholderUtils.isCapture(pattern)) {
-                return this.handleCapture(pattern, target);
-            }
-            // Check if nodes have the same kind
-            if (pattern.kind !== target.kind) {
-                return false;
-            }
-            const matcher = this;
-            return yield ((new class extends JavaScriptTemplateSemanticallyEqualVisitor {
-                hasSameKind(j, other) {
-                    return super.hasSameKind(j, other) || j.kind == java_1.J.Kind.Identifier && this.matchesParameter(j, other);
-                }
-                visitIdentifier(identifier, other) {
-                    const _super = Object.create(null, {
-                        visitIdentifier: { get: () => super.visitIdentifier }
-                    });
-                    return __awaiter(this, void 0, void 0, function* () {
-                        return this.matchesParameter(identifier, other) ? identifier : yield _super.visitIdentifier.call(this, identifier, other);
-                    });
-                }
-                matchesParameter(identifier, other) {
-                    return PlaceholderUtils.isCapture(identifier) && matcher.handleCapture(identifier, other);
-                }
-            }).compare(pattern, target));
-        });
-    }
-    /**
-     * Handles a capture placeholder.
-     *
-     * @param pattern The pattern node
-     * @param target The target node
-     * @returns true if the capture is successful, false otherwise
-     */
-    handleCapture(pattern, target) {
-        const captureName = PlaceholderUtils.getCaptureName(pattern);
-        if (!captureName) {
-            return false;
-        }
-        // Store the binding
-        this.bindings.set(captureName, target);
-        return true;
-    }
-}
-/**
- * Tagged template function for creating patterns.
- *
- * @param strings The string parts of the template
- * @param captures The captures between the string parts
- * @returns A Pattern object
- *
- * @example
- * // Using the same capture multiple times for repeated patterns
- * const expr = capture('expr');
- * const redundantOr = pattern`${expr} || ${expr}`;
- */
-function pattern(strings, ...captures) {
-    const capturesByName = captures.reduce((map, c) => {
-        const capture = typeof c === "string" ? new CaptureImpl(c) : c;
-        return map.set(capture.name, capture);
-    }, new Map());
-    return new Pattern(strings, captures.map(c => capturesByName.get(typeof c === "string" ? c : c.name)));
-}
-var JavaCoordinates;
-(function (JavaCoordinates) {
-    let Mode;
-    (function (Mode) {
-        Mode[Mode["Before"] = 0] = "Before";
-        Mode[Mode["After"] = 1] = "After";
-        Mode[Mode["Replace"] = 2] = "Replace";
-    })(Mode = JavaCoordinates.Mode || (JavaCoordinates.Mode = {}));
-})(JavaCoordinates || (JavaCoordinates = {}));
-/**
- * Template for creating AST nodes.
- *
- * This class provides the public API for template generation.
- * The actual templating logic is handled by the internal TemplateEngine.
- *
- * @example
- * // Generate a literal AST node
- * const result = template`2`.apply(cursor, coordinates);
- *
- * @example
- * // Generate an AST node with a parameter
- * const result = template`${capture()}`.apply(cursor, coordinates);
- */
-class Template {
-    /**
-     * Creates a new template.
-     *
-     * @param templateParts The string parts of the template
-     * @param parameters The parameters between the string parts
-     */
-    constructor(templateParts, parameters) {
-        this.templateParts = templateParts;
-        this.parameters = parameters;
-        this.options = {};
-    }
-    /**
-     * Configures this template with additional options.
-     *
-     * @param options Configuration options
-     * @returns This template for method chaining
-     *
-     * @example
-     * template`isDate(${capture('date')})`
-     *     .configure({
-     *         imports: ['import { isDate } from "util"'],
-     *         dependencies: { 'util': '^1.0.0' }
-     *     })
-     */
-    configure(options) {
-        this.options = Object.assign(Object.assign({}, this.options), options);
-        return this;
-    }
-    /**
-     * Applies this template and returns the resulting tree.
-     *
-     * @param cursor The cursor pointing to the current location in the AST
-     * @param tree Input tree
-     * @param values values for parameters in template
-     * @returns A Promise resolving to the generated AST node
-     */
-    apply(cursor, tree, values) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return TemplateEngine.applyTemplate(this.templateParts, this.parameters, cursor, {
-                tree,
-                mode: JavaCoordinates.Mode.Replace
-            }, values, this.options.imports || [], this.options.dependencies || {});
-        });
-    }
-}
-exports.Template = Template;
-function template(strings, ...parameters) {
-    // Convert parameters to Parameter objects (no longer need to check for mutable tree property)
-    const processedParameters = parameters.map(param => {
-        // Just wrap each parameter value in a Parameter object
-        return { value: param };
-    });
-    return new Template(strings, processedParameters);
-}
-/**
- * Internal template engine - handles the core templating logic.
- * Not exported, so only visible within this module.
- */
-class TemplateEngine {
-    /**
-     * Applies a template with optional match results from pattern matching.
-     *
-     * @param templateParts The string parts of the template
-     * @param parameters The parameters between the string parts
-     * @param cursor The cursor pointing to the current location in the AST
-     * @param coordinates The coordinates specifying where and how to insert the generated AST
-     * @param values Map of capture names to values to replace the parameters with
-     * @param imports Import statements to prepend for type attribution
-     * @param dependencies NPM dependencies for type attribution
-     * @returns A Promise resolving to the generated AST node
-     */
-    static applyTemplate(templateParts_1, parameters_1, cursor_1, coordinates_1) {
-        return __awaiter(this, arguments, void 0, function* (templateParts, parameters, cursor, coordinates, values = new Map(), imports = [], dependencies = {}) {
-            // Build the template string with parameter placeholders
-            const templateString = TemplateEngine.buildTemplateString(templateParts, parameters);
-            // If the template string is empty, return undefined
-            if (!templateString.trim()) {
-                return undefined;
-            }
-            // Use cache to get or parse the compilation unit
-            // For templates, we don't have captures, so use empty array
-            const cu = yield templateCache.getOrParse(templateString, [], // templates don't have captures in the cache key
-            imports, dependencies);
-            // Check if there are any statements
-            if (!cu.statements || cu.statements.length === 0) {
-                return undefined;
-            }
-            // Skip import statements to get to the actual template code
-            const templateStatementIndex = imports.length;
-            if (templateStatementIndex >= cu.statements.length) {
-                return undefined;
-            }
-            // Extract the relevant part of the AST
-            const firstStatement = cu.statements[templateStatementIndex].element;
-            let extracted = firstStatement.kind === _1.JS.Kind.ExpressionStatement ?
-                firstStatement.expression :
-                firstStatement;
-            // Create a copy to avoid sharing cached AST instances
-            const ast = (0, immer_1.produce)(extracted, draft => { });
-            // Create substitutions map for placeholders
-            const substitutions = new Map();
-            for (let i = 0; i < parameters.length; i++) {
-                const placeholder = `${PlaceholderUtils.PLACEHOLDER_PREFIX}${i}__`;
-                substitutions.set(placeholder, parameters[i]);
-            }
-            // Unsubstitute placeholders with actual parameter values and match results
-            const visitor = new PlaceholderReplacementVisitor(substitutions, values);
-            const unsubstitutedAst = (yield visitor.visit(ast, null));
-            // Apply the template to the current AST
-            return new TemplateApplier(cursor, coordinates, unsubstitutedAst, parameters).apply();
-        });
-    }
-    /**
-     * Builds a template string with parameter placeholders.
-     *
-     * @param templateParts The string parts of the template
-     * @param parameters The parameters between the string parts
-     * @returns The template string
-     */
-    static buildTemplateString(templateParts, parameters) {
-        let result = '';
-        for (let i = 0; i < templateParts.length; i++) {
-            result += templateParts[i];
-            if (i < parameters.length) {
-                const param = parameters[i].value;
-                // Use a placeholder for Captures and Tree nodes
-                // Inline everything else (strings, numbers, booleans) directly
-                if (param instanceof CaptureImpl || (0, __1.isTree)(param)) {
-                    const placeholder = `${PlaceholderUtils.PLACEHOLDER_PREFIX}${i}__`;
-                    result += placeholder;
-                }
-                else {
-                    result += param;
-                }
-            }
-        }
-        return result;
-    }
-}
-/**
- * Utility class for managing placeholder naming and parsing.
- * Centralizes all logic related to capture placeholders.
- */
-class PlaceholderUtils {
-    /**
-     * Checks if a node is a capture placeholder.
-     *
-     * @param node The node to check
-     * @returns true if the node is a capture placeholder, false otherwise
-     */
-    static isCapture(node) {
-        // Check for CaptureMarker first (efficient)
-        for (const marker of node.markers.markers) {
-            if (marker instanceof CaptureMarker) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Gets the capture name from a node with a CaptureMarker.
-     *
-     * @param node The node to extract capture name from
-     * @returns The capture name, or null if not a capture
-     */
-    static getCaptureName(node) {
-        // Check for CaptureMarker
-        for (const marker of node.markers.markers) {
-            if (marker instanceof CaptureMarker) {
-                return marker.captureName;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Parses a capture placeholder to extract name and type constraint.
-     *
-     * @param identifier The identifier string to parse
-     * @returns Object with name and optional type constraint, or null if not a valid capture
-     */
-    static parseCapture(identifier) {
-        if (!identifier.startsWith(this.CAPTURE_PREFIX)) {
-            return null;
-        }
-        // Handle unnamed captures: "__capture_unnamed_N__"
-        if (identifier.startsWith(`${this.CAPTURE_PREFIX}unnamed_`)) {
-            const match = identifier.match(/__capture_(unnamed_\d+)__/);
-            return match ? { name: match[1] } : null;
-        }
-        // Handle named captures: "__capture_name__" or "__capture_name_type__"
-        const match = identifier.match(/__capture_([^_]+)(?:_([^_]+))?__/);
-        if (!match) {
-            return null;
-        }
-        return {
-            name: match[1],
-            typeConstraint: match[2]
-        };
-    }
-    /**
-     * Creates a capture placeholder string.
-     *
-     * @param name The capture name
-     * @param typeConstraint Optional type constraint
-     * @returns The formatted placeholder string
-     */
-    static createCapture(name, typeConstraint) {
-        return typeConstraint
-            ? `${this.CAPTURE_PREFIX}${name}_${typeConstraint}__`
-            : `${this.CAPTURE_PREFIX}${name}__`;
-    }
-}
-PlaceholderUtils.CAPTURE_PREFIX = '__capture_';
-PlaceholderUtils.PLACEHOLDER_PREFIX = '__PLACEHOLDER_';
-/**
- * Visitor that replaces placeholder nodes with actual parameter values.
- */
-class PlaceholderReplacementVisitor extends visitor_1.JavaScriptVisitor {
-    constructor(substitutions, values = new Map()) {
-        super();
-        this.substitutions = substitutions;
-        this.values = values;
-    }
-    visit(tree, p, parent) {
-        const _super = Object.create(null, {
-            visit: { get: () => super.visit }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            // Check if this node is a placeholder
-            if (this.isPlaceholder(tree)) {
-                const replacement = this.replacePlaceholder(tree);
-                if (replacement !== tree) {
-                    return replacement;
-                }
-            }
-            // Continue with normal traversal
-            return _super.visit.call(this, tree, p, parent);
-        });
-    }
-    /**
-     * Checks if a node is a placeholder.
-     *
-     * @param node The node to check
-     * @returns True if the node is a placeholder
-     */
-    isPlaceholder(node) {
-        var _a;
-        if (node.kind === java_1.J.Kind.Identifier) {
-            const identifier = node;
-            return identifier.simpleName.startsWith(PlaceholderUtils.PLACEHOLDER_PREFIX);
-        }
-        else if (node.kind === java_1.J.Kind.Literal) {
-            const literal = node;
-            return ((_a = literal.valueSource) === null || _a === void 0 ? void 0 : _a.startsWith(PlaceholderUtils.PLACEHOLDER_PREFIX)) || false;
-        }
-        return false;
-    }
-    /**
-     * Replaces a placeholder node with the actual parameter value.
-     *
-     * @param placeholder The placeholder node
-     * @returns The replacement node or the original if not a placeholder
-     */
-    replacePlaceholder(placeholder) {
-        const placeholderText = this.getPlaceholderText(placeholder);
-        if (!placeholderText || !placeholderText.startsWith(PlaceholderUtils.PLACEHOLDER_PREFIX)) {
-            return placeholder;
-        }
-        // Find the corresponding parameter
-        const param = this.substitutions.get(placeholderText);
-        if (!param || param.value === undefined) {
-            return placeholder;
-        }
-        // If the parameter value is a Capture, look up the matched result
-        if (param.value instanceof CaptureImpl) {
-            const matchedNode = this.values.get(param.value.name);
-            if (matchedNode) {
-                return (0, immer_1.produce)(matchedNode, draft => {
-                    draft.markers = placeholder.markers;
-                    draft.prefix = placeholder.prefix;
-                });
-            }
-            // If no match found, return placeholder unchanged
-            return placeholder;
-        }
-        // If the parameter value is an AST node, use it directly
-        if ((0, __1.isTree)(param.value)) {
-            // Return the AST node, preserving the original prefix
-            return (0, immer_1.produce)(param.value, draft => {
-                draft.markers = placeholder.markers;
-                draft.prefix = placeholder.prefix;
-            });
-        }
-        return placeholder;
-    }
-    /**
-     * Gets the placeholder text from a node.
-     *
-     * @param node The node to get placeholder text from
-     * @returns The placeholder text or null
-     */
-    getPlaceholderText(node) {
-        if (node.kind === java_1.J.Kind.Identifier) {
-            return node.simpleName;
-        }
-        else if (node.kind === java_1.J.Kind.Literal) {
-            return node.valueSource || null;
-        }
-        return null;
-    }
-}
-/**
- * Helper class for applying a template to an AST.
- */
-class TemplateApplier {
-    constructor(cursor, coordinates, ast, parameters = []) {
-        this.cursor = cursor;
-        this.coordinates = coordinates;
-        this.ast = ast;
-        this.parameters = parameters;
-    }
-    /**
-     * Applies the template to the current AST.
-     *
-     * @returns A Promise resolving to the modified AST
-     */
-    apply() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { loc } = this.coordinates;
-            // Apply the template based on the location and mode
-            switch (loc || 'EXPRESSION_PREFIX') {
-                case 'EXPRESSION_PREFIX':
-                    return this.applyToExpression();
-                case 'STATEMENT_PREFIX':
-                    return this.applyToStatement();
-                case 'BLOCK_END':
-                    return this.applyToBlock();
-                default:
-                    throw new Error(`Unsupported location: ${loc}`);
-            }
-        });
-    }
-    /**
-     * Applies the template to an expression.
-     *
-     * @returns A Promise resolving to the modified AST
-     */
-    applyToExpression() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { tree } = this.coordinates;
-            // Create a copy of the AST with the prefix from the target
-            return tree ? (0, immer_1.produce)(this.ast, draft => {
-                draft.prefix = tree.prefix;
-            }) : this.ast;
-        });
-    }
-    /**
-     * Applies the template to a statement.
-     *
-     * @returns A Promise resolving to the modified AST
-     */
-    applyToStatement() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { tree } = this.coordinates;
-            // Create a copy of the AST with the prefix from the target
-            return (0, immer_1.produce)(this.ast, draft => {
-                draft.prefix = tree.prefix;
-            });
-        });
-    }
-    /**
-     * Applies the template to a block.
-     *
-     * @returns A Promise resolving to the modified AST
-     */
-    applyToBlock() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { tree } = this.coordinates;
-            // Create a copy of the AST with the prefix from the target
-            return (0, immer_1.produce)(this.ast, draft => {
-                draft.prefix = tree.prefix;
-            });
-        });
-    }
-}
-/**
- * Processor for template strings.
- * Converts a template string with captures into an AST pattern.
- */
-class TemplateProcessor {
-    /**
-     * Creates a new template processor.
-     *
-     * @param templateParts The string parts of the template
-     * @param captures The captures between the string parts
-     * @param imports Import statements to prepend for type attribution
-     * @param dependencies NPM dependencies for type attribution
-     */
-    constructor(templateParts, captures, imports = [], dependencies = {}) {
-        this.templateParts = templateParts;
-        this.captures = captures;
-        this.imports = imports;
-        this.dependencies = dependencies;
-    }
-    /**
-     * Converts the template to an AST pattern.
-     *
-     * @returns A Promise resolving to the AST pattern
-     */
-    toAstPattern() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Combine template parts and placeholders
-            const templateString = this.buildTemplateString();
-            // Use cache to get or parse the compilation unit
-            const cu = yield templateCache.getOrParse(templateString, this.captures, this.imports, this.dependencies);
-            // Extract the relevant part of the AST
-            return this.extractPatternFromAst(cu);
-        });
-    }
-    /**
-     * Builds a template string with placeholders for captures.
-     *
-     * @returns The template string
-     */
-    buildTemplateString() {
-        let result = '';
-        for (let i = 0; i < this.templateParts.length; i++) {
-            result += this.templateParts[i];
-            if (i < this.captures.length) {
-                const capture = this.captures[i];
-                result += PlaceholderUtils.createCapture(capture.name);
-            }
-        }
-        return result;
-    }
-    /**
-     * Extracts the pattern from the parsed AST.
-     *
-     * @param cu The compilation unit
-     * @returns The extracted pattern
-     */
-    extractPatternFromAst(cu) {
-        // Skip import statements to get to the actual pattern code
-        const patternStatementIndex = this.imports.length;
-        // Extract the relevant part of the AST based on the template content
-        const firstStatement = cu.statements[patternStatementIndex].element;
-        let extracted;
-        // If the first statement is an expression statement, extract the expression
-        if (firstStatement.kind === _1.JS.Kind.ExpressionStatement) {
-            extracted = firstStatement.expression;
-        }
-        else {
-            // Otherwise, return the statement itself
-            extracted = firstStatement;
-        }
-        // Attach CaptureMarkers to capture identifiers
-        return this.attachCaptureMarkers(extracted);
-    }
-    /**
-     * Attaches CaptureMarkers to capture identifiers in the AST.
-     * This allows efficient capture detection without string parsing.
-     *
-     * @param ast The AST to process
-     * @returns The AST with CaptureMarkers attached
-     */
-    attachCaptureMarkers(ast) {
-        const visited = new Set();
-        return (0, immer_1.produce)(ast, draft => {
-            this.visitAndAttachMarkers(draft, visited);
-        });
-    }
-    /**
-     * Recursively visits AST nodes and attaches CaptureMarkers to capture identifiers.
-     *
-     * @param node The node to visit
-     * @param visited Set of already visited nodes to avoid cycles
-     */
-    visitAndAttachMarkers(node, visited) {
-        var _a;
-        if (!node || typeof node !== 'object' || visited.has(node)) {
-            return;
-        }
-        // Mark as visited to avoid cycles
-        visited.add(node);
-        // If this is an identifier that looks like a capture, attach a marker
-        if (node.kind === java_1.J.Kind.Identifier && ((_a = node.simpleName) === null || _a === void 0 ? void 0 : _a.startsWith(PlaceholderUtils.CAPTURE_PREFIX))) {
-            const captureInfo = PlaceholderUtils.parseCapture(node.simpleName);
-            if (captureInfo) {
-                // Initialize markers if needed
-                if (!node.markers) {
-                    node.markers = { kind: 'org.openrewrite.marker.Markers', id: (0, uuid_1.randomId)(), markers: [] };
-                }
-                if (!node.markers.markers) {
-                    node.markers.markers = [];
-                }
-                // Add CaptureMarker
-                node.markers.markers.push(new CaptureMarker(captureInfo.name));
-            }
-        }
-        // Recursively visit all properties
-        for (const key in node) {
-            if (node.hasOwnProperty(key)) {
-                const value = node[key];
-                if (Array.isArray(value)) {
-                    value.forEach(item => this.visitAndAttachMarkers(item, visited));
-                }
-                else if (typeof value === 'object' && value !== null) {
-                    this.visitAndAttachMarkers(value, visited);
-                }
-            }
-        }
-    }
-}
-/**
- * Implementation of a replacement rule.
- */
-class RewriteRuleImpl {
-    constructor(before, after) {
-        this.before = before;
-        this.after = after;
-    }
-    tryOn(cursor, node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const pattern of this.before) {
-                const match = yield pattern.match(node);
-                if (match) {
-                    const result = yield this.after.apply(cursor, node, match);
-                    if (result) {
-                        return result;
-                    }
-                }
-            }
-            // Return undefined if no patterns match
-            return undefined;
-        });
-    }
-}
-/**
- * Creates a replacement rule using a capture context and configuration.
- *
- * @param builderFn Function that takes a capture context and returns before/after configuration
- * @returns A replacement rule that can be applied to AST nodes
- *
- * @example
- * // Single pattern
- * const swapOperands = rewrite(() => ({
- *     before: pattern`${"left"} + ${"right"}`,
- *     after: template`${"right"} + ${"left"}`
- * }));
- *
- * @example
- * // Multiple patterns
- * const normalizeComparisons = rewrite(() => ({
- *     before: [
- *         pattern`${"left"} == ${"right"}`,
- *         pattern`${"left"} === ${"right"}`
- *     ],
- *     after: template`${"left"} === ${"right"}`
- * }));
- *
- * @example
- * // Using in a visitor - IMPORTANT: use `|| node` to handle undefined when no match
- * class MyVisitor extends JavaScriptVisitor<any> {
- *     override async visitBinary(binary: J.Binary, p: any): Promise<J | undefined> {
- *         const rule = rewrite(() => ({
- *             before: pattern`${capture('a')} + ${capture('b')}`,
- *             after: template`${capture('b')} + ${capture('a')}`
- *         }));
- *         // tryOn() returns undefined if no pattern matches, so always use || node
- *         return await rule.tryOn(this.cursor, binary) || binary;
- *     }
- * }
- */
-function rewrite(builderFn) {
-    const config = builderFn();
-    // Ensure we have valid before and after properties
-    if (!config.before || !config.after) {
-        throw new Error('Builder function must return an object with before and after properties');
-    }
-    return new RewriteRuleImpl(Array.isArray(config.before) ? config.before : [config.before], config.after);
-}
-//# sourceMappingURL=templating.js.map