@openrewrite/rewrite 8.69.0-20251207-160255 → 8.69.0-20251207-214914

package/src/javascript/recipes/index.ts

@@ -14,4 +14,7 @@
  * limitations under the License.
  */
 
+export * from "./async-callback-in-sync-array-method";
 export * from "./upgrade-dependency-version";
+export * from "./order-imports";
+export * from "./change-import";

package/src/javascript/recipes/order-imports.ts

@@ -0,0 +1,242 @@
+/*
+ * 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.
+ */
+
+import {Recipe} from "../../recipe";
+import {produceAsync, TreeVisitor} from "../../visitor";
+import {ExecutionContext} from "../../execution";
+import {JavaScriptVisitor, JS} from "../index";
+import {J} from "../../java";
+import {Draft, produce} from "immer";
+import {SpacesStyle, styleFromSourceFile, StyleKind} from "../style";
+
+/**
+ * Import type categories for sorting order:
+ * 1. Side-effect imports (no specifier): import 'module';
+ * 2. Namespace imports: import * as foo from 'module';
+ * 3. Default imports: import foo from 'module';
+ * 4. Named imports: import { foo } from 'module';
+ * 5. Type imports: import type { Foo } from 'module';
+ */
+enum ImportCategory {
+    SideEffect = 0,
+    Namespace = 1,
+    Default = 2,
+    Named = 3,
+    Type = 4
+}
+
+export class OrderImports extends Recipe {
+    readonly name = "org.openrewrite.javascript.cleanup.order-imports";
+    readonly displayName = "Order imports";
+    readonly description = "Sort imports by category and module path. Categories: side-effect, namespace, default, named, type. Within each category, imports are sorted alphabetically by module path. Named specifiers within each import are also sorted alphabetically.";
+
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+
+            protected async visitJsCompilationUnit(cu: JS.CompilationUnit, p: ExecutionContext): Promise<J | undefined> {
+                const importCount = this.countImports(cu);
+                if (importCount === 0) {
+                    return cu;
+                }
+
+                const imports = cu.statements.slice(0, importCount) as J.RightPadded<JS.Import>[];
+                const originalImportPosition = Object.fromEntries(imports.map((item, i) => [item.element.id, i]));
+                const restStatements = cu.statements.slice(importCount);
+
+                // Get style for consistent brace spacing
+                const spacesStyle = styleFromSourceFile(StyleKind.SpacesStyle, cu) as SpacesStyle | undefined;
+                const useBraceSpaces = spacesStyle?.within.es6ImportExportBraces ?? false;
+
+                // Sort named specifiers within each import
+                const sortedSpecifiers = this.sortNamedSpecifiersWithinImports(imports, useBraceSpaces);
+
+                // Sort imports by category and module path
+                sortedSpecifiers.sort((aPadded, bPadded) => {
+                    const a = aPadded.element;
+                    const b = bPadded.element;
+
+                    // First, compare by category
+                    const categoryA = this.getImportCategory(a);
+                    const categoryB = this.getImportCategory(b);
+                    if (categoryA !== categoryB) {
+                        return categoryA - categoryB;
+                    }
+
+                    // Within same category, sort by module path (case-insensitive)
+                    const modulePathA = this.getModulePath(a).toLowerCase();
+                    const modulePathB = this.getModulePath(b).toLowerCase();
+                    const pathComparison = modulePathA.localeCompare(modulePathB);
+                    if (pathComparison !== 0) {
+                        return pathComparison;
+                    }
+
+                    // Tiebreaker: keep original order for stability
+                    return originalImportPosition[aPadded.element.id] - originalImportPosition[bPadded.element.id];
+                });
+
+                const cuWithImportsSorted = await produceAsync(cu, async draft => {
+                    draft.statements = [...sortedSpecifiers, ...restStatements];
+                });
+
+                return produce(cuWithImportsSorted!, draft => {
+                    for (let i = 0; i < importCount; i++) {
+                        draft.statements[i].element.prefix.whitespace = i > 0 ? "\n" : "";
+                    }
+                });
+            }
+
+            /**
+             * Determine the category of an import for sorting purposes.
+             */
+            private getImportCategory(import_: JS.Import): ImportCategory {
+                // Type imports: import type { Foo } from 'module'
+                if (import_.importClause?.typeOnly) {
+                    return ImportCategory.Type;
+                }
+
+                // Side-effect imports: import 'module'
+                if (import_.importClause === undefined) {
+                    return ImportCategory.SideEffect;
+                }
+
+                // Namespace imports: import * as foo from 'module'
+                if (import_.importClause.namedBindings?.kind === JS.Kind.Alias) {
+                    const alias = import_.importClause.namedBindings as JS.Alias;
+                    if (alias.propertyName.element.simpleName === "*") {
+                        return ImportCategory.Namespace;
+                    }
+                }
+
+                // Default imports (without named imports): import foo from 'module'
+                if (import_.importClause.name && !import_.importClause.namedBindings) {
+                    return ImportCategory.Default;
+                }
+
+                // Default with named imports or just named imports: import foo, { bar } from 'module' or import { foo } from 'module'
+                return ImportCategory.Named;
+            }
+
+            /**
+             * Extract the module path from an import statement.
+             */
+            private getModulePath(import_: JS.Import): string {
+                if (import_.moduleSpecifier?.element.kind === J.Kind.Literal) {
+                    const literal = import_.moduleSpecifier.element as J.Literal;
+                    // Remove quotes from the value
+                    return String(literal.value ?? '');
+                }
+                return '';
+            }
+
+            private countImports(cu: JS.CompilationUnit): number {
+                let i = 0;
+                while ((i < cu.statements.length) && (cu.statements[i].element.kind === JS.Kind.Import)) {
+                    i++;
+                }
+                return i;
+            }
+
+            /**
+             * Sort named specifiers within each import statement alphabetically.
+             */
+            private sortNamedSpecifiersWithinImports(imports: J.RightPadded<JS.Import>[], useBraceSpaces: boolean): J.RightPadded<JS.Import>[] {
+                const ret = [];
+                for (const importPadded of imports) {
+                    const import_ = importPadded.element;
+                    if (this.hasNamedImports(import_)) {
+                        const importSorted = produce(import_, draft => {
+                            const namedBindings = draft.importClause!.namedBindings as Draft<JS.NamedImports>;
+                            let elements = namedBindings.elements.elements;
+
+                            if (elements.length <= 1) {
+                                return; // Nothing to sort
+                            }
+
+                            // Handle trailing comma
+                            const trailingComma = elements.length > 0 &&
+                                elements[elements.length - 1].markers?.markers.find(m => m.kind === J.Markers.TrailingComma);
+                            if (trailingComma) {
+                                elements[elements.length - 1].markers.markers =
+                                    elements[elements.length - 1].markers.markers.filter(m => m.kind !== J.Markers.TrailingComma);
+                            }
+
+                            // Sort by the imported name (not alias)
+                            elements.sort((a, b) => {
+                                const nameA = this.getSpecifierSortKey(a.element as JS.ImportSpecifier);
+                                const nameB = this.getSpecifierSortKey(b.element as JS.ImportSpecifier);
+                                return nameA.localeCompare(nameB);
+                            });
+
+                            // Normalize spacing based on es6ImportExportBraces style
+                            const braceSpace = useBraceSpaces ? " " : "";
+                            for (let i = 0; i < elements.length; i++) {
+                                if (i === 0) {
+                                    // First element: space after opening brace based on style
+                                    elements[i].element.prefix = {kind: J.Kind.Space, whitespace: braceSpace, comments: []};
+                                } else {
+                                    // Other elements: space after comma
+                                    elements[i].element.prefix = {kind: J.Kind.Space, whitespace: ' ', comments: []};
+                                }
+                            }
+                            // Last element: space before closing brace based on style
+                            elements[elements.length - 1].after = {kind: J.Kind.Space, whitespace: braceSpace, comments: []};
+
+                            // Restore trailing comma to last element
+                            if (trailingComma && elements.length > 0 &&
+                                !elements[elements.length - 1].markers.markers.find(m => m.kind === J.Markers.TrailingComma)) {
+                                elements[elements.length - 1].markers.markers.push(trailingComma);
+                            }
+                        });
+
+                        ret.push(produce(importPadded, draft => {
+                            draft.element = importSorted;
+                        }));
+                    } else {
+                        ret.push(importPadded);
+                    }
+                }
+                return ret;
+            }
+
+            /**
+             * Check if an import has named imports that can be sorted.
+             */
+            private hasNamedImports(import_: JS.Import): boolean {
+                if (import_.importClause?.namedBindings?.kind === JS.Kind.NamedImports) {
+                    const namedImports = import_.importClause.namedBindings as JS.NamedImports;
+                    return namedImports.elements.kind === J.Kind.Container &&
+                        namedImports.elements.elements.length > 1;
+                }
+                return false;
+            }
+
+            /**
+             * Get the sort key for an import specifier (the original name, not alias).
+             */
+            private getSpecifierSortKey(specifier: JS.ImportSpecifier): string {
+                if (specifier.specifier.kind === JS.Kind.Alias) {
+                    // import { foo as bar } - sort by 'foo'
+                    return (specifier.specifier as JS.Alias).propertyName.element.simpleName;
+                } else if (specifier.specifier.kind === J.Kind.Identifier) {
+                    // import { foo } - sort by 'foo'
+                    return (specifier.specifier as J.Identifier).simpleName;
+                }
+                return '';
+            }
+        }
+    }
+}

package/src/javascript/templating/index.ts

@@ -56,7 +56,8 @@ export {
 // Export rewrite functionality
 export {
     rewrite,
-    fromRecipe
+    fromRecipe,
+    flattenBlock
 } from './rewrite';
 
 // Export template functionality

package/src/javascript/templating/rewrite.ts

@@ -13,11 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {Cursor, ExecutionContext, Recipe} from '../..';
-import {J} from '../../java';
-import {RewriteRule, RewriteConfig, PreMatchContext, PostMatchContext} from './types';
-import {Pattern, MatchResult} from './pattern';
+import {Cursor, ExecutionContext, Recipe, TreeVisitor} from '../..';
+import {J, Statement} from '../../java';
+import {PostMatchContext, PreMatchContext, RewriteConfig, RewriteRule} from './types';
+import {MatchResult, Pattern} from './pattern';
 import {Template} from './template';
+import {JavaScriptVisitor} from '../visitor';
 
 /**
  * Implementation of a replacement rule.
@@ -228,3 +229,87 @@ export const fromRecipe = (recipe: Recipe, ctx: ExecutionContext): RewriteRule =
         }
     })();
 }
+
+/**
+ * Registers an after-visitor that will flatten a block's statements into its parent block.
+ *
+ * When a rewrite template produces a J.Block containing multiple statements, but you want
+ * those statements to be inserted directly into the parent block (not nested), use this
+ * function to register a follow-up visitor that performs the flattening.
+ *
+ * @param visitor The current visitor instance (to register the after-visitor)
+ * @param block The block whose statements should be flattened into its parent
+ * @returns The block (for chaining in return statements)
+ *
+ * @example
+ * ```typescript
+ * override async visitReturn(ret: J.Return, ctx: ExecutionContext): Promise<J | undefined> {
+ *     const result = await rewrite(() => ({
+ *         before: pattern`return #{cond} || #{arr}.some(#{cb})`,
+ *         after: template`{
+ *             if (#{cond}) return true;
+ *             for (const item of #{arr}) {
+ *                 if (await #{cb}(item)) return true;
+ *             }
+ *             return false;
+ *         }`
+ *     })).tryOn(this.cursor, ret);
+ *
+ *     if (result && result.kind === J.Kind.Block) {
+ *         return flattenBlock(this, result as J.Block);
+ *     }
+ *     return result ?? ret;
+ * }
+ * ```
+ */
+export function flattenBlock<P>(
+    visitor: TreeVisitor<any, P>,
+    block: J.Block
+): J.Block {
+    // Create a visitor that will flatten this specific block when found in a parent block
+    const flattenVisitor = new class extends JavaScriptVisitor<P> {
+        protected override async visitBlock(parentBlock: J.Block, p: P): Promise<J | undefined> {
+            let modified = false;
+            const newStatements: typeof parentBlock.statements = [];
+
+            for (const stmt of parentBlock.statements) {
+                // Check if this statement is the block we want to flatten
+                if (stmt.element === block || stmt.element.id === block.id) {
+                    // Splice in the inner block's statements
+                    for (let i = 0; i < block.statements.length; i++) {
+                        const innerStmt = block.statements[i];
+                        if (i === 0) {
+                            // First statement inherits the outer statement's padding
+                            newStatements.push({
+                                ...innerStmt,
+                                element: {
+                                    ...innerStmt.element,
+                                    prefix: stmt.element.prefix  // Use the original statement's prefix
+                                } as Statement
+                            });
+                        } else {
+                            newStatements.push(innerStmt);
+                        }
+                    }
+                    modified = true;
+                } else {
+                    newStatements.push(stmt);
+                }
+            }
+
+            if (modified) {
+                return {
+                    ...parentBlock,
+                    statements: newStatements
+                } as J.Block;
+            }
+
+            return super.visitBlock(parentBlock, p);
+        }
+    }();
+
+    // Register the flatten visitor to run after the main visitor completes
+    visitor.afterVisit.push(flattenVisitor);
+
+    return block;
+}

package/src/json/parser.ts

@@ -79,21 +79,38 @@ class ParseJsonReader extends ParserSourceReader {
         }
         if (Array.isArray(parsed)) {
             this.cursor++; // skip '['
-            const values = parsed.map((p, i) => {
-                const element = this.json(p) as Json.Value;
+            let values: Json.RightPadded<Json.Value>[];
+            if (parsed.length === 0) {
+                // Empty array - capture whitespace in an Empty element
                 const afterWhitespace = this.whitespace();
-                // Check if there's a comma after this element
-                const hasComma = this.source[this.cursor] === ',';
-                if (hasComma) {
-                    this.cursor++; // skip ','
-                }
-                return {
+                values = [{
                     kind: Json.Kind.RightPadded,
-                    element,
+                    element: {
+                        kind: Json.Kind.Empty,
+                        id: randomId(),
+                        prefix: emptySpace,
+                        markers: emptyMarkers
+                    } satisfies Json.Empty as Json.Empty,
                     after: space(afterWhitespace),
                     markers: emptyMarkers
-                } satisfies Json.RightPadded<Json.Value> as Json.RightPadded<Json.Value>;
-            });
+                } satisfies Json.RightPadded<Json.Value> as Json.RightPadded<Json.Value>];
+            } else {
+                values = parsed.map((p, i) => {
+                    const element = this.json(p) as Json.Value;
+                    const afterWhitespace = this.whitespace();
+                    // Check if there's a comma after this element
+                    const hasComma = this.source[this.cursor] === ',';
+                    if (hasComma) {
+                        this.cursor++; // skip ','
+                    }
+                    return {
+                        kind: Json.Kind.RightPadded,
+                        element,
+                        after: space(afterWhitespace),
+                        markers: emptyMarkers
+                    } satisfies Json.RightPadded<Json.Value> as Json.RightPadded<Json.Value>;
+                });
+            }
             this.cursor++; // skip ']'
             return {
                 kind: Json.Kind.Array,
@@ -103,21 +120,38 @@ class ParseJsonReader extends ParserSourceReader {
         } else if (parsed !== null && typeof parsed === "object") {
             this.cursor++; // skip '{'
             const keys = Object.keys(parsed);
-            const members = keys.map((key, i) => {
-                const element = this.member(parsed, key);
+            let members: Json.RightPadded<Json.Member>[];
+            if (keys.length === 0) {
+                // Empty object - capture whitespace in an Empty element
                 const afterWhitespace = this.whitespace();
-                // Check if there's a comma after this element
-                const hasComma = this.source[this.cursor] === ',';
-                if (hasComma) {
-                    this.cursor++; // skip ','
-                }
-                return {
+                members = [{
                     kind: Json.Kind.RightPadded,
-                    element,
+                    element: {
+                        kind: Json.Kind.Empty,
+                        id: randomId(),
+                        prefix: emptySpace,
+                        markers: emptyMarkers
+                    } satisfies Json.Empty as Json.Empty as unknown as Json.Member,
                     after: space(afterWhitespace),
                     markers: emptyMarkers
-                } satisfies Json.RightPadded<Json.Member> as Json.RightPadded<Json.Member>;
-            });
+                } satisfies Json.RightPadded<Json.Member> as Json.RightPadded<Json.Member>];
+            } else {
+                members = keys.map((key, i) => {
+                    const element = this.member(parsed, key);
+                    const afterWhitespace = this.whitespace();
+                    // Check if there's a comma after this element
+                    const hasComma = this.source[this.cursor] === ',';
+                    if (hasComma) {
+                        this.cursor++; // skip ','
+                    }
+                    return {
+                        kind: Json.Kind.RightPadded,
+                        element,
+                        after: space(afterWhitespace),
+                        markers: emptyMarkers
+                    } satisfies Json.RightPadded<Json.Member> as Json.RightPadded<Json.Member>;
+                });
+            }
             this.cursor++; // skip '}'
             return {
                 kind: Json.Kind.Object,
@@ -147,11 +181,22 @@ class ParseJsonReader extends ParserSourceReader {
                 value: parsed
             } satisfies Json.Literal as Json.Literal;
         } else if (typeof parsed === "number") {
-            this.cursor += parsed.toString().length;
+            // Extract original source to preserve precision for large numbers
+            const sourceStart = this.cursor;
+            // Numbers can have optional sign, digits, decimal point, and exponent
+            while (this.cursor < this.source.length) {
+                const char = this.source[this.cursor];
+                if (/[\d.eE+\-]/.test(char)) {
+                    this.cursor++;
+                } else {
+                    break;
+                }
+            }
+            const source = this.source.slice(sourceStart, this.cursor);
             return {
                 kind: Json.Kind.Literal,
                 ...base,
-                source: parsed.toString(),
+                source,
                 value: parsed,
             } satisfies Json.Literal as Json.Literal;
         } else if (typeof parsed === "boolean") {

package/src/run.ts

@@ -41,7 +41,11 @@ export class Result {
 }
 
 async function hasScanningRecipe(recipe: Recipe): Promise<boolean> {
-    return recipe instanceof ScanningRecipe || (await recipe.recipeList()).some(hasScanningRecipe);
+    if (recipe instanceof ScanningRecipe) return true;
+    for (const item of (await recipe.recipeList())) {
+        if (await hasScanningRecipe(item)) return true;
+    }
+    return false;
 }
 
 async function recurseRecipeList<T>(recipe: Recipe, initial: T, fn: (recipe: Recipe, t: T) => Promise<T | undefined>): Promise<T | undefined> {
@@ -145,10 +149,7 @@ export async function* scheduleRunStreaming(
     } else {
         // For non-scanning recipes, process files immediately as they come in
         const iterable = Array.isArray(before) ? before : before;
-        let processCount = 0;
         for await (const b of iterable) {
-            processCount++;
-            onProgress?.('processing', processCount, -1, b.sourcePath);
             const editedB = await recurseRecipeList(recipe, b, async (recipe, b2) => (await recipe.editor()).visit(b2, ctx, cursor));
             // Always yield a result so the caller knows when each file is processed
             yield new Result(b, editedB !== b ? editedB : b);

package/dist/recipe/index.d.ts

@@ -1,2 +0,0 @@
-export { OrderImports } from "./order-imports";
-//# sourceMappingURL=index.d.ts.map

package/dist/recipe/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/recipe/index.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC"}

package/dist/recipe/index.js

@@ -1,21 +0,0 @@
-"use strict";
-/*
- * 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.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OrderImports = void 0;
-var order_imports_1 = require("./order-imports");
-Object.defineProperty(exports, "OrderImports", { enumerable: true, get: function () { return order_imports_1.OrderImports; } });
-//# sourceMappingURL=index.js.map

package/dist/recipe/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/recipe/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,iDAA6C;AAArC,6GAAA,YAAY,OAAA"}

package/dist/recipe/order-imports.d.ts

@@ -1,10 +0,0 @@
-import { Recipe } from "../recipe";
-import { TreeVisitor } from "../visitor";
-import { ExecutionContext } from "../execution";
-export declare class OrderImports extends Recipe {
-    name: string;
-    displayName: string;
-    description: string;
-    editor(): Promise<TreeVisitor<any, ExecutionContext>>;
-}
-//# sourceMappingURL=order-imports.d.ts.map

package/dist/recipe/order-imports.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"order-imports.d.ts","sourceRoot":"","sources":["../../src/recipe/order-imports.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAC,MAAM,EAAC,MAAM,WAAW,CAAC;AACjC,OAAO,EAAe,WAAW,EAAC,MAAM,YAAY,CAAC;AACrD,OAAO,EAAC,gBAAgB,EAAC,MAAM,cAAc,CAAC;AAM9C,qBAAa,YAAa,SAAQ,MAAM;IACpC,IAAI,SAAkC;IACtC,WAAW,SAAmB;IAC9B,WAAW,SAAoG;IAGzG,MAAM,IAAI,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;CAoK9D"}