@gapi/schematics 1.8.122

package/dist/utils/metadata.manager.ts

@@ -0,0 +1,219 @@
+import {
+  ArrayLiteralExpression,
+  CallExpression,
+  createSourceFile,
+  Decorator,
+  Expression,
+  Identifier,
+  Node,
+  NodeArray,
+  ObjectLiteralElement,
+  ObjectLiteralExpression,
+  PropertyAssignment,
+  ScriptTarget,
+  SourceFile,
+  StringLiteral,
+  SyntaxKind,
+} from 'typescript';
+import { DeclarationOptions } from './module.declarator';
+
+export class MetadataManager {
+  constructor(private content: string) {}
+
+  public insert(
+    metadata: string,
+    symbol: string,
+    staticOptions?: DeclarationOptions['staticOptions'],
+  ): string {
+    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;
+        }
+      });
+
+    symbol = this.mergeSymbolAndExpr(symbol, staticOptions);
+    const addBlankLinesIfDynamic = () => {
+      symbol = staticOptions ? this.addBlankLines(symbol) : symbol;
+    };
+    if (matchingProperties.length === 0) {
+      const expr = node as ObjectLiteralExpression;
+      if (expr.properties.length === 0) {
+        addBlankLinesIfDynamic();
+        return this.insertMetadataToEmptyModuleDecorator(
+          expr,
+          metadata,
+          symbol,
+        );
+      } else {
+        addBlankLinesIfDynamic();
+        return this.insertNewMetadataToDecorator(
+          expr,
+          source,
+          metadata,
+          symbol,
+        );
+      }
+    } else {
+      return this.insertSymbolToMetadata(
+        source,
+        matchingProperties,
+        symbol,
+        staticOptions,
+      );
+    }
+  }
+
+  private getDecoratorMetadata(source: SourceFile, identifier: string): Node[] {
+    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);
+  }
+
+  private getSourceNodes(sourceFile: SourceFile): Node[] {
+    const nodes: Node[] = [sourceFile];
+    const result = [];
+    while (nodes.length > 0) {
+      const node = nodes.shift();
+      if (node) {
+        result.push(node);
+        if (node.getChildCount(sourceFile) >= 0) {
+          nodes.unshift(...node.getChildren());
+        }
+      }
+    }
+    return result;
+  }
+
+  private insertMetadataToEmptyModuleDecorator(
+    expr: ObjectLiteralExpression,
+    metadata: string,
+    symbol: string,
+  ): string {
+    const position = expr.getEnd() - 1;
+    const toInsert = `  ${metadata}: [${symbol}]`;
+    return this.content.split('').reduce((content, char, index) => {
+      if (index === position) {
+        return `${content}\n${toInsert}\n${char}`;
+      } else {
+        return `${content}${char}`;
+      }
+    }, '');
+  }
+
+  private insertNewMetadataToDecorator(
+    expr: ObjectLiteralExpression,
+    source: SourceFile,
+    metadata: string,
+    symbol: string,
+  ): string {
+    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: string;
+    if (matches.length > 0) {
+      toInsert = `,${matches[0]}${metadata}: [${symbol}]`;
+    } else {
+      toInsert = `, ${metadata}: [${symbol}]`;
+    }
+    return this.content.split('').reduce((content, char, index) => {
+      if (index === position) {
+        return `${content}${toInsert}${char}`;
+      } else {
+        return `${content}${char}`;
+      }
+    }, '');
+  }
+
+  private insertSymbolToMetadata(
+    source: SourceFile,
+    matchingProperties: ObjectLiteralElement[],
+    symbol: string,
+    staticOptions?: DeclarationOptions['staticOptions'],
+  ): string {
+    const assignment = matchingProperties[0] as PropertyAssignment;
+    let node: Node | NodeArray<Expression>;
+    const arrLiteral = assignment.initializer as ArrayLiteralExpression;
+    if (arrLiteral.elements.length === 0) {
+      node = arrLiteral;
+    } else {
+      node = arrLiteral.elements;
+    }
+    if (Array.isArray(node)) {
+      const nodeArray = (node as {}) as Node[];
+      const symbolsArray = nodeArray.map(childNode =>
+        childNode.getText(source),
+      );
+      if (symbolsArray.includes(symbol)) {
+        return this.content;
+      }
+      node = node[node.length - 1];
+    }
+    let toInsert: string;
+    let position = (node as Node).getEnd();
+
+    if ((node as Node).kind === SyntaxKind.ArrayLiteralExpression) {
+      position--;
+      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}`;
+      }
+    }
+    return this.content.split('').reduce((content, char, index) => {
+      if (index === position) {
+        return `${content}${toInsert}${char}`;
+      } else {
+        return `${content}${char}`;
+      }
+    }, '');
+  }
+
+  private mergeSymbolAndExpr(
+    symbol: string,
+    staticOptions?: DeclarationOptions['staticOptions'],
+  ): string {
+    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.slice(0, options.length - 1) + '    }';
+    symbol += `.${staticOptions.name}(${options})`;
+    return symbol;
+  }
+
+  private addBlankLines(expr: string): string {
+    return `\n    ${expr}\n  `;
+  }
+}

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

@@ -0,0 +1,11 @@
+import { DeclarationOptions } from './module.declarator';
+import { PathSolver } from './path.solver';
+export declare class ModuleImportDeclarator {
+    private solver;
+    constructor(solver?: PathSolver);
+    declare(content: string, options: DeclarationOptions): string;
+    private findImports;
+    private findOtherLines;
+    private buildLineToInsert;
+    private computeRelativePath;
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleImportDeclarator = void 0;
+const core_1 = require("@angular-devkit/core");
+const path_solver_1 = require("./path.solver");
+class ModuleImportDeclarator {
+    constructor(solver = new path_solver_1.PathSolver()) {
+        this.solver = solver;
+    }
+    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'));
+    }
+    findImports(content) {
+        return content.split('\n').filter(line => line.match(/import {/));
+    }
+    findOtherLines(content, importLines) {
+        return content.split('\n').filter(line => importLines.indexOf(line) < 0);
+    }
+    buildLineToInsert(options) {
+        return `import { ${options.symbol} } from '${this.computeRelativePath(options)}';\n`;
+    }
+    computeRelativePath(options) {
+        let importModulePath;
+        if (options.type !== undefined) {
+            importModulePath = core_1.normalize(`/${options.path}/${options.name}.${options.type}`);
+        }
+        else {
+            importModulePath = core_1.normalize(`/${options.path}/${options.name}`);
+        }
+        return this.solver.relative(options.module, importModulePath);
+    }
+}
+exports.ModuleImportDeclarator = ModuleImportDeclarator;

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

@@ -0,0 +1,41 @@
+import { normalize, Path } from '@angular-devkit/core';
+import { DeclarationOptions } from './module.declarator';
+import { PathSolver } from './path.solver';
+
+export class ModuleImportDeclarator {
+  constructor(private solver: PathSolver = new PathSolver()) {}
+
+  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'));
+  }
+
+  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);
+  }
+
+  private buildLineToInsert(options: DeclarationOptions): string {
+    return `import { ${options.symbol} } from '${this.computeRelativePath(
+      options,
+    )}';\n`;
+  }
+
+  private computeRelativePath(options: DeclarationOptions): string {
+    let importModulePath: Path;
+    if (options.type !== undefined) {
+      importModulePath = normalize(
+        `/${options.path}/${options.name}.${options.type}`,
+      );
+    } else {
+      importModulePath = normalize(`/${options.path}/${options.name}`);
+    }
+    return this.solver.relative(options.module, importModulePath);
+  }
+}

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

@@ -0,0 +1,4 @@
+import { DeclarationOptions } from './module.declarator';
+export declare class ModuleMetadataDeclarator {
+    declare(content: string, options: DeclarationOptions): string;
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleMetadataDeclarator = void 0;
+const metadata_manager_1 = require("./metadata.manager");
+class ModuleMetadataDeclarator {
+    declare(content, options) {
+        const manager = new metadata_manager_1.MetadataManager(content);
+        const inserted = manager.insert(options.metadata, options.symbol, options.staticOptions);
+        return inserted;
+    }
+}
+exports.ModuleMetadataDeclarator = ModuleMetadataDeclarator;

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

@@ -0,0 +1,14 @@
+import { MetadataManager } from './metadata.manager';
+import { DeclarationOptions } from './module.declarator';
+
+export class ModuleMetadataDeclarator {
+  public declare(content: string, options: DeclarationOptions): string {
+    const manager = new MetadataManager(content);
+    const inserted = manager.insert(
+      options.metadata,
+      options.symbol,
+      options.staticOptions,
+    );
+    return inserted;
+  }
+}

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

@@ -0,0 +1,22 @@
+import { Path } from '@angular-devkit/core';
+import { ModuleImportDeclarator } from './module-import.declarator';
+import { ModuleMetadataDeclarator } from './module-metadata.declarator';
+export interface DeclarationOptions {
+    metadata: string;
+    type?: string;
+    name: string;
+    path: Path;
+    module: Path;
+    symbol?: string;
+    staticOptions?: {
+        name: string;
+        value: Record<string, any>;
+    };
+}
+export declare class ModuleDeclarator {
+    private imports;
+    private metadata;
+    constructor(imports?: ModuleImportDeclarator, metadata?: ModuleMetadataDeclarator);
+    declare(content: string, options: DeclarationOptions): string;
+    private computeSymbol;
+}

package/dist/utils/module.declarator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleDeclarator = void 0;
+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 {
+    constructor(imports = new module_import_declarator_1.ModuleImportDeclarator(), metadata = new module_metadata_declarator_1.ModuleMetadataDeclarator()) {
+        this.imports = imports;
+        this.metadata = metadata;
+    }
+    declare(content, options) {
+        options = this.computeSymbol(options);
+        content = this.imports.declare(content, options);
+        content = this.metadata.declare(content, options);
+        return content;
+    }
+    computeSymbol(options) {
+        const target = Object.assign({}, options);
+        if (options.type !== undefined) {
+            target.symbol = strings_1.classify(options.name).concat(strings_1.capitalize(options.type));
+        }
+        else {
+            target.symbol = strings_1.classify(options.name);
+        }
+        return target;
+    }
+}
+exports.ModuleDeclarator = ModuleDeclarator;

package/dist/utils/module.declarator.ts

@@ -0,0 +1,41 @@
+import { Path } from '@angular-devkit/core';
+import { capitalize, classify } from '@angular-devkit/core/src/utils/strings';
+import { ModuleImportDeclarator } from './module-import.declarator';
+import { ModuleMetadataDeclarator } from './module-metadata.declarator';
+
+export interface DeclarationOptions {
+  metadata: string;
+  type?: string;
+  name: string;
+  path: Path;
+  module: Path;
+  symbol?: string;
+  staticOptions?: {
+    name: string;
+    value: Record<string, any>;
+  };
+}
+
+export class ModuleDeclarator {
+  constructor(
+    private imports: ModuleImportDeclarator = new ModuleImportDeclarator(),
+    private metadata: ModuleMetadataDeclarator = new ModuleMetadataDeclarator(),
+  ) {}
+
+  public declare(content: string, options: DeclarationOptions): string {
+    options = this.computeSymbol(options);
+    content = this.imports.declare(content, options);
+    content = this.metadata.declare(content, options);
+    return content;
+  }
+
+  private computeSymbol(options: DeclarationOptions): DeclarationOptions {
+    const target = Object.assign({}, options);
+    if (options.type !== undefined) {
+      target.symbol = classify(options.name).concat(capitalize(options.type));
+    } else {
+      target.symbol = classify(options.name);
+    }
+    return target;
+  }
+}