@openrewrite/rewrite 8.69.0-20251207-184829 → 8.69.0-20251207-220615

package/src/javascript/recipes/index.ts

@@ -15,4 +15,7 @@
  */
 
 export * from "./async-callback-in-sync-array-method";
+export * from "./auto-format";
 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/style.ts

@@ -234,7 +234,7 @@ export namespace IntelliJ {
                     additive: true,
                     multiplicative: true,
                     shift: true,
-                    unary: true,
+                    unary: false,
                     arrowFunction: true,
                     beforeUnaryNotAndNotNull: false,
                     afterUnaryNotAndNotNull: false
@@ -378,7 +378,7 @@ export namespace IntelliJ {
                     additive: true,
                     multiplicative: true,
                     shift: true,
-                    unary: true,
+                    unary: false,
                     arrowFunction: true,
                     beforeUnaryNotAndNotNull: false,
                     afterUnaryNotAndNotNull: false

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/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"}

package/dist/recipe/order-imports.js

@@ -1,213 +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.
- */
-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.OrderImports = void 0;
-const recipe_1 = require("../recipe");
-const visitor_1 = require("../visitor");
-const javascript_1 = require("../javascript");
-const java_1 = require("../java");
-const immer_1 = require("immer");
-const format_1 = require("../javascript/format");
-class OrderImports extends recipe_1.Recipe {
-    constructor() {
-        super(...arguments);
-        this.name = "org.openrewrite.OrderImports";
-        this.displayName = "Order imports";
-        this.description = "Sort top-level imports alphabetically within groups: no qualifier, asterisk, multiple, single.";
-    }
-    editor() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new class extends javascript_1.JavaScriptVisitor {
-                visitJsCompilationUnit(cu, p) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        const importCount = this.countImports(cu);
-                        const imports = cu.statements.slice(0, importCount);
-                        const originalImportPosition = Object.fromEntries(imports.map((item, i) => [item.element.id, i]));
-                        const restStatements = cu.statements.slice(importCount);
-                        const sortedImports = yield this.sortNamesWithinEachLine(imports);
-                        sortedImports.sort((aPadded, bPadded) => {
-                            const a = aPadded.element;
-                            const b = bPadded.element;
-                            const noSpecifier = (a.importClause == undefined ? 1 : 0) - (b.importClause == undefined ? 1 : 0);
-                            if (noSpecifier != 0) {
-                                return -noSpecifier;
-                            }
-                            const asterisk = this.isAsteriskImport(a) - this.isAsteriskImport(b);
-                            if (asterisk != 0) {
-                                return -asterisk;
-                            }
-                            const multipleImport = this.isMultipleImport(a) - this.isMultipleImport(b);
-                            if (multipleImport != 0) {
-                                return -multipleImport;
-                            }
-                            const comparedSpecifiers = this.compareStringArrays(this.extractImportSpecifierNames(a), this.extractImportSpecifierNames(b));
-                            if (comparedSpecifiers != 0) {
-                                return comparedSpecifiers;
-                            }
-                            // Tiebreaker, keep the sort stable
-                            return originalImportPosition[aPadded.element.id] - originalImportPosition[bPadded.element.id];
-                        });
-                        const cuWithImportsSorted = yield (0, visitor_1.produceAsync)(cu, (draft) => __awaiter(this, void 0, void 0, function* () {
-                            draft.statements = [...sortedImports, ...restStatements];
-                        }));
-                        return (0, immer_1.produce)(cuWithImportsSorted, draft => {
-                            for (let i = 0; i < importCount; i++) {
-                                draft.statements[i].element.prefix.whitespace = i > 0 ? "\n" : "";
-                            }
-                            // TODO deal with comments in the whitespace around imports
-                        });
-                    });
-                }
-                isAsteriskImport(import_) {
-                    if (import_.importClause != undefined) {
-                        if (import_.importClause.namedBindings != undefined) {
-                            if (import_.importClause.namedBindings.kind == javascript_1.JS.Kind.Alias) {
-                                return import_.importClause.namedBindings.propertyName.element.simpleName == "*" ? 1 : 0;
-                            }
-                        }
-                    }
-                    return 0;
-                }
-                isMultipleImport(import_) {
-                    if (import_.importClause != undefined) {
-                        if (import_.importClause.namedBindings != undefined) {
-                            if (import_.importClause.namedBindings.kind == javascript_1.JS.Kind.NamedImports) {
-                                const namedImports = import_.importClause.namedBindings;
-                                if (namedImports.elements.kind == java_1.J.Kind.Container) {
-                                    return namedImports.elements.elements.length > 1 ? 1 : 0;
-                                }
-                            }
-                        }
-                    }
-                    return 0;
-                }
-                extractImportSpecifierNames(import_) {
-                    const names = [];
-                    if (import_.importClause != undefined) {
-                        if (import_.importClause.namedBindings != undefined) {
-                            if (import_.importClause.namedBindings.kind == javascript_1.JS.Kind.NamedImports) {
-                                const namedImports = import_.importClause.namedBindings;
-                                if (namedImports.elements.kind == java_1.J.Kind.Container) {
-                                    const elements = namedImports.elements.elements;
-                                    for (let i = 0; i < elements.length; i++) {
-                                        const importSpecifier = elements[i].element;
-                                        if (importSpecifier.specifier.kind == java_1.J.Kind.Identifier) {
-                                            names.push(importSpecifier.specifier.simpleName);
-                                        }
-                                        else if (importSpecifier.specifier.kind == javascript_1.JS.Kind.Alias) {
-                                            names.push(importSpecifier.specifier.propertyName.element.simpleName);
-                                        }
-                                        else {
-                                            throw new Error("Unknown kind " + elements[i].kind);
-                                        }
-                                    }
-                                }
-                            }
-                            else if (import_.importClause.namedBindings.kind == javascript_1.JS.Kind.Alias) {
-                                const alias = import_.importClause.namedBindings;
-                                names.push(alias.propertyName.element.simpleName);
-                                if (alias.alias.kind == java_1.J.Kind.Identifier) {
-                                    names.push(alias.alias.simpleName);
-                                }
-                            }
-                        }
-                    }
-                    return names;
-                }
-                compareStringArrays(a, b) {
-                    let i = 0;
-                    while (i < a.length && i < b.length) {
-                        const comparison = a[i].localeCompare(b[i]);
-                        if (comparison !== 0) {
-                            return comparison;
-                        }
-                        i++;
-                    }
-                    if (i < a.length) {
-                        return 1;
-                    }
-                    else if (i < b.length) {
-                        return -1;
-                    }
-                    return 0;
-                }
-                countImports(cu) {
-                    let i = 0;
-                    while ((i < cu.statements.length) && (cu.statements[i].element.kind === javascript_1.JS.Kind.Import)) {
-                        i++;
-                    }
-                    return i;
-                }
-                sortNamesWithinEachLine(imports) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        const ret = [];
-                        for (const importPadded of imports) {
-                            const import_ = importPadded.element;
-                            if (this.isMultipleImport(import_) == 1) {
-                                const importSorted = (0, immer_1.produce)(import_, draft => {
-                                    var _a;
-                                    let elements = draft.importClause.namedBindings.elements.elements;
-                                    const trailingComma = elements.length > 0 && ((_a = elements[elements.length - 1].markers) === null || _a === void 0 ? void 0 : _a.markers.find(m => m.kind === java_1.J.Markers.TrailingComma));
-                                    if (trailingComma) {
-                                        elements[elements.length - 1].markers.markers = elements[elements.length - 1].markers.markers.filter(m => m.kind !== java_1.J.Markers.TrailingComma);
-                                    }
-                                    elements.sort((a, b) => {
-                                        const namesExtracted = [a.element, b.element].map(expr => {
-                                            const is = expr;
-                                            if (is.specifier.kind == javascript_1.JS.Kind.Alias) {
-                                                return is.specifier.propertyName.element.simpleName;
-                                            }
-                                            else if (is.specifier.kind == java_1.J.Kind.Identifier) {
-                                                return is.specifier.simpleName;
-                                            }
-                                            else {
-                                                throw new Error("Unsupported kind " + expr.kind);
-                                            }
-                                        });
-                                        return namesExtracted[0].localeCompare(namesExtracted[1]);
-                                    });
-                                    if (trailingComma && elements.length > 0 && !elements[elements.length - 1].markers.markers.find(m => m.kind === java_1.J.Markers.TrailingComma)) {
-                                        elements[elements.length - 1].markers.markers.push(trailingComma);
-                                    }
-                                });
-                                const formatted = yield new format_1.AutoformatVisitor().visit(importSorted, {});
-                                ret.push((0, immer_1.produce)(importPadded, draft => {
-                                    draft.element = formatted;
-                                }));
-                            }
-                            else {
-                                ret.push(importPadded);
-                            }
-                        }
-                        return ret;
-                    });
-                }
-            };
-        });
-    }
-}
-exports.OrderImports = OrderImports;
-//# sourceMappingURL=order-imports.js.map