@rhtml/schematics 0.0.132 → 0.0.134

package/dist/utils/metadata.manager.js

@@ -2,15 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetadataManager = void 0;
 const typescript_1 = require("typescript");
+/**
+ * The `MetadataManager` class provides utilities for managing metadata entries
+ * within a `@Module` decorator in a TypeScript source file. It allows for the
+ * insertion of new metadata entries, merging symbols with static options, and
+ * handling various scenarios such as empty module decorators or existing metadata
+ * properties.
+ */
 class MetadataManager {
     constructor(content) {
         this.content = content;
     }
+    /**
+     * Inserts a new metadata entry into the `@Module` decorator.
+     *
+     * @param metadata - The metadata key to insert.
+     * @param symbol - The symbol to insert.
+     * @param staticOptions - The static options to insert.
+     * @returns The new content string.
+     */
     insert(metadata, symbol, staticOptions) {
         const source = (0, typescript_1.createSourceFile)('filename.ts', this.content, typescript_1.ScriptTarget.ES2017);
-        const decoratorNodes = this.getDecoratorMetadata(source, '@Module');
-        const node = decoratorNodes[0];
-        const matchingProperties = node.properties
+        const moduleDecoratorNode = this.findFirstDecoratorMetadata(source, 'Module');
+        // If there is no occurrence of `@Module` decorator, nothing will be inserted
+        if (!moduleDecoratorNode) {
+            return;
+        }
+        const matchingProperties = moduleDecoratorNode.properties
             .filter((prop) => prop.kind === typescript_1.SyntaxKind.PropertyAssignment)
             .filter((prop) => {
             const name = prop.name;
@@ -28,7 +46,7 @@ class MetadataManager {
             symbol = staticOptions ? this.addBlankLines(symbol) : symbol;
         };
         if (matchingProperties.length === 0) {
-            const expr = node;
+            const expr = moduleDecoratorNode;
             if (expr.properties.length === 0) {
                 addBlankLinesIfDynamic();
                 return this.insertMetadataToEmptyModuleDecorator(expr, metadata, symbol);
@@ -42,16 +60,38 @@ class MetadataManager {
             return this.insertSymbolToMetadata(source, matchingProperties, symbol, staticOptions);
         }
     }
-    getDecoratorMetadata(source, identifier) {
-        identifier;
-        return this.getSourceNodes(source)
-            .filter((node) => node.kind === typescript_1.SyntaxKind.Decorator &&
-            node.expression.kind === typescript_1.SyntaxKind.CallExpression)
-            .map((node) => node.expression)
-            .filter((expr) => expr.arguments[0] &&
-            expr.arguments[0].kind === typescript_1.SyntaxKind.ObjectLiteralExpression)
-            .map((expr) => expr.arguments[0]);
+    /**
+     * Finds the first `@Module` decorator metadata in the source file.
+     *
+     * @param source - The source file to search.
+     * @param identifier - The identifier to match.
+     * @returns The first matching `ObjectLiteralExpression` or undefined.
+     */
+    findFirstDecoratorMetadata(source, identifier) {
+        var _a;
+        for (const node of this.getSourceNodes(source)) {
+            const isDecoratorFactoryNode = node.kind === typescript_1.SyntaxKind.Decorator &&
+                node.expression.kind === typescript_1.SyntaxKind.CallExpression;
+            if (!isDecoratorFactoryNode)
+                continue;
+            const expr = node.expression;
+            const isExpectedExpression = ((_a = expr.arguments[0]) === null || _a === void 0 ? void 0 : _a.kind) === typescript_1.SyntaxKind.ObjectLiteralExpression;
+            if (!isExpectedExpression)
+                continue;
+            if (expr.expression.kind === typescript_1.SyntaxKind.Identifier) {
+                const escapedText = expr.expression.escapedText;
+                const isTargetIdentifier = escapedText
+                    ? escapedText.toLowerCase() === identifier.toLowerCase()
+                    : true;
+                if (isTargetIdentifier) {
+                    return expr.arguments[0];
+                }
+            }
+        }
     }
+    /**
+     * Returns an array of all nodes in the source file.
+     */
     getSourceNodes(sourceFile) {
         const nodes = [sourceFile];
         const result = [];
@@ -60,12 +100,21 @@ class MetadataManager {
             if (node) {
                 result.push(node);
                 if (node.getChildCount(sourceFile) >= 0) {
-                    nodes.unshift(...node.getChildren());
+                    nodes.unshift(...node.getChildren(sourceFile));
                 }
             }
         }
         return result;
     }
+    /**
+     * Inserts a new metadata entry into an empty `@Module` decorator.
+     * This method is called when the `@Module` decorator has no properties.
+     * It inserts the metadata and symbol into the decorator.
+     * @param expr - The `@Module` decorator node.
+     * @param metadata - The metadata key to insert.
+     * @param symbol - The symbol to insert.
+     * @returns The new content string.
+     */
     insertMetadataToEmptyModuleDecorator(expr, metadata, symbol) {
         const position = expr.getEnd() - 1;
         const toInsert = `  ${metadata}: [${symbol}]`;
@@ -78,13 +127,23 @@ class MetadataManager {
             }
         }, '');
     }
+    /**
+     * Inserts a new symbol into an existing metadata property in the `@Module` decorator.
+     * This method is called when the metadata property already exists in the decorator.
+     * It inserts the symbol into the existing metadata property.
+     * @param source - The source file.
+     * @param matchingProperties - The matching metadata properties.
+     * @param symbol - The symbol to insert.
+     * @param staticOptions - The static options to insert.
+     * @returns The new content string.
+     */
     insertNewMetadataToDecorator(expr, source, metadata, symbol) {
         const node = expr.properties[expr.properties.length - 1];
         const position = node.getEnd();
         const text = node.getFullText(source);
         const matches = text.match(/^\r?\n\s*/);
         let toInsert;
-        if (matches.length > 0) {
+        if (matches) {
             toInsert = `,${matches[0]}${metadata}: [${symbol}]`;
         }
         else {
@@ -99,10 +158,24 @@ class MetadataManager {
             }
         }, '');
     }
+    /**
+     * Inserts a new symbol into an existing metadata property in the `@Module` decorator.
+     * This method is called when the metadata property already exists in the decorator.
+     * It inserts the symbol into the existing metadata property.
+     * @param source - The source file.
+     * @param matchingProperties - The matching metadata properties.
+     * @param symbol - The symbol to insert.
+     * @param staticOptions - The static options to insert.
+     * @returns The new content string.
+     */
     insertSymbolToMetadata(source, matchingProperties, symbol, staticOptions) {
         const assignment = matchingProperties[0];
         let node;
         const arrLiteral = assignment.initializer;
+        if (!arrLiteral.elements) {
+            // "imports" is not an array but rather function/constant
+            return this.content;
+        }
         if (arrLiteral.elements.length === 0) {
             node = arrLiteral;
         }
@@ -125,12 +198,10 @@ class MetadataManager {
         }
         else {
             const text = node.getFullText(source);
-            if (text.match(/^\r?\n/)) {
-                toInsert = `,${text.match(/^\r?\n(\r?)\s+/)[0]}${symbol}`;
-            }
-            else {
-                toInsert = `, ${symbol}`;
-            }
+            const itemSeparator = (text.match(/^\r?\n(\r?)\s+/) ||
+                text.match(/^\r?\n/) ||
+                ' ')[0];
+            toInsert = `,${itemSeparator}${symbol}`;
         }
         return this.content.split('').reduce((content, char, index) => {
             if (index === position) {
@@ -141,18 +212,27 @@ class MetadataManager {
             }
         }, '');
     }
+    /**
+     * Merges a symbol with static options into a single string.
+     * @param symbol - The symbol to merge.
+     * @param staticOptions - The static options to merge.
+     * @returns The merged string.
+     */
     mergeSymbolAndExpr(symbol, staticOptions) {
         if (!staticOptions) {
             return symbol;
         }
         const spacing = 6;
         let options = JSON.stringify(staticOptions.value, null, spacing);
-        options = options.replace(/\"([^(\")"]+)\":/g, '$1:');
-        options = options.replace(/\"/g, `'`);
+        options = options.replace(/"([^(")"]+)":/g, '$1:');
+        options = options.replace(/"/g, `'`);
         options = options.slice(0, options.length - 1) + '    }';
         symbol += `.${staticOptions.name}(${options})`;
         return symbol;
     }
+    /**
+     * Adds blank lines around an expression.
+     */
     addBlankLines(expr) {
         return `\n    ${expr}\n  `;
     }

package/dist/utils/metadata.manager.ts

@@ -12,49 +12,68 @@ import {
   PropertyAssignment,
   ScriptTarget,
   SourceFile,
-  StringLiteral,
   SyntaxKind,
 } from 'typescript';
 
 import { DeclarationOptions } from './module.declarator';
 
+/**
+ * The `MetadataManager` class provides utilities for managing metadata entries
+ * within a `@Module` decorator in a TypeScript source file. It allows for the
+ * insertion of new metadata entries, merging symbols with static options, and
+ * handling various scenarios such as empty module decorators or existing metadata
+ * properties.
+ */
 export class MetadataManager {
   constructor(private content: string) {}
 
+  /**
+   * Inserts a new metadata entry into the `@Module` decorator.
+   *
+   * @param metadata - The metadata key to insert.
+   * @param symbol - The symbol to insert.
+   * @param staticOptions - The static options to insert.
+   * @returns The new content string.
+   */
   public insert(
     metadata: string,
     symbol: string,
     staticOptions?: DeclarationOptions['staticOptions']
-  ): string {
+  ): string | undefined {
     const source: SourceFile = createSourceFile(
       'filename.ts',
       this.content,
       ScriptTarget.ES2017
     );
-    const decoratorNodes: Node[] = this.getDecoratorMetadata(source, '@Module');
-    const node: Node = decoratorNodes[0];
-    const matchingProperties: ObjectLiteralElement[] = (
-      node as ObjectLiteralExpression
-    ).properties
-      .filter((prop) => prop.kind === SyntaxKind.PropertyAssignment)
-      .filter((prop: PropertyAssignment) => {
-        const name = prop.name;
-        switch (name.kind) {
-          case SyntaxKind.Identifier:
-            return (name as Identifier).getText(source) === metadata;
-          case SyntaxKind.StringLiteral:
-            return (name as StringLiteral).text === metadata;
-          default:
-            return false;
-        }
-      });
+    const moduleDecoratorNode = this.findFirstDecoratorMetadata(
+      source,
+      'Module'
+    );
+    // If there is no occurrence of `@Module` decorator, nothing will be inserted
+    if (!moduleDecoratorNode) {
+      return;
+    }
+    const matchingProperties: ObjectLiteralElement[] =
+      moduleDecoratorNode.properties
+        .filter((prop) => prop.kind === SyntaxKind.PropertyAssignment)
+        .filter((prop: PropertyAssignment) => {
+          const name = prop.name;
+          switch (name.kind) {
+            case SyntaxKind.Identifier:
+              return name.getText(source) === metadata;
+            case SyntaxKind.StringLiteral:
+              return name.text === metadata;
+            default:
+              return false;
+          }
+        });
 
     symbol = this.mergeSymbolAndExpr(symbol, staticOptions);
     const addBlankLinesIfDynamic = () => {
       symbol = staticOptions ? this.addBlankLines(symbol) : symbol;
     };
     if (matchingProperties.length === 0) {
-      const expr = node as ObjectLiteralExpression;
+      const expr = moduleDecoratorNode;
       if (expr.properties.length === 0) {
         addBlankLinesIfDynamic();
         return this.insertMetadataToEmptyModuleDecorator(
@@ -81,38 +100,68 @@ export class MetadataManager {
     }
   }
 
-  private getDecoratorMetadata(source: SourceFile, identifier: string): Node[] {
-    identifier;
-    return this.getSourceNodes(source)
-      .filter(
-        (node) =>
-          node.kind === SyntaxKind.Decorator &&
-          (node as Decorator).expression.kind === SyntaxKind.CallExpression
-      )
-      .map((node) => (node as Decorator).expression as CallExpression)
-      .filter(
-        (expr) =>
-          expr.arguments[0] &&
-          expr.arguments[0].kind === SyntaxKind.ObjectLiteralExpression
-      )
-      .map((expr) => expr.arguments[0] as ObjectLiteralExpression);
+  /**
+   * Finds the first `@Module` decorator metadata in the source file.
+   *
+   * @param source - The source file to search.
+   * @param identifier - The identifier to match.
+   * @returns The first matching `ObjectLiteralExpression` or undefined.
+   */
+  private findFirstDecoratorMetadata(
+    source: SourceFile,
+    identifier: string
+  ): ObjectLiteralExpression | undefined {
+    for (const node of this.getSourceNodes(source)) {
+      const isDecoratorFactoryNode =
+        node.kind === SyntaxKind.Decorator &&
+        (node as Decorator).expression.kind === SyntaxKind.CallExpression;
+      if (!isDecoratorFactoryNode) continue;
+
+      const expr = (node as Decorator).expression as CallExpression;
+
+      const isExpectedExpression =
+        expr.arguments[0]?.kind === SyntaxKind.ObjectLiteralExpression;
+      if (!isExpectedExpression) continue;
+
+      if (expr.expression.kind === SyntaxKind.Identifier) {
+        const escapedText = (expr.expression as Identifier).escapedText;
+        const isTargetIdentifier = escapedText
+          ? escapedText.toLowerCase() === identifier.toLowerCase()
+          : true;
+        if (isTargetIdentifier) {
+          return expr.arguments[0] as ObjectLiteralExpression;
+        }
+      }
+    }
   }
 
+  /**
+   * Returns an array of all nodes in the source file.
+   */
   private getSourceNodes(sourceFile: SourceFile): Node[] {
     const nodes: Node[] = [sourceFile];
-    const result = [];
+    const result: Node[] = [];
     while (nodes.length > 0) {
       const node = nodes.shift();
       if (node) {
         result.push(node);
         if (node.getChildCount(sourceFile) >= 0) {
-          nodes.unshift(...node.getChildren());
+          nodes.unshift(...node.getChildren(sourceFile));
         }
       }
     }
     return result;
   }
 
+  /**
+   * Inserts a new metadata entry into an empty `@Module` decorator.
+   * This method is called when the `@Module` decorator has no properties.
+   * It inserts the metadata and symbol into the decorator.
+   * @param expr - The `@Module` decorator node.
+   * @param metadata - The metadata key to insert.
+   * @param symbol - The symbol to insert.
+   * @returns The new content string.
+   */
   private insertMetadataToEmptyModuleDecorator(
     expr: ObjectLiteralExpression,
     metadata: string,
@@ -129,6 +178,16 @@ export class MetadataManager {
     }, '');
   }
 
+  /**
+   * Inserts a new symbol into an existing metadata property in the `@Module` decorator.
+   * This method is called when the metadata property already exists in the decorator.
+   * It inserts the symbol into the existing metadata property.
+   * @param source - The source file.
+   * @param matchingProperties - The matching metadata properties.
+   * @param symbol - The symbol to insert.
+   * @param staticOptions - The static options to insert.
+   * @returns The new content string.
+   */
   private insertNewMetadataToDecorator(
     expr: ObjectLiteralExpression,
     source: SourceFile,
@@ -140,7 +199,7 @@ export class MetadataManager {
     const text = node.getFullText(source);
     const matches = text.match(/^\r?\n\s*/);
     let toInsert: string;
-    if (matches.length > 0) {
+    if (matches) {
       toInsert = `,${matches[0]}${metadata}: [${symbol}]`;
     } else {
       toInsert = `, ${metadata}: [${symbol}]`;
@@ -154,6 +213,16 @@ export class MetadataManager {
     }, '');
   }
 
+  /**
+   * Inserts a new symbol into an existing metadata property in the `@Module` decorator.
+   * This method is called when the metadata property already exists in the decorator.
+   * It inserts the symbol into the existing metadata property.
+   * @param source - The source file.
+   * @param matchingProperties - The matching metadata properties.
+   * @param symbol - The symbol to insert.
+   * @param staticOptions - The static options to insert.
+   * @returns The new content string.
+   */
   private insertSymbolToMetadata(
     source: SourceFile,
     matchingProperties: ObjectLiteralElement[],
@@ -163,13 +232,17 @@ export class MetadataManager {
     const assignment = matchingProperties[0] as PropertyAssignment;
     let node: Node | NodeArray<Expression>;
     const arrLiteral = assignment.initializer as ArrayLiteralExpression;
+    if (!arrLiteral.elements) {
+      // "imports" is not an array but rather function/constant
+      return this.content;
+    }
     if (arrLiteral.elements.length === 0) {
       node = arrLiteral;
     } else {
       node = arrLiteral.elements;
     }
     if (Array.isArray(node)) {
-      const nodeArray = node as {} as Node[];
+      const nodeArray = node as unknown as Node[];
       const symbolsArray = nodeArray.map((childNode) =>
         childNode.getText(source)
       );
@@ -186,11 +259,10 @@ export class MetadataManager {
       toInsert = staticOptions ? this.addBlankLines(symbol) : `${symbol}`;
     } else {
       const text = (node as Node).getFullText(source);
-      if (text.match(/^\r?\n/)) {
-        toInsert = `,${text.match(/^\r?\n(\r?)\s+/)[0]}${symbol}`;
-      } else {
-        toInsert = `, ${symbol}`;
-      }
+      const itemSeparator = (text.match(/^\r?\n(\r?)\s+/) ||
+        text.match(/^\r?\n/) ||
+        ' ')[0];
+      toInsert = `,${itemSeparator}${symbol}`;
     }
     return this.content.split('').reduce((content, char, index) => {
       if (index === position) {
@@ -201,6 +273,12 @@ export class MetadataManager {
     }, '');
   }
 
+  /**
+   * Merges a symbol with static options into a single string.
+   * @param symbol - The symbol to merge.
+   * @param staticOptions - The static options to merge.
+   * @returns The merged string.
+   */
   private mergeSymbolAndExpr(
     symbol: string,
     staticOptions?: DeclarationOptions['staticOptions']
@@ -210,13 +288,16 @@ export class MetadataManager {
     }
     const spacing = 6;
     let options = JSON.stringify(staticOptions.value, null, spacing);
-    options = options.replace(/\"([^(\")"]+)\":/g, '$1:');
-    options = options.replace(/\"/g, `'`);
+    options = options.replace(/"([^(")"]+)":/g, '$1:');
+    options = options.replace(/"/g, `'`);
     options = options.slice(0, options.length - 1) + '    }';
     symbol += `.${staticOptions.name}(${options})`;
     return symbol;
   }
 
+  /**
+   * Adds blank lines around an expression.
+   */
   private addBlankLines(expr: string): string {
     return `\n    ${expr}\n  `;
   }

package/dist/utils/module-import.declarator.d.ts

@@ -1,11 +1,40 @@
 import { DeclarationOptions } from './module.declarator';
 import { PathSolver } from './path.solver';
+/**
+ * The `ModuleImportDeclarator` class is responsible for declaring module imports
+ * in a TypeScript file. It provides methods to insert import statements into the
+ * file content based on the provided declaration options.
+ */
 export declare class ModuleImportDeclarator {
     private solver;
     constructor(solver?: PathSolver);
+    /**
+     * Declares a module import in the given content string.
+     *
+     * @param content - The content of the file where the import will be declared.
+     * @param options - The options for the declaration, including the symbol and path.
+     * @returns The updated content string with the import statement inserted.
+     */
     declare(content: string, options: DeclarationOptions): string;
-    private findImports;
-    private findOtherLines;
+    /**
+     * Finds the endpoint of the existing import statements in the content.
+     *
+     * @param contentLines - The lines of the content.
+     * @returns The index of the last import statement.
+     */
+    private findImportsEndpoint;
+    /**
+     * Builds the import line to insert based on the declaration options.
+     *
+     * @param options - The options for the declaration, including the symbol and path.
+     * @returns The import line to insert.
+     */
     private buildLineToInsert;
+    /**
+     * Computes the relative path for the import statement.
+     *
+     * @param options - The options for the declaration, including the symbol and path.
+     * @returns The relative path for the import statement.
+     */
     private computeRelativePath;
 }

package/dist/utils/module-import.declarator.js

@@ -3,26 +3,58 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModuleImportDeclarator = void 0;
 const core_1 = require("@angular-devkit/core");
 const path_solver_1 = require("./path.solver");
+/**
+ * The `ModuleImportDeclarator` class is responsible for declaring module imports
+ * in a TypeScript file. It provides methods to insert import statements into the
+ * file content based on the provided declaration options.
+ */
 class ModuleImportDeclarator {
     constructor(solver = new path_solver_1.PathSolver()) {
         this.solver = solver;
     }
+    /**
+     * Declares a module import in the given content string.
+     *
+     * @param content - The content of the file where the import will be declared.
+     * @param options - The options for the declaration, including the symbol and path.
+     * @returns The updated content string with the import statement inserted.
+     */
     declare(content, options) {
         const toInsert = this.buildLineToInsert(options);
-        const importLines = this.findImports(content);
-        const otherLines = this.findOtherLines(content, importLines);
-        importLines.push(toInsert);
-        return importLines.join('\n').concat(otherLines.join('\n'));
+        const contentLines = content.split('\n');
+        const finalImportIndex = this.findImportsEndpoint(contentLines);
+        contentLines.splice(finalImportIndex + 1, 0, toInsert);
+        return contentLines.join('\n');
     }
-    findImports(content) {
-        return content.split('\n').filter((line) => line.match(/import {/));
-    }
-    findOtherLines(content, importLines) {
-        return content.split('\n').filter((line) => importLines.indexOf(line) < 0);
+    /**
+     * Finds the endpoint of the existing import statements in the content.
+     *
+     * @param contentLines - The lines of the content.
+     * @returns The index of the last import statement.
+     */
+    findImportsEndpoint(contentLines) {
+        const reversedContent = Array.from(contentLines).reverse();
+        const reverseImports = reversedContent.filter((line) => line.match(/\} from ('|")/));
+        if (reverseImports.length <= 0) {
+            return 0;
+        }
+        return contentLines.indexOf(reverseImports[0]);
     }
+    /**
+     * Builds the import line to insert based on the declaration options.
+     *
+     * @param options - The options for the declaration, including the symbol and path.
+     * @returns The import line to insert.
+     */
     buildLineToInsert(options) {
-        return `import { ${options.symbol} } from '${this.computeRelativePath(options)}';\n`;
+        return `import { ${options.symbol} } from '${this.computeRelativePath(options)}';`;
     }
+    /**
+     * Computes the relative path for the import statement.
+     *
+     * @param options - The options for the declaration, including the symbol and path.
+     * @returns The relative path for the import statement.
+     */
     computeRelativePath(options) {
         let importModulePath;
         if (options.type !== undefined) {