@rhtml/schematics 0.0.132 → 0.0.134

package/dist/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/dist/utils/module-metadata.declarator.d.ts

@@ -1,4 +1,16 @@
 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 declare 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.
+     */
     declare(content: string, options: DeclarationOptions): string;
 }

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

@@ -2,11 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModuleMetadataDeclarator = void 0;
 const metadata_manager_1 = require("./metadata.manager");
+/**
+ * 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.
+ */
 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.
+     */
     declare(content, options) {
         const manager = new metadata_manager_1.MetadataManager(content);
         const inserted = manager.insert(options.metadata, options.symbol, options.staticOptions);
-        return inserted;
+        return inserted !== null && inserted !== void 0 ? inserted : content;
     }
 }
 exports.ModuleMetadataDeclarator = ModuleMetadataDeclarator;

package/dist/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/dist/utils/module.declarator.d.ts

@@ -5,18 +5,38 @@ 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 declare class ModuleDeclarator {
     private imports;
     private metadata;
+    /**
+     * Constructs a new `ModuleDeclarator` instance.
+     *
+     * @param imports - The `ModuleImportDeclarator` instance for handling import declarations.
+     * @param metadata - The `ModuleMetadataDeclarator` instance for handling metadata declarations.
+     */
     constructor(imports?: ModuleImportDeclarator, metadata?: 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.
+     */
     declare(content: string, options: DeclarationOptions): string;
+    /**
+     * 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;
 }

package/dist/utils/module.declarator.js

@@ -5,19 +5,41 @@ const strings_1 = require("@angular-devkit/core/src/utils/strings");
 const module_import_declarator_1 = require("./module-import.declarator");
 const module_metadata_declarator_1 = require("./module-metadata.declarator");
 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(imports = new module_import_declarator_1.ModuleImportDeclarator(), metadata = new module_metadata_declarator_1.ModuleMetadataDeclarator()) {
         this.imports = imports;
         this.metadata = metadata;
     }
+    /**
+     * 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.
+     */
     declare(content, options) {
         options = this.computeSymbol(options);
         content = this.imports.declare(content, options);
         content = this.metadata.declare(content, options);
         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.
+     */
     computeSymbol(options) {
         const target = Object.assign({}, options);
-        if (options.type !== undefined) {
+        if (options.className) {
+            target.symbol = options.className;
+        }
+        else if (options.type !== undefined) {
             target.symbol = (0, strings_1.classify)(options.name).concat((0, strings_1.capitalize)(options.type));
         }
         else {

package/dist/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/dist/utils/module.finder.d.ts

@@ -8,6 +8,18 @@ export interface FindOptions {
 export declare class ModuleFinder {
     private tree;
     constructor(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.
+     */
     find(options: FindOptions): Path | null;
+    /**
+     * 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;
 }

package/dist/utils/module.finder.js

@@ -6,16 +6,28 @@ class ModuleFinder {
     constructor(tree) {
         this.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.
+     */
     find(options) {
         const generatedDirectoryPath = options.path;
         const generatedDirectory = this.tree.getDir(generatedDirectoryPath);
         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.
+     */
     findIn(directory) {
         if (!directory) {
             return null;
         }
-        const moduleFilename = directory.subfiles.find((filename) => /\.module\.(t|j)s/.test(filename));
+        const moduleFilename = directory.subfiles.find((filename) => /\.module\.(t|j)s$/.test(filename));
         return moduleFilename !== undefined
             ? (0, core_1.join)(directory.path, moduleFilename.valueOf())
             : this.findIn(directory.parent);

package/dist/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/dist/utils/name.parser.d.ts

@@ -8,5 +8,11 @@ export interface Location {
     path: Path;
 }
 export declare 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.
+     */
     parse(options: ParseOptions): Location;
 }

package/dist/utils/name.parser.js

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NameParser = void 0;
 const core_1 = require("@angular-devkit/core");
 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.
+     */
     parse(options) {
         const nameWithoutPath = (0, core_1.basename)(options.name);
         const namePath = (0, core_1.dirname)((options.path === undefined ? '' : options.path)

package/dist/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/dist/utils/path.solver.d.ts

@@ -1,4 +1,11 @@
 import { Path } from '@angular-devkit/core';
 export declare 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.
+     */
     relative(from: Path, to: Path): string;
 }

package/dist/utils/path.solver.js

@@ -3,6 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PathSolver = void 0;
 const core_1 = require("@angular-devkit/core");
 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.
+     */
     relative(from, to) {
         const placeholder = '/placeholder';
         const relativeDir = (0, core_1.relative)((0, core_1.dirname)((placeholder + from)), (0, core_1.dirname)((placeholder + to)));

package/dist/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/dist/utils/source-root.helpers.d.ts

@@ -1,6 +1,18 @@
 import { Rule, Tree } from '@angular-devkit/schematics';
+/**
+ * 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 declare function isInRootDirectory(host: Tree, extraFiles?: string[]): boolean;
+/**
+ * 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 declare function mergeSourceRoot<T extends {
     sourceRoot?: string;
     path?: string;
-} = unknown>(options: T): Rule;
+} = never>(options: T): Rule;

package/dist/utils/source-root.helpers.js

@@ -3,11 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeSourceRoot = exports.isInRootDirectory = void 0;
 const core_1 = require("@angular-devkit/core");
 const defaults_1 = require("../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.
+ */
 function isInRootDirectory(host, extraFiles = []) {
-    const files = ['nest-cli.json', 'nest.json'].concat(extraFiles || []);
+    const files = [].concat(extraFiles || []);
     return files.map((file) => host.exists(file)).some((isPresent) => isPresent);
 }
 exports.isInRootDirectory = isInRootDirectory;
+/**
+ * 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.
+ */
 function mergeSourceRoot(options) {
     return (host) => {
         const isInRoot = isInRootDirectory(host, ['tsconfig.json', 'package.json']);

package/dist/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']);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhtml/schematics",
-  "version": "0.0.132",
+  "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/controller.factory.ts

@@ -0,0 +1,92 @@
+import { join, Path, strings } from '@angular-devkit/core';
+import {
+  apply,
+  branchAndMerge,
+  chain,
+  filter,
+  mergeWith,
+  move,
+  noop,
+  Rule,
+  SchematicContext,
+  template,
+  Tree,
+  url,
+} from '@angular-devkit/schematics';
+
+import {
+  DeclarationOptions,
+  ModuleDeclarator,
+} from '../../utils/module.declarator';
+import { ModuleFinder } from '../../utils/module.finder';
+import { Location, NameParser } from '../../utils/name.parser';
+import { mergeSourceRoot } from '../../utils/source-root.helpers';
+import { DEFAULT_LANGUAGE } from '../defaults';
+import { ControllerOptions } from './controller.schema';
+
+const ELEMENT_METADATA = 'bootstrap';
+const ELEMENT_TYPE = 'controller';
+
+export function main(options: ControllerOptions): Rule {
+  options = transform(options);
+  return (tree: Tree, context: SchematicContext) => {
+    return branchAndMerge(
+      chain([
+        mergeSourceRoot(options),
+        mergeWith(generate(options)),
+        addDeclarationToModule(options),
+      ])
+    )(tree, context);
+  };
+}
+
+function transform(source: ControllerOptions): ControllerOptions {
+  const target: ControllerOptions = Object.assign({}, source);
+  target.metadata = ELEMENT_METADATA;
+  target.type = ELEMENT_TYPE;
+
+  const location: Location = new NameParser().parse(target);
+  target.name = strings.dasherize(location.name);
+  target.path = strings.dasherize(location.path);
+  target.language =
+    target.language !== undefined ? target.language : DEFAULT_LANGUAGE;
+
+  target.path = target.flat
+    ? target.path
+    : join(target.path as Path, target.name);
+  return target;
+}
+
+function generate(options: ControllerOptions) {
+  return (context: SchematicContext) =>
+    apply(url(join('./files' as Path, options.language)), [
+      options.spec ? noop() : filter((path) => !path.endsWith('.spec.ts')),
+      template({
+        ...strings,
+        ...options,
+      }),
+      move(options.path),
+    ])(context);
+}
+
+function addDeclarationToModule(options: ControllerOptions): Rule {
+  return (tree: Tree) => {
+    if (options.skipImport !== undefined && options.skipImport) {
+      return tree;
+    }
+    options.module = new ModuleFinder(tree).find({
+      name: options.name,
+      path: options.path as Path,
+    });
+    if (!options.module) {
+      return tree;
+    }
+    const content = tree.read(options.module).toString();
+    const declarator: ModuleDeclarator = new ModuleDeclarator();
+    tree.overwrite(
+      options.module,
+      declarator.declare(content, options as DeclarationOptions)
+    );
+    return tree;
+  };
+}