@openrewrite/rewrite 8.66.0 → 8.66.2

package/dist/javascript/templating/template.js

@@ -0,0 +1,367 @@
+"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.TemplateBuilder = void 0;
+exports.template = template;
+const pattern_1 = require("./pattern");
+const utils_1 = require("./utils");
+const capture_1 = require("./capture");
+const engine_1 = require("./engine");
+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 = {}));
+/**
+ * Builder for creating templates programmatically.
+ * Use when template structure is not known at compile time.
+ *
+ * @example
+ * // Conditional construction
+ * const builder = Template.builder().code('function foo(x) {');
+ * if (needsValidation) {
+ *     builder.code('if (typeof x !== "number") throw new Error("Invalid");');
+ * }
+ * builder.code('return x * 2; }');
+ * const tmpl = builder.build();
+ *
+ * @example
+ * // Composition from fragments
+ * function createWrapper(innerBody: Capture): Template {
+ *     return Template.builder()
+ *         .code('function wrapper() { try { ')
+ *         .param(innerBody)
+ *         .code(' } catch(e) { console.error(e); } }')
+ *         .build();
+ * }
+ */
+class TemplateBuilder {
+    constructor() {
+        this.parts = [];
+        this.params = [];
+    }
+    /**
+     * Adds a static string part to the template.
+     *
+     * @param str The string to add
+     * @returns This builder for chaining
+     */
+    code(str) {
+        // If there are already params, we need to add an empty string before this
+        if (this.params.length > this.parts.length) {
+            this.parts.push('');
+        }
+        // Append to the last part or start a new one
+        if (this.parts.length === 0) {
+            this.parts.push(str);
+        }
+        else {
+            this.parts[this.parts.length - 1] += str;
+        }
+        return this;
+    }
+    /**
+     * Adds a parameter to the template.
+     *
+     * @param value The parameter value (Capture, Tree, or primitive)
+     * @returns This builder for chaining
+     */
+    param(value) {
+        // Ensure we have a part for after this parameter
+        if (this.parts.length === 0) {
+            this.parts.push('');
+        }
+        this.params.push(value);
+        // Add an empty string for the next part
+        this.parts.push('');
+        return this;
+    }
+    /**
+     * Builds the template from accumulated parts and parameters.
+     *
+     * @returns A Template instance
+     */
+    build() {
+        // Ensure parts array is one longer than params array
+        while (this.parts.length <= this.params.length) {
+            this.parts.push('');
+        }
+        // Create a synthetic TemplateStringsArray
+        const templateStrings = this.parts.slice();
+        templateStrings.raw = this.parts.slice();
+        Object.defineProperty(templateStrings, 'raw', {
+            value: this.parts.slice(),
+            writable: false
+        });
+        // Delegate to the template() function
+        return template(templateStrings, ...this.params);
+    }
+}
+exports.TemplateBuilder = TemplateBuilder;
+/**
+ * Template for creating AST nodes.
+ *
+ * This class provides the public API for template generation.
+ * The actual templating logic is handled by the internal TemplateEngine.
+ *
+ * Templates can reference captures from patterns, and you can access properties
+ * of captured nodes using dot notation. This allows you to extract and insert
+ * specific subtrees from matched AST nodes.
+ *
+ * @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);
+ *
+ * @example
+ * // Access properties of captured nodes in templates
+ * const method = capture<J.MethodInvocation>('method');
+ * const pat = pattern`foo(${method})`;
+ * const tmpl = template`bar(${method.name})`; // Access the 'name' property
+ *
+ * const match = await pat.match(someNode);
+ * if (match) {
+ *     // The template will insert just the 'name' subtree from the captured method
+ *     const result = await tmpl.apply(cursor, someNode, match);
+ * }
+ *
+ * @example
+ * // Deep property access chains
+ * const method = capture<J.MethodInvocation>('method');
+ * template`console.log(${method.name.simpleName})` // Navigate multiple properties
+ *
+ * @example
+ * // Array element access
+ * const invocation = capture<J.MethodInvocation>('invocation');
+ * template`bar(${invocation.arguments.elements[0].element})` // Access array elements
+ */
+class Template {
+    /**
+     * Creates a new builder for constructing templates programmatically.
+     *
+     * @returns A new TemplateBuilder instance
+     *
+     * @example
+     * const tmpl = Template.builder()
+     *     .code('function foo() {')
+     *     .code('return ')
+     *     .param(capture('value'))
+     *     .code('; }')
+     *     .build();
+     */
+    static builder() {
+        return new TemplateBuilder();
+    }
+    /**
+     * 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({
+     *         context: ['import { isDate } from "util"'],
+     *         dependencies: { 'util': '^1.0.0' }
+     *     })
+     */
+    configure(options) {
+        this.options = Object.assign(Object.assign({}, this.options), options);
+        // Invalidate cache when configuration changes
+        this._cachedTemplate = undefined;
+        return this;
+    }
+    /**
+     * Gets the template tree for this template, using two-level caching:
+     * - Level 1: Instance cache (this._cachedTemplate) - fastest, no lookup needed
+     * - Level 2: Global cache (globalAstCache) - fast, shared across all templates
+     * - Level 3: TemplateEngine - slow, parses and processes the template
+     *
+     * Most parameters use placeholders that are replaced during application, so templates
+     * with the same structure share cached ASTs. However, raw() parameters are spliced at
+     * construction time, so their values must be included in the cache key.
+     *
+     * @returns The cached or newly computed template tree
+     * @internal
+     */
+    getTemplateTree() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Level 1: Instance cache (fastest path)
+            if (this._cachedTemplate) {
+                return this._cachedTemplate;
+            }
+            // Generate cache key for global lookup
+            // For raw() parameters, we need to include their code values in the key
+            // since they're spliced at construction time, not application time
+            const contextStatements = this.options.context || this.options.imports || [];
+            const parametersKey = this.parameters.map((p, i) => {
+                const value = p.value;
+                // Include raw code values in the cache key using the symbol
+                if (value && typeof value === 'object' && value[capture_1.RAW_CODE_SYMBOL]) {
+                    return `raw:${value.code}`;
+                }
+                return i.toString();
+            }).join(',');
+            const cacheKey = (0, utils_1.generateCacheKey)(this.templateParts, parametersKey, contextStatements, this.options.dependencies || {});
+            // Level 2: Global cache (fast path - shared with Pattern)
+            const cached = utils_1.globalAstCache.get(cacheKey);
+            if (cached) {
+                this._cachedTemplate = cached;
+                return cached;
+            }
+            // Level 3: Compute via TemplateEngine (slow path)
+            const result = yield engine_1.TemplateEngine.getTemplateTree(this.templateParts, this.parameters, contextStatements, this.options.dependencies || {});
+            // Cache in both levels
+            utils_1.globalAstCache.set(cacheKey, result);
+            this._cachedTemplate = result;
+            return result;
+        });
+    }
+    /**
+     * 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* () {
+            // Normalize the values map: convert any Capture keys to string keys
+            let normalizedValues;
+            let wrappersMap = new Map();
+            if (values instanceof pattern_1.MatchResult) {
+                // MatchResult - extract both bindings and wrappersMap
+                normalizedValues = values;
+                wrappersMap = values[utils_1.WRAPPERS_MAP_SYMBOL]();
+            }
+            else if (values instanceof Map) {
+                const normalized = new Map();
+                for (const [key, value] of values.entries()) {
+                    const stringKey = typeof key === 'string'
+                        ? key
+                        : (key[capture_1.CAPTURE_NAME_SYMBOL] || key.getName());
+                    normalized.set(stringKey, value);
+                }
+                normalizedValues = normalized;
+            }
+            else if (values && typeof values === 'object') {
+                // Check if it's a Map-like object with 'get' method, or a plain object literal
+                if ('get' in values && typeof values.get === 'function') {
+                    // Map-like object with get method
+                    normalizedValues = values;
+                }
+                else {
+                    // Plain object literal - convert to Map
+                    // Keys may be strings or Capture objects (via computed properties {[x]: value})
+                    const normalized = new Map();
+                    for (const [key, value] of Object.entries(values)) {
+                        // If the key happens to be a stringified Capture (from computed properties),
+                        // it's already been converted to a string by JavaScript
+                        normalized.set(key, value);
+                    }
+                    normalizedValues = normalized;
+                }
+            }
+            // Use instance-level cache to get the template tree
+            const ast = yield this.getTemplateTree();
+            // Delegate to TemplateEngine for placeholder substitution and application
+            return engine_1.TemplateEngine.applyTemplateFromAst(ast, this.parameters, cursor, {
+                tree,
+                mode: JavaCoordinates.Mode.Replace
+            }, normalizedValues, wrappersMap);
+        });
+    }
+}
+exports.Template = Template;
+/**
+ * Tagged template function for creating templates that generate AST nodes.
+ *
+ * Templates support property access on captures from patterns, allowing you to
+ * extract and insert specific subtrees from matched AST nodes. Use dot notation
+ * to navigate properties (e.g., `method.name`) or array bracket notation to
+ * access array elements (e.g., `args.elements[0].element`).
+ *
+ * Templates can also accept AST wrapper types directly:
+ * - J.RightPadded<T>: The element will be extracted and inserted
+ * - J.RightPadded<T>[]: Elements will be expanded in place
+ * - J.Container<T>: Elements will be expanded in place
+ *
+ * @param strings The string parts of the template
+ * @param parameters The parameters between the string parts (Capture, CaptureValue, TemplateParam, Tree, Tree[], J.RightPadded, J.RightPadded[], or J.Container)
+ * @returns A Template object that can be applied to generate AST nodes
+ *
+ * @example
+ * // Simple template with literal
+ * const tmpl = template`console.log("hello")`;
+ * const result = await tmpl.apply(cursor, node);
+ *
+ * @example
+ * // Template with capture - matches captured value from pattern
+ * const expr = capture('expr');
+ * const pat = pattern`foo(${expr})`;
+ * const tmpl = template`bar(${expr})`;
+ *
+ * const match = await pat.match(node);
+ * if (match) {
+ *     const result = await tmpl.apply(cursor, node, match);
+ * }
+ *
+ * @example
+ * // Property access on captures - extract subtrees
+ * const method = capture<J.MethodInvocation>('method');
+ * const pat = pattern`foo(${method})`;
+ * // Access the 'name' property of the captured method invocation
+ * const tmpl = template`bar(${method.name})`;
+ *
+ * @example
+ * // Deep property chains
+ * const method = capture<J.MethodInvocation>('method');
+ * template`console.log(${method.name.simpleName})`
+ *
+ * @example
+ * // Array element access
+ * const invocation = capture<J.MethodInvocation>('invocation');
+ * template`bar(${invocation.arguments.elements[0].element})`
+ *
+ * @example
+ * // Using J.RightPadded and J.Container directly
+ * const selectExpr = method.select;  // J.RightPadded<Expression>
+ * const args = method.arguments;      // J.Container<Expression>
+ * template`${selectExpr}.newMethod(${args})`
+ */
+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);
+}
+//# sourceMappingURL=template.js.map

package/dist/javascript/templating/template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.js","sourceRoot":"","sources":["../../../src/javascript/templating/template.ts"],"names":[],"mappings":"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"}