Update from TSCO CLI (#112)

Author: aljazsim

README.md

@@ -222,6 +222,8 @@ See [TypeScript Code Organizer Command Line Interface](https://www.npmjs.com/pac
 - add support for declaration dependency order resolution
 - fix issue with file name casing
 
-### 2.0.13
+### 2.0.15
 
 - fix issue with access modifiers not being correctly updated
+- fix issue with leading and trailing comments being lost
+- fix issue with unused imports not being removed correctly

package.json

@@ -2,7 +2,7 @@
     "name": "tsco",
     "displayName": "TypeScript Code Organizer",
     "description": "TypeScript Code Organizer for VS Code",
-    "version": "2.0.13",
+    "version": "2.0.15",
     "publisher": "aljazsim",
     "author": {
         "name": "aljazsim",

src/tsco-cli/elements/class-node.ts

@@ -45,8 +45,8 @@ export class ClassNode extends ElementNode
 
         if (classDeclaration.members && classDeclaration.members.length > 0)
         {
-            this.membersStart = classDeclaration.members[0].getFullStart() - classDeclaration.getFullStart();
-            this.membersEnd = classDeclaration.members[classDeclaration.members.length - 1].getEnd() - classDeclaration.getFullStart();
+            this.membersStart = this.getOpeningBraceIndex(sourceFile, classDeclaration) + 1 - classDeclaration.getStart(sourceFile);
+            this.membersEnd = this.getClosingBraceIndex(sourceFile, classDeclaration) - 1 - classDeclaration.getStart(sourceFile);
         }
 
         this.decorators = getDecorators(classDeclaration, sourceFile);

src/tsco-cli/elements/element-node.ts

@@ -4,9 +4,10 @@ import { getLeadingComment, getTrailingComment } from "../helpers/node-helper";
 
 export abstract class ElementNode
 {
-    // #region Properties (5)
+    // #region Properties (6)
 
     public readonly dependencies: string[] = [];
+    public readonly indentation: string = "";
     public readonly leadingComment: string | null;
     public abstract readonly name: string;
     public readonly sourceCode: string;
@@ -18,20 +19,86 @@ export abstract class ElementNode
 
     constructor(sourceFile: ts.SourceFile, public readonly node: ts.Node, leadingComment: string | null = null, trailingComment: string | null = null)
     {
-        this.sourceCode = ElementNode.getSourceCode(sourceFile, node.getFullStart(), node.getEnd());
+        this.indentation = this.getIndentation(sourceFile, node);
 
         this.leadingComment = leadingComment ?? getLeadingComment(node, sourceFile);
         this.trailingComment = trailingComment ?? getTrailingComment(node, sourceFile);
+
+        this.sourceCode = node.getText(sourceFile);
+        this.sourceCode = this.sourceCode.replace(leadingComment ?? "", "");
+        this.sourceCode = this.sourceCode.replace(trailingComment ?? "", "");
+        this.sourceCode = this.indentation + this.sourceCode.trim();
     }
 
     // #endregion Constructors
 
-    // #region Private Static Methods (1)
+    // #region Protected Methods (2)
+
+    protected getClosingBraceIndex(sourceFile: ts.SourceFile, node: ts.ClassDeclaration | ts.InterfaceDeclaration | ts.TypeLiteralNode)
+    {
+        const closingBrace = "}";
+        const sourceCode = sourceFile.getText();
+
+        for (let i = node.getEnd(); i > node.getStart(sourceFile); i--)
+        {
+            if (sourceCode[i] === closingBrace)
+            {
+                return i
+            }
+        }
+
+        throw new Error("Closing brace not found");
+    }
+
+    protected getOpeningBraceIndex(sourceFile: ts.SourceFile, node: ts.ClassDeclaration | ts.InterfaceDeclaration | ts.TypeLiteralNode)
+    {
+        const openingBrace = "{";
+        const sourceCode = sourceFile.getText();
+        let startIndex = node.getStart(sourceFile);
+
+        if (ts.isClassDeclaration(node))
+        {
+            // class could start with a decorator containing curly braces
+            startIndex = sourceCode.indexOf("class ", startIndex);
+        }
+
+        for (let i = startIndex; i < node.getEnd(); i++)
+        {
+            if (sourceCode[i] === openingBrace)
+            {
+                return i
+            }
+        }
+
+        throw new Error("Opening brace not found");
+    }
+
+    // #endregion Protected Methods
+
+    // #region Private Methods (1)
 
-    private static getSourceCode(sourceFile: ts.SourceFile, start: number, end: number)
+    private getIndentation(sourceFile: ts.SourceFile, node: ts.Node)
     {
-        return sourceFile.getFullText().substring(start, end);
+        const space = " ";
+        const tab = "\t";
+        const sourceCode = sourceFile.getText();
+        const startIndex = sourceCode.indexOf(node.getText(sourceFile));
+        let indentation = "";
+
+        for (let i = startIndex - 1; i > 0; i--)
+        {
+            if (sourceCode[i] === space || sourceCode[i] === tab)
+            {
+                indentation = sourceCode[i] + indentation;
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        return indentation;
     }
 
-    // #endregion Private Static Methods
+    // #endregion Private Methods
 }

src/tsco-cli/elements/interface-node.ts

@@ -37,8 +37,8 @@ export class InterfaceNode extends ElementNode
 
         if (interfaceDeclaration.members && interfaceDeclaration.members.length > 0)
         {
-            this.membersStart = interfaceDeclaration.members[0].getFullStart() - interfaceDeclaration.getFullStart();
-            this.membersEnd = interfaceDeclaration.members[interfaceDeclaration.members.length - 1].getEnd() - interfaceDeclaration.getFullStart();
+            this.membersStart = this.getOpeningBraceIndex(sourceFile, interfaceDeclaration) + 1 - interfaceDeclaration.getStart(sourceFile);
+            this.membersEnd = this.getClosingBraceIndex(sourceFile, interfaceDeclaration) - 1 - interfaceDeclaration.getStart(sourceFile);
         }
 
         // members

src/tsco-cli/elements/type-alias-node.ts

@@ -39,8 +39,8 @@ export class TypeAliasNode extends ElementNode
 
                 if (typeLiteral.members && typeLiteral.members.length > 0)
                 {
-                    this.membersStart = typeLiteral.members[0].getFullStart() - typeAliasDeclaration.getFullStart();
-                    this.membersEnd = typeLiteral.members[typeLiteral.members.length - 1].getEnd() - typeAliasDeclaration.getFullStart();
+                    this.membersStart = this.getOpeningBraceIndex(sourceFile, typeLiteral) + 1 - typeAliasDeclaration.getStart(sourceFile);
+                    this.membersEnd = this.getClosingBraceIndex(sourceFile, typeLiteral) - 1 - typeAliasDeclaration.getStart(sourceFile);
 
                     // members
                     for (const member of typeLiteral.members)

src/tsco-cli/helpers/node-helper.ts

@@ -227,16 +227,15 @@ export function getIsStatic(node: ts.ClassDeclaration | ts.GetAccessorDeclaratio
 
 export function getLeadingComment(node: ts.Node, sourceFile: ts.SourceFile)
 {
-    const sourceCode = node.getFullText(sourceFile);
-    const commentRanges = ts.getLeadingCommentRanges(sourceCode, 0)
+    const commentRanges = ts.getLeadingCommentRanges(sourceFile.getFullText(), node.pos);
 
     if (commentRanges && commentRanges.length > 0)
     {
         const start = commentRanges[0].pos;
         const end = commentRanges[commentRanges.length - 1].end;
         const trailingNewLine = commentRanges[commentRanges.length - 1].hasTrailingNewLine;
 
-        return sourceCode.substring(start, end).trimStart() + (trailingNewLine ? newLine : "");
+        return sourceFile.getFullText().substring(start, end) + (trailingNewLine ? newLine : "");
     }
     else
     {
@@ -339,16 +338,14 @@ export function getNodeNames(nodes: ElementNode[])
 
 export function getTrailingComment(node: ts.Node, sourceFile: ts.SourceFile)
 {
-    const sourceCode = node.getFullText(sourceFile);
-    const commentRanges = ts.getTrailingCommentRanges(sourceCode, 0);
+    const commentRanges = ts.getTrailingCommentRanges(sourceFile.getFullText(), node.end);
 
     if (commentRanges && commentRanges.length > 0)
     {
         const start = commentRanges[0].pos;
         const end = commentRanges[commentRanges.length - 1].end;
-        const trailingNewLine = commentRanges[commentRanges.length - 1].hasTrailingNewLine;
 
-        return sourceCode.substring(start, end).trimEnd() + (trailingNewLine ? newLine : "");
+        return sourceFile.getFullText().substring(start, end);
     }
     else
     {

src/tsco-cli/source-code/source-code-dependency-resolver.ts

@@ -0,0 +1,64 @@
+import { ElementNode } from "../elements/element-node";
+import { ElementNodeGroup } from "../elements/element-node-group";
+import { distinct } from "../helpers/array-helper";
+import { getNodeNames } from "../helpers/node-helper";
+
+// #region Functions (1)
+
+function resolveDeclarationDependenciesOrderWithinGroup(nodes: ElementNode[])
+{
+    const maxIterations = 1000; // there might be a declaration dependency cycle
+
+    for (let iteration = 0; iteration < maxIterations; iteration++)
+    {
+        let dependenciesDetected = false;
+
+        for (let i = 0; i < nodes.length; i++)
+        {
+            const dependencies = distinct(nodes[i].dependencies.sort());
+
+            for (const dependency of dependencies)
+            {
+                const dependencyIndex = nodes.findIndex(n => getNodeNames([n]).indexOf(dependency) >= 0);
+
+                if (dependencyIndex > i)
+                {
+                    const node = nodes[i];
+                    const dependencyNode = nodes[dependencyIndex];
+
+                    for (let j = dependencyIndex; j > i; j--)
+                    {
+                        nodes[j] = nodes[j - 1];
+                    }
+
+                    nodes[i] = dependencyNode;
+                    nodes[i + 1] = node;
+
+                    dependenciesDetected = true;
+
+                    break;
+                }
+            }
+        }
+
+        if (!dependenciesDetected)
+        {
+            break;
+        }
+    }
+}
+
+// #endregion Functions
+
+// #region Exported Functions (1)
+
+export function resolveDeclarationDependenciesOrder(nodeGroups: ElementNodeGroup[])
+{
+    for (const nodeGroup of nodeGroups)
+    {
+        resolveDeclarationDependenciesOrderWithinGroup(nodeGroup.nodes);
+        resolveDeclarationDependenciesOrder(nodeGroup.nodeSubGroups);
+    }
+}
+
+// #endregion Exported Functions