@dugararchit/cdk 0.0.0-dugararchit

package/schematics/schematics/update-tool/utils/parse-tsconfig.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as ts from 'typescript';
+import {FileSystem, WorkspacePath} from '../file-system';
+import {FileSystemHost} from './virtual-host';
+import {dirname} from 'path';
+
+export function parseTsconfigFile(
+  tsconfigPath: WorkspacePath,
+  fileSystem: FileSystem,
+): ts.ParsedCommandLine {
+  const {config} = ts.readConfigFile(tsconfigPath, p => fileSystem.read(fileSystem.resolve(p))!);
+  return ts.parseJsonConfigFileContent(
+    config,
+    new FileSystemHost(fileSystem),
+    dirname(tsconfigPath),
+    {},
+  );
+}

package/schematics/schematics/update-tool/utils/property-name.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as ts from 'typescript';
+
+/** Type that describes a property name with an obtainable text. */
+type PropertyNameWithText = Exclude<ts.PropertyName, ts.ComputedPropertyName>;
+
+/**
+ * Gets the text of the given property name. Returns null if the property
+ * name couldn't be determined statically.
+ */
+export function getPropertyNameText(node: ts.PropertyName): string | null {
+  if (ts.isIdentifier(node) || ts.isStringLiteralLike(node)) {
+    return node.text;
+  }
+  return null;
+}
+
+/** Checks whether the given property name has a text. */
+export function hasPropertyNameText(node: ts.PropertyName): node is PropertyNameWithText {
+  return ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isIdentifier(node);
+}

package/schematics/schematics/update-tool/utils/virtual-host.ts

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as ts from 'typescript';
+import {FileSystem} from '../file-system';
+
+// We use TypeScript's native `ts.matchFiles` utility for the virtual file system
+// hosts, as that function implements complex logic for matching files with respect
+// to root directory, extensions, excludes, includes etc. The function is currently
+// internal but we can use it as the API most likely will not change any time soon,
+// nor does it seem like this is being made public any time soon.
+// Related issue for tracking: https://github.com/microsoft/TypeScript/issues/13793.
+// https://github.com/microsoft/TypeScript/blob/b397d1fd4abd0edef85adf0afd91c030bb0b4955/src/compiler/utilities.ts#L6192
+declare module 'typescript' {
+  export interface FileSystemEntries {
+    readonly files: readonly string[];
+    readonly directories: readonly string[];
+  }
+
+  export const matchFiles:
+    | undefined
+    | ((
+        path: string,
+        extensions: readonly string[] | undefined,
+        excludes: readonly string[] | undefined,
+        includes: readonly string[] | undefined,
+        useCaseSensitiveFileNames: boolean,
+        currentDirectory: string,
+        depth: number | undefined,
+        getFileSystemEntries: (path: string) => FileSystemEntries,
+        realpath: (path: string) => string,
+        directoryExists: (path: string) => boolean,
+      ) => string[]);
+}
+
+/**
+ * Implementation of a TypeScript parse config host that relies fully on
+ * a given virtual file system.
+ */
+export class FileSystemHost implements ts.ParseConfigHost {
+  useCaseSensitiveFileNames = ts.sys.useCaseSensitiveFileNames;
+
+  constructor(private _fileSystem: FileSystem) {}
+
+  fileExists(path: string): boolean {
+    return this._fileSystem.fileExists(this._fileSystem.resolve(path));
+  }
+
+  readFile(path: string): string | undefined {
+    const content = this._fileSystem.read(this._fileSystem.resolve(path));
+    if (content === null) {
+      return undefined;
+    }
+    // Strip BOM as otherwise TSC methods (e.g. "getWidth") will return an offset which
+    // which breaks the CLI UpdateRecorder. https://github.com/angular/angular/pull/30719
+    return content.replace(/^\uFEFF/, '');
+  }
+
+  readDirectory(
+    rootDir: string,
+    extensions: string[],
+    excludes: string[] | undefined,
+    includes: string[],
+    depth?: number,
+  ): string[] {
+    if (ts.matchFiles === undefined) {
+      throw Error(
+        'Unable to read directory in virtual file system host. This means that ' +
+          'TypeScript changed its file matching internals.\n\nPlease consider downgrading your ' +
+          'TypeScript version, and report an issue in the Angular Components repository.',
+      );
+    }
+    return ts.matchFiles(
+      rootDir,
+      extensions,
+      extensions,
+      includes,
+      this.useCaseSensitiveFileNames,
+      '/',
+      depth,
+      p => this._getFileSystemEntries(p),
+      p => this._fileSystem.resolve(p),
+      p => this._fileSystem.directoryExists(this._fileSystem.resolve(p)),
+    );
+  }
+
+  private _getFileSystemEntries(path: string): ts.FileSystemEntries {
+    return this._fileSystem.readDirectory(this._fileSystem.resolve(path));
+  }
+}
+
+/**
+ * Creates a TypeScript compiler host that fully relies fully on the given
+ * virtual file system. i.e. no interactions with the working directory.
+ */
+export function createFileSystemCompilerHost(
+  options: ts.CompilerOptions,
+  fileSystem: FileSystem,
+): ts.CompilerHost {
+  const host = ts.createCompilerHost(options, true);
+  const virtualHost = new FileSystemHost(fileSystem);
+
+  host.readFile = virtualHost.readFile.bind(virtualHost);
+  host.readDirectory = virtualHost.readDirectory.bind(virtualHost);
+  host.fileExists = virtualHost.fileExists.bind(virtualHost);
+  host.directoryExists = dirPath => fileSystem.directoryExists(fileSystem.resolve(dirPath));
+  host.getCurrentDirectory = () => '/';
+  host.getCanonicalFileName = p => fileSystem.resolve(p);
+
+  return host;
+}

package/schematics/schematics/update-tool/version-changes.ts

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {TargetVersion} from './target-version';
+
+export type VersionChanges<T> = {
+  [target in TargetVersion]?: ReadableChange<T>[];
+};
+
+export type ReadableChange<T> = {
+  pr: string;
+  changes: T[];
+};
+
+/** Conditional type that unwraps the value of a version changes type. */
+export type ValueOfChanges<T> = T extends VersionChanges<infer X> ? X : null;
+
+/**
+ * Gets the changes for a given target version from the specified version changes object.
+ *
+ * For readability and a good overview of breaking changes, the version change data always
+ * includes the related Pull Request link. Since this data is not needed when performing the
+ * upgrade, this unused data can be removed and the changes data can be flattened into an
+ * easy iterable array.
+ */
+export function getChangesForTarget<T>(target: TargetVersion, data: VersionChanges<T>): T[] {
+  if (!data) {
+    const version = (TargetVersion as Record<string, string>)[target];
+    throw new Error(`No data could be found for target version: ${version}`);
+  }
+
+  return (data[target] || []).reduce((result, prData) => result.concat(prData.changes), [] as T[]);
+}
+
+/**
+ * Gets all changes from the specified version changes object. This is helpful in case a migration
+ * rule does not distinguish data based on the target version, but for readability the
+ * upgrade data is separated for each target version.
+ */
+export function getAllChanges<T>(data: VersionChanges<T>): T[] {
+  return Object.keys(data as any)
+    .map(targetVersion => getChangesForTarget(targetVersion as TargetVersion, data))
+    .reduce((result, versionData) => result.concat(versionData), []);
+}

package/schematics/schematics/utils/ast/ng-module-imports.spec.ts

@@ -0,0 +1,43 @@
+import {HostTree} from '@angular-devkit/schematics';
+import {UnitTestTree} from '@angular-devkit/schematics/testing';
+import {hasNgModuleImport} from './ng-module-imports';
+
+describe('NgModule import utils', () => {
+  let host: UnitTestTree;
+
+  beforeEach(() => {
+    host = new UnitTestTree(new HostTree());
+  });
+
+  describe('hasNgModuleImport', () => {
+    it('should properly detect imports', () => {
+      host.create(
+        '/test.ts',
+        `
+      @NgModule({
+        imports: [TestModule],
+      })
+      export class MyModule {}
+    `,
+      );
+
+      expect(hasNgModuleImport(host, '/test.ts', 'TestModule')).toBe(true);
+      expect(hasNgModuleImport(host, '/test.ts', 'NotExistent')).toBe(false);
+    });
+
+    it(`should detect imports for NgModule's using a namespaced identifier`, () => {
+      host.create(
+        '/test.ts',
+        `
+      @myImport.NgModule({
+        imports: [TestModule],
+      })
+      export class MyModule {}
+    `,
+      );
+
+      expect(hasNgModuleImport(host, '/test.ts', 'TestModule')).toBe(true);
+      expect(hasNgModuleImport(host, '/test.ts', 'NotExistent')).toBe(false);
+    });
+  });
+});

package/schematics/schematics/utils/ast/ng-module-imports.ts

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {SchematicsException, Tree} from '@angular-devkit/schematics';
+import * as ts from 'typescript';
+
+/**
+ * Whether the Angular module in the given path imports the specified module class name.
+ */
+export function hasNgModuleImport(tree: Tree, modulePath: string, className: string): boolean {
+  const moduleFileContent = tree.read(modulePath);
+
+  if (!moduleFileContent) {
+    throw new SchematicsException(`Could not read Angular module file: ${modulePath}`);
+  }
+
+  const parsedFile = ts.createSourceFile(
+    modulePath,
+    moduleFileContent.toString(),
+    ts.ScriptTarget.Latest,
+    true,
+  );
+  const ngModuleMetadata = findNgModuleMetadata(parsedFile);
+
+  if (!ngModuleMetadata) {
+    throw new SchematicsException(`Could not find NgModule declaration inside: "${modulePath}"`);
+  }
+
+  for (let property of ngModuleMetadata!.properties) {
+    if (
+      !ts.isPropertyAssignment(property) ||
+      property.name.getText() !== 'imports' ||
+      !ts.isArrayLiteralExpression(property.initializer)
+    ) {
+      continue;
+    }
+
+    if (property.initializer.elements.some(element => element.getText() === className)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Resolves the last identifier that is part of the given expression. This helps resolving
+ * identifiers of nested property access expressions (e.g. myNamespace.core.NgModule).
+ */
+function resolveIdentifierOfExpression(expression: ts.Expression): ts.Identifier | null {
+  if (ts.isIdentifier(expression)) {
+    return expression;
+  } else if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.name)) {
+    return expression.name;
+  }
+  return null;
+}
+
+/**
+ * Finds a NgModule declaration within the specified TypeScript node and returns the
+ * corresponding metadata for it. This function searches breadth first because
+ * NgModule's are usually not nested within other expressions or declarations.
+ */
+function findNgModuleMetadata(rootNode: ts.Node): ts.ObjectLiteralExpression | null {
+  // Add immediate child nodes of the root node to the queue.
+  const nodeQueue: ts.Node[] = [...rootNode.getChildren()];
+
+  while (nodeQueue.length) {
+    const node = nodeQueue.shift()!;
+
+    if (
+      ts.isDecorator(node) &&
+      ts.isCallExpression(node.expression) &&
+      isNgModuleCallExpression(node.expression)
+    ) {
+      return node.expression.arguments[0] as ts.ObjectLiteralExpression;
+    } else {
+      nodeQueue.push(...node.getChildren());
+    }
+  }
+
+  return null;
+}
+
+/** Whether the specified call expression is referring to a NgModule definition. */
+function isNgModuleCallExpression(callExpression: ts.CallExpression): boolean {
+  if (
+    !callExpression.arguments.length ||
+    !ts.isObjectLiteralExpression(callExpression.arguments[0])
+  ) {
+    return false;
+  }
+
+  // The `NgModule` call expression name is never referring to a `PrivateIdentifier`.
+  const decoratorIdentifier = resolveIdentifierOfExpression(callExpression.expression);
+  return decoratorIdentifier ? decoratorIdentifier.text === 'NgModule' : false;
+}

package/schematics/schematics/utils/ast.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {SchematicsException, Tree} from '@angular-devkit/schematics';
+import {Schema as ComponentOptions} from '@schematics/angular/component/schema';
+import {InsertChange} from '@schematics/angular/utility/change';
+import {getWorkspace} from '@schematics/angular/utility/workspace';
+import {findModuleFromOptions as internalFindModule} from '@schematics/angular/utility/find-module';
+import {ProjectDefinition} from '@angular-devkit/core/src/workspace';
+import * as ts from 'typescript';
+import {getProjectMainFile} from './project-main-file';
+import {addImportToModule, getAppModulePath} from './vendored-ast-utils';
+
+/** Reads file given path and returns TypeScript source file. */
+export function parseSourceFile(host: Tree, path: string): ts.SourceFile {
+  const buffer = host.read(path);
+  if (!buffer) {
+    throw new SchematicsException(`Could not find file for path: ${path}`);
+  }
+  return ts.createSourceFile(path, buffer.toString(), ts.ScriptTarget.Latest, true);
+}
+
+/** Import and add module to root app module. */
+export function addModuleImportToRootModule(
+  host: Tree,
+  moduleName: string,
+  src: string,
+  project: ProjectDefinition,
+) {
+  const modulePath = getAppModulePath(host, getProjectMainFile(project));
+  addModuleImportToModule(host, modulePath, moduleName, src);
+}
+
+/**
+ * Import and add module to specific module path.
+ * @param host the tree we are updating
+ * @param modulePath src location of the module to import
+ * @param moduleName name of module to import
+ * @param src src location to import
+ */
+export function addModuleImportToModule(
+  host: Tree,
+  modulePath: string,
+  moduleName: string,
+  src: string,
+) {
+  const moduleSource = parseSourceFile(host, modulePath);
+
+  if (!moduleSource) {
+    throw new SchematicsException(`Module not found: ${modulePath}`);
+  }
+
+  const changes = addImportToModule(moduleSource, modulePath, moduleName, src);
+  const recorder = host.beginUpdate(modulePath);
+
+  changes.forEach(change => {
+    if (change instanceof InsertChange) {
+      recorder.insertLeft(change.pos, change.toAdd);
+    }
+  });
+
+  host.commitUpdate(recorder);
+}
+
+/** Wraps the internal find module from options with undefined path handling  */
+export async function findModuleFromOptions(
+  host: Tree,
+  options: ComponentOptions,
+): Promise<string | undefined> {
+  const workspace = await getWorkspace(host);
+
+  if (!options.project) {
+    options.project = Array.from(workspace.projects.keys())[0];
+  }
+
+  const project = workspace.projects.get(options.project)!;
+
+  if (options.path === undefined) {
+    options.path = `/${project.root}/src/app`;
+  }
+
+  return internalFindModule(host, options);
+}