feat: #454 - Wrap NamespaceImport.

.gitignore

@@ -17,4 +17,5 @@
 /dist-scripts
 /dist-declarations
 /.nyc_output
-/npm-debug.log
+/npm-debug.log
+/yarn-error.log

src/compiler/ast/CompilerNodeToWrappedType.ts

@@ -90,6 +90,7 @@ export type CompilerNodeToWrappedType<T extends ts.Node> = T extends ts.ArrayBin
     T extends ts.ImportEqualsDeclaration ? compiler.ImportEqualsDeclaration :
     T extends ts.ImportSpecifier ? compiler.ImportSpecifier :
     T extends ts.NamespaceDeclaration ? compiler.NamespaceDeclaration :
+    T extends ts.NamespaceImport ? compiler.NamespaceImport :
     T extends ts.SourceFile ? compiler.SourceFile :
     T extends ts.Block ? compiler.Block :
     T extends ts.BreakStatement ? compiler.BreakStatement :

src/compiler/ast/kindToNodeMappings.ts

@@ -91,6 +91,7 @@ export interface KindToNodeMappings {
     [SyntaxKind.MethodDeclaration]: compiler.MethodDeclaration;
     [SyntaxKind.MethodSignature]: compiler.MethodSignature;
     [SyntaxKind.ModuleDeclaration]: compiler.NamespaceDeclaration;
+    [SyntaxKind.NamespaceImport]: compiler.NamespaceImport;
     [SyntaxKind.NewExpression]: compiler.NewExpression;
     [SyntaxKind.NonNullExpression]: compiler.NonNullExpression;
     [SyntaxKind.NotEmittedStatement]: compiler.NotEmittedStatement;

src/compiler/ast/module/ExportSpecifier.ts

@@ -20,13 +20,7 @@ export class ExportSpecifier extends ExportSpecifierBase<ts.ExportSpecifier> {
         if (nameNode.getText() === name)
             return this;
 
-        const start = nameNode.getStart();
-        replaceNodeText({
-            sourceFile: this.sourceFile,
-            start,
-            replacingLength: nameNode.getWidth(),
-            newText: name
-        });
+        nameNode.replaceWithText(name);
 
         return this;
     }

src/compiler/ast/module/ImportDeclaration.ts

@@ -239,7 +239,7 @@ export class ImportDeclaration extends ImportDeclarationBase<ts.ImportDeclaratio
     }
 
     /**
-     * Gets the namespace import, if it exists.
+     * Gets the namespace import identifier, if it exists.
      */
     getNamespaceImport() {
         const importClause = this.getImportClause();

src/compiler/ast/module/ImportSpecifier.ts

@@ -1,4 +1,4 @@
-import { insertIntoParentTextRange, removeCommaSeparatedChild, replaceNodeText, removeChildren } from "../../../manipulation";
+import { insertIntoParentTextRange, removeCommaSeparatedChild, removeChildren } from "../../../manipulation";
 import { SyntaxKind, ts } from "../../../typescript";
 import { StringUtils } from "../../../utils";
 import { Node } from "../common";

src/compiler/ast/module/NamespaceImport.ts

@@ -0,0 +1,32 @@
+import { ts } from "../../../typescript";
+import { RenameableNode } from "../base";
+import { Node } from "../common";
+
+export const NamespaceImportBase = RenameableNode(Node);
+export class NamespaceImport extends NamespaceImportBase<ts.NamespaceImport> {
+    /**
+     * Sets the name of the namespace import.
+     */
+    setName(name: string) {
+        const nameNode = this.getNameNode();
+        if (nameNode.getText() === name)
+            return this;
+
+        nameNode.replaceWithText(name);
+        return this;
+    }
+
+    /**
+     * Gets the name of the namespace import.
+     */
+    getName() {
+        return this.getNameNode().getText();
+    }
+
+    /**
+     * Gets the namespace import's name node.
+     */
+    getNameNode() {
+        return this.getNodeFromCompilerNode(this.compilerNode.name);
+    }
+}

src/compiler/ast/module/index.ts

@@ -9,4 +9,5 @@ export * from "./ImportSpecifier";
 export * from "./NamespaceChildableNode";
 export * from "./NamespaceDeclaration";
 export * from "./NamespaceDeclarationKind";
+export * from "./NamespaceImport";
 export * from "./SourceFile";

src/factories/kindToWrapperMappings.ts

@@ -88,6 +88,7 @@ export const kindToWrapperMappings: { [key: number]: any } = {
     [SyntaxKind.MethodDeclaration]: compiler.MethodDeclaration,
     [SyntaxKind.MethodSignature]: compiler.MethodSignature,
     [SyntaxKind.ModuleDeclaration]: compiler.NamespaceDeclaration,
+    [SyntaxKind.NamespaceImport]: compiler.NamespaceImport,
     [SyntaxKind.NewExpression]: compiler.NewExpression,
     [SyntaxKind.NonNullExpression]: compiler.NonNullExpression,
     [SyntaxKind.NotEmittedStatement]: compiler.NotEmittedStatement,

src/tests/compiler/module/namespaceImportTests.ts

@@ -0,0 +1,52 @@
+import { expect } from "chai";
+import { NamespaceImport } from "../../../compiler";
+import { SyntaxKind } from "../../../typescript";
+import { getInfoFromText, getInfoFromTextWithDescendant } from "../testHelpers";
+
+describe(nameof(NamespaceImport), () => {
+    function getNamespaceImport(text: string) {
+        return getInfoFromTextWithDescendant<NamespaceImport>(text, SyntaxKind.NamespaceImport);
+    }
+
+    describe(nameof<NamespaceImport>(n => n.setName), () => {
+        it("should only change what's imported", () => {
+            const { descendant, sourceFile, project } = getNamespaceImport("import * as ts from './file'; const t = ts;");
+            const otherSourceFile = project.createSourceFile("file.ts", "export class name {}\nexport class newName {}");
+            descendant.setName("tsNew");
+            expect(sourceFile.getText()).to.equal("import * as tsNew from './file'; const t = ts;");
+            expect(otherSourceFile.getText()).to.equal("export class name {}\nexport class newName {}");
+        });
+    });
+
+    describe(nameof<NamespaceImport>(n => n.rename), () => {
+        it("should rename what's imported", () => {
+            const { descendant, sourceFile, project } = getNamespaceImport("import * as ts from './file'; const t = ts;");
+            const otherSourceFile = project.createSourceFile("file.ts", "export class name {}\nexport class newName {}");
+            descendant.rename("tsNew");
+            expect(sourceFile.getText()).to.equal("import * as tsNew from './file'; const t = tsNew;");
+            expect(otherSourceFile.getText()).to.equal("export class name {}\nexport class newName {}");
+        });
+    });
+
+    describe(nameof<NamespaceImport>(n => n.getNameNode), () => {
+        function doTest(text: string, name: string) {
+            const { descendant } = getNamespaceImport(text);
+            expect(descendant.getNameNode().getText()).to.equal(name);
+        }
+
+        it("should get the name", () => {
+            doTest(`import * as name from "./test";`, "name");
+        });
+    });
+
+    describe(nameof<NamespaceImport>(n => n.getName), () => {
+        function doTest(text: string, name: string) {
+            const { descendant } = getNamespaceImport(text);
+            expect(descendant.getName()).to.equal(name);
+        }
+
+        it("should get the name", () => {
+            doTest(`import * as name from "./test";`, "name");
+        });
+    });
+});

src/utils/TypeGuards.ts

@@ -1523,6 +1523,14 @@ export class TypeGuards {
         return node.getKind() === SyntaxKind.ModuleDeclaration;
     }
 
+    /**
+     * Gets if the node is a NamespaceImport.
+     * @param node - Node to check.
+     */
+    static isNamespaceImport(node: compiler.Node): node is compiler.NamespaceImport {
+        return node.getKind() === SyntaxKind.NamespaceImport;
+    }
+
     /**
      * Gets if the node is a NeverKeyword.
      * @param node - Node to check.