@openrewrite/rewrite 8.66.0 → 8.66.1

package/dist/javascript/templating/template.d.ts

@@ -0,0 +1,204 @@
+import { Cursor, Tree } from '../..';
+import { J } from '../../java';
+import { TemplateOptions, TemplateParameter, Capture } from './types';
+import { Parameter } from './engine';
+/**
+ * Coordinates for template application.
+ */
+type JavaCoordinates = {
+    tree?: Tree;
+    loc?: JavaCoordinates.Location;
+    mode?: JavaCoordinates.Mode;
+};
+declare namespace JavaCoordinates {
+    type Location = 'EXPRESSION_PREFIX' | 'STATEMENT_PREFIX' | 'BLOCK_END';
+    enum Mode {
+        Before = 0,
+        After = 1,
+        Replace = 2
+    }
+}
+/**
+ * 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();
+ * }
+ */
+export declare class TemplateBuilder {
+    private parts;
+    private params;
+    /**
+     * Adds a static string part to the template.
+     *
+     * @param str The string to add
+     * @returns This builder for chaining
+     */
+    code(str: string): this;
+    /**
+     * Adds a parameter to the template.
+     *
+     * @param value The parameter value (Capture, Tree, or primitive)
+     * @returns This builder for chaining
+     */
+    param(value: TemplateParameter): this;
+    /**
+     * Builds the template from accumulated parts and parameters.
+     *
+     * @returns A Template instance
+     */
+    build(): Template;
+}
+/**
+ * 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
+ */
+export declare class Template {
+    private readonly templateParts;
+    private readonly parameters;
+    private options;
+    /**
+     * 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(): TemplateBuilder;
+    /**
+     * Creates a new template.
+     *
+     * @param templateParts The string parts of the template
+     * @param parameters The parameters between the string parts
+     */
+    constructor(templateParts: TemplateStringsArray, parameters: Parameter[]);
+    /**
+     * 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: TemplateOptions): Template;
+    /**
+     * 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: Cursor, tree: J, values?: Map<Capture | string, J> | Pick<Map<string, J>, 'get'>): Promise<J | undefined>;
+}
+/**
+ * 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`).
+ *
+ * @param strings The string parts of the template
+ * @param parameters The parameters between the string parts (Capture, Tree, or primitives)
+ * @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})`
+ */
+export declare function template(strings: TemplateStringsArray, ...parameters: TemplateParameter[]): Template;
+export type { JavaCoordinates };
+//# sourceMappingURL=template.d.ts.map

package/dist/javascript/templating/template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../../src/javascript/templating/template.ts"],"names":[],"mappings":"AAeA,OAAO,EAAC,MAAM,EAAE,IAAI,EAAC,MAAM,OAAO,CAAC;AACnC,OAAO,EAAC,CAAC,EAAC,MAAM,YAAY,CAAC;AAC7B,OAAO,EAAC,eAAe,EAAE,iBAAiB,EAAE,OAAO,EAAC,MAAM,SAAS,CAAC;AAIpE,OAAO,EAAiB,SAAS,EAAC,MAAM,UAAU,CAAC;AAEnD;;GAEG;AACH,KAAK,eAAe,GAAG;IACnB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,GAAG,CAAC,EAAE,eAAe,CAAC,QAAQ,CAAC;IAC/B,IAAI,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC;CAC/B,CAAC;AAEF,kBAAU,eAAe,CAAC;IAEtB,KAAY,QAAQ,GAAG,mBAAmB,GAAG,kBAAkB,GAAG,WAAW,CAAC;IAE9E,KAAY,IAAI;QACZ,MAAM,IAAA;QACN,KAAK,IAAA;QACL,OAAO,IAAA;KACV;CACJ;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,eAAe;IACxB,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,MAAM,CAA2B;IAEzC;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAcvB;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;IAWrC;;;;OAIG;IACH,KAAK,IAAI,QAAQ;CAiBpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,qBAAa,QAAQ;IA2Bb,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU;IA3B/B,OAAO,CAAC,OAAO,CAAuB;IAEtC;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,OAAO,IAAI,eAAe;IAIjC;;;;;OAKG;gBAEkB,aAAa,EAAE,oBAAoB,EACnC,UAAU,EAAE,SAAS,EAAE;IAI5C;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,OAAO,EAAE,eAAe,GAAG,QAAQ;IAK7C;;;;;;;OAOG;IACG,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,OAAO,GAAG,MAAM,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;CAuChI;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,UAAU,EAAE,iBAAiB,EAAE,GAAG,QAAQ,CAQpG;AAED,YAAY,EAAC,eAAe,EAAC,CAAC"}

package/dist/javascript/templating/template.js

@@ -0,0 +1,293 @@
+"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({
+     *         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* () {
+            // Normalize the values map: convert any Capture keys to string keys
+            let normalizedValues;
+            let wrappersMap = new Map();
+            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 instanceof pattern_1.MatchResult) {
+                // MatchResult - extract both bindings and wrappersMap
+                normalizedValues = values;
+                wrappersMap = values[utils_1.WRAPPERS_MAP_SYMBOL]();
+            }
+            else {
+                // Other Pick<Map> implementation
+                normalizedValues = values;
+            }
+            // Prefer 'context' over deprecated 'imports'
+            const contextStatements = this.options.context || this.options.imports || [];
+            return engine_1.TemplateEngine.applyTemplate(this.templateParts, this.parameters, cursor, {
+                tree,
+                mode: JavaCoordinates.Mode.Replace
+            }, normalizedValues, wrappersMap, contextStatements, this.options.dependencies || {});
+        });
+    }
+}
+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`).
+ *
+ * @param strings The string parts of the template
+ * @param parameters The parameters between the string parts (Capture, Tree, or primitives)
+ * @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})`
+ */
+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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"}