@rhtml/schematics 0.0.133 → 0.0.134

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhtml/schematics",
-  "version": "0.0.133",
+  "version": "0.0.134",
   "description": "Reactive HyperText Markup Language",
   "scripts": {
     "start": "npx parcel ./examples/index.html --out-dir build/examples",
@@ -15,10 +15,10 @@
     "build": "rm -rf dist && tsc || true && rsync -a --prune-empty-dirs --include '*/' --include '*' --exclude '*' src/ dist/"
   },
   "dependencies": {
-    "@angular-devkit/core": "^7.3.7",
-    "@angular-devkit/schematics": "^7.3.7",
-    "@angular-devkit/schematics-cli": "^0.13.7",
-    "ts-morph": "^1.3.1"
+    "@angular-devkit/core": "^19.2.0",
+    "@angular-devkit/schematics": "^19.2.0",
+    "@angular-devkit/schematics-cli": "^19.2.0",
+    "ts-morph": "^25.0.1"
   },
   "devDependencies": {},
   "repository": {

package/src/lib/component/schema.json

@@ -1,6 +1,6 @@
 {
   "$schema": "http://json-schema.org/schema",
-  "id": "SchematicsRHTMLComponent",
+  "$id": "SchematicsRHTMLComponent",
   "title": "@rhtml Component Options Schema",
   "type": "object",
   "properties": {

package/src/lib/controller/schema.json

@@ -1,6 +1,6 @@
 {
   "$schema": "http://json-schema.org/schema",
-  "id": "SchematicsRHTMLController",
+  "$id": "SchematicsRHTMLController",
   "title": "RHTML Controller Options Schema",
   "type": "object",
   "properties": {

package/src/lib/module/schema.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/schema",
-  "id": "SchematicsNestModule",
-  "title": "Nest Module Options Schema",
+  "$id": "SchematicsRhtmlModule",
+  "title": "Rhtml Module Options Schema",
   "type": "object",
   "properties": {
     "name": {
@@ -25,11 +25,11 @@
     },
     "language": {
       "type": "string",
-      "description": "Nest module language (ts/js)."
+      "description": "Rhtml module language (ts/js)."
     },
     "sourceRoot": {
       "type": "string",
-      "description": "Nest module source root directory."
+      "description": "Rhtml module source root directory."
     },
     "skipImport": {
       "description": "Flag to skip the module import.",

package/src/lib/provider/schema.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/schema",
-  "id": "SchematicsNestProvider",
-  "title": "Nest Provider Options Schema",
+  "$id": "SchematicsRhtmlProvider",
+  "title": "Rhtml Provider Options Schema",
   "type": "object",
   "properties": {
     "name": {
@@ -20,11 +20,11 @@
     },
     "language": {
       "type": "string",
-      "description": "Nest provider language (ts/js)."
+      "description": "Rhtml provider language (ts/js)."
     },
     "sourceRoot": {
       "type": "string",
-      "description": "Nest provider source root directory."
+      "description": "Rhtml provider source root directory."
     },
     "flat": {
       "default": true,

package/src/lib/service/schema.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/schema",
-  "id": "SchematicsNestService",
-  "title": "Nest Service Options Schema",
+  "$id": "SchematicsRhtmlService",
+  "title": "Rhtml Service Options Schema",
   "type": "object",
   "properties": {
     "name": {
@@ -20,7 +20,7 @@
     },
     "language": {
       "type": "string",
-      "description": "Nest service language (ts/js)."
+      "description": "Rhtml service language (ts/js)."
     },
     "sourceRoot": {
       "type": "string",

package/src/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/src/utils/module-import.declarator.ts

@@ -3,31 +3,64 @@ import { normalize, Path } from '@angular-devkit/core';
 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 class ModuleImportDeclarator {
   constructor(private solver: PathSolver = new 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.
+   */
   public declare(content: string, options: DeclarationOptions): string {
-    const toInsert: string = this.buildLineToInsert(options);
-    const importLines: string[] = this.findImports(content);
-    const otherLines: string[] = this.findOtherLines(content, importLines);
-    importLines.push(toInsert);
-    return importLines.join('\n').concat(otherLines.join('\n'));
+    const toInsert = this.buildLineToInsert(options);
+    const contentLines = content.split('\n');
+    const finalImportIndex = this.findImportsEndpoint(contentLines);
+    contentLines.splice(finalImportIndex + 1, 0, toInsert);
+    return contentLines.join('\n');
   }
 
-  private findImports(content: string): string[] {
-    return content.split('\n').filter((line) => line.match(/import {/));
-  }
-
-  private findOtherLines(content: string, importLines: string[]) {
-    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.
+   */
+  private findImportsEndpoint(contentLines: string[]): number {
+    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.
+   */
   private buildLineToInsert(options: DeclarationOptions): string {
     return `import { ${options.symbol} } from '${this.computeRelativePath(
       options
-    )}';\n`;
+    )}';`;
   }
 
+  /**
+   * 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(options: DeclarationOptions): string {
     let importModulePath: Path;
     if (options.type !== undefined) {

package/src/utils/module-metadata.declarator.ts

@@ -1,7 +1,19 @@
 import { MetadataManager } from './metadata.manager';
 import { DeclarationOptions } from './module.declarator';
 
+/**
+ * The `ModuleMetadataDeclarator` class is responsible for declaring metadata
+ * in a TypeScript file. It provides methods to insert metadata entries into the
+ * file content based on the provided declaration options.
+ */
 export class ModuleMetadataDeclarator {
+  /**
+   * Declares metadata in the given content string.
+   *
+   * @param content - The content of the file where the metadata will be declared.
+   * @param options - The options for the declaration, including the metadata, symbol, and static options.
+   * @returns The updated content string with the metadata entry inserted.
+   */
   public declare(content: string, options: DeclarationOptions): string {
     const manager = new MetadataManager(content);
     const inserted = manager.insert(
@@ -9,6 +21,6 @@ export class ModuleMetadataDeclarator {
       options.symbol,
       options.staticOptions
     );
-    return inserted;
+    return inserted ?? content;
   }
 }

package/src/utils/module.declarator.ts

@@ -8,21 +8,35 @@ export interface DeclarationOptions {
   metadata: string;
   type?: string;
   name: string;
+  className?: string;
   path: Path;
   module: Path;
   symbol?: string;
   staticOptions?: {
     name: string;
-    value: Record<string, unknown>;
+    value: Record<string, never>;
   };
 }
 
 export class ModuleDeclarator {
+  /**
+   * Constructs a new `ModuleDeclarator` instance.
+   *
+   * @param imports - The `ModuleImportDeclarator` instance for handling import declarations.
+   * @param metadata - The `ModuleMetadataDeclarator` instance for handling metadata declarations.
+   */
   constructor(
     private imports: ModuleImportDeclarator = new ModuleImportDeclarator(),
     private metadata: ModuleMetadataDeclarator = new ModuleMetadataDeclarator()
   ) {}
 
+  /**
+   * Declares module imports and metadata in the given content string.
+   *
+   * @param content - The content of the file where the declarations will be made.
+   * @param options - The options for the declaration, including the symbol and static options.
+   * @returns The updated content string with the declarations inserted.
+   */
   public declare(content: string, options: DeclarationOptions): string {
     options = this.computeSymbol(options);
     content = this.imports.declare(content, options);
@@ -30,9 +44,17 @@ export class ModuleDeclarator {
     return content;
   }
 
+  /**
+   * Computes the symbol for the declaration options if not provided.
+   *
+   * @param options - The options for the declaration.
+   * @returns The updated declaration options with the computed symbol.
+   */
   private computeSymbol(options: DeclarationOptions): DeclarationOptions {
     const target = Object.assign({}, options);
-    if (options.type !== undefined) {
+    if (options.className) {
+      target.symbol = options.className;
+    } else if (options.type !== undefined) {
       target.symbol = classify(options.name).concat(capitalize(options.type));
     } else {
       target.symbol = classify(options.name);

package/src/utils/module.finder.ts

@@ -10,6 +10,12 @@ export interface FindOptions {
 export class ModuleFinder {
   constructor(private tree: Tree) {}
 
+  /**
+   * Finds the module file in the given path.
+   *
+   * @param options - The options for finding the module, including the path.
+   * @returns The path to the module file, or null if not found.
+   */
   public find(options: FindOptions): Path | null {
     const generatedDirectoryPath: Path = options.path;
     const generatedDirectory: DirEntry = this.tree.getDir(
@@ -18,12 +24,18 @@ export class ModuleFinder {
     return this.findIn(generatedDirectory);
   }
 
+  /**
+   * Recursively searches for the module file in the given directory.
+   *
+   * @param directory - The directory to search in.
+   * @returns The path to the module file, or null if not found.
+   */
   private findIn(directory: DirEntry): Path | null {
     if (!directory) {
       return null;
     }
     const moduleFilename: PathFragment = directory.subfiles.find((filename) =>
-      /\.module\.(t|j)s/.test(filename)
+      /\.module\.(t|j)s$/.test(filename)
     );
     return moduleFilename !== undefined
       ? join(directory.path, moduleFilename.valueOf())

package/src/utils/name.parser.ts

@@ -11,6 +11,12 @@ export interface Location {
 }
 
 export class NameParser {
+  /**
+   * Parses the provided options to extract the name and path.
+   *
+   * @param options - The options containing the name and path.
+   * @returns An object containing the parsed name and normalized path.
+   */
   public parse(options: ParseOptions): Location {
     const nameWithoutPath: string = basename(options.name as Path);
     const namePath: string = dirname(

package/src/utils/path.solver.ts

@@ -1,6 +1,13 @@
 import { basename, dirname, Path, relative } from '@angular-devkit/core';
 
 export class PathSolver {
+  /**
+   * Computes the relative path between two paths.
+   *
+   * @param from - The source path.
+   * @param to - The target path.
+   * @returns The relative path between the two paths.
+   */
   public relative(from: Path, to: Path): string {
     const placeholder = '/placeholder';
     const relativeDir = relative(

package/src/utils/source-root.helpers.ts

@@ -3,16 +3,28 @@ import { Rule, Tree } from '@angular-devkit/schematics';
 
 import { DEFAULT_PATH_NAME } from '../lib/defaults';
 
+/**
+ * Checks if the current directory is the root directory.
+ *
+ * @param host - The file tree representing the project.
+ * @param extraFiles - Additional files to check for in the root directory.
+ * @returns True if the current directory is the root directory, otherwise false.
+ */
 export function isInRootDirectory(
   host: Tree,
   extraFiles: string[] = []
 ): boolean {
-  const files = ['nest-cli.json', 'nest.json'].concat(extraFiles || []);
+  const files = [].concat(extraFiles || []);
   return files.map((file) => host.exists(file)).some((isPresent) => isPresent);
 }
 
+/**
+ * Merges the source root with the provided options.
+ * @param options - The options to merge with the source root.
+ * @returns A rule to merge the source root with the provided options.
+ */
 export function mergeSourceRoot<
-  T extends { sourceRoot?: string; path?: string } = unknown
+  T extends { sourceRoot?: string; path?: string } = never
 >(options: T): Rule {
   return (host: Tree) => {
     const isInRoot = isInRootDirectory(host, ['tsconfig.json', 'package.json']);