@angular/cdk 8.0.2 → 8.1.0

package/{schematics/ng-update/upgrade-rules/class-names/classNamesIdentifierRule.d.ts → typings/schematics/ng-update/upgrade-rules/class-names-rule.d.ts}

@@ -5,17 +5,15 @@
  * 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 { RuleFailure, Rules, RuleWalker } from 'tslint';
 import * as ts from 'typescript';
-import { ClassNameUpgradeData } from '../../data';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { ClassNameUpgradeData } from '../data';
+import { RuleUpgradeData } from '../upgrade-data';
 /**
  * Rule that walks through every identifier that is part of Angular Material or thr CDK
  * and replaces the outdated name with the new one if specified in the upgrade data.
  */
-export declare class Rule extends Rules.AbstractRule {
-    apply(sourceFile: ts.SourceFile): RuleFailure[];
-}
-export declare class Walker extends RuleWalker {
+export declare class ClassNamesRule extends MigrationRule<RuleUpgradeData> {
     /** Change data that upgrades to the specified target version. */
     data: ClassNameUpgradeData[];
     /**
@@ -25,8 +23,10 @@ export declare class Walker extends RuleWalker {
     trustedIdentifiers: Set<string>;
     /** List of namespaces that have been imported from `@angular/material` or `@angular/cdk`. */
     trustedNamespaces: Set<string>;
+    ruleEnabled: boolean;
+    visitNode(node: ts.Node): void;
     /** Method that is called for every identifier inside of the specified project. */
-    visitIdentifier(identifier: ts.Identifier): void;
+    private _visitIdentifier;
     /** Creates a failure and replacement for the specified identifier. */
     private _createFailureWithReplacement;
 }

package/typings/schematics/ng-update/upgrade-rules/constructor-signature-rule.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @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 { MigrationRule } from '../../update-tool/migration-rule';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Rule that visits every TypeScript new expression or super call and checks if
+ * the parameter type signature is invalid and needs to be updated manually.
+ */
+export declare class ConstructorSignatureRule extends MigrationRule<RuleUpgradeData> {
+    data: string[];
+    ruleEnabled: boolean;
+    visitNode(node: ts.Node): void;
+    /**
+     * Method that will be called for each source file of the upgrade project. In order to
+     * properly determine invalid constructor signatures, we take advantage of the pre-emit
+     * diagnostics from TypeScript.
+     *
+     * By using the diagnostics, the migration can handle type assignability. Not using
+     * diagnostics would mean that we need to use simple type equality checking which is
+     * too strict. See related issue: https://github.com/Microsoft/TypeScript/issues/9879
+     */
+    private _visitSourceFile;
+}

package/typings/schematics/ng-update/upgrade-rules/css-selectors-rule.d.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 { ResolvedResource } from '../../update-tool/component-resource-collector';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Rule that walks through every string literal, template and stylesheet in
+ * order to migrate outdated CSS selectors to the new selector.
+ */
+export declare class CssSelectorsRule extends MigrationRule<RuleUpgradeData> {
+    /** Change data that upgrades to the specified target version. */
+    data: any;
+    ruleEnabled: any;
+    visitNode(node: ts.Node): void;
+    visitTemplate(template: ResolvedResource): void;
+    visitStylesheet(stylesheet: ResolvedResource): void;
+    private _visitStringLiteralLike;
+    private _replaceSelector;
+}

package/typings/schematics/ng-update/upgrade-rules/element-selectors-rule.d.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 { ResolvedResource } from '../../update-tool/component-resource-collector';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Rule that walks through every string literal, template and stylesheet in order
+ * to migrate outdated element selectors to the new one.
+ */
+export declare class ElementSelectorsRule extends MigrationRule<RuleUpgradeData> {
+    /** Change data that upgrades to the specified target version. */
+    data: any;
+    ruleEnabled: any;
+    visitNode(node: ts.Node): void;
+    visitTemplate(template: ResolvedResource): void;
+    visitStylesheet(stylesheet: ResolvedResource): void;
+    private _visitStringLiteralLike;
+    private _replaceSelector;
+}

package/typings/schematics/ng-update/upgrade-rules/index.d.ts

@@ -6,7 +6,16 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { Rule } from '@angular-devkit/schematics';
-import { TargetVersion } from '../target-version';
-import { UpgradeTSLintConfig } from './tslint-config';
-/** Creates a Angular schematic rule that runs the upgrade for the specified target version. */
-export declare function createUpgradeRule(targetVersion: TargetVersion, upgradeConfig: UpgradeTSLintConfig): Rule;
+import { Constructor } from '../../update-tool';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { TargetVersion } from '../../update-tool/target-version';
+import { RuleUpgradeData } from '../upgrade-data';
+/** List of migration rules which run for the CDK update. */
+export declare const cdkMigrationRules: Constructor<MigrationRule<RuleUpgradeData>>[];
+declare type NullableMigrationRule = Constructor<MigrationRule<RuleUpgradeData | null>>;
+/**
+ * Creates a Angular schematic rule that runs the upgrade for the
+ * specified target version.
+ */
+export declare function createUpgradeRule(targetVersion: TargetVersion, extraRules: NullableMigrationRule[], upgradeData: RuleUpgradeData, onMigrationCompleteFn?: (targetVersion: TargetVersion, hasFailures: boolean) => void): Rule;
+export {};

package/typings/schematics/ng-update/upgrade-rules/input-names-rule.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @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 { ResolvedResource } from '../../update-tool/component-resource-collector';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { InputNameUpgradeData } from '../data';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Rule that walks through every template or stylesheet and replaces outdated input
+ * names to the new input name. Selectors in stylesheets could also target input
+ * bindings declared as static attribute. See for example:
+ *
+ * e.g. `<my-component color="primary">` becomes `my-component[color]`
+ */
+export declare class InputNamesRule extends MigrationRule<RuleUpgradeData> {
+    /** Change data that upgrades to the specified target version. */
+    data: InputNameUpgradeData[];
+    ruleEnabled: boolean;
+    visitStylesheet(stylesheet: ResolvedResource): void;
+    visitTemplate(template: ResolvedResource): void;
+    private _replaceInputName;
+}

package/{schematics/ng-update/upgrade-rules/signature-check/methodCallsCheckRule.d.ts → typings/schematics/ng-update/upgrade-rules/method-call-arguments-rule.d.ts}

@@ -5,19 +5,18 @@
  * 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 { ProgramAwareRuleWalker, RuleFailure, Rules } from 'tslint';
 import * as ts from 'typescript';
-import { MethodCallUpgradeData } from '../../data';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { MethodCallUpgradeData } from '../data';
+import { RuleUpgradeData } from '../upgrade-data';
 /**
- * Rule that visits every TypeScript method call expression and checks if the argument count
- * is invalid and needs to be *manually* updated.
+ * Rule that visits every TypeScript method call expression and checks if the
+ * argument count is invalid and needs to be *manually* updated.
  */
-export declare class Rule extends Rules.TypedRule {
-    applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): RuleFailure[];
-}
-export declare class Walker extends ProgramAwareRuleWalker {
+export declare class MethodCallArgumentsRule extends MigrationRule<RuleUpgradeData> {
     /** Change data that upgrades to the specified target version. */
     data: MethodCallUpgradeData[];
-    visitCallExpression(node: ts.CallExpression): void;
+    ruleEnabled: boolean;
+    visitNode(node: ts.Node): void;
     private _checkPropertyAccessMethodCall;
 }

package/typings/schematics/ng-update/upgrade-rules/misc-template-rule.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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 { ResolvedResource } from '../../update-tool/component-resource-collector';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Rule that walks through every template and reports if there are
+ * instances of outdated Angular CDK API that can't be migrated automatically.
+ */
+export declare class MiscTemplateRule extends MigrationRule<RuleUpgradeData> {
+    ruleEnabled: boolean;
+    visitTemplate(template: ResolvedResource): void;
+}

package/typings/schematics/ng-update/upgrade-rules/output-names-rule.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @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 { ResolvedResource } from '../../update-tool/component-resource-collector';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { OutputNameUpgradeData } from '../data';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Rule that walks through every inline or external HTML template and switches
+ * changed output binding names to the proper new output name.
+ */
+export declare class OutputNamesRule extends MigrationRule<RuleUpgradeData> {
+    /** Change data that upgrades to the specified target version. */
+    data: OutputNameUpgradeData[];
+    ruleEnabled: boolean;
+    visitTemplate(template: ResolvedResource): void;
+    private _replaceOutputName;
+}

package/typings/schematics/ng-update/upgrade-rules/property-names-rule.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @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 { MigrationRule } from '../../update-tool/migration-rule';
+import { PropertyNameUpgradeData } from '../data';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Rule that walks through every property access expression and updates
+ * accessed properties that have been updated to a new name.
+ */
+export declare class PropertyNamesRule extends MigrationRule<RuleUpgradeData> {
+    /** Change data that upgrades to the specified target version. */
+    data: PropertyNameUpgradeData[];
+    ruleEnabled: boolean;
+    visitNode(node: ts.Node): void;
+    private _visitPropertyAccessExpression;
+}

package/typings/schematics/update-tool/component-resource-collector.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @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 { LineAndCharacter } from './utils/line-mappings';
+export interface ResolvedResource {
+    /** Class declaration that contains this resource. */
+    container: ts.ClassDeclaration | null;
+    /** File content of the given template. */
+    content: string;
+    /** Start offset of the resource content (e.g. in the inline source file) */
+    start: number;
+    /** Whether the given resource is inline or not. */
+    inline: boolean;
+    /** Path to the file that contains this resource. */
+    filePath: string;
+    /**
+     * Gets the character and line of a given position index in the resource.
+     * If the resource is declared inline within a TypeScript source file, the line and
+     * character are based on the full source file content.
+     */
+    getCharacterAndLineOfPosition: (pos: number) => LineAndCharacter;
+}
+/**
+ * Collector that can be used to find Angular templates and stylesheets referenced within
+ * given TypeScript source files (inline or external referenced files)
+ */
+export declare class ComponentResourceCollector {
+    typeChecker: ts.TypeChecker;
+    resolvedTemplates: ResolvedResource[];
+    resolvedStylesheets: ResolvedResource[];
+    constructor(typeChecker: ts.TypeChecker);
+    visitNode(node: ts.Node): void;
+    private _visitClassDeclaration;
+    /** Resolves an external stylesheet by reading its content and computing line mappings. */
+    resolveExternalStylesheet(filePath: string, container: ts.ClassDeclaration | null): ResolvedResource;
+}

package/typings/schematics/update-tool/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @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 { logging } from '@angular-devkit/core';
+import { Tree } from '@angular-devkit/schematics';
+import { MigrationRule } from './migration-rule';
+import { TargetVersion } from './target-version';
+export declare type Constructor<T> = new (...args: any[]) => T;
+export declare function runMigrationRules<T>(tree: Tree, logger: logging.LoggerApi, tsconfigPath: string, targetVersion: TargetVersion, ruleTypes: Constructor<MigrationRule<T>>[], upgradeData: T, analyzedFiles: Set<string>): boolean;

package/typings/schematics/update-tool/migration-rule.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @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 { UpdateRecorder } from '@angular-devkit/schematics';
+import * as ts from 'typescript';
+import { ResolvedResource } from './component-resource-collector';
+import { TargetVersion } from './target-version';
+import { LineAndCharacter } from './utils/line-mappings';
+export interface MigrationFailure {
+    filePath: string;
+    message: string;
+    position: LineAndCharacter;
+}
+export declare class MigrationRule<T> {
+    program: ts.Program;
+    typeChecker: ts.TypeChecker;
+    targetVersion: TargetVersion;
+    upgradeData: T;
+    /** List of migration failures that need to be reported. */
+    failures: MigrationFailure[];
+    /** Whether the migration rule is enabled or not. */
+    ruleEnabled: boolean;
+    constructor(program: ts.Program, typeChecker: ts.TypeChecker, targetVersion: TargetVersion, upgradeData: T);
+    /** Method can be used to perform global analysis of the program. */
+    init(): void;
+    /**
+     * Method that will be called for each node in a given source file. Unlike tslint, this
+     * function will only retrieve TypeScript nodes that need to be casted manually. This
+     * allows us to only walk the program source files once per program and not per
+     * migration rule (significant performance boost).
+     */
+    visitNode(node: ts.Node): void;
+    /** Method that will be called for each Angular template in the program. */
+    visitTemplate(template: ResolvedResource): void;
+    /** Method that will be called for each stylesheet in the program. */
+    visitStylesheet(stylesheet: ResolvedResource): void;
+    /** Gets the update recorder for a given source file or resolved template. */
+    getUpdateRecorder(filePath: string): UpdateRecorder;
+    /** Creates a failure with a specified message at the given node location. */
+    createFailureAtNode(node: ts.Node, message: string): void;
+}

package/typings/schematics/update-tool/public-api.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @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
+ */
+export * from './index';
+export * from './target-version';
+export * from './version-changes';
+export * from './migration-rule';
+export * from './component-resource-collector';

package/typings/schematics/{ng-update → update-tool}/target-version.d.ts

@@ -7,9 +7,9 @@
  */
 /** Possible versions that can be automatically migrated by `ng update`. */
 export declare enum TargetVersion {
-    V6 = 0,
-    V7 = 1,
-    V8 = 2
+    V6 = "version 6",
+    V7 = "version 7",
+    V8 = "version 8"
 }
 /**
  * Returns all versions that are supported by "ng update". The versions are determined

package/typings/schematics/update-tool/utils/decorators.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @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 { Import } from './imports';
+export declare type CallExpressionDecorator = ts.Decorator & {
+    expression: ts.CallExpression;
+};
+export interface NgDecorator {
+    name: string;
+    node: CallExpressionDecorator;
+    importNode: ts.ImportDeclaration;
+}
+/**
+ * Gets all decorators which are imported from an Angular package
+ * (e.g. "@angular/core") from a list of decorators.
+ */
+export declare function getAngularDecorators(typeChecker: ts.TypeChecker, decorators: ReadonlyArray<ts.Decorator>): NgDecorator[];
+export declare function getCallDecoratorImport(typeChecker: ts.TypeChecker, decorator: ts.Decorator): Import | null;

package/typings/schematics/update-tool/utils/functions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @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';
+/**
+ * Unwraps a given expression TypeScript node. Expressions can be wrapped within multiple
+ * parentheses. e.g. "(((({exp}))))()". The function should return the TypeScript node
+ * referring to the inner expression. e.g "exp".
+ */
+export declare function unwrapExpression(node: ts.Expression | ts.ParenthesizedExpression): ts.Expression;

package/typings/schematics/update-tool/utils/imports.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @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';
+export declare type Import = {
+    name: string;
+    importModule: string;
+    node: ts.ImportDeclaration;
+};
+/** Gets import information about the specified identifier by using the type checker. */
+export declare function getImportOfIdentifier(typeChecker: ts.TypeChecker, node: ts.Identifier): Import | null;

package/typings/schematics/update-tool/utils/line-mappings.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @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
+ */
+export interface LineAndCharacter {
+    character: number;
+    line: number;
+}
+/** Gets the line and character for the given position from the line starts map. */
+export declare function getLineAndCharacterFromPosition(lineStartsMap: number[], position: number): {
+    character: number;
+    line: number;
+};
+/**
+ * Computes the line start map of the given text. This can be used in order to
+ * retrieve the line and character of a given text position index.
+ */
+export declare function computeLineStartsMap(text: string): number[];

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

@@ -0,0 +1,9 @@
+/**
+ * @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';
+export declare function parseTsconfigFile(tsconfigPath: string, basePath: string): ts.ParsedCommandLine;

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

@@ -0,0 +1,18 @@
+/**
+ * @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. */
+declare 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 declare function getPropertyNameText(node: ts.PropertyName): string | null;
+/** Checks whether the given property name has a text. */
+export declare function hasPropertyNameText(node: ts.PropertyName): node is PropertyNameWithText;
+export {};

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

@@ -0,0 +1,32 @@
+/**
+ * @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 declare type VersionChanges<T> = {
+    [target in TargetVersion]?: ReadableChange<T>[];
+};
+export declare type ReadableChange<T> = {
+    pr: string;
+    changes: T[];
+};
+/** Conditional type that unwraps the value of a version changes type. */
+export declare 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 declare function getChangesForTarget<T>(target: TargetVersion, data: VersionChanges<T>): 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 declare function getAllChanges<T>(data: VersionChanges<T>): T[];

package/typings/schematics/{ng-update/upgrade-rules → utils}/project-tsconfig-paths.d.ts

@@ -10,4 +10,7 @@ import { Tree } from '@angular-devkit/schematics';
  * Gets all tsconfig paths from a CLI project by reading the workspace configuration
  * and looking for common tsconfig locations.
  */
-export declare function getProjectTsConfigPaths(tree: Tree): string[];
+export declare function getProjectTsConfigPaths(tree: Tree): {
+    buildPaths: string[];
+    testPaths: string[];
+};

package/schematics/ng-update/target-version.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"target-version.js","sourceRoot":"","sources":["../../../../../src/cdk/schematics/ng-update/target-version.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;AAEH,2EAA2E;AAC3E,IAAY,aAIX;AAJD,WAAY,aAAa;IACvB,6CAAE,CAAA;IACF,6CAAE,CAAA;IACF,6CAAE,CAAA;AACJ,CAAC,EAJW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAIxB;AAED;;;GAGG;AACH,SAAgB,kBAAkB;IAChC,OAAO,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC;SAC9B,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,OAAO,aAAa,CAAC,SAAS,CAAC,KAAK,QAAQ,CAAC,CAAC;AACvE,CAAC;AAHD,gDAGC"}

package/schematics/ng-update/tslint/component-file.d.ts

@@ -1,14 +0,0 @@
-/**
- * @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';
-export declare type ExternalResource = ts.SourceFile;
-/**
- * Creates a fake TypeScript source file that can contain content of templates or stylesheets.
- * The fake TypeScript source file then can be passed to TSLint in combination with a rule failure.
- */
-export declare function createComponentFile(filePath: string, content: string): ExternalResource;

package/schematics/ng-update/tslint/component-file.js

@@ -1,31 +0,0 @@
-"use strict";
-/**
- * @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
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const ts = require("typescript");
-/**
- * Creates a fake TypeScript source file that can contain content of templates or stylesheets.
- * The fake TypeScript source file then can be passed to TSLint in combination with a rule failure.
- */
-function createComponentFile(filePath, content) {
-    const sourceFile = ts.createSourceFile(filePath, `\`${content}\``, ts.ScriptTarget.ES5);
-    // Subtract two characters because the string literal quotes are only needed for parsing
-    // and are not part of the actual source file.
-    sourceFile.end = sourceFile.end - 2;
-    // Note: This does not affect the way TSLint applies replacements for external resource files.
-    // At the time of writing, TSLint loads files manually if the actual rule source file is not
-    // equal to the source file of the replacement. This means that the replacements need proper
-    // offsets without the string literal quote symbols.
-    sourceFile.getFullText = function () {
-        return sourceFile.text.substring(1, sourceFile.text.length - 1);
-    };
-    sourceFile.getText = sourceFile.getFullText;
-    return sourceFile;
-}
-exports.createComponentFile = createComponentFile;
-//# sourceMappingURL=component-file.js.map

package/schematics/ng-update/tslint/component-file.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"component-file.js","sourceRoot":"","sources":["../../../../../../src/cdk/schematics/ng-update/tslint/component-file.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;AAEH,iCAAiC;AAIjC;;;GAGG;AACH,SAAgB,mBAAmB,CAAC,QAAgB,EAAE,OAAe;IACnE,MAAM,UAAU,GAAG,EAAE,CAAC,gBAAgB,CAAC,QAAQ,EAAE,KAAK,OAAO,IAAI,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;IAExF,wFAAwF;IACxF,8CAA8C;IAC9C,UAAU,CAAC,GAAG,GAAG,UAAU,CAAC,GAAG,GAAG,CAAC,CAAC;IAEpC,8FAA8F;IAC9F,4FAA4F;IAC5F,4FAA4F;IAC5F,oDAAoD;IACpD,UAAU,CAAC,WAAW,GAAG;QACvB,OAAO,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,UAAU,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAClE,CAAC,CAAC;IAEF,UAAU,CAAC,OAAO,GAAG,UAAU,CAAC,WAAW,CAAC;IAE5C,OAAO,UAAU,CAAC;AACpB,CAAC;AAlBD,kDAkBC"}

package/schematics/ng-update/tslint/component-walker.d.ts

@@ -1,47 +0,0 @@
-/**
- * @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 { ExternalResource } from './component-file';
-import { ExternalFailureWalker } from './external-failure-walker';
-/**
- * Custom TSLint rule walker that identifies Angular components and visits specific parts of
- * the component metadata.
- */
-export declare class ComponentWalker extends ExternalFailureWalker {
-    visitInlineTemplate(_template: ts.StringLiteralLike): void;
-    visitInlineStylesheet(_stylesheet: ts.StringLiteralLike): void;
-    visitExternalTemplate(_template: ExternalResource): void;
-    visitExternalStylesheet(_stylesheet: ExternalResource): void;
-    /**
-     * We keep track of all visited stylesheet files because we allow manually reporting external
-     * stylesheets which couldn't be detected by the component walker. Reporting these files multiple
-     * times will result in duplicated TSLint failures and replacements.
-     */
-    private _visitedStylesheetFiles;
-    visitNode(node: ts.Node): void;
-    private _visitDirectiveCallExpression;
-    private _reportExternalTemplate;
-    private _reportInlineStyles;
-    private _visitExternalStylesArrayLiteral;
-    private _reportExternalStyle;
-    /**
-     * Recursively searches for the metadata object literal expression inside of a directive call
-     * expression. Since expression calls can be nested through *parenthesized* expressions, we
-     * need to recursively visit and check every expression inside of a parenthesized expression.
-     *
-     * e.g. @Component((({myMetadataExpression}))) will return `myMetadataExpression`.
-     */
-    private _findMetadataFromExpression;
-    /**
-     * Creates a TSLint failure that reports that the resource file that belongs to the specified
-     * TypeScript node could not be resolved in the file system.
-     */
-    private _createResourceNotFoundFailure;
-    /** Reports the specified additional stylesheets. */
-    _reportExtraStylesheetFiles(filePaths: string[]): void;
-}