@openrewrite/rewrite 8.67.0-20251104-084009 → 8.67.0-20251104-114312

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

@@ -0,0 +1,263 @@
+import { Cursor, Tree } from '../..';
+import { J } from '../../java';
+/**
+ * Options for variadic captures that match zero or more nodes in a sequence.
+ */
+export interface VariadicOptions {
+    /**
+     * Minimum number of nodes that must be matched (default: 0).
+     */
+    min?: number;
+    /**
+     * Maximum number of nodes that can be matched (default: unlimited).
+     */
+    max?: number;
+}
+/**
+ * Options for the capture function.
+ *
+ * The constraint function receives different parameter types depending on whether
+ * the capture is variadic:
+ * - For regular captures: constraint receives a single node of type T
+ * - For variadic captures: constraint receives an array of nodes of type T[]
+ */
+export interface CaptureOptions<T = any> {
+    name?: string;
+    variadic?: boolean | VariadicOptions;
+    constraint?: (node: T) => boolean;
+}
+/**
+ * Capture specification for pattern matching.
+ * Represents a placeholder in a template pattern that can capture a part of the AST.
+ *
+ * @template T The expected type of the captured AST node (for TypeScript autocomplete)
+ *
+ * @remarks
+ * **Important: Type Parameter is for IDE Support Only**
+ *
+ * The generic type parameter `<T>` provides IDE autocomplete and type checking in your code,
+ * but does NOT enforce any runtime constraints on what the capture will match.
+ *
+ * **Pattern Matching Behavior:**
+ * - A bare `pattern`${capture('x')}`` will structurally match ANY expression
+ * - Pattern structure determines matching: `pattern`foo(${capture('x')})`` only matches `foo()` calls
+ * - Use structural patterns to narrow matching scope before applying semantic validation
+ *
+ * **Variadic Captures:**
+ * Use `{ variadic: true }` to match zero or more nodes in a sequence:
+ * ```typescript
+ * const args = capture('args', { variadic: true });
+ * pattern`foo(${args})`  // Matches: foo(), foo(a), foo(a, b, c)
+ * ```
+ */
+export interface Capture<T = any> {
+    /**
+     * Gets the string name of this capture.
+     */
+    getName(): string;
+    /**
+     * Returns true if this is a variadic capture (matching zero or more nodes).
+     */
+    isVariadic(): boolean;
+    /**
+     * Returns the variadic options if this is a variadic capture, undefined otherwise.
+     */
+    getVariadicOptions(): VariadicOptions | undefined;
+    /**
+     * Gets the constraint function if this capture has one.
+     * For regular captures (T = Expression), constraint receives a single node.
+     * For variadic captures (T = Expression[]), constraint receives an array of nodes.
+     */
+    getConstraint?(): ((node: T) => boolean) | undefined;
+}
+/**
+ * Non-capturing pattern match specification.
+ * Represents a placeholder in a pattern that matches AST nodes without binding them to a name.
+ *
+ * Use `any()` when you need to match structure without caring about the specific values.
+ * The key difference from `Capture` is that `Any` cannot be used in templates - the TypeScript
+ * type system prevents this at compile time.
+ *
+ * @template T The expected type of the matched AST node (for TypeScript autocomplete and constraints)
+ *
+ * @remarks
+ * **Why Any<T> is Separate from Capture<T>:**
+ *
+ * Using a separate type provides compile-time safety:
+ * - `pattern`foo(${any()})`` - ✅ OK in patterns
+ * - `template`bar(${any()})`` - ❌ TypeScript error (Any<T> not assignable to template parameters)
+ *
+ * This prevents logical errors where you try to use a non-capturing match in a template.
+ *
+ * **Semantic Parallel with TypeScript's `any`:**
+ *
+ * Just as TypeScript's `any` type means "be permissive about types here",
+ * pattern matching's `any()` means "be permissive about values here":
+ * - TypeScript `any`: Accept any type, don't check it
+ * - Pattern `any()`: Match any value, don't bind it
+ *
+ * @example
+ * // Match without capturing
+ * const pat = pattern`foo(${any()})`
+ *
+ * @example
+ * // Variadic any - match zero or more without capturing
+ * const rest = any({ variadic: true });
+ * const pat = pattern`bar(${capture('first')}, ${rest})`
+ *
+ * @example
+ * // With constraints - validate but don't capture
+ * const numericArg = any<J.Literal>({
+ *     constraint: (node) => typeof node.value === 'number'
+ * });
+ * const pat = pattern`process(${numericArg})`
+ */
+export interface Any<T = any> {
+    /**
+     * Gets the internal identifier for this any pattern.
+     */
+    getName(): string;
+    /**
+     * Returns true if this is a variadic any (matching zero or more nodes).
+     */
+    isVariadic(): boolean;
+    /**
+     * Returns the variadic options if this is a variadic any, undefined otherwise.
+     */
+    getVariadicOptions(): VariadicOptions | undefined;
+    /**
+     * Gets the constraint function if this any pattern has one.
+     * For regular any (T = Expression), constraint receives a single node.
+     * For variadic any (T = Expression[]), constraint receives an array of nodes.
+     */
+    getConstraint?(): ((node: T) => boolean) | undefined;
+}
+/**
+ * Template parameter specification for template-only parameter substitution.
+ * Unlike Capture, TemplateParam does not support property access and is simpler.
+ *
+ * @template T The expected type of the parameter value (for TypeScript autocomplete only)
+ */
+export interface TemplateParam<T = any> {
+    /**
+     * The name of the parameter, used to look up the value in the values map.
+     */
+    readonly name: string;
+    /**
+     * Gets the string name of this parameter.
+     */
+    getName(): string;
+}
+/**
+ * Configuration options for patterns.
+ */
+export interface PatternOptions {
+    /**
+     * Declarations to provide type attribution context for the pattern.
+     * These can include import statements, type declarations, function declarations, or any
+     * other declarations needed for proper type information. They are prepended to the pattern
+     * when parsing to ensure proper type attribution.
+     *
+     * @example
+     * ```typescript
+     * pattern`forwardRef(${capture('comp')})`
+     *     .configure({
+     *         context: [
+     *             `import { forwardRef } from 'react'`,
+     *             `type MyType = { value: number }`
+     *         ]
+     *     })
+     * ```
+     */
+    context?: string[];
+    /**
+     * @deprecated Use `context` instead. This alias will be removed in a future version.
+     *
+     * Import statements to provide type attribution context.
+     * These are prepended to the pattern when parsing to ensure proper type information.
+     */
+    imports?: string[];
+    /**
+     * NPM dependencies required for import resolution and type attribution.
+     * Maps package names to version specifiers (e.g., { 'util': '^1.0.0' }).
+     * The template engine will create a package.json with these dependencies.
+     */
+    dependencies?: Record<string, string>;
+    /**
+     * When true, allows patterns without type annotations to match code with type annotations.
+     * This enables more flexible pattern matching during development or when full type attribution
+     * is not needed. When false, enforces strict type matching where both pattern and target must
+     * have matching type annotations.
+     *
+     * @default true (lenient matching enabled for backward compatibility)
+     */
+    lenientTypeMatching?: boolean;
+}
+/**
+ * Valid parameter types for template literals.
+ * - Capture: For pattern matching and reuse
+ * - CaptureValue: Result of property access or array operations on captures (e.g., capture.prop, capture[0], capture.slice(1))
+ * - Tree: AST nodes to be inserted directly
+ * - Tree[]: Arrays of AST nodes (from variadic capture operations like slice)
+ * - Primitives: Values to be converted to literals
+ */
+export type TemplateParameter = Capture | any | TemplateParam | Tree | Tree[] | string | number | boolean;
+/**
+ * Configuration options for templates.
+ */
+export interface TemplateOptions {
+    /**
+     * Declarations to provide type attribution context for the template.
+     * These can include import statements, type declarations, function declarations, or any
+     * other declarations needed for proper type information. They are prepended to the template
+     * when parsing to ensure proper type attribution.
+     *
+     * @example
+     * ```typescript
+     * template`console.log(${capture('value')})`
+     *     .configure({
+     *         context: [
+     *             `type MyType = { value: number }`,
+     *             `const console = { log: (x: any) => void 0 }`
+     *         ]
+     *     })
+     * ```
+     */
+    context?: string[];
+    /**
+     * @deprecated Use `context` instead. This alias will be removed in a future version.
+     *
+     * Import statements to provide type attribution context.
+     * These are prepended to the template when parsing to ensure proper type information.
+     */
+    imports?: string[];
+    /**
+     * NPM dependencies required for import resolution and type attribution.
+     * Maps package names to version specifiers (e.g., { 'util': '^1.0.0' }).
+     * The template engine will create a package.json with these dependencies.
+     */
+    dependencies?: Record<string, string>;
+}
+/**
+ * Represents a replacement rule that can match a pattern and apply a template.
+ */
+export interface RewriteRule {
+    /**
+     * Attempts to apply this rewrite rule to the given AST node.
+     *
+     * @param cursor The cursor context at the current position in the AST
+     * @param node The AST node to try matching and transforming
+     * @returns The transformed node if a pattern matched, or `undefined` if no pattern matched.
+     *          When using in a visitor, always use the `|| node` pattern to return the original
+     *          node when there's no match: `return await rule.tryOn(this.cursor, node) || node;`
+     */
+    tryOn(cursor: Cursor, node: J): Promise<J | undefined>;
+}
+/**
+ * Configuration for a replacement rule.
+ */
+export interface RewriteConfig {
+    before: any;
+    after: any;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/javascript/templating/types.ts"],"names":[],"mappings":"AAeA,OAAO,EAAC,MAAM,EAAE,IAAI,EAAC,MAAM,OAAO,CAAC;AACnC,OAAO,EAAC,CAAC,EAAC,MAAM,YAAY,CAAC;AAE7B;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,GAAG;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,GAAG,eAAe,CAAC;IACrC,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC,GAAG,GAAG;IAC5B;;OAEG;IACH,OAAO,IAAI,MAAM,CAAC;IAElB;;OAEG;IACH,UAAU,IAAI,OAAO,CAAC;IAEtB;;OAEG;IACH,kBAAkB,IAAI,eAAe,GAAG,SAAS,CAAC;IAElD;;;;OAIG;IACH,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,GAAG,SAAS,CAAC;CACxD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,WAAW,GAAG,CAAC,CAAC,GAAG,GAAG;IACxB;;OAEG;IACH,OAAO,IAAI,MAAM,CAAC;IAElB;;OAEG;IACH,UAAU,IAAI,OAAO,CAAC;IAEtB;;OAEG;IACH,kBAAkB,IAAI,eAAe,GAAG,SAAS,CAAC;IAElD;;;;OAIG;IACH,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,GAAG,SAAS,CAAC;CACxD;AAED;;;;;GAKG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,GAAG;IAClC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,OAAO,IAAI,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEtC;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,GAAG,GAAG,aAAa,GAAG,IAAI,GAAG,IAAI,EAAE,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE1G;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB;;;;;;;;OAQG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CAC1D;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B,MAAM,EAAE,GAAG,CAAC;IACZ,KAAK,EAAE,GAAG,CAAC;CACd"}

package/dist/javascript/templating/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/javascript/templating/types.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,118 @@
+import { J } from '../../java';
+import { JS } from '../index';
+import { Marker } from '../../markers';
+import { VariadicOptions, Capture, Any } from './types';
+/**
+ * Internal storage value type for pattern match captures.
+ * - J: Scalar captures without wrapper (fallback)
+ * - J.RightPadded<J>: Scalar captures with wrapper (preserves trailing markers like semicolons)
+ * - J[]: Variadic captures without wrapper metadata
+ * - J.RightPadded<J>[]: Variadic captures with wrapper metadata (preserves markers like commas)
+ */
+export type CaptureStorageValue = J | J.RightPadded<J> | J[] | J.RightPadded<J>[];
+/**
+ * Symbol to access wrappersMap without exposing it as public API
+ */
+export declare const WRAPPERS_MAP_SYMBOL: unique symbol;
+/**
+ * Cache for compiled templates and patterns.
+ * Stores parsed ASTs to avoid expensive re-parsing and dependency resolution.
+ */
+export declare class TemplateCache {
+    private cache;
+    /**
+     * Generates a cache key from template string, captures, and options.
+     */
+    private generateKey;
+    /**
+     * Gets a cached compilation unit or creates and caches a new one.
+     */
+    getOrParse(templateString: string, captures: (Capture | Any<any>)[], contextStatements: string[], dependencies: Record<string, string>): Promise<JS.CompilationUnit>;
+    /**
+     * Clears the cache.
+     */
+    clear(): void;
+}
+export declare const templateCache: TemplateCache;
+/**
+ * Marker that stores capture metadata on pattern AST nodes.
+ * This avoids the need to parse capture names from identifiers during matching.
+ */
+export declare class CaptureMarker implements Marker {
+    readonly captureName: string;
+    readonly variadicOptions?: VariadicOptions | undefined;
+    readonly kind = "org.openrewrite.javascript.CaptureMarker";
+    readonly id: string;
+    constructor(captureName: string, variadicOptions?: VariadicOptions | undefined);
+}
+/**
+ * Utility class for managing placeholder naming and parsing.
+ * Centralizes all logic related to capture placeholders.
+ */
+export declare class PlaceholderUtils {
+    static readonly CAPTURE_PREFIX = "__capt_";
+    static readonly PLACEHOLDER_PREFIX = "__PLACEHOLDER_";
+    /**
+     * 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: J): boolean;
+    /**
+     * 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: J): string | undefined;
+    /**
+     * Gets the CaptureMarker from a node, if present.
+     *
+     * @param node The node to check
+     * @returns The CaptureMarker or undefined
+     */
+    static getCaptureMarker(node: J): CaptureMarker | 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: string): {
+        name: string;
+        typeConstraint?: string;
+    } | null;
+    /**
+     * Creates a capture placeholder string.
+     *
+     * @param name The capture name
+     * @param typeConstraint Optional type constraint
+     * @returns The formatted placeholder string
+     */
+    static createCapture(name: string, typeConstraint?: string): string;
+    /**
+     * Checks if a capture marker indicates a variadic capture.
+     *
+     * @param node The node to check
+     * @returns true if the node has a variadic CaptureMarker, false otherwise
+     */
+    static isVariadicCapture(node: J): boolean;
+    /**
+     * Gets the variadic options from a capture marker.
+     *
+     * @param node The node to extract variadic options from
+     * @returns The VariadicOptions, or undefined if not a variadic capture
+     */
+    static getVariadicOptions(node: J): VariadicOptions | undefined;
+    /**
+     * Checks if a statement is an ExpressionStatement wrapping a capture identifier.
+     * When a capture placeholder appears in statement position, the parser wraps it as
+     * an ExpressionStatement. This method unwraps it to get the identifier.
+     *
+     * @param stmt The statement to check
+     * @returns The unwrapped capture identifier, or the original statement if not wrapped
+     */
+    static unwrapStatementCapture(stmt: J): J;
+}
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/javascript/templating/utils.ts"],"names":[],"mappings":"AAeA,OAAO,EAAC,CAAC,EAAC,MAAM,YAAY,CAAC;AAC7B,OAAO,EAAC,EAAE,EAAC,MAAM,UAAU,CAAC;AAG5B,OAAO,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AAErC,OAAO,EAAC,eAAe,EAAE,OAAO,EAAE,GAAG,EAAC,MAAM,SAAS,CAAC;AAEtD;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;AAElF;;GAEG;AACH,eAAO,MAAM,mBAAmB,eAAwB,CAAC;AAEzD;;;GAGG;AACH,qBAAa,aAAa;IACtB,OAAO,CAAC,KAAK,CAAyC;IAEtD;;OAEG;IACH,OAAO,CAAC,WAAW;IAqBnB;;OAEG;IACG,UAAU,CACZ,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,CAAC,OAAO,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EAChC,iBAAiB,EAAE,MAAM,EAAE,EAC3B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACrC,OAAO,CAAC,EAAE,CAAC,eAAe,CAAC;IA8B9B;;OAEG;IACH,KAAK,IAAI,IAAI;CAGhB;AAGD,eAAO,MAAM,aAAa,eAAsB,CAAC;AAEjD;;;GAGG;AACH,qBAAa,aAAc,YAAW,MAAM;aAKpB,WAAW,EAAE,MAAM;aACnB,eAAe,CAAC,EAAE,eAAe;IALrD,QAAQ,CAAC,IAAI,8CAA8C;IAC3D,QAAQ,CAAC,EAAE,SAAc;gBAGL,WAAW,EAAE,MAAM,EACnB,eAAe,CAAC,EAAE,eAAe,YAAA;CAGxD;AAED;;;GAGG;AACH,qBAAa,gBAAgB;IACzB,MAAM,CAAC,QAAQ,CAAC,cAAc,aAAa;IAC3C,MAAM,CAAC,QAAQ,CAAC,kBAAkB,oBAAoB;IAEtD;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO;IAUlC;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM,GAAG,SAAS;IAWlD;;;;;OAKG;IACH,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC,GAAG,aAAa,GAAG,SAAS;IAS3D;;;;;OAKG;IACH,MAAM,CAAC,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAuBzF;;;;;;OAMG;IACH,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM;IAOnE;;;;;OAKG;IACH,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO;IAS1C;;;;;OAKG;IACH,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC,GAAG,eAAe,GAAG,SAAS;IAS/D;;;;;;;OAOG;IACH,MAAM,CAAC,sBAAsB,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC;CAc5C"}

package/dist/javascript/templating/utils.js

@@ -0,0 +1,253 @@
+"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.PlaceholderUtils = exports.CaptureMarker = exports.templateCache = exports.TemplateCache = exports.WRAPPERS_MAP_SYMBOL = void 0;
+/*
+ * 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 java_1 = require("../../java");
+const index_1 = require("../index");
+const parser_1 = require("../parser");
+const dependency_workspace_1 = require("../dependency-workspace");
+const uuid_1 = require("../../uuid");
+/**
+ * Symbol to access wrappersMap without exposing it as public API
+ */
+exports.WRAPPERS_MAP_SYMBOL = Symbol('wrappersMap');
+/**
+ * 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, contextStatements, dependencies) {
+        // Use the actual template string (with placeholders) as the primary key
+        const templateKey = templateString;
+        // Capture names
+        const capturesKey = captures.map(c => c.getName()).join(',');
+        // Context statements
+        const contextKey = contextStatements.join(';');
+        // Dependencies
+        const depsKey = JSON.stringify(dependencies || {});
+        return `${templateKey}::${capturesKey}::${contextKey}::${depsKey}`;
+    }
+    /**
+     * Gets a cached compilation unit or creates and caches a new one.
+     */
+    getOrParse(templateString, captures, contextStatements, dependencies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this.generateKey(templateString, captures, contextStatements, 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 context statements for type attribution context
+            const fullTemplateString = contextStatements.length > 0
+                ? contextStatements.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();
+    }
+}
+exports.TemplateCache = TemplateCache;
+// Global cache instance
+exports.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, variadicOptions) {
+        this.captureName = captureName;
+        this.variadicOptions = variadicOptions;
+        this.kind = 'org.openrewrite.javascript.CaptureMarker';
+        this.id = (0, uuid_1.randomId)();
+    }
+}
+exports.CaptureMarker = CaptureMarker;
+/**
+ * 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;
+    }
+    /**
+     * Gets the CaptureMarker from a node, if present.
+     *
+     * @param node The node to check
+     * @returns The CaptureMarker or undefined
+     */
+    static getCaptureMarker(node) {
+        for (const marker of node.markers.markers) {
+            if (marker instanceof CaptureMarker) {
+                return marker;
+            }
+        }
+        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: "__capt_unnamed_N__"
+        if (identifier.startsWith(`${this.CAPTURE_PREFIX}unnamed_`)) {
+            const match = identifier.match(/__capt_(unnamed_\d+)__/);
+            return match ? { name: match[1] } : null;
+        }
+        // Handle all other captures (including any()): "__capt_name__" or "__capt_name_type__"
+        const match = identifier.match(/__capt_([^_]+(?:_\d+)?)(?:_([^_]+))?__/);
+        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) {
+        // Always use CAPTURE_PREFIX - the capturing flag is used internally for binding behavior
+        return typeConstraint
+            ? `${this.CAPTURE_PREFIX}${name}_${typeConstraint}__`
+            : `${this.CAPTURE_PREFIX}${name}__`;
+    }
+    /**
+     * Checks if a capture marker indicates a variadic capture.
+     *
+     * @param node The node to check
+     * @returns true if the node has a variadic CaptureMarker, false otherwise
+     */
+    static isVariadicCapture(node) {
+        for (const marker of node.markers.markers) {
+            if (marker instanceof CaptureMarker && marker.variadicOptions) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Gets the variadic options from a capture marker.
+     *
+     * @param node The node to extract variadic options from
+     * @returns The VariadicOptions, or undefined if not a variadic capture
+     */
+    static getVariadicOptions(node) {
+        for (const marker of node.markers.markers) {
+            if (marker instanceof CaptureMarker) {
+                return marker.variadicOptions;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Checks if a statement is an ExpressionStatement wrapping a capture identifier.
+     * When a capture placeholder appears in statement position, the parser wraps it as
+     * an ExpressionStatement. This method unwraps it to get the identifier.
+     *
+     * @param stmt The statement to check
+     * @returns The unwrapped capture identifier, or the original statement if not wrapped
+     */
+    static unwrapStatementCapture(stmt) {
+        var _a, _b;
+        // Check if it's an ExpressionStatement containing a capture identifier
+        if (stmt.kind === index_1.JS.Kind.ExpressionStatement) {
+            const exprStmt = stmt;
+            if (((_a = exprStmt.expression) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.Identifier) {
+                const identifier = exprStmt.expression;
+                // Check if this is a capture placeholder
+                if ((_b = identifier.simpleName) === null || _b === void 0 ? void 0 : _b.startsWith(this.CAPTURE_PREFIX)) {
+                    return identifier;
+                }
+            }
+        }
+        return stmt;
+    }
+}
+exports.PlaceholderUtils = PlaceholderUtils;
+PlaceholderUtils.CAPTURE_PREFIX = '__capt_';
+PlaceholderUtils.PLACEHOLDER_PREFIX = '__PLACEHOLDER_';
+//# sourceMappingURL=utils.js.map

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

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

package/dist/version.txt

@@ -1 +1 @@
-8.67.0-20251104-084009
+8.67.0-20251104-114312