@openrewrite/rewrite 8.92.14 → 8.92.16

package/src/javascript/add-import.ts

@@ -2,7 +2,8 @@ import {JavaScriptVisitor} from "./visitor";
 import {ElementRemovalFormatter, emptySpace, isIdentifier, J, NameTree, rightPadded, singleSpace, space, Statement, TrailingComma, Type} from "../java";
 import {JS, JSX} from "./tree";
 import {randomId, UUID} from "../uuid";
-import {emptyMarkers, findMarker, markers} from "../markers";
+import {emptyMarkers, findMarker, markers, MarkersKind} from "../markers";
+import {NamedStyles} from "../style";
 import {getStyle, SpacesStyle, StyleKind} from "./style";
 import {bindingNames, compilationUnitOf, cursorOf, declarationsOf, deconflict, isValueReference, namesDeclaredIn, scopeOf, walk} from "./scope";
 import {create as produce, Draft} from "mutative";
@@ -437,7 +438,7 @@ export function moduleNameOf(module: string | J.Literal): string {
     }
     restored += source.slice(cut);
     const quote = restored.charAt(0);
-    return (quote === "'" || quote === '"') && restored.endsWith(quote) && restored.length > 1
+    return (quote === "'" || quote === '"' || quote === '`') && restored.endsWith(quote) && restored.length > 1
         ? restored.slice(1, -1)
         : restored;
 }
@@ -455,12 +456,34 @@ function quoteOf(expression: J | undefined): QuoteChar | undefined {
         : undefined;
 }
 
+/**
+ * The value a Prettier configuration on `cu` gives `option`, or Prettier's own `fallback` where the
+ * configuration does not name it; `undefined` without a configuration in force. A configuration
+ * outranks the file's own evidence, since running Prettier would arrive at its answer anyway.
+ */
+function prettierOption<T>(cu: JS.CompilationUnit, option: string, fallback: T): T | undefined {
+    const prettier = getPrettierStyle(cu);
+    if (!prettier || prettier.ignored) {
+        return undefined;
+    }
+    const value = prettier.config[option];
+    return typeof value === typeof fallback ? value as T : fallback;
+}
+
 /**
  * Pick the quote character for a module specifier being added to `cu`, so that it agrees
- * with the file it lands in. An existing specifier is the most direct precedent; a Prettier
- * config states intent even where the file itself has not been formatted to match.
+ * with the file it lands in. A Prettier configuration settles it; short of one, the caller's
+ * `requested` quote, then an existing specifier as the most direct precedent.
  */
-async function detectQuote(cu: JS.CompilationUnit): Promise<QuoteChar> {
+async function detectQuote(cu: JS.CompilationUnit, requested?: QuoteChar): Promise<QuoteChar> {
+    const singleQuote = prettierOption(cu, 'singleQuote', false);
+    if (singleQuote !== undefined) {
+        return singleQuote ? "'" : '"';
+    }
+    if (requested) {
+        return requested;
+    }
+
     // Static imports are top-level, so the highest-ranked signal needs no traversal to find.
     for (const statement of cu.statements) {
         const element = statement.element;
@@ -521,25 +544,87 @@ async function detectQuote(cu: JS.CompilationUnit): Promise<QuoteChar> {
         return specifierQuote;
     }
 
-    const prettier = getPrettierStyle(cu);
-    if (prettier && !prettier.ignored) {
-        const singleQuote = prettier.config.singleQuote;
-        if (typeof singleQuote === 'boolean') {
-            return singleQuote ? "'" : '"';
+    return double > single ? '"' : "'";
+}
+
+/** Top-level statements that end in `;` in a file that uses semicolons at all. */
+const semicolonTerminated = new Set<string>([
+    JS.Kind.Import, JS.Kind.ExportDeclaration, JS.Kind.ExportAssignment, JS.Kind.TypeDeclaration,
+    JS.Kind.ExpressionStatement, J.Kind.VariableDeclarations, J.Kind.MethodInvocation, J.Kind.Assignment
+]);
+
+/**
+ * Whether an import statement added to `cu` should end in `;`. A Prettier configuration settles
+ * it; short of one, the file's imports, then its other statements that would take one.
+ */
+function detectSemi(cu: JS.CompilationUnit): boolean {
+    const semi = prettierOption(cu, 'semi', true);
+    if (semi !== undefined) {
+        return semi;
+    }
+    const tally = (kinds: (kind: string) => boolean): number => {
+        let score = 0;
+        for (const statement of cu.statements) {
+            if (statement.element && kinds(statement.element.kind)) {
+                score += findMarker(statement, J.Markers.Semicolon) ? 1 : -1;
+            }
         }
-    }
+        return score;
+    };
+    const score = cu.statements.some(s => s.element?.kind === JS.Kind.Import)
+        ? tally(kind => kind === JS.Kind.Import)
+        : tally(kind => semicolonTerminated.has(kind));
+    return score >= 0;
+}
 
-    return double > single ? '"' : "'";
+/**
+ * Whether a brace list added to `cu` is written `{ x }` rather than `{x}`. A Prettier configuration
+ * settles it; short of one, the file's own single-line import lists, then the style in force.
+ */
+function detectBraceSpacing(cu: JS.CompilationUnit): boolean {
+    const bracketSpacing = prettierOption(cu, 'bracketSpacing', true);
+    if (bracketSpacing !== undefined) {
+        return bracketSpacing;
+    }
+    let score = 0;
+    for (const statement of cu.statements) {
+        const namedBindings = statement.element?.kind === JS.Kind.Import
+            ? (statement.element as JS.Import).importClause?.namedBindings
+            : undefined;
+        if (namedBindings?.kind !== JS.Kind.NamedImports) {
+            continue;
+        }
+        const first = (namedBindings as JS.NamedImports).elements.elements[0]?.element;
+        // A list laid out one per line says nothing about how a one-line list is spaced.
+        if (first && !first.prefix.whitespace.includes('\n')) {
+            score += first.prefix.whitespace.length > 0 ? 1 : -1;
+        }
+    }
+    if (score !== 0) {
+        return score > 0;
+    }
+    return (getStyle(StyleKind.SpacesStyle, cu) as SpacesStyle).within.es6ImportExportBraces;
 }
 
 /**
- * Lays out the import statement `AddImport` wrote, so that the file's own style — a Prettier
- * configuration's brace spacing and print width, say — reaches it.
+ * Lays out the import statement `AddImport` wrote, so that a Prettier configuration's print width,
+ * say, reaches it. Its quote, brace spacing and semicolon were already chosen to match the file.
  */
-async function formatImport<P>(cu: JS.CompilationUnit, id: UUID, p: P): Promise<JS.CompilationUnit> {
+async function formatImport<P>(cu: JS.CompilationUnit, id: UUID, p: P, braceSpacing?: boolean): Promise<JS.CompilationUnit> {
+    // The formatter would otherwise re-space the braces by the style in force, over the file's own evidence.
+    const spaces = getStyle(StyleKind.SpacesStyle, cu) as SpacesStyle;
+    const styles: NamedStyles<string>[] | undefined =
+        braceSpacing === undefined || braceSpacing === spaces.within.es6ImportExportBraces ? undefined : [{
+            kind: MarkersKind.NamedStyles,
+            id: randomId(),
+            name: "org.openrewrite.javascript.AddImport",
+            displayName: "Brace spacing detected by AddImport",
+            tags: [],
+            styles: [{...spaces, within: {...spaces.within, es6ImportExportBraces: braceSpacing}} as SpacesStyle]
+        }];
     return await new class extends JavaScriptVisitor<P> {
         override async visitImportDeclaration(jsImport: JS.Import, p: P): Promise<J | undefined> {
-            return jsImport.id === id ? await autoFormat(jsImport, p, undefined, this.cursor.parent) : jsImport;
+            return jsImport.id === id ? await autoFormat(jsImport, p, undefined, this.cursor.parent, styles) : jsImport;
         }
     }().visit(cu, p) as JS.CompilationUnit;
 }
@@ -820,15 +905,13 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
 
         const withImport = await this.produceJavaScript(compilationUnit, p, async draft => {
             // Insert the import at the appropriate position
-            // Create semicolon marker for the import statement
-            const semicolonMarkers = markers({
-                kind: J.Markers.Semicolon,
-                id: randomId()
-            });
+            const semicolonMarkers = detectSemi(compilationUnit)
+                ? markers({kind: J.Markers.Semicolon, id: randomId()})
+                : emptyMarkers;
 
             if (insertionIndex === 0) {
                 // Insert at the beginning
-                // The `after` space should be empty since semicolon is printed after it
+                // The `after` space should be empty since any semicolon is printed after it
                 // The spacing comes from updating the next statement's prefix
                 const updatedStatements = compilationUnit.statements.length > 0
                     ? [
@@ -876,7 +959,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
             }
         });
 
-        return formatImport(withImport, newImport.id, p);
+        return formatImport(withImport, newImport.id, p, detectBraceSpacing(compilationUnit));
     }
 
     /**
@@ -1150,6 +1233,9 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
      * or extracting it from the FQN.
      */
     private getModuleFromClassType(classType: Type.Class): string | undefined {
+        if (Type.isFunctionType(classType)) {
+            return undefined;
+        }
         // Traverse owningClass chain to find the root
         let current: Type.Class = classType;
         while (current.owningClass && Type.isClass(current.owningClass)) {
@@ -1272,6 +1358,8 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
         const targetModule = this.module;
         let found = false;
         const self = this;
+        const matchesModule = (name: string | undefined) =>
+            name !== undefined && (name === expectedDeclaringType || name === targetModule);
 
         // If no existing imports from this module, look for unresolved references
         // If there ARE existing imports, look for references with the expected declaring type
@@ -1285,12 +1373,13 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
                         // We have an expected declaring type - check for exact match
                         if (type && Type.isMethod(type)) {
                             const declaringTypeName = Type.FullyQualified.getFullyQualifiedName((type as Type.Method).declaringType);
-                            if (declaringTypeName === expectedDeclaringType) {
+                            if (matchesModule(declaringTypeName)) {
                                 found = true;
                             }
                         }
                         else if (type && Type.isClass(type)) {
-                            if (self.classTypeMatchesModule(type as Type.Class, expectedDeclaringType)) {
+                            if (self.classTypeMatchesModule(type as Type.Class, expectedDeclaringType) ||
+                                self.classTypeMatchesModule(type as Type.Class, targetModule)) {
                                 found = true;
                             }
                         }
@@ -1298,7 +1387,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
                             const ownerTypeName = (fieldType as Type.Variable).owner
                                 ? Type.FullyQualified.getFullyQualifiedName((fieldType as Type.Variable).owner!)
                                 : undefined;
-                            if (ownerTypeName === expectedDeclaringType) {
+                            if (matchesModule(ownerTypeName)) {
                                 found = true;
                             }
                         }
@@ -1346,25 +1435,17 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
             }
 
             override async visitMethodInvocation(methodInvocation: J.MethodInvocation, p: void): Promise<J | undefined> {
-                if (methodInvocation.methodType && methodInvocation.methodType.name === targetName) {
-                    if (expectedDeclaringType) {
-                        const declaringTypeName = Type.FullyQualified.getFullyQualifiedName(methodInvocation.methodType.declaringType);
-                        if (declaringTypeName === expectedDeclaringType) {
-                            found = true;
-                        }
-                    }
+                if (expectedDeclaringType && methodInvocation.methodType && methodInvocation.methodType.name === targetName &&
+                    matchesModule(Type.FullyQualified.getFullyQualifiedName(methodInvocation.methodType.declaringType))) {
+                    found = true;
                 }
                 return super.visitMethodInvocation(methodInvocation, p);
             }
 
             override async visitFunctionCall(functionCall: JS.FunctionCall, p: void): Promise<J | undefined> {
-                if (functionCall.methodType && functionCall.methodType.name === targetName) {
-                    if (expectedDeclaringType) {
-                        const declaringTypeName = Type.FullyQualified.getFullyQualifiedName(functionCall.methodType.declaringType);
-                        if (declaringTypeName === expectedDeclaringType) {
-                            found = true;
-                        }
-                    }
+                if (expectedDeclaringType && functionCall.methodType && functionCall.methodType.name === targetName &&
+                    matchesModule(Type.FullyQualified.getFullyQualifiedName(functionCall.methodType.declaringType))) {
+                    found = true;
                 }
                 return super.visitFunctionCall(functionCall, p);
             }
@@ -1373,13 +1454,9 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
                 const type = fieldAccess.type;
                 if (type && Type.isMethod(type)) {
                     const methodType = type as Type.Method;
-                    if (methodType.name === targetName) {
-                        if (expectedDeclaringType) {
-                            const declaringTypeName = Type.FullyQualified.getFullyQualifiedName(methodType.declaringType);
-                            if (declaringTypeName === expectedDeclaringType) {
-                                found = true;
-                            }
-                        }
+                    if (expectedDeclaringType && methodType.name === targetName &&
+                        matchesModule(Type.FullyQualified.getFullyQualifiedName(methodType.declaringType))) {
+                        found = true;
                     }
                 }
                 return super.visitFieldAccess(fieldAccess, p);
@@ -1403,7 +1480,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
         // Note: value is the unquoted module name; valueSource and unicodeEscapes are its printed form
         let valueSource = this.moduleValueSource;
         if (valueSource === undefined) {
-            const quote = this.quoteStyle ?? await detectQuote(compilationUnit);
+            const quote = await detectQuote(compilationUnit, this.quoteStyle);
             valueSource = `${quote}${this.module}${quote}`;
         }
         const moduleSpecifier: J.Literal = {
@@ -1490,9 +1567,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
         } else {
             // Named import: import { member } from 'module'
 
-            // Get the spaces style for brace spacing
-            const spacesStyle = getStyle(StyleKind.SpacesStyle, compilationUnit) as SpacesStyle;
-            const braceSpace = spacesStyle.within.es6ImportExportBraces ? singleSpace : emptySpace;
+            const braceSpace = detectBraceSpacing(compilationUnit) ? singleSpace : emptySpace;
 
             const importSpec = this.createImportSpecifier();
             // Apply brace spacing: the space after { is in the specifier's prefix,
@@ -1672,7 +1747,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
  */
 function importBinds(jsImport: JS.Import, module: string, member: string | undefined): string | undefined {
     const specifier = jsImport.moduleSpecifier?.element;
-    if (specifier?.kind !== J.Kind.Literal || (specifier as J.Literal).value !== module) {
+    if (specifier?.kind !== J.Kind.Literal || moduleNameOf(specifier as J.Literal) !== module) {
         return undefined;
     }
     const importClause = jsImport.importClause;
@@ -1822,7 +1897,7 @@ function aliasing(local: J.Identifier, member: string): JS.Alias {
  * Drops the binding for `member` from `jsImport`'s clause — the default, the namespace alias, or
  * one entry of the named list, whichever `member` names — keeping everything else the clause
  * binds. `ElementRemovalFormatter` carries the dropped binding's prefix onto whatever prints
- * next, the same way `RemoveImport` keeps formatting sane when trimming a list.
+ * next, and a dropped last entry's trailing space onto the new last, as `RemoveImport` does.
  */
 function removeBinding(jsImport: JS.Import, member: string | undefined): JS.Import {
     const importClause = jsImport.importClause;
@@ -1876,6 +1951,12 @@ function removeBinding(jsImport: JS.Import, member: string | undefined): JS.Impo
         // last member; the caller drops the whole statement when no default remains either.
         return {...jsImport, importClause: {...importClause, namedBindings: undefined}};
     }
+    // The space before `}` and any trailing comma belong to the last entry, so they move onto the
+    // new last entry when the old one is dropped.
+    const originalLast = namedImports.elements.elements[namedImports.elements.elements.length - 1];
+    if (namedSpecifierImports(originalLast.element.specifier, key)) {
+        kept[kept.length - 1] = {...kept[kept.length - 1], after: originalLast.after, markers: originalLast.markers};
+    }
     const updatedNamedImports: JS.NamedImports = {...namedImports, elements: {...namedImports.elements, elements: kept}};
     return {...jsImport, importClause: {...importClause, namedBindings: updatedNamedImports}};
 }
@@ -1948,6 +2029,7 @@ export class RebindImport<P> extends JavaScriptVisitor<P> {
             const originalSource = literal.valueSource || `"${this.from.module}"`;
             const quoteChar = originalSource.startsWith("'") ? "'" : '"';
             literal.valueSource = `${quoteChar}${this.to.module}${quoteChar}`;
+            literal.unicodeEscapes = undefined;
 
             // A default or namespace import carries its local name on the clause itself; a named
             // one states the member alongside it, in the specifier.

package/src/javascript/amd.ts

@@ -29,6 +29,7 @@ import {
     TrailingComma
 } from "../java";
 import {JS} from "./tree";
+import {moduleNameOf} from "./add-import";
 import {cursorOf, deconflict, namesDeclaredWithin, scopeOf} from "./scope";
 import {Cursor} from "../tree";
 import {JavaScriptVisitor} from "./visitor";
@@ -183,7 +184,7 @@ function foldDeclarationTrailingSpace(entry: J.RightPadded<J>): J.RightPadded<J>
 export function dependencyNames(block: AmdBlock): string[] {
     return elementsOf(block).map(padded => {
         const element = padded.element;
-        return isLiteral(element) && typeof element.value === "string" ? element.value : "";
+        return isLiteral(element) && typeof element.value === "string" ? moduleNameOf(element) : "";
     });
 }
 
@@ -519,7 +520,7 @@ export function withDependencyModuleAt(
     const elements = [...elementsOf(block)];
     const entry = elements[index];
     const literal = entry.element as J.Literal;
-    const updated: J.Literal = {...literal, value: module, valueSource: `${quote}${module}${quote}`};
+    const updated: J.Literal = {...literal, value: module, valueSource: `${quote}${module}${quote}`, unicodeEscapes: undefined};
     elements[index] = {...entry, element: updated};
     const dependencies = withElements(block.dependencies, elements);
     return withParts(call, block, dependencies, block.factory);

package/src/javascript/binding.ts

@@ -164,7 +164,7 @@ function dynamicallyImportedModule(declaration: J.VariableDeclarations): string
     }
     const argument = call.arguments.elements[0]?.element;
     return argument?.kind === J.Kind.Literal && typeof (argument as J.Literal).value === "string"
-        ? (argument as J.Literal).value as string
+        ? moduleNameOf(argument as J.Literal)
         : undefined;
 }
 
@@ -200,10 +200,10 @@ function moduleObjectBindings(cu: JS.CompilationUnit): ModuleObjectBinding[] {
         if (specifier?.kind !== J.Kind.Literal) {
             continue;
         }
-        const module = (specifier as J.Literal).value;
-        if (typeof module !== "string") {
+        if (typeof (specifier as J.Literal).value !== "string") {
             continue;
         }
+        const module = moduleNameOf(specifier as J.Literal);
         const clause = jsImport.importClause;
         const typeOnly = clause?.typeOnly ?? false;
         if (clause?.name?.element?.kind === J.Kind.Identifier) {

package/src/javascript/index.ts

@@ -54,6 +54,9 @@ export * from "./remove-import";
 export * from "./cleanup/index";
 export * from "./recipes/index";
 export * from "./search/index";
+export * from "./migrate/index";
+export * from "./migrate/es6/index";
+export * from "./migrate/typescript/index";
 
 import "./print";
 import "./rpc";

package/src/javascript/migrate/es6/modernize-octal-escape-sequences.ts

@@ -19,12 +19,13 @@ import {TreeVisitor} from "../../../visitor";
 import {ExecutionContext} from "../../../execution";
 import {JavaScriptVisitor} from "../../visitor";
 import {J} from "../../../java";
+import {JS} from "../../tree";
 import {create as produce} from "mutative";
 
 export class ModernizeOctalEscapeSequences extends Recipe {
     name = "org.openrewrite.javascript.migrate.es6.modernize-octal-escape-sequences";
     displayName = "Modernize octal escape sequences";
-    description = "Convert old-style octal escape sequences (e.g., `\\0`, `\\123`) to modern hex escape sequences (e.g., `\\x00`, `\\x53`) or Unicode escape sequences (e.g., `\\u0000`, `\\u0053`).";
+    description = "Convert legacy octal escape sequences in string literals (e.g., `\\1`, `\\123`) to hex escape sequences (e.g., `\\x01`, `\\x53`) or Unicode escape sequences (e.g., `\\u0001`, `\\u0053`). The `\\0` escape is left alone unless a digit follows it.";
 
     @Option({
         displayName: "Use Unicode escapes",
@@ -41,50 +42,41 @@ export class ModernizeOctalEscapeSequences extends Recipe {
 
     async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
         const useUnicode = this.useUnicodeEscapes;
+        const modernize = (source: string) => source.replace(
+            /\\([0-3][0-7]{0,2}|[4-7][0-7]?|[\s\S])/g,
+            (escape: string, body: string, offset: number) => {
+                if (!/^[0-7]/.test(body) || (body === '0' && !/[0-9]/.test(source[offset + 2] ?? ''))) {
+                    return escape;
+                }
+                const code = parseInt(body, 8);
+                return useUnicode ?
+                    `\\u${code.toString(16).padStart(4, '0')}` :
+                    `\\x${code.toString(16).padStart(2, '0')}`;
+            });
         return new class extends JavaScriptVisitor<ExecutionContext> {
 
             protected async visitLiteral(literal: J.Literal, _ctx: ExecutionContext): Promise<J | undefined> {
-                // Only process string literals
-                if (typeof literal.value !== 'string') {
-                    return literal;
-                }
-
                 const valueSource = literal.valueSource;
-                if (!valueSource) {
+                if (!valueSource || (valueSource[0] !== '"' && valueSource[0] !== "'") ||
+                    this.cursor.parentTree()?.value.kind === JS.Kind.JsxAttribute) {
                     return literal;
                 }
 
-                // Check if this string contains octal escape sequences
-                // Octal escape sequences: \0 through \377 (1-3 octal digits)
-                // Pattern: backslash followed by 1-3 octal digits (0-7)
-                // We need to be careful not to match already escaped sequences
-                const octalEscapePattern = /\\([0-7]{1,3})/g;
-
-                let hasOctalEscapes = false;
-                let modernized = valueSource;
-
-                // Replace all octal escape sequences with hex or Unicode equivalents
-                modernized = valueSource.replace(octalEscapePattern, (match, octalDigits) => {
-                    hasOctalEscapes = true;
-                    // Convert octal string to decimal number
-                    const decimalValue = parseInt(octalDigits, 8);
-
-                    if (useUnicode) {
-                        // Convert to Unicode escape sequence (4 hex digits, zero-padded)
-                        return `\\u${decimalValue.toString(16).padStart(4, '0')}`;
-                    } else {
-                        // Convert to hex escape sequence (2 hex digits, zero-padded)
-                        return `\\x${decimalValue.toString(16).padStart(2, '0')}`;
-                    }
+                // Surrogate escapes are held outside valueSource, so each run between them is rewritten on its own
+                // and the escapes are moved to where their runs now end.
+                let modernized = '';
+                let cut = 0;
+                const unicodeEscapes = literal.unicodeEscapes?.map(escape => {
+                    modernized += modernize(valueSource.slice(cut, escape.valueSourceIndex));
+                    cut = escape.valueSourceIndex;
+                    return {...escape, valueSourceIndex: modernized.length};
                 });
+                modernized += modernize(valueSource.slice(cut));
 
-                if (hasOctalEscapes) {
-                    return produce(literal, draft => {
-                        draft.valueSource = modernized;
-                    });
-                }
-
-                return literal;
+                return modernized === valueSource ? literal : produce(literal, draft => {
+                    draft.valueSource = modernized;
+                    draft.unicodeEscapes = unicodeEscapes;
+                });
             }
         }
     }

package/src/javascript/preconditions.ts

@@ -15,7 +15,7 @@
  */
 import {RecipeRef} from "../preconditions";
 import {IsSourceFile} from "../search";
-import {UsesMethod, UsesType} from "./search";
+import {IsVendoredOrBundled, UsesMethod, UsesType} from "./search";
 
 /**
  * Match source files by path glob.
@@ -40,6 +40,24 @@ export function hasSourcePath(filePattern: string): RecipeRef {
     );
 }
 
+/**
+ * Match vendored, bundled and build-output JavaScript and TypeScript sources,
+ * typically negated with {@link not} so that a recipe leaves them alone.
+ *
+ * Returns a {@link RecipeRef} placeholder bundled with a native
+ * {@link IsVendoredOrBundled} visitor for in-process evaluation; see
+ * {@link hasSourcePath} for the introspection / lazy-evaluation pattern.
+ *
+ * Delegates to {@code org.openrewrite.javascript.search.FindVendoredOrBundled}.
+ */
+export function isVendoredOrBundled(): RecipeRef {
+    return new RecipeRef(
+        "org.openrewrite.javascript.search.FindVendoredOrBundled",
+        {},
+        new IsVendoredOrBundled(),
+    );
+}
+
 /**
  * Match files using a specific method.
  *

package/src/javascript/search/index.ts

@@ -1,6 +1,7 @@
 import {CategoryDescriptor, JavaScript} from "../../marketplace";
 
 export * from './find-dependency';
+export * from './is-vendored-or-bundled';
 export * from './uses-method';
 export * from './uses-type';
 

package/src/javascript/search/is-vendored-or-bundled.ts

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2026 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.
+ */
+import * as picomatch from "picomatch";
+import {ExecutionContext} from "../../execution";
+import {TreeVisitor} from "../../visitor";
+import {foundSearchResult} from "../../markers";
+import {J, TextComment} from "../../java";
+import {JS} from "../tree";
+
+const PATH_PATTERNS = [
+    "**/node_modules/**",
+    "**/bower_components/**",
+    "**/vendor/**",
+    "**/dist/**",
+    "**/*.min.*",
+    "**/*.bundle.*"
+];
+
+const SOURCE_MAPPING_URL = /^[#@] sourceMappingURL=/;
+
+/**
+ * Marks JavaScript and TypeScript sources that are vendored, bundled or build output.
+ * In-process counterpart of {@code org.openrewrite.javascript.search.FindVendoredOrBundled};
+ * keep the two in sync.
+ */
+export class IsVendoredOrBundled extends TreeVisitor<any, ExecutionContext> {
+    private readonly matcher: picomatch.Matcher =
+        picomatch.default ? picomatch.default(PATH_PATTERNS) : (picomatch as any)(PATH_PATTERNS);
+
+    protected async preVisit(tree: any, _: ExecutionContext): Promise<any> {
+        this.stopAfterPreVisit();
+        if (tree.kind === JS.Kind.CompilationUnit && this.isVendoredOrBundled(tree as JS.CompilationUnit)) {
+            return foundSearchResult(tree);
+        }
+        return tree;
+    }
+
+    private isVendoredOrBundled(cu: JS.CompilationUnit): boolean {
+        if (this.matcher(cu.sourcePath.replace(/\\/g, '/'))) {
+            return true;
+        }
+        const comments = cu.eof.comments;
+        const last = comments[comments.length - 1];
+        return last?.kind === J.Kind.TextComment && SOURCE_MAPPING_URL.test((last as TextComment).text.trim());
+    }
+}