@gapi/schematics 1.8.122

package/src/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/src/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/src/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;
+  }
+}

package/src/utils/module.finder.ts

@@ -0,0 +1,32 @@
+import { join, Path, PathFragment } from '@angular-devkit/core';
+import { DirEntry, Tree } from '@angular-devkit/schematics';
+
+export interface FindOptions {
+  name?: string;
+  path: Path;
+  kind?: string;
+}
+
+export class ModuleFinder {
+  constructor(private tree: Tree) {}
+
+  public find(options: FindOptions): Path | null {
+    const generatedDirectoryPath: Path = options.path;
+    const generatedDirectory: DirEntry = this.tree.getDir(
+      generatedDirectoryPath,
+    );
+    return this.findIn(generatedDirectory);
+  }
+
+  private findIn(directory: DirEntry): Path | null {
+    if (!directory) {
+      return null;
+    }
+    const moduleFilename: PathFragment = directory.subfiles.find(filename =>
+      /\.module\.(t|j)s/.test(filename),
+    );
+    return moduleFilename !== undefined
+      ? join(directory.path, moduleFilename.valueOf())
+      : this.findIn(directory.parent);
+  }
+}

package/src/utils/name.parser.ts

@@ -0,0 +1,29 @@
+import { basename, dirname, normalize, Path } from '@angular-devkit/core';
+
+export interface ParseOptions {
+  name: string;
+  path?: string;
+}
+
+export interface Location {
+  name: string;
+  path: Path;
+}
+
+export class NameParser {
+  constructor() {}
+
+  public parse(options: ParseOptions): Location {
+    const nameWithoutPath: string = basename(options.name as Path);
+    const namePath: string = dirname((options.path === undefined
+      ? ''
+      : options.path
+    )
+      .concat('/')
+      .concat(options.name) as Path);
+    return {
+      name: nameWithoutPath,
+      path: normalize('/'.concat(namePath)),
+    };
+  }
+}

package/src/utils/path.solver.ts

@@ -0,0 +1,17 @@
+import { basename, dirname, Path, relative } from '@angular-devkit/core';
+
+export class PathSolver {
+  constructor() {}
+
+  public relative(from: Path, to: Path): string {
+    const placeholder = '/placeholder';
+    const relativeDir = relative(
+      dirname((placeholder + from) as Path),
+      dirname((placeholder + to) as Path),
+    );
+    return (relativeDir.startsWith('.')
+      ? relativeDir
+      : './' + relativeDir
+    ).concat(relativeDir.length === 0 ? basename(to) : '/' + basename(to));
+  }
+}

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

@@ -0,0 +1,30 @@
+import { join, normalize } from '@angular-devkit/core';
+import { Rule, Tree } from '@angular-devkit/schematics';
+import { DEFAULT_PATH_NAME } from '../lib/defaults';
+
+export function isInRootDirectory(
+  host: Tree,
+  extraFiles: string[] = [],
+): boolean {
+  const files = ['nest-cli.json', 'nest.json'].concat(extraFiles || []);
+  return files.map(file => host.exists(file)).some(isPresent => isPresent);
+}
+
+export function mergeSourceRoot<
+  T extends { sourceRoot?: string; path?: string } = any
+>(options: T): Rule {
+  return (host: Tree) => {
+    const isInRoot = isInRootDirectory(host, ['tsconfig.json', 'package.json']);
+    if (!isInRoot) {
+      return host;
+    }
+    const defaultSourceRoot =
+      options.sourceRoot !== undefined ? options.sourceRoot : DEFAULT_PATH_NAME;
+
+    options.path =
+      options.path !== undefined
+        ? join(normalize(defaultSourceRoot), options.path)
+        : normalize(defaultSourceRoot);
+    return host;
+  };
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "module": "commonjs",
+    "target": "es6",
+    "baseUrl": ".",
+    "stripInternal": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "moduleResolution": "node",
+    "outDir": "dist",
+    "rootDir": "src",
+    "lib": ["es2017", "es2016", "es2015", "es6", "dom", "esnext.asynciterable"],
+    "skipLibCheck": true,
+    "types": []
+  },
+  "angularCompilerOptions": {
+    "annotateForClosureCompiler": true,
+    "strictMetadataEmit": true,
+    "skipTemplateCodegen": true,
+    "flatModuleOutFile": "gapi-voyager.js",
+    "flatModuleId": "gapi-voyager"
+  },
+  "include": ["src/utils", "src/lib"],
+  "exclude": ["node_modules", "src/**/*.test.ts", "src/**/files/**"]
+}