style(ngcc): reformat of ngcc after clang update (#36447)

PR Close #36447
This commit is contained in:
Pete Bacon Darwin 2020-04-06 08:30:08 +01:00 committed by Kara Erickson
parent c8bef1259c
commit 8be8466a00
118 changed files with 1386 additions and 1046 deletions

View File

@ -7,9 +7,10 @@
*/
import {CachedFileSystem, NodeJSFileSystem, setFileSystem} from '../src/ngtsc/file_system';
import {AsyncNgccOptions, NgccOptions, SyncNgccOptions, mainNgcc} from './src/main';
import {AsyncNgccOptions, mainNgcc, NgccOptions, SyncNgccOptions} from './src/main';
export {ConsoleLogger} from './src/logging/console_logger';
export {LogLevel, Logger} from './src/logging/logger';
export {Logger, LogLevel} from './src/logging/logger';
export {AsyncNgccOptions, NgccOptions, SyncNgccOptions} from './src/main';
export {PathMappings} from './src/utils';

View File

@ -125,7 +125,7 @@ if (require.main === module) {
// And we have to convert the option to a string to handle `no-tsconfig`, which will be `false`.
const tsConfigPath = `${options['tsconfig']}` === 'false' ? null : options['tsconfig'];
(async() => {
(async () => {
try {
const logger = logLevel && new ConsoleLogger(LogLevel[logLevel]);
@ -137,7 +137,10 @@ if (require.main === module) {
createNewEntryPointFormats,
logger,
enableI18nLegacyMessageIdFormat,
async: options['async'], invalidateEntryPointManifest, errorOnFailedEntryPoint, tsConfigPath
async: options['async'],
invalidateEntryPointManifest,
errorOnFailedEntryPoint,
tsConfigPath
});
if (logger) {

View File

@ -12,7 +12,7 @@ import {ParsedConfiguration} from '../../..';
import {ComponentDecoratorHandler, DirectiveDecoratorHandler, InjectableDecoratorHandler, NgModuleDecoratorHandler, PipeDecoratorHandler, ReferencesRegistry, ResourceLoader} from '../../../src/ngtsc/annotations';
import {CycleAnalyzer, ImportGraph} from '../../../src/ngtsc/cycles';
import {isFatalDiagnosticError} from '../../../src/ngtsc/diagnostics';
import {FileSystem, LogicalFileSystem, absoluteFrom, dirname, resolve} from '../../../src/ngtsc/file_system';
import {absoluteFrom, dirname, FileSystem, LogicalFileSystem, resolve} from '../../../src/ngtsc/file_system';
import {AbsoluteModuleStrategy, LocalIdentifierStrategy, LogicalProjectStrategy, ModuleResolver, NOOP_DEFAULT_IMPORT_RECORDER, PrivateExportAliasingHost, Reexport, ReferenceEmitter} from '../../../src/ngtsc/imports';
import {CompoundMetadataReader, CompoundMetadataRegistry, DtsMetadataReader, InjectableClassRegistry, LocalMetadataRegistry} from '../../../src/ngtsc/metadata';
import {PartialEvaluator} from '../../../src/ngtsc/partial_evaluator';
@ -28,7 +28,7 @@ import {EntryPointBundle} from '../packages/entry_point_bundle';
import {DefaultMigrationHost} from './migration_host';
import {NgccTraitCompiler} from './ngcc_trait_compiler';
import {CompiledClass, CompiledFile, DecorationAnalyses} from './types';
import {NOOP_DEPENDENCY_TRACKER, isWithinPackage} from './util';
import {isWithinPackage, NOOP_DEPENDENCY_TRACKER} from './util';
@ -38,8 +38,12 @@ import {NOOP_DEPENDENCY_TRACKER, isWithinPackage} from './util';
class NgccResourceLoader implements ResourceLoader {
constructor(private fs: FileSystem) {}
canPreload = false;
preload(): undefined|Promise<void> { throw new Error('Not implemented.'); }
load(url: string): string { return this.fs.readFile(resolve(url)); }
preload(): undefined|Promise<void> {
throw new Error('Not implemented.');
}
load(url: string): string {
return this.fs.readFile(resolve(url));
}
resolve(url: string, containingFile: string): string {
return resolve(dirname(absoluteFrom(containingFile)), url);
}
@ -56,7 +60,7 @@ export class DecorationAnalyzer {
private rootDirs = this.bundle.rootDirs;
private packagePath = this.bundle.entryPoint.package;
private isCore = this.bundle.isCore;
private compilerOptions = this.tsConfig !== null? this.tsConfig.options: {};
private compilerOptions = this.tsConfig !== null ? this.tsConfig.options : {};
moduleResolver =
new ModuleResolver(this.program, this.options, this.host, /* moduleResolutionCache */ null);
@ -73,8 +77,9 @@ export class DecorationAnalyzer {
// based on whether a bestGuessOwningModule is present in the Reference.
new LogicalProjectStrategy(this.reflectionHost, new LogicalFileSystem(this.rootDirs)),
]);
aliasingHost = this.bundle.entryPoint.generateDeepReexports?
new PrivateExportAliasingHost(this.reflectionHost): null;
aliasingHost = this.bundle.entryPoint.generateDeepReexports ?
new PrivateExportAliasingHost(this.reflectionHost) :
null;
dtsModuleScopeResolver =
new MetadataDtsModuleScopeResolver(this.dtsMetaReader, this.aliasingHost);
scopeRegistry = new LocalModuleScopeRegistry(
@ -191,7 +196,9 @@ export class DecorationAnalyzer {
});
}
protected reportDiagnostics() { this.compiler.diagnostics.forEach(this.diagnosticHandler); }
protected reportDiagnostics() {
this.compiler.diagnostics.forEach(this.diagnosticHandler);
}
protected compileFile(sourceFile: ts.SourceFile): CompiledFile {
const constantPool = new ConstantPool();
@ -211,7 +218,8 @@ export class DecorationAnalyzer {
compiledClasses.push({
name: record.node.name.text,
decorators: this.compiler.getAllDecorators(record.node),
declaration: record.node, compilation
declaration: record.node,
compilation
});
}
@ -224,7 +232,7 @@ export class DecorationAnalyzer {
if (!exportStatements.has(sf.fileName)) {
return [];
}
const exports = exportStatements.get(sf.fileName) !;
const exports = exportStatements.get(sf.fileName)!;
const reexports: Reexport[] = [];
exports.forEach(([fromModule, symbolName], asAlias) => {

View File

@ -75,10 +75,9 @@ export class ModuleWithProvidersAnalyzer {
const dtsClass = this.host.getDtsDeclaration(containerClass.declaration.valueDeclaration);
// Get the declaration of the matching static method
dtsFn = dtsClass && ts.isClassDeclaration(dtsClass) ?
dtsClass.members
.find(
member => ts.isMethodDeclaration(member) && ts.isIdentifier(member.name) &&
member.name.text === fn.name) as ts.Declaration :
dtsClass.members.find(
member => ts.isMethodDeclaration(member) && ts.isIdentifier(member.name) &&
member.name.text === fn.name) as ts.Declaration :
null;
} else {
dtsFn = this.host.getDtsDeclaration(fn.declaration);
@ -87,8 +86,8 @@ export class ModuleWithProvidersAnalyzer {
throw new Error(`Matching type declaration for ${fn.declaration.getText()} is missing`);
}
if (!isFunctionOrMethod(dtsFn)) {
throw new Error(
`Matching type declaration for ${fn.declaration.getText()} is not a function: ${dtsFn.getText()}`);
throw new Error(`Matching type declaration for ${
fn.declaration.getText()} is not a function: ${dtsFn.getText()}`);
}
return dtsFn;
}
@ -106,12 +105,14 @@ export class ModuleWithProvidersAnalyzer {
// to its type declaration.
const dtsNgModule = this.host.getDtsDeclaration(ngModule.node);
if (!dtsNgModule) {
throw new Error(
`No typings declaration can be found for the referenced NgModule class in ${fn.declaration.getText()}.`);
throw new Error(`No typings declaration can be found for the referenced NgModule class in ${
fn.declaration.getText()}.`);
}
if (!ts.isClassDeclaration(dtsNgModule) || !hasNameIdentifier(dtsNgModule)) {
throw new Error(
`The referenced NgModule in ${fn.declaration.getText()} is not a named class declaration in the typings program; instead we get ${dtsNgModule.getText()}`);
throw new Error(`The referenced NgModule in ${
fn.declaration
.getText()} is not a named class declaration in the typings program; instead we get ${
dtsNgModule.getText()}`);
}
return {node: dtsNgModule, known: null, viaModule: null};

View File

@ -45,5 +45,7 @@ export class NgccReferencesRegistry implements ReferencesRegistry {
* Create and return a mapping for the registered resolved references.
* @returns A map of reference identifiers to reference declarations.
*/
getDeclarationMap(): Map<ts.Identifier, ConcreteDeclaration> { return this.map; }
getDeclarationMap(): Map<ts.Identifier, ConcreteDeclaration> {
return this.map;
}
}

View File

@ -29,7 +29,9 @@ export class NgccTraitCompiler extends TraitCompiler {
/* compileNonExportedClasses */ true, new DtsTransformRegistry());
}
get analyzedFiles(): ts.SourceFile[] { return Array.from(this.fileToClasses.keys()); }
get analyzedFiles(): ts.SourceFile[] {
return Array.from(this.fileToClasses.keys());
}
/**
* Analyzes the source file in search for classes to process. For any class that is found in the
@ -81,5 +83,7 @@ export class NgccTraitCompiler extends TraitCompiler {
}
class NoIncrementalBuild implements IncrementalBuild<any> {
priorWorkFor(sf: ts.SourceFile): any[]|null { return null; }
priorWorkFor(sf: ts.SourceFile): any[]|null {
return null;
}
}

View File

@ -7,10 +7,11 @@
*/
import * as ts from 'typescript';
import {AbsoluteFsPath, absoluteFromSourceFile} from '../../../src/ngtsc/file_system';
import {absoluteFromSourceFile, AbsoluteFsPath} from '../../../src/ngtsc/file_system';
import {ConcreteDeclaration} from '../../../src/ngtsc/reflection';
import {NgccReflectionHost} from '../host/ngcc_host';
import {hasNameIdentifier, isDefined} from '../utils';
import {NgccReferencesRegistry} from './ngcc_references_registry';
export interface ExportInfo {
@ -48,7 +49,7 @@ export class PrivateDeclarationsAnalyzer {
exports.forEach((declaration, exportedName) => {
if (declaration.node !== null && hasNameIdentifier(declaration.node)) {
if (privateDeclarations.has(declaration.node.name)) {
const privateDeclaration = privateDeclarations.get(declaration.node.name) !;
const privateDeclaration = privateDeclarations.get(declaration.node.name)!;
if (privateDeclaration.node !== declaration.node) {
throw new Error(`${declaration.node.name.text} is declared multiple times.`);
}
@ -62,7 +63,7 @@ export class PrivateDeclarationsAnalyzer {
return Array.from(privateDeclarations.keys()).map(id => {
const from = absoluteFromSourceFile(id.getSourceFile());
const declaration = privateDeclarations.get(id) !;
const declaration = privateDeclarations.get(id)!;
const dtsDeclaration = this.host.getDtsDeclaration(declaration.node);
const dtsFrom = dtsDeclaration && absoluteFromSourceFile(dtsDeclaration.getSourceFile());

View File

@ -7,7 +7,7 @@
*/
import * as ts from 'typescript';
import {AbsoluteFsPath, absoluteFromSourceFile, relative} from '../../../src/ngtsc/file_system';
import {absoluteFromSourceFile, AbsoluteFsPath, relative} from '../../../src/ngtsc/file_system';
import {DependencyTracker} from '../../../src/ngtsc/incremental/api';
export function isWithinPackage(packagePath: AbsoluteFsPath, sourceFile: ts.SourceFile): boolean {

View File

@ -6,8 +6,10 @@
* found in the LICENSE file at https://angular.io/license
*/
import * as ts from 'typescript';
import {AbsoluteFsPath} from '../../../src/ngtsc/file_system';
import {RequireCall, isReexportStatement, isRequireCall} from '../host/commonjs_umd_utils';
import {isReexportStatement, isRequireCall, RequireCall} from '../host/commonjs_umd_utils';
import {DependencyHostBase} from './dependency_host';
import {ResolvedDeepImport, ResolvedRelativeModule} from './module_resolver';
@ -120,5 +122,7 @@ export class CommonJsDependencyHost extends DependencyHostBase {
* @returns false if there are definitely no require calls
* in this file, true otherwise.
*/
private hasRequireCalls(source: string): boolean { return /require\(['"]/.test(source); }
private hasRequireCalls(source: string): boolean {
return /require\(['"]/.test(source);
}
}

View File

@ -7,12 +7,14 @@
*/
import {DepGraph} from 'dependency-graph';
import {AbsoluteFsPath, FileSystem, resolve} from '../../../src/ngtsc/file_system';
import {Logger} from '../logging/logger';
import {NgccConfiguration} from '../packages/configuration';
import {EntryPoint, EntryPointFormat, SUPPORTED_FORMAT_PROPERTIES, getEntryPointFormat} from '../packages/entry_point';
import {EntryPoint, EntryPointFormat, getEntryPointFormat, SUPPORTED_FORMAT_PROPERTIES} from '../packages/entry_point';
import {PartiallyOrderedList} from '../utils';
import {DependencyHost, DependencyInfo, createDependencyInfo} from './dependency_host';
import {createDependencyInfo, DependencyHost, DependencyInfo} from './dependency_host';
const builtinNodeJsModules = new Set<string>(require('module').builtinModules);
@ -123,7 +125,8 @@ export class DependencyResolver {
const host = this.hosts[formatInfo.format];
if (!host) {
throw new Error(
`Could not find a suitable format for computing dependencies of entry-point: '${entryPoint.path}'.`);
`Could not find a suitable format for computing dependencies of entry-point: '${
entryPoint.path}'.`);
}
const depInfo = createDependencyInfo();
host.collectDependencies(formatInfo.path, depInfo);

View File

@ -5,8 +5,8 @@
* 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 {AbsoluteFsPath, FileSystem, absoluteFrom, dirname, isRoot, join, resolve} from '../../../src/ngtsc/file_system';
import {PathMappings, isRelativePath, resolveFileWithPostfixes} from '../utils';
import {absoluteFrom, AbsoluteFsPath, dirname, FileSystem, isRoot, join, resolve} from '../../../src/ngtsc/file_system';
import {isRelativePath, PathMappings, resolveFileWithPostfixes} from '../utils';
/**
* This is a very cut-down implementation of the TypeScript module resolution strategy.
@ -222,7 +222,7 @@ export class ModuleResolver {
}
/** The result of resolving an import to a module. */
export type ResolvedModule = ResolvedExternalModule | ResolvedRelativeModule | ResolvedDeepImport;
export type ResolvedModule = ResolvedExternalModule|ResolvedRelativeModule|ResolvedDeepImport;
/**
* A module that is external to the package doing the importing.

View File

@ -84,5 +84,7 @@ export class UmdDependencyHost extends DependencyHostBase {
* @returns false if there are definitely no require calls
* in this file, true otherwise.
*/
private hasRequireCalls(source: string): boolean { return /require\(['"]/.test(source); }
private hasRequireCalls(source: string): boolean {
return /require\(['"]/.test(source);
}
}

View File

@ -9,10 +9,11 @@ import {AbsoluteFsPath, FileSystem, PathSegment} from '../../../src/ngtsc/file_s
import {DependencyResolver, SortedEntryPointsInfo} from '../dependencies/dependency_resolver';
import {Logger} from '../logging/logger';
import {NgccConfiguration} from '../packages/configuration';
import {EntryPoint, INCOMPATIBLE_ENTRY_POINT, NO_ENTRY_POINT, getEntryPointInfo} from '../packages/entry_point';
import {EntryPoint, getEntryPointInfo, INCOMPATIBLE_ENTRY_POINT, NO_ENTRY_POINT} from '../packages/entry_point';
import {EntryPointManifest} from '../packages/entry_point_manifest';
import {PathMappings} from '../utils';
import {NGCC_DIRECTORY} from '../writing/new_entry_point_file_writer';
import {EntryPointFinder} from './interface';
import {getBasePaths, trackDuration} from './utils';

View File

@ -5,13 +5,14 @@
* 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 {AbsoluteFsPath, FileSystem, PathSegment, join, relative, relativeFrom} from '../../../src/ngtsc/file_system';
import {AbsoluteFsPath, FileSystem, join, PathSegment, relative, relativeFrom} from '../../../src/ngtsc/file_system';
import {DependencyResolver, SortedEntryPointsInfo} from '../dependencies/dependency_resolver';
import {Logger} from '../logging/logger';
import {hasBeenProcessed} from '../packages/build_marker';
import {NgccConfiguration} from '../packages/configuration';
import {EntryPoint, EntryPointJsonProperty, INCOMPATIBLE_ENTRY_POINT, NO_ENTRY_POINT, getEntryPointInfo} from '../packages/entry_point';
import {EntryPoint, EntryPointJsonProperty, getEntryPointInfo, INCOMPATIBLE_ENTRY_POINT, NO_ENTRY_POINT} from '../packages/entry_point';
import {PathMappings} from '../utils';
import {EntryPointFinder} from './interface';
import {getBasePaths} from './utils';
@ -76,7 +77,7 @@ export class TargetedEntryPointFinder implements EntryPointFinder {
}
private processNextPath(): void {
const path = this.unprocessedPaths.shift() !;
const path = this.unprocessedPaths.shift()!;
const entryPoint = this.getEntryPoint(path);
if (entryPoint === null || !entryPoint.compiledByAngular) {
return;
@ -130,7 +131,7 @@ export class TargetedEntryPointFinder implements EntryPointFinder {
// Start the search at the deepest nested `node_modules` folder that is below the `basePath`
// but above the `entryPointPath`, if there are any.
while (nodeModulesIndex >= 0) {
packagePath = join(packagePath, segments.shift() !);
packagePath = join(packagePath, segments.shift()!);
nodeModulesIndex--;
}

View File

@ -30,7 +30,7 @@ import {PathMappings} from '../utils';
*/
export function getBasePaths(
logger: Logger, sourceDirectory: AbsoluteFsPath,
pathMappings: PathMappings | undefined): AbsoluteFsPath[] {
pathMappings: PathMappings|undefined): AbsoluteFsPath[] {
const fs = getFileSystem();
const basePaths = [sourceDirectory];
if (pathMappings) {
@ -51,7 +51,8 @@ export function getBasePaths(
basePaths.push(basePath);
} else {
logger.warn(
`The basePath "${basePath}" computed from baseUrl "${baseUrl}" and path mapping "${path}" does not exist in the file-system.\n` +
`The basePath "${basePath}" computed from baseUrl "${baseUrl}" and path mapping "${
path}" does not exist in the file-system.\n` +
`It will not be scanned for entry-points.`);
}
}));
@ -109,8 +110,8 @@ function removeContainedPaths(value: AbsoluteFsPath, index: number, array: Absol
* @param log The function to call with the duration of the task
* @returns The result of calling `task`.
*/
export function trackDuration<T = void>(
task: () => T extends Promise<unknown>? never : T, log: (duration: number) => void): T {
export function trackDuration<T = void>(task: () => T extends Promise<unknown>? never : T,
log: (duration: number) => void): T {
const startTime = Date.now();
const result = task();
const duration = Math.round((Date.now() - startTime) / 100) / 10;

View File

@ -44,7 +44,7 @@ export interface UpdatePackageJsonMessage extends JsonObject {
}
/** The type of messages sent from cluster workers to the cluster master. */
export type MessageFromWorker = ErrorMessage | TaskCompletedMessage | UpdatePackageJsonMessage;
export type MessageFromWorker = ErrorMessage|TaskCompletedMessage|UpdatePackageJsonMessage;
/** The type of messages sent from the cluster master to cluster workers. */
export type MessageToWorker = ProcessTaskMessage;

View File

@ -35,8 +35,8 @@ export class ClusterExecutor implements Executor {
if (cluster.isMaster) {
// This process is the cluster master.
return this.lockFile.lock(() => {
this.logger.debug(
`Running ngcc on ${this.constructor.name} (using ${this.workerCount} worker processes).`);
this.logger.debug(`Running ngcc on ${this.constructor.name} (using ${
this.workerCount} worker processes).`);
const master = new ClusterMaster(
this.workerCount, this.logger, this.pkgJsonUpdater, analyzeEntryPoints,
this.createTaskCompletedCallback);

View File

@ -262,7 +262,7 @@ export class ClusterMaster {
*/
private wrapEventHandler<Args extends unknown[]>(fn: (...args: Args) => void|Promise<void>):
(...args: Args) => Promise<void> {
return async(...args: Args) => {
return async (...args: Args) => {
try {
await fn(...args);
} catch (err) {

View File

@ -12,7 +12,7 @@ import * as cluster from 'cluster';
import {AbsoluteFsPath} from '../../../../src/ngtsc/file_system';
import {JsonObject} from '../../packages/entry_point';
import {PackageJsonChange, PackageJsonUpdate, PackageJsonUpdater, applyChange} from '../../writing/package_json_updater';
import {applyChange, PackageJsonChange, PackageJsonUpdate, PackageJsonUpdater} from '../../writing/package_json_updater';
import {sendMessageToMaster} from './utils';

View File

@ -23,14 +23,14 @@ export class Deferred<T> {
*
* @param value The value to resolve the promise with.
*/
resolve !: (value: T) => void;
resolve!: (value: T) => void;
/**
* Rejects the associated promise with the specified reason.
*
* @param reason The rejection reason.
*/
reject !: (reason: any) => void;
reject!: (reason: any) => void;
/** The `Promise` instance associated with this deferred. */
promise = new Promise<T>((resolve, reject) => {

View File

@ -30,7 +30,7 @@ export abstract class SingleProcessorExecutorBase {
const startTime = Date.now();
while (!taskQueue.allTasksCompleted) {
const task = taskQueue.getNextTask() !;
const task = taskQueue.getNextTask()!;
compile(task);
taskQueue.markTaskCompleted(task);
}
@ -65,6 +65,6 @@ export class SingleProcessExecutorAsync extends SingleProcessorExecutorBase impl
}
async execute(analyzeEntryPoints: AnalyzeEntryPointsFn, createCompileFn: CreateCompileFn):
Promise<void> {
await this.lockFile.lock(async() => this.doExecute(analyzeEntryPoints, createCompileFn));
await this.lockFile.lock(async () => this.doExecute(analyzeEntryPoints, createCompileFn));
}
}

View File

@ -66,7 +66,7 @@ export type CreateTaskCompletedCallback = (taskQueue: TaskQueue) => TaskComplete
* A function to be called once a task has been processed.
*/
export type TaskCompletedCallback =
(task: Task, outcome: TaskProcessingOutcome, message: string | null) => void;
(task: Task, outcome: TaskProcessingOutcome, message: string|null) => void;
/**
* Represents the outcome of processing a `Task`.

View File

@ -8,8 +8,9 @@
import {FileSystem, resolve} from '../../../../src/ngtsc/file_system';
import {Logger} from '../../logging/logger';
import {markAsProcessed} from '../../packages/build_marker';
import {PackageJsonFormatProperties, getEntryPointFormat} from '../../packages/entry_point';
import {getEntryPointFormat, PackageJsonFormatProperties} from '../../packages/entry_point';
import {PackageJsonUpdater} from '../../writing/package_json_updater';
import {Task, TaskCompletedCallback, TaskProcessingOutcome, TaskQueue} from './api';
/**
@ -18,7 +19,7 @@ import {Task, TaskCompletedCallback, TaskProcessingOutcome, TaskQueue} from './a
* These functions can be composed using the `composeTaskCompletedCallbacks()`
* to create a `TaskCompletedCallback` function that can be passed to an `Executor`.
*/
export type TaskCompletedHandler = (task: Task, message: string | null) => void;
export type TaskCompletedHandler = (task: Task, message: string|null) => void;
/**
* Compose a group of TaskCompletedHandlers into a single TaskCompletedCallback.
@ -30,11 +31,11 @@ export type TaskCompletedHandler = (task: Task, message: string | null) => void;
*/
export function composeTaskCompletedCallbacks(
callbacks: Record<TaskProcessingOutcome, TaskCompletedHandler>): TaskCompletedCallback {
return (task: Task, outcome: TaskProcessingOutcome, message: string | null): void => {
return (task: Task, outcome: TaskProcessingOutcome, message: string|null): void => {
const callback = callbacks[outcome];
if (callback === undefined) {
throw new Error(
`Unknown task outcome: "${outcome}" - supported outcomes: ${JSON.stringify(Object.keys(callbacks))}`);
throw new Error(`Unknown task outcome: "${outcome}" - supported outcomes: ${
JSON.stringify(Object.keys(callbacks))}`);
}
callback(task, message);
};
@ -64,10 +65,11 @@ export function createMarkAsProcessedHandler(pkgJsonUpdater: PackageJsonUpdater)
* Create a handler that will throw an error.
*/
export function createThrowErrorHandler(fs: FileSystem): TaskCompletedHandler {
return (task: Task, message: string | null): void => {
return (task: Task, message: string|null): void => {
const format = getEntryPointFormat(fs, task.entryPoint, task.formatProperty);
throw new Error(
`Failed to compile entry-point ${task.entryPoint.name} (${task.formatProperty} as ${format})` +
`Failed to compile entry-point ${task.entryPoint.name} (${task.formatProperty} as ${
format})` +
(message !== null ? ` due to ${message}` : ''));
};
}
@ -77,11 +79,12 @@ export function createThrowErrorHandler(fs: FileSystem): TaskCompletedHandler {
*/
export function createLogErrorHandler(
logger: Logger, fs: FileSystem, taskQueue: TaskQueue): TaskCompletedHandler {
return (task: Task, message: string | null): void => {
return (task: Task, message: string|null): void => {
taskQueue.markAsFailed(task);
const format = getEntryPointFormat(fs, task.entryPoint, task.formatProperty);
logger.error(
`Failed to compile entry-point ${task.entryPoint.name} (${task.formatProperty} as ${format})` +
`Failed to compile entry-point ${task.entryPoint.name} (${task.formatProperty} as ${
format})` +
(message !== null ? ` due to ${message}` : ''));
};
}

View File

@ -38,9 +38,9 @@ export abstract class BaseTaskQueue implements TaskQueue {
}
// We are skipping this task so mark it as complete
this.markTaskCompleted(nextTask);
const failedTask = this.tasksToSkip.get(nextTask) !;
this.logger.warn(
`Skipping processing of ${nextTask.entryPoint.name} because its dependency ${failedTask.entryPoint.name} failed to compile.`);
const failedTask = this.tasksToSkip.get(nextTask)!;
this.logger.warn(`Skipping processing of ${nextTask.entryPoint.name} because its dependency ${
failedTask.entryPoint.name} failed to compile.`);
nextTask = this.computeNextTask();
}
return nextTask;
@ -48,7 +48,7 @@ export abstract class BaseTaskQueue implements TaskQueue {
markAsFailed(task: Task) {
if (this.dependencies.has(task)) {
for (const dependentTask of this.dependencies.get(task) !) {
for (const dependentTask of this.dependencies.get(task)!) {
this.skipDependentTasks(dependentTask, task);
}
}
@ -81,7 +81,7 @@ export abstract class BaseTaskQueue implements TaskQueue {
protected skipDependentTasks(task: Task, failedTask: Task) {
this.tasksToSkip.set(task, failedTask);
if (this.dependencies.has(task)) {
for (const dependentTask of this.dependencies.get(task) !) {
for (const dependentTask of this.dependencies.get(task)!) {
this.skipDependentTasks(dependentTask, failedTask);
}
}

View File

@ -49,9 +49,9 @@ export class ParallelTaskQueue extends BaseTaskQueue {
}
// Unblock the tasks that are dependent upon `task`
for (const dependentTask of this.dependencies.get(task) !) {
for (const dependentTask of this.dependencies.get(task)!) {
if (this.blockedTasks.has(dependentTask)) {
const blockingTasks = this.blockedTasks.get(dependentTask) !;
const blockingTasks = this.blockedTasks.get(dependentTask)!;
// Remove the completed task from the lists of tasks blocking other tasks.
blockingTasks.delete(task);
if (blockingTasks.size === 0) {

View File

@ -10,8 +10,8 @@ import {EntryPoint} from '../../packages/entry_point';
import {PartiallyOrderedTasks, Task, TaskDependencies} from './api';
/** Stringify a task for debugging purposes. */
export const stringifyTask = (task: Task): string =>
`{entryPoint: ${task.entryPoint.name}, formatProperty: ${task.formatProperty}, processDts: ${task.processDts}}`;
export const stringifyTask = (task: Task): string => `{entryPoint: ${
task.entryPoint.name}, formatProperty: ${task.formatProperty}, processDts: ${task.processDts}}`;
/**
* Compute a mapping of tasks to the tasks that are dependent on them (if any).
@ -45,7 +45,7 @@ export function computeTaskDependencies(
// Find the earlier tasks (`candidateDependencies`) that this task depends upon.
const deps = graph.dependenciesOf(entryPointPath);
const taskDependencies = deps.filter(dep => candidateDependencies.has(dep))
.map(dep => candidateDependencies.get(dep) !);
.map(dep => candidateDependencies.get(dep)!);
// If this task has dependencies, add it to the dependencies and dependents maps.
if (taskDependencies.length > 0) {
@ -61,7 +61,7 @@ export function computeTaskDependencies(
// dependency of other tasks), so the following should theoretically never happen, but check
// just in case.
if (candidateDependencies.has(entryPointPath)) {
const otherTask = candidateDependencies.get(entryPointPath) !;
const otherTask = candidateDependencies.get(entryPointPath)!;
throw new Error(
'Invariant violated: Multiple tasks are assigned generating typings for ' +
`'${entryPointPath}':\n - ${stringifyTask(otherTask)}\n - ${stringifyTask(task)}`);
@ -73,7 +73,7 @@ export function computeTaskDependencies(
// This task is not generating typings so we need to add it to the dependents of the task that
// does generate typings, if that exists
if (candidateDependencies.has(entryPointPath)) {
const typingsTask = candidateDependencies.get(entryPointPath) !;
const typingsTask = candidateDependencies.get(entryPointPath)!;
const typingsTaskDependents = getDependentsSet(dependencies, typingsTask);
typingsTaskDependents.add(task);
}
@ -87,7 +87,7 @@ export function getDependentsSet(map: TaskDependencies, task: Task): Set<Task> {
if (!map.has(task)) {
map.set(task, new Set());
}
return map.get(task) !;
return map.get(task)!;
}
/**
@ -125,13 +125,13 @@ export function sortTasksByPriority(
tasks: PartiallyOrderedTasks, dependencies: TaskDependencies): PartiallyOrderedTasks {
const priorityPerTask = new Map<Task, [number, number]>();
const computePriority = (task: Task, idx: number):
[number, number] => [dependencies.has(task) ? dependencies.get(task) !.size : 0, idx];
[number, number] => [dependencies.has(task) ? dependencies.get(task)!.size : 0, idx];
tasks.forEach((task, i) => priorityPerTask.set(task, computePriority(task, i)));
return tasks.slice().sort((task1, task2) => {
const [p1, idx1] = priorityPerTask.get(task1) !;
const [p2, idx2] = priorityPerTask.get(task2) !;
const [p1, idx1] = priorityPerTask.get(task1)!;
const [p2, idx2] = priorityPerTask.get(task2)!;
return (p2 - p1) || (idx1 - idx2);
});

View File

@ -7,13 +7,14 @@
*/
import * as ts from 'typescript';
import {absoluteFrom} from '../../../src/ngtsc/file_system';
import {Declaration, Import} from '../../../src/ngtsc/reflection';
import {Logger} from '../logging/logger';
import {BundleProgram} from '../packages/bundle_program';
import {FactoryMap, getTsHelperFnFromIdentifier, isDefined, stripExtension} from '../utils';
import {ExportDeclaration, ExportStatement, ReexportStatement, RequireCall, findNamespaceOfIdentifier, findRequireCallReference, isExportStatement, isReexportStatement, isRequireCall} from './commonjs_umd_utils';
import {ExportDeclaration, ExportStatement, findNamespaceOfIdentifier, findRequireCallReference, isExportStatement, isReexportStatement, isRequireCall, ReexportStatement, RequireCall} from './commonjs_umd_utils';
import {Esm5ReflectionHost} from './esm5_host';
import {NgccClassSymbol} from './ngcc_host';

View File

@ -16,7 +16,12 @@ export interface ExportDeclaration {
}
export interface ExportStatement extends ts.ExpressionStatement {
expression: ts.BinaryExpression&{left: ts.PropertyAccessExpression & {expression: ts.Identifier}};
expression: ts.BinaryExpression&{
left: ts.PropertyAccessExpression &
{
expression: ts.Identifier
}
};
}
/**
@ -34,7 +39,9 @@ export interface ExportStatement extends ts.ExpressionStatement {
* expression and can be either a `require('...')` call or an identifier (initialized via a
* `require('...')` call).
*/
export interface ReexportStatement extends ts.ExpressionStatement { expression: ts.CallExpression; }
export interface ReexportStatement extends ts.ExpressionStatement {
expression: ts.CallExpression;
}
export interface RequireCall extends ts.CallExpression {
arguments: ts.CallExpression['arguments']&[ts.StringLiteral];

View File

@ -13,7 +13,8 @@ import {Declaration, Import} from '../../../src/ngtsc/reflection';
import {Logger} from '../logging/logger';
import {BundleProgram} from '../packages/bundle_program';
import {FactoryMap, getTsHelperFnFromIdentifier, stripExtension} from '../utils';
import {ExportDeclaration, ExportStatement, ReexportStatement, findNamespaceOfIdentifier, findRequireCallReference, isExportStatement, isReexportStatement, isRequireCall} from './commonjs_umd_utils';
import {ExportDeclaration, ExportStatement, findNamespaceOfIdentifier, findRequireCallReference, isExportStatement, isReexportStatement, isRequireCall, ReexportStatement} from './commonjs_umd_utils';
import {Esm5ReflectionHost, stripParentheses} from './esm5_host';
export class UmdReflectionHost extends Esm5ReflectionHost {
@ -61,7 +62,8 @@ export class UmdReflectionHost extends Esm5ReflectionHost {
return this.umdImportPaths.get(importParameter);
}
/** Get the top level statements for a module.
/**
* Get the top level statements for a module.
*
* In UMD modules these are the body of the UMD factory function.
*

View File

@ -52,7 +52,7 @@ export class AsyncLocker {
if (attempts === 0) {
this.logger.info(
`Another process, with id ${pid}, is currently running ngcc.\n` +
`Waiting up to ${this.retryDelay*this.retryAttempts/1000}s for it to finish.`);
`Waiting up to ${this.retryDelay * this.retryAttempts / 1000}s for it to finish.`);
}
// The file is still locked by another process so wait for a bit and retry
await new Promise(resolve => setTimeout(resolve, this.retryDelay));
@ -60,7 +60,10 @@ export class AsyncLocker {
}
// If we fall out of the loop then we ran out of rety attempts
throw new Error(
`Timed out waiting ${this.retryAttempts * this.retryDelay/1000}s for another ngcc process, with id ${pid}, to complete.\n` +
`(If you are sure no ngcc process is running then you should delete the lock-file at ${this.lockFile.path}.)`);
`Timed out waiting ${
this.retryAttempts * this.retryDelay /
1000}s for another ngcc process, with id ${pid}, to complete.\n` +
`(If you are sure no ngcc process is running then you should delete the lock-file at ${
this.lockFile.path}.)`);
}
}

View File

@ -8,8 +8,8 @@
import {ChildProcess, fork} from 'child_process';
import {AbsoluteFsPath, CachedFileSystem, FileSystem} from '../../../../src/ngtsc/file_system';
import {LogLevel, Logger} from '../../logging/logger';
import {LockFile, getLockFilePath} from '../lock_file';
import {Logger, LogLevel} from '../../logging/logger';
import {getLockFilePath, LockFile} from '../lock_file';
import {removeLockFile} from './util';

View File

@ -20,14 +20,14 @@ const fs = new NodeJSFileSystem();
// We create a logger that has the same logging level as the parent process, since it should have
// been passed through as one of the args
const logLevel = parseInt(process.argv.pop() !, 10);
const logLevel = parseInt(process.argv.pop()!, 10);
const logger = new ConsoleLogger(logLevel);
// We must store the parent PID now as it changes if the parent process is killed early
const ppid = process.ppid.toString();
// The path to the lock-file to remove should have been passed as one of the args
const lockFilePath = fs.resolve(process.argv.pop() !);
const lockFilePath = fs.resolve(process.argv.pop()!);
logger.debug(`Starting unlocker at process ${process.pid} on behalf of process ${ppid}`);
logger.debug(`The lock-file path is ${lockFilePath}`);
@ -36,4 +36,6 @@ logger.debug(`The lock-file path is ${lockFilePath}`);
* When the parent process exits (for whatever reason) remove the loc-file if it exists and as long
* as it was one that was created by the parent process.
*/
process.on('disconnect', () => { removeLockFile(fs, logger, lockFilePath, ppid); });
process.on('disconnect', () => {
removeLockFile(fs, logger, lockFilePath, ppid);
});

View File

@ -57,6 +57,7 @@ export class SyncLocker {
`ngcc is already running at process with id ${pid}.\n` +
`If you are running multiple builds in parallel then you should pre-process your node_modules via the command line ngcc tool before starting the builds;\n` +
`See https://v9.angular.io/guide/ivy#speeding-up-ngcc-compilation.\n` +
`(If you are sure no ngcc process is running then you should delete the lock-file at ${this.lockFile.path}.)`);
`(If you are sure no ngcc process is running then you should delete the lock-file at ${
this.lockFile.path}.)`);
}
}

View File

@ -5,7 +5,7 @@
* 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 {LogLevel, Logger} from './logger';
import {Logger, LogLevel} from './logger';
const RESET = '\x1b[0m';
const RED = '\x1b[31m';

View File

@ -14,7 +14,7 @@ import * as ts from 'typescript';
import {readConfiguration} from '../..';
import {replaceTsWithNgInErrors} from '../../src/ngtsc/diagnostics';
import {AbsoluteFsPath, FileSystem, absoluteFrom, dirname, getFileSystem, resolve} from '../../src/ngtsc/file_system';
import {absoluteFrom, AbsoluteFsPath, dirname, FileSystem, getFileSystem, resolve} from '../../src/ngtsc/file_system';
import {CommonJsDependencyHost} from './dependencies/commonjs_dependency_host';
import {DependencyResolver, InvalidEntryPoint} from './dependencies/dependency_resolver';
@ -38,10 +38,10 @@ import {AsyncLocker} from './locking/async_locker';
import {LockFileWithChildProcess} from './locking/lock_file_with_child_process';
import {SyncLocker} from './locking/sync_locker';
import {ConsoleLogger} from './logging/console_logger';
import {LogLevel, Logger} from './logging/logger';
import {Logger, LogLevel} from './logging/logger';
import {hasBeenProcessed} from './packages/build_marker';
import {NgccConfiguration} from './packages/configuration';
import {EntryPoint, EntryPointJsonProperty, EntryPointPackageJson, SUPPORTED_FORMAT_PROPERTIES, getEntryPointFormat} from './packages/entry_point';
import {EntryPoint, EntryPointJsonProperty, EntryPointPackageJson, getEntryPointFormat, SUPPORTED_FORMAT_PROPERTIES} from './packages/entry_point';
import {makeEntryPointBundle} from './packages/entry_point_bundle';
import {EntryPointManifest, InvalidatingEntryPointManifest} from './packages/entry_point_manifest';
import {Transformer} from './packages/transformer';
@ -164,12 +164,12 @@ export interface SyncNgccOptions {
/**
* The options to configure the ngcc compiler for asynchronous execution.
*/
export type AsyncNgccOptions = Omit<SyncNgccOptions, 'async'>& {async: true};
export type AsyncNgccOptions = Omit<SyncNgccOptions, 'async'>&{async: true};
/**
* The options to configure the ngcc compiler.
*/
export type NgccOptions = AsyncNgccOptions | SyncNgccOptions;
export type NgccOptions = AsyncNgccOptions|SyncNgccOptions;
/**
* This is the main entry-point into ngcc (aNGular Compatibility Compiler).
@ -181,12 +181,20 @@ export type NgccOptions = AsyncNgccOptions | SyncNgccOptions;
*/
export function mainNgcc(options: AsyncNgccOptions): Promise<void>;
export function mainNgcc(options: SyncNgccOptions): void;
export function mainNgcc(
{basePath, targetEntryPointPath, propertiesToConsider = SUPPORTED_FORMAT_PROPERTIES,
compileAllFormats = true, createNewEntryPointFormats = false,
logger = new ConsoleLogger(LogLevel.info), pathMappings, async = false,
errorOnFailedEntryPoint = false, enableI18nLegacyMessageIdFormat = true,
invalidateEntryPointManifest = false, tsConfigPath}: NgccOptions): void|Promise<void> {
export function mainNgcc({
basePath,
targetEntryPointPath,
propertiesToConsider = SUPPORTED_FORMAT_PROPERTIES,
compileAllFormats = true,
createNewEntryPointFormats = false,
logger = new ConsoleLogger(LogLevel.info),
pathMappings,
async = false,
errorOnFailedEntryPoint = false,
enableI18nLegacyMessageIdFormat = true,
invalidateEntryPointManifest = false,
tsConfigPath
}: NgccOptions): void|Promise<void> {
if (!!targetEntryPointPath) {
// targetEntryPointPath forces us to error if an entry-point fails.
errorOnFailedEntryPoint = true;
@ -279,7 +287,7 @@ export function mainNgcc(
continue;
}
const formatPropertiesToMarkAsProcessed = equivalentPropertiesMap.get(formatProperty) !;
const formatPropertiesToMarkAsProcessed = equivalentPropertiesMap.get(formatProperty)!;
tasks.push({entryPoint, formatProperty, formatPropertiesToMarkAsProcessed, processDts});
// Only process typings for the first property (if not already processed).
@ -442,7 +450,7 @@ function getExecutor(
function getDependencyResolver(
fileSystem: FileSystem, logger: Logger, config: NgccConfiguration,
pathMappings: PathMappings | undefined): DependencyResolver {
pathMappings: PathMappings|undefined): DependencyResolver {
const moduleResolver = new ModuleResolver(fileSystem, pathMappings);
const esmDependencyHost = new EsmDependencyHost(fileSystem, moduleResolver);
const umdDependencyHost = new UmdDependencyHost(fileSystem, moduleResolver);
@ -461,8 +469,8 @@ function getDependencyResolver(
function getEntryPointFinder(
fs: FileSystem, logger: Logger, resolver: DependencyResolver, config: NgccConfiguration,
entryPointManifest: EntryPointManifest, basePath: AbsoluteFsPath,
absoluteTargetEntryPointPath: AbsoluteFsPath | null,
pathMappings: PathMappings | undefined): EntryPointFinder {
absoluteTargetEntryPointPath: AbsoluteFsPath|null,
pathMappings: PathMappings|undefined): EntryPointFinder {
if (absoluteTargetEntryPointPath !== null) {
return new TargetedEntryPointFinder(
fs, config, logger, resolver, basePath, absoluteTargetEntryPointPath, pathMappings);
@ -533,7 +541,7 @@ function getPropertiesToProcess(
const equivalentPropertiesMap = new Map<EntryPointJsonProperty, EntryPointJsonProperty[]>();
for (const prop of propertiesToConsider) {
const formatPath = packageJson[prop] !;
const formatPath = packageJson[prop]!;
const equivalentProperties = formatPathToProperties[formatPath];
equivalentPropertiesMap.set(prop, equivalentProperties);
}

View File

@ -102,7 +102,7 @@ function migrateProviders(metadata: ResolvedValueMap, field: string, host: Migra
if (!metadata.has(field)) {
return;
}
const providers = metadata.get(field) !;
const providers = metadata.get(field)!;
if (!Array.isArray(providers)) {
return;
}
@ -127,10 +127,10 @@ function migrateProvider(provider: ResolvedValue, host: MigrationHost): void {
// as the provider itself configures 'deps'. Only if 'deps' is missing will this require a
// factory to exist on SomeClass.
if (!provider.has('deps')) {
migrateProviderClass(provider.get('useClass') !, host);
migrateProviderClass(provider.get('useClass')!, host);
}
} else {
migrateProviderClass(provider.get('provide') !, host);
migrateProviderClass(provider.get('provide')!, host);
}
} else if (Array.isArray(provider)) {
for (const v of provider) {

View File

@ -43,7 +43,7 @@ export function hasConstructor(host: MigrationHost, clazz: ClassDeclaration): bo
*/
export function createDirectiveDecorator(
clazz: ClassDeclaration,
metadata?: {selector: string | null, exportAs: string[] | null}): Decorator {
metadata?: {selector: string|null, exportAs: string[]|null}): Decorator {
const args: ts.Expression[] = [];
if (metadata !== undefined) {
const metaArgs: ts.PropertyAssignment[] = [];
@ -60,7 +60,8 @@ export function createDirectiveDecorator(
identifier: null,
import: {name: 'Directive', from: '@angular/core'},
node: null,
synthesizedFor: clazz.name, args,
synthesizedFor: clazz.name,
args,
};
}
@ -69,7 +70,7 @@ export function createDirectiveDecorator(
*/
export function createComponentDecorator(
clazz: ClassDeclaration,
metadata: {selector: string | null, exportAs: string[] | null}): Decorator {
metadata: {selector: string|null, exportAs: string[]|null}): Decorator {
const metaArgs: ts.PropertyAssignment[] = [
property('template', ''),
];
@ -127,5 +128,5 @@ function reifySourceFile(expr: ts.Expression): ts.Expression {
if (!ts.isVariableStatement(stmt)) {
throw new Error(`Expected VariableStatement, got ${ts.SyntaxKind[stmt.kind]}`);
}
return stmt.declarationList.declarations[0].initializer !;
return stmt.declarationList.declarations[0].initializer!;
}

View File

@ -6,17 +6,19 @@
* found in the LICENSE file at https://angular.io/license
*/
import * as ts from 'typescript';
import {AbsoluteFsPath, FileSystem, dirname, resolve} from '../../../src/ngtsc/file_system';
import {AbsoluteFsPath, dirname, FileSystem, resolve} from '../../../src/ngtsc/file_system';
import {patchTsGetExpandoInitializer, restoreGetExpandoInitializer} from './patch_ts_expando_initializer';
/**
* An entry point bundle contains one or two programs, e.g. `src` and `dts`,
* that are compiled via TypeScript.
*
* To aid with processing the program, this interface exposes the program itself,
* as well as path and TS file of the entry-point to the program and the r3Symbols
* file, if appropriate.
*/
* An entry point bundle contains one or two programs, e.g. `src` and `dts`,
* that are compiled via TypeScript.
*
* To aid with processing the program, this interface exposes the program itself,
* as well as path and TS file of the entry-point to the program and the r3Symbols
* file, if appropriate.
*/
export interface BundleProgram {
program: ts.Program;
options: ts.CompilerOptions;
@ -46,7 +48,7 @@ export function makeBundleProgram(
program.getTypeChecker();
restoreGetExpandoInitializer(originalGetExpandoInitializer);
const file = program.getSourceFile(path) !;
const file = program.getSourceFile(path)!;
const r3SymbolsFile = r3SymbolsPath && program.getSourceFile(r3SymbolsPath) || null;
return {program, options, host, package: pkg, path, file, r3SymbolsPath, r3SymbolsFile};

View File

@ -8,7 +8,9 @@
import {createHash} from 'crypto';
import {satisfies} from 'semver';
import * as vm from 'vm';
import {AbsoluteFsPath, FileSystem, dirname, join, resolve} from '../../../src/ngtsc/file_system';
import {AbsoluteFsPath, dirname, FileSystem, join, resolve} from '../../../src/ngtsc/file_system';
import {PackageJsonFormatPropertiesMap} from './entry_point';
/**
@ -178,7 +180,7 @@ export class NgccConfiguration {
getConfig(packagePath: AbsoluteFsPath, version: string|null): VersionedPackageConfig {
const cacheKey = packagePath + (version !== null ? `@${version}` : '');
if (this.cache.has(cacheKey)) {
return this.cache.get(cacheKey) !;
return this.cache.get(cacheKey)!;
}
const projectLevelConfig =
@ -256,7 +258,8 @@ export class NgccConfiguration {
const theExports = {};
const sandbox = {
module: {exports: theExports},
exports: theExports, require,
exports: theExports,
require,
__dirname: dirname(srcPath),
__filename: srcPath
};
@ -292,9 +295,8 @@ export class NgccConfiguration {
}
}
function findSatisfactoryVersion(
configs: VersionedPackageConfig[] | undefined, version: string | null): VersionedPackageConfig|
null {
function findSatisfactoryVersion(configs: VersionedPackageConfig[]|undefined, version: string|null):
VersionedPackageConfig|null {
if (configs === undefined) {
return null;
}

View File

@ -17,7 +17,7 @@ import {NgccConfiguration, NgccEntryPointConfig} from './configuration';
/**
* The possible values for the format of an entry-point.
*/
export type EntryPointFormat = 'esm5' | 'esm2015' | 'umd' | 'commonjs';
export type EntryPointFormat = 'esm5'|'esm2015'|'umd'|'commonjs';
/**
* An object containing information about an entry-point, including paths
@ -42,10 +42,12 @@ export interface EntryPoint extends JsonObject {
generateDeepReexports: boolean;
}
export type JsonPrimitive = string | number | boolean | null;
export type JsonValue = JsonPrimitive | JsonArray | JsonObject | undefined;
export type JsonPrimitive = string|number|boolean|null;
export type JsonValue = JsonPrimitive|JsonArray|JsonObject|undefined;
export interface JsonArray extends Array<JsonValue> {}
export interface JsonObject { [key: string]: JsonValue; }
export interface JsonObject {
[key: string]: JsonValue;
}
export interface PackageJsonFormatPropertiesMap {
fesm2015?: string;
@ -97,8 +99,7 @@ export const INCOMPATIBLE_ENTRY_POINT = 'incompatible-entry-point';
* * INCOMPATIBLE_ENTRY_POINT - the path was a non-processable entry-point that should be searched
* for sub-entry-points
*/
export type GetEntryPointResult =
EntryPoint | typeof INCOMPATIBLE_ENTRY_POINT | typeof NO_ENTRY_POINT;
export type GetEntryPointResult = EntryPoint|typeof INCOMPATIBLE_ENTRY_POINT|typeof NO_ENTRY_POINT;
/**
@ -161,7 +162,8 @@ export function getEntryPointInfo(
packageJson: entryPointPackageJson,
package: packagePath,
path: entryPointPath,
typings: resolve(entryPointPath, typings), compiledByAngular,
typings: resolve(entryPointPath, typings),
compiledByAngular,
ignoreMissingDependencies:
entryPointConfig !== undefined ? !!entryPointConfig.ignoreMissingDependencies : false,
generateDeepReexports:
@ -236,7 +238,7 @@ function isUmdModule(fs: FileSystem, sourceFilePath: AbsoluteFsPath): boolean {
}
function mergeConfigAndPackageJson(
entryPointPackageJson: EntryPointPackageJson | null, entryPointConfig: NgccEntryPointConfig,
entryPointPackageJson: EntryPointPackageJson|null, entryPointConfig: NgccEntryPointConfig,
packagePath: AbsoluteFsPath, entryPointPath: AbsoluteFsPath): EntryPointPackageJson {
if (entryPointPackageJson !== null) {
return {...entryPointPackageJson, ...entryPointConfig.override};

View File

@ -48,10 +48,8 @@ export function makeEntryPointBundle(
enableI18nLegacyMessageIdFormat: boolean = true): EntryPointBundle {
// Create the TS program and necessary helpers.
const rootDir = entryPoint.package;
const options: ts.CompilerOptions = {
allowJs: true,
maxNodeModuleJsDepth: Infinity, rootDir, ...pathMappings
};
const options: ts
.CompilerOptions = {allowJs: true, maxNodeModuleJsDepth: Infinity, rootDir, ...pathMappings};
const srcHost = new NgccSourcesCompilerHost(fs, options, entryPoint.path);
const dtsHost = new NgtscCompilerHost(fs, options);
@ -72,7 +70,12 @@ export function makeEntryPointBundle(
return {
entryPoint,
format,
rootDirs: [rootDir], isCore, isFlatCore, src, dts, enableI18nLegacyMessageIdFormat
rootDirs: [rootDir],
isCore,
isFlatCore,
src,
dts,
enableI18nLegacyMessageIdFormat
};
}

View File

@ -12,7 +12,7 @@ import {Logger} from '../logging/logger';
import {NGCC_VERSION} from './build_marker';
import {NgccConfiguration} from './configuration';
import {EntryPoint, INCOMPATIBLE_ENTRY_POINT, NO_ENTRY_POINT, getEntryPointInfo} from './entry_point';
import {EntryPoint, getEntryPointInfo, INCOMPATIBLE_ENTRY_POINT, NO_ENTRY_POINT} from './entry_point';
/**
* Manages reading and writing a manifest file that contains a list of all the entry-points that
@ -63,8 +63,8 @@ export class EntryPointManifest {
return null;
}
this.logger.debug(
`Entry-point manifest found for ${basePath} so loading entry-point information directly.`);
this.logger.debug(`Entry-point manifest found for ${
basePath} so loading entry-point information directly.`);
const startTime = Date.now();
const entryPoints: EntryPoint[] = [];
@ -72,8 +72,9 @@ export class EntryPointManifest {
const result =
getEntryPointInfo(this.fs, this.config, this.logger, packagePath, entryPointPath);
if (result === NO_ENTRY_POINT || result === INCOMPATIBLE_ENTRY_POINT) {
throw new Error(
`The entry-point manifest at ${manifestPath} contained an invalid pair of package paths: [${packagePath}, ${entryPointPath}]`);
throw new Error(`The entry-point manifest at ${
manifestPath} contained an invalid pair of package paths: [${packagePath}, ${
entryPointPath}]`);
} else {
entryPoints.push(result);
}
@ -142,7 +143,9 @@ export class EntryPointManifest {
* called.
*/
export class InvalidatingEntryPointManifest extends EntryPointManifest {
readEntryPointsUsingManifest(basePath: AbsoluteFsPath): EntryPoint[]|null { return null; }
readEntryPointsUsingManifest(basePath: AbsoluteFsPath): EntryPoint[]|null {
return null;
}
}
/**

View File

@ -58,17 +58,16 @@ export function patchTsGetExpandoInitializer(): unknown {
}
// Override the function to add support for recognizing the IIFE structure used in ES5 bundles.
(ts as any).getExpandoInitializer =
(initializer: ts.Node, isPrototypeAssignment: boolean): ts.Expression | undefined => {
// If the initializer is a call expression within parenthesis, unwrap the parenthesis
// upfront such that unsupported IIFE syntax `(function(){}())` becomes `function(){}()`,
// which is supported.
if (ts.isParenthesizedExpression(initializer) &&
ts.isCallExpression(initializer.expression)) {
initializer = initializer.expression;
}
return originalGetExpandoInitializer(initializer, isPrototypeAssignment);
};
(ts as any).getExpandoInitializer = (initializer: ts.Node,
isPrototypeAssignment: boolean): ts.Expression|undefined => {
// If the initializer is a call expression within parenthesis, unwrap the parenthesis
// upfront such that unsupported IIFE syntax `(function(){}())` becomes `function(){}()`,
// which is supported.
if (ts.isParenthesizedExpression(initializer) && ts.isCallExpression(initializer.expression)) {
initializer = initializer.expression;
}
return originalGetExpandoInitializer(initializer, isPrototypeAssignment);
};
return originalGetExpandoInitializer;
}
@ -125,16 +124,36 @@ function checkIfExpandoPropertyIsPresent(): boolean {
const sourceFile =
ts.createSourceFile('test.js', sourceText, ts.ScriptTarget.ES5, true, ts.ScriptKind.JS);
const host: ts.CompilerHost = {
getSourceFile(): ts.SourceFile | undefined{return sourceFile;},
fileExists(): boolean{return true;},
readFile(): string | undefined{return '';},
getSourceFile(): ts.SourceFile |
undefined {
return sourceFile;
},
fileExists(): boolean {
return true;
},
readFile(): string |
undefined {
return '';
},
writeFile() {},
getDefaultLibFileName(): string{return '';},
getCurrentDirectory(): string{return '';},
getDirectories(): string[]{return [];},
getCanonicalFileName(fileName: string): string{return fileName;},
useCaseSensitiveFileNames(): boolean{return true;},
getNewLine(): string{return '\n';},
getDefaultLibFileName(): string {
return '';
},
getCurrentDirectory(): string {
return '';
},
getDirectories(): string[] {
return [];
},
getCanonicalFileName(fileName: string): string {
return fileName;
},
useCaseSensitiveFileNames(): boolean {
return true;
},
getNewLine(): string {
return '\n';
},
};
const options = {noResolve: true, noLib: true, noEmit: true, allowJs: true};
const program = ts.createProgram(['test.js'], options, host);

View File

@ -36,8 +36,7 @@ import {EntryPointBundle} from './entry_point_bundle';
export type TransformResult = {
success: true; diagnostics: ts.Diagnostic[]; transformedFiles: FileToWrite[];
} |
{
}|{
success: false;
diagnostics: ts.Diagnostic[];
};
@ -79,8 +78,13 @@ export class Transformer {
const reflectionHost = new DelegatingReflectionHost(tsReflectionHost, ngccReflectionHost);
// Parse and analyze the files.
const {decorationAnalyses, switchMarkerAnalyses, privateDeclarationsAnalyses,
moduleWithProvidersAnalyses, diagnostics} = this.analyzeProgram(reflectionHost, bundle);
const {
decorationAnalyses,
switchMarkerAnalyses,
privateDeclarationsAnalyses,
moduleWithProvidersAnalyses,
diagnostics
} = this.analyzeProgram(reflectionHost, bundle);
// Bail if the analysis produced any errors.
if (hasErrors(diagnostics)) {
@ -162,8 +166,13 @@ export class Transformer {
const privateDeclarationsAnalyses =
privateDeclarationsAnalyzer.analyzeProgram(bundle.src.program);
return {decorationAnalyses, switchMarkerAnalyses, privateDeclarationsAnalyses,
moduleWithProvidersAnalyses, diagnostics};
return {
decorationAnalyses,
switchMarkerAnalyses,
privateDeclarationsAnalyses,
moduleWithProvidersAnalyses,
diagnostics
};
}
}

View File

@ -6,13 +6,15 @@
* found in the LICENSE file at https://angular.io/license
*/
import {dirname, relative} from 'canonical-path';
import * as ts from 'typescript';
import MagicString from 'magic-string';
import * as ts from 'typescript';
import {Reexport} from '../../../src/ngtsc/imports';
import {Import, ImportManager} from '../../../src/ngtsc/translator';
import {ExportInfo} from '../analysis/private_declarations_analyzer';
import {isRequireCall} from '../host/commonjs_umd_utils';
import {NgccReflectionHost} from '../host/ngcc_host';
import {Esm5RenderingFormatter} from './esm5_rendering_formatter';
import {stripExtension} from './utils';

View File

@ -7,20 +7,22 @@
*/
import MagicString from 'magic-string';
import * as ts from 'typescript';
import {FileSystem} from '../../../src/ngtsc/file_system';
import {Reexport} from '../../../src/ngtsc/imports';
import {CompileResult} from '../../../src/ngtsc/transform';
import {translateType, ImportManager} from '../../../src/ngtsc/translator';
import {ImportManager, translateType} from '../../../src/ngtsc/translator';
import {ModuleWithProvidersAnalyses, ModuleWithProvidersInfo} from '../analysis/module_with_providers_analyzer';
import {ExportInfo, PrivateDeclarationsAnalyses} from '../analysis/private_declarations_analyzer';
import {DecorationAnalyses} from '../analysis/types';
import {ModuleWithProvidersInfo, ModuleWithProvidersAnalyses} from '../analysis/module_with_providers_analyzer';
import {PrivateDeclarationsAnalyses, ExportInfo} from '../analysis/private_declarations_analyzer';
import {IMPORT_PREFIX} from '../constants';
import {NgccReflectionHost} from '../host/ngcc_host';
import {EntryPointBundle} from '../packages/entry_point_bundle';
import {Logger} from '../logging/logger';
import {FileToWrite, getImportRewriter} from './utils';
import {EntryPointBundle} from '../packages/entry_point_bundle';
import {RenderingFormatter} from './rendering_formatter';
import {renderSourceAndMap} from './source_maps';
import {FileToWrite, getImportRewriter} from './utils';
/**
* A structure that captures information about what needs to be rendered
@ -84,7 +86,7 @@ export class DtsRenderer {
const outputText = new MagicString(dtsFile.text);
const printer = ts.createPrinter();
const importManager = new ImportManager(
getImportRewriter(this.bundle.dts !.r3SymbolsFile, this.bundle.isCore, false),
getImportRewriter(this.bundle.dts!.r3SymbolsFile, this.bundle.isCore, false),
IMPORT_PREFIX);
renderInfo.classInfo.forEach(dtsClass => {
@ -129,7 +131,7 @@ export class DtsRenderer {
const dtsDeclaration = this.host.getDtsDeclaration(compiledClass.declaration);
if (dtsDeclaration) {
const dtsFile = dtsDeclaration.getSourceFile();
const renderInfo = dtsMap.has(dtsFile) ? dtsMap.get(dtsFile) ! : new DtsRenderInfo();
const renderInfo = dtsMap.has(dtsFile) ? dtsMap.get(dtsFile)! : new DtsRenderInfo();
renderInfo.classInfo.push({dtsDeclaration, compilation: compiledClass.compilation});
// Only add re-exports if the .d.ts tree is overlayed with the .js tree, as re-exports in
// ngcc are only used to support deep imports into e.g. commonjs code. For a deep import
@ -150,7 +152,7 @@ export class DtsRenderer {
// Capture the ModuleWithProviders functions/methods that need updating
if (moduleWithProvidersAnalyses !== null) {
moduleWithProvidersAnalyses.forEach((moduleWithProvidersToFix, dtsFile) => {
const renderInfo = dtsMap.has(dtsFile) ? dtsMap.get(dtsFile) ! : new DtsRenderInfo();
const renderInfo = dtsMap.has(dtsFile) ? dtsMap.get(dtsFile)! : new DtsRenderInfo();
renderInfo.moduleWithProviders = moduleWithProvidersToFix;
dtsMap.set(dtsFile, renderInfo);
});
@ -167,9 +169,9 @@ export class DtsRenderer {
`The simplest fix for this is to ensure that this class is exported from the package's entry-point.`);
}
});
const dtsEntryPoint = this.bundle.dts !.file;
const dtsEntryPoint = this.bundle.dts!.file;
const renderInfo =
dtsMap.has(dtsEntryPoint) ? dtsMap.get(dtsEntryPoint) ! : new DtsRenderInfo();
dtsMap.has(dtsEntryPoint) ? dtsMap.get(dtsEntryPoint)! : new DtsRenderInfo();
renderInfo.privateExports = privateDeclarationsAnalyses;
dtsMap.set(dtsEntryPoint, renderInfo);
}

View File

@ -25,14 +25,14 @@ export class Esm5RenderingFormatter extends EsmRenderingFormatter {
addDefinitions(output: MagicString, compiledClass: CompiledClass, definitions: string): void {
const iifeBody = getIifeBody(compiledClass.declaration);
if (!iifeBody) {
throw new Error(
`Compiled class declaration is not inside an IIFE: ${compiledClass.name} in ${compiledClass.declaration.getSourceFile().fileName}`);
throw new Error(`Compiled class declaration is not inside an IIFE: ${compiledClass.name} in ${
compiledClass.declaration.getSourceFile().fileName}`);
}
const returnStatement = iifeBody.statements.find(ts.isReturnStatement);
if (!returnStatement) {
throw new Error(
`Compiled class wrapper IIFE does not have a return statement: ${compiledClass.name} in ${compiledClass.declaration.getSourceFile().fileName}`);
throw new Error(`Compiled class wrapper IIFE does not have a return statement: ${
compiledClass.name} in ${compiledClass.declaration.getSourceFile().fileName}`);
}
const insertionPoint = returnStatement.getFullStart();

View File

@ -8,17 +8,19 @@
import {Statement} from '@angular/compiler';
import MagicString from 'magic-string';
import * as ts from 'typescript';
import {relative, dirname, AbsoluteFsPath, absoluteFromSourceFile} from '../../../src/ngtsc/file_system';
import {absoluteFromSourceFile, AbsoluteFsPath, dirname, relative} from '../../../src/ngtsc/file_system';
import {NOOP_DEFAULT_IMPORT_RECORDER, Reexport} from '../../../src/ngtsc/imports';
import {Import, ImportManager, translateStatement} from '../../../src/ngtsc/translator';
import {isDtsPath} from '../../../src/ngtsc/util/src/typescript';
import {CompiledClass} from '../analysis/types';
import {NgccReflectionHost, POST_R3_MARKER, PRE_R3_MARKER, SwitchableVariableDeclaration} from '../host/ngcc_host';
import {ModuleWithProvidersInfo} from '../analysis/module_with_providers_analyzer';
import {ExportInfo} from '../analysis/private_declarations_analyzer';
import {RenderingFormatter, RedundantDecoratorMap} from './rendering_formatter';
import {stripExtension} from './utils';
import {CompiledClass} from '../analysis/types';
import {isAssignment} from '../host/esm2015_host';
import {NgccReflectionHost, POST_R3_MARKER, PRE_R3_MARKER, SwitchableVariableDeclaration} from '../host/ngcc_host';
import {RedundantDecoratorMap, RenderingFormatter} from './rendering_formatter';
import {stripExtension} from './utils';
/**
* A RenderingFormatter that works with ECMAScript Module import and export statements.
@ -226,7 +228,8 @@ export class EsmRenderingFormatter implements RenderingFormatter {
info.declaration.getEnd();
outputText.appendLeft(
insertPoint,
`: ${generateImportString(importManager, '@angular/core', 'ModuleWithProviders')}<${ngModule}>`);
`: ${generateImportString(importManager, '@angular/core', 'ModuleWithProviders')}<${
ngModule}>`);
}
});
}
@ -296,7 +299,7 @@ function findStatement(node: ts.Node): ts.Statement|undefined {
}
function generateImportString(
importManager: ImportManager, importPath: string | null, importName: string) {
importManager: ImportManager, importPath: string|null, importName: string) {
const importAs = importPath ? importManager.generateNamedImport(importPath, importName) : null;
return importAs ? `${importAs.moduleImport}.${importAs.symbol}` : `${importName}`;
}

View File

@ -8,16 +8,18 @@
import {ConstantPool, Expression, Statement, WrappedNodeExpr, WritePropExpr} from '@angular/compiler';
import MagicString from 'magic-string';
import * as ts from 'typescript';
import {FileSystem} from '../../../src/ngtsc/file_system';
import {ImportManager} from '../../../src/ngtsc/translator';
import {CompiledClass, CompiledFile, DecorationAnalyses} from '../analysis/types';
import {PrivateDeclarationsAnalyses} from '../analysis/private_declarations_analyzer';
import {SwitchMarkerAnalyses, SwitchMarkerAnalysis} from '../analysis/switch_marker_analyzer';
import {CompiledClass, CompiledFile, DecorationAnalyses} from '../analysis/types';
import {IMPORT_PREFIX} from '../constants';
import {FileSystem} from '../../../src/ngtsc/file_system';
import {NgccReflectionHost} from '../host/ngcc_host';
import {Logger} from '../logging/logger';
import {EntryPointBundle} from '../packages/entry_point_bundle';
import {RenderingFormatter, RedundantDecoratorMap} from './rendering_formatter';
import {RedundantDecoratorMap, RenderingFormatter} from './rendering_formatter';
import {renderSourceAndMap} from './source_maps';
import {FileToWrite, getImportRewriter, stripExtension} from './utils';
@ -138,11 +140,11 @@ export class Renderer {
if (dec.node === null) {
return;
}
const decoratorArray = dec.node.parent !;
const decoratorArray = dec.node.parent!;
if (!decoratorsToRemove.has(decoratorArray)) {
decoratorsToRemove.set(decoratorArray, [dec.node]);
} else {
decoratorsToRemove.get(decoratorArray) !.push(dec.node);
decoratorsToRemove.get(decoratorArray)!.push(dec.node);
}
});
});
@ -160,8 +162,9 @@ export class Renderer {
private renderDefinitions(
sourceFile: ts.SourceFile, compiledClass: CompiledClass, imports: ImportManager): string {
const name = this.host.getInternalNameOfClass(compiledClass.declaration);
const statements: Statement[] = compiledClass.compilation.map(
c => { return createAssignmentStatement(name, c.name, c.initializer); });
const statements: Statement[] = compiledClass.compilation.map(c => {
return createAssignmentStatement(name, c.name, c.initializer);
});
return this.renderStatements(sourceFile, statements, imports);
}

View File

@ -8,12 +8,13 @@
import {Statement} from '@angular/compiler';
import MagicString from 'magic-string';
import * as ts from 'typescript';
import {Reexport} from '../../../src/ngtsc/imports';
import {Import, ImportManager} from '../../../src/ngtsc/translator';
import {ModuleWithProvidersInfo} from '../analysis/module_with_providers_analyzer';
import {ExportInfo} from '../analysis/private_declarations_analyzer';
import {CompiledClass} from '../analysis/types';
import {SwitchableVariableDeclaration} from '../host/ngcc_host';
import {ModuleWithProvidersInfo} from '../analysis/module_with_providers_analyzer';
/**
* The collected decorators that have become redundant after the compilation

View File

@ -5,14 +5,16 @@
* 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 {SourceMapConverter, fromObject, generateMapFileComment} from 'convert-source-map';
import {fromObject, generateMapFileComment, SourceMapConverter} from 'convert-source-map';
import MagicString from 'magic-string';
import * as ts from 'typescript';
import {FileSystem, absoluteFromSourceFile, basename, absoluteFrom} from '../../../src/ngtsc/file_system';
import {FileToWrite} from './utils';
import {SourceFileLoader} from '../sourcemaps/source_file_loader';
import {RawSourceMap} from '../sourcemaps/raw_source_map';
import {absoluteFrom, absoluteFromSourceFile, basename, FileSystem} from '../../../src/ngtsc/file_system';
import {Logger} from '../logging/logger';
import {RawSourceMap} from '../sourcemaps/raw_source_map';
import {SourceFileLoader} from '../sourcemaps/source_file_loader';
import {FileToWrite} from './utils';
export interface SourceMapInfo {
source: string;
@ -53,8 +55,8 @@ export function renderSourceAndMap(
];
}
} catch (e) {
logger.error(
`Error when flattening the source-map "${generatedMapPath}" for "${generatedPath}": ${e.toString()}`);
logger.error(`Error when flattening the source-map "${generatedMapPath}" for "${
generatedPath}": ${e.toString()}`);
return [
{path: generatedPath, contents: generatedContent},
{path: generatedMapPath, contents: fromObject(generatedMap).toJSON()},

View File

@ -6,17 +6,19 @@
* found in the LICENSE file at https://angular.io/license
*/
import {dirname, relative} from 'canonical-path';
import * as ts from 'typescript';
import MagicString from 'magic-string';
import * as ts from 'typescript';
import {Reexport} from '../../../src/ngtsc/imports';
import {Import, ImportManager} from '../../../src/ngtsc/translator';
import {ExportInfo} from '../analysis/private_declarations_analyzer';
import {UmdReflectionHost} from '../host/umd_host';
import {Esm5RenderingFormatter} from './esm5_rendering_formatter';
import {stripExtension} from './utils';
import {Reexport} from '../../../src/ngtsc/imports';
type CommonJsConditional = ts.ConditionalExpression & {whenTrue: ts.CallExpression};
type AmdConditional = ts.ConditionalExpression & {whenTrue: ts.CallExpression};
type CommonJsConditional = ts.ConditionalExpression&{whenTrue: ts.CallExpression};
type AmdConditional = ts.ConditionalExpression&{whenTrue: ts.CallExpression};
/**
* A RenderingFormatter that works with UMD files, instead of `import` and `export` statements
@ -24,7 +26,9 @@ type AmdConditional = ts.ConditionalExpression & {whenTrue: ts.CallExpression};
* wrapper function for AMD, CommonJS and global module formats.
*/
export class UmdRenderingFormatter extends Esm5RenderingFormatter {
constructor(protected umdHost: UmdReflectionHost, isCore: boolean) { super(umdHost, isCore); }
constructor(protected umdHost: UmdReflectionHost, isCore: boolean) {
super(umdHost, isCore);
}
/**
* Add the imports to the UMD module IIFE.

View File

@ -24,11 +24,11 @@ export interface FileToWrite {
* Create an appropriate ImportRewriter given the parameters.
*/
export function getImportRewriter(
r3SymbolsFile: ts.SourceFile | null, isCore: boolean, isFlat: boolean): ImportRewriter {
r3SymbolsFile: ts.SourceFile|null, isCore: boolean, isFlat: boolean): ImportRewriter {
if (isCore && isFlat) {
return new NgccFlatImportRewriter();
} else if (isCore) {
return new R3SymbolsImportRewriter(r3SymbolsFile !.fileName);
return new R3SymbolsImportRewriter(r3SymbolsFile!.fileName);
} else {
return new NoopImportRewriter();
}

View File

@ -8,11 +8,11 @@
/**
* A marker that indicates the start of a segment in a mapping.
*
* The end of a segment is indicated by the the first segment-marker of another mapping whose start
* is greater or equal to this one.
*/
* A marker that indicates the start of a segment in a mapping.
*
* The end of a segment is indicated by the the first segment-marker of another mapping whose start
* is greater or equal to this one.
*/
export interface SegmentMarker {
readonly line: number;
readonly column: number;

View File

@ -6,10 +6,12 @@
* found in the LICENSE file at https://angular.io/license
*/
import {removeComments, removeMapFileComments} from 'convert-source-map';
import {SourceMapMappings, SourceMapSegment, decode, encode} from 'sourcemap-codec';
import {decode, encode, SourceMapMappings, SourceMapSegment} from 'sourcemap-codec';
import {AbsoluteFsPath, dirname, relative} from '../../../src/ngtsc/file_system';
import {RawSourceMap} from './raw_source_map';
import {SegmentMarker, compareSegments, offsetSegment} from './segment_marker';
import {compareSegments, offsetSegment, SegmentMarker} from './segment_marker';
export function removeSourceMapComments(contents: string): string {
return removeMapFileComments(removeComments(contents)).replace(/\n\n$/, '\n');
@ -77,7 +79,8 @@ export class SourceFile {
const sourceMap: RawSourceMap = {
version: 3,
file: relative(sourcePathDir, this.sourcePath),
sources: sources.map(sf => relative(sourcePathDir, sf.sourcePath)), names,
sources: sources.map(sf => relative(sourcePathDir, sf.sourcePath)),
names,
mappings: encode(mappings),
sourcesContent: sources.map(sf => sf.contents),
};
@ -302,7 +305,7 @@ export function mergeMappings(generatedSource: SourceFile, ab: Mapping, bc: Mapp
* in the `sources` parameter.
*/
export function parseMappings(
rawMap: RawSourceMap | null, sources: (SourceFile | null)[],
rawMap: RawSourceMap|null, sources: (SourceFile|null)[],
generatedSourceStartOfLinePositions: number[]): Mapping[] {
if (rawMap === null) {
return [];
@ -318,15 +321,15 @@ export function parseMappings(
const generatedLineMappings = rawMappings[generatedLine];
for (const rawMapping of generatedLineMappings) {
if (rawMapping.length >= 4) {
const originalSource = sources[rawMapping[1] !];
const originalSource = sources[rawMapping[1]!];
if (originalSource === null || originalSource === undefined) {
// the original source is missing so ignore this mapping
continue;
}
const generatedColumn = rawMapping[0];
const name = rawMapping.length === 5 ? rawMap.names[rawMapping[4]] : undefined;
const line = rawMapping[2] !;
const column = rawMapping[3] !;
const line = rawMapping[2]!;
const column = rawMapping[3]!;
const generatedSegment: SegmentMarker = {
line: generatedLine,
column: generatedColumn,
@ -361,7 +364,7 @@ export function extractOriginalSegments(mappings: Mapping[]): Map<SourceFile, Se
if (!originalSegments.has(originalSource)) {
originalSegments.set(originalSource, []);
}
const segments = originalSegments.get(originalSource) !;
const segments = originalSegments.get(originalSource)!;
segments.push(mapping.originalSegment);
}
originalSegments.forEach(segmentMarkers => segmentMarkers.sort(compareSegments));

View File

@ -6,7 +6,9 @@
* found in the LICENSE file at https://angular.io/license
*/
import {commentRegex, fromComment, mapFileCommentRegex} from 'convert-source-map';
import {AbsoluteFsPath, FileSystem, absoluteFrom} from '../../../src/ngtsc/file_system';
import {absoluteFrom, AbsoluteFsPath, FileSystem} from '../../../src/ngtsc/file_system';
import {RawSourceMap} from './raw_source_map';
import {SourceFile} from './source_file';
@ -51,8 +53,8 @@ export class SourceFileLoader {
// Track source file paths if we have loaded them from disk so that we don't get into an
// infinite recursion
if (previousPaths.includes(sourcePath)) {
throw new Error(
`Circular source file mapping dependency: ${previousPaths.join(' -> ')} -> ${sourcePath}`);
throw new Error(`Circular source file mapping dependency: ${
previousPaths.join(' -> ')} -> ${sourcePath}`);
}
previousPaths = previousPaths.concat([sourcePath]);
@ -66,7 +68,7 @@ export class SourceFileLoader {
let map: RawSourceMap|null = null;
let inline = true;
let sources: (SourceFile | null)[] = [];
let sources: (SourceFile|null)[] = [];
if (mapAndPath !== null) {
const basePath = mapAndPath.mapPath || sourcePath;
sources = this.processSources(basePath, mapAndPath.map, previousPaths);
@ -87,7 +89,7 @@ export class SourceFileLoader {
private loadSourceMap(sourcePath: AbsoluteFsPath, contents: string): MapAndPath|null {
const inline = commentRegex.exec(contents);
if (inline !== null) {
return {map: fromComment(inline.pop() !).sourcemap, mapPath: null};
return {map: fromComment(inline.pop()!).sourcemap, mapPath: null};
}
const external = mapFileCommentRegex.exec(contents);

View File

@ -6,7 +6,8 @@
* found in the LICENSE file at https://angular.io/license
*/
import * as ts from 'typescript';
import {AbsoluteFsPath, FileSystem, absoluteFrom} from '../../src/ngtsc/file_system';
import {absoluteFrom, AbsoluteFsPath, FileSystem} from '../../src/ngtsc/file_system';
import {KnownDeclaration} from '../../src/ngtsc/reflection';
/**
@ -37,11 +38,11 @@ export function getOriginalSymbol(checker: ts.TypeChecker): (symbol: ts.Symbol)
};
}
export function isDefined<T>(value: T | undefined | null): value is T {
export function isDefined<T>(value: T|undefined|null): value is T {
return (value !== undefined) && (value !== null);
}
export function getNameText(name: ts.PropertyName | ts.BindingName): string {
export function getNameText(name: ts.PropertyName|ts.BindingName): string {
return ts.isIdentifier(name) || ts.isLiteralExpression(name) ? name.text : name.getText();
}
@ -111,10 +112,12 @@ export class FactoryMap<K, V> {
this.internalMap.set(key, this.factory(key));
}
return this.internalMap.get(key) !;
return this.internalMap.get(key)!;
}
set(key: K, value: V): void { this.internalMap.set(key, value); }
set(key: K, value: V): void {
this.internalMap.set(key, value);
}
}
/**

View File

@ -5,15 +5,16 @@
* 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 {AbsoluteFsPath, FileSystem, PathSegment, absoluteFrom} from '../../../../src/ngtsc/file_system';
import {absoluteFrom, AbsoluteFsPath, FileSystem, PathSegment} from '../../../../src/ngtsc/file_system';
import {cleanPackageJson} from '../../packages/build_marker';
import {NGCC_BACKUP_EXTENSION} from '../in_place_file_writer';
import {NGCC_DIRECTORY} from '../new_entry_point_file_writer';
import {isLocalDirectory} from './utils';
/**
* Implement this interface to extend the cleaning strategies of the `PackageCleaner`.
*/
* Implement this interface to extend the cleaning strategies of the `PackageCleaner`.
*/
export interface CleaningStrategy {
canClean(path: AbsoluteFsPath, basename: PathSegment): boolean;
clean(path: AbsoluteFsPath, basename: PathSegment): void;
@ -44,7 +45,9 @@ export class NgccDirectoryCleaner implements CleaningStrategy {
canClean(path: AbsoluteFsPath, basename: PathSegment): boolean {
return basename === NGCC_DIRECTORY && isLocalDirectory(this.fs, path);
}
clean(path: AbsoluteFsPath, _basename: PathSegment): void { this.fs.removeDeep(path); }
clean(path: AbsoluteFsPath, _basename: PathSegment): void {
this.fs.removeDeep(path);
}
}
/**

View File

@ -5,11 +5,12 @@
* 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 {FileSystem, absoluteFrom, dirname} from '../../../src/ngtsc/file_system';
import {absoluteFrom, dirname, FileSystem} from '../../../src/ngtsc/file_system';
import {Logger} from '../logging/logger';
import {EntryPointJsonProperty} from '../packages/entry_point';
import {EntryPointBundle} from '../packages/entry_point_bundle';
import {FileToWrite} from '../rendering/utils';
import {FileWriter} from './file_writer';
export const NGCC_BACKUP_EXTENSION = '.__ivy_ngcc_bak';
@ -37,7 +38,9 @@ export class InPlaceFileWriter implements FileWriter {
`Tried to overwrite ${backPath} with an ngcc back up file, which is disallowed.`);
} else {
this.logger.error(
`Tried to write ${backPath} with an ngcc back up file but it already exists so not writing, nor backing up, ${file.path}.\n` +
`Tried to write ${
backPath} with an ngcc back up file but it already exists so not writing, nor backing up, ${
file.path}.\n` +
`This error may be because two or more entry-points overlap and ngcc has been asked to process some files more than once.\n` +
`You should check other entry-points in this package and set up a config to ignore any that you are not using.`);
}

View File

@ -6,7 +6,7 @@
* 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 {AbsoluteFsPath, FileSystem, absoluteFromSourceFile, dirname, join, relative} from '../../../src/ngtsc/file_system';
import {absoluteFromSourceFile, AbsoluteFsPath, dirname, FileSystem, join, relative} from '../../../src/ngtsc/file_system';
import {isDtsPath} from '../../../src/ngtsc/util/src/typescript';
import {Logger} from '../logging/logger';
import {EntryPoint, EntryPointJsonProperty} from '../packages/entry_point';
@ -83,8 +83,8 @@ export class NewEntryPointFileWriter extends InPlaceFileWriter {
const packageJsonPath = join(entryPoint.path, 'package.json');
// All format properties point to the same format-path.
const oldFormatProp = formatProperties[0] !;
const oldFormatPath = packageJson[oldFormatProp] !;
const oldFormatProp = formatProperties[0]!;
const oldFormatPath = packageJson[oldFormatProp]!;
const oldAbsFormatPath = join(entryPoint.path, oldFormatPath);
const newAbsFormatPath = join(ngccFolder, relative(entryPoint.package, oldAbsFormatPath));
const newFormatPath = relative(entryPoint.path, newAbsFormatPath);

View File

@ -6,12 +6,12 @@
* found in the LICENSE file at https://angular.io/license
*/
import {AbsoluteFsPath, FileSystem, dirname} from '../../../src/ngtsc/file_system';
import {AbsoluteFsPath, dirname, FileSystem} from '../../../src/ngtsc/file_system';
import {JsonObject, JsonValue} from '../packages/entry_point';
export type PackageJsonChange = [string[], JsonValue, PackageJsonPropertyPositioning];
export type PackageJsonPropertyPositioning = 'unimportant' | 'alphabetic' | {before: string};
export type PackageJsonPropertyPositioning = 'unimportant'|'alphabetic'|{before: string};
export type WritePackageJsonChangesFn =
(changes: PackageJsonChange[], packageJsonPath: AbsoluteFsPath, parsedJson?: JsonObject) =>
void;

View File

@ -9,7 +9,7 @@ import * as ts from 'typescript';
import {FatalDiagnosticError, makeDiagnostic} from '../../../src/ngtsc/diagnostics';
import {absoluteFrom, getFileSystem, getSourceFileOrError} from '../../../src/ngtsc/file_system';
import {TestFile, runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {ClassDeclaration, Decorator} from '../../../src/ngtsc/reflection';
import {AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerPrecedence} from '../../../src/ngtsc/transform';
import {loadFakeCore, loadTestFiles} from '../../../test/helpers';
@ -21,7 +21,7 @@ import {Migration, MigrationHost} from '../../src/migrations/migration';
import {MockLogger} from '../helpers/mock_logger';
import {getRootFiles, makeTestEntryPointBundle} from '../helpers/utils';
type DecoratorHandlerWithResolve = DecoratorHandler<unknown, unknown, unknown>& {
type DecoratorHandlerWithResolve = DecoratorHandler<unknown, unknown, unknown>&{
resolve: NonNullable<DecoratorHandler<unknown, unknown, unknown>['resolve']>;
};
@ -29,7 +29,9 @@ runInEachFileSystem(() => {
describe('DecorationAnalyzer', () => {
let _: typeof absoluteFrom;
beforeEach(() => { _ = absoluteFrom; });
beforeEach(() => {
_ = absoluteFrom;
});
describe('analyzeProgram()', () => {
let logs: string[];
@ -50,8 +52,8 @@ runInEachFileSystem(() => {
]);
// Only detect the Component and Directive decorators
handler.detect.and.callFake(
(node: ts.Declaration, decorators: Decorator[] | null): DetectResult<unknown>|
undefined => {
(node: ts.Declaration, decorators: Decorator[]|null): DetectResult<unknown>|
undefined => {
const className = (node as any).name.text;
if (decorators === null) {
logs.push(`detect: ${className} (no decorators)`);
@ -94,17 +96,17 @@ runInEachFileSystem(() => {
// The "test" compilation result is just the name of the decorator being compiled
// (suffixed with `(compiled)`)
handler.compile.and.callFake((decl: ts.Declaration, analysis: any) => {
logs.push(
`compile: ${(decl as any).name.text}@${analysis.decoratorName} (resolved: ${analysis.resolved})`);
logs.push(`compile: ${(decl as any).name.text}@${analysis.decoratorName} (resolved: ${
analysis.resolved})`);
return `@${analysis.decoratorName} (compiled)`;
});
return handler;
};
function setUpAnalyzer(
testFiles: TestFile[],
options: {analyzeError: boolean,
resolveError: boolean} = {analyzeError: false, resolveError: false}) {
function setUpAnalyzer(testFiles: TestFile[], options: {
analyzeError: boolean,
resolveError: boolean
} = {analyzeError: false, resolveError: false}) {
logs = [];
loadTestFiles(testFiles);
loadFakeCore(getFileSystem());
@ -173,9 +175,9 @@ runInEachFileSystem(() => {
it('should return an object containing a reference to the original source file', () => {
const testFile = getSourceFileOrError(program, _('/node_modules/test-package/test.js'));
expect(result.get(testFile) !.sourceFile).toBe(testFile);
expect(result.get(testFile)!.sourceFile).toBe(testFile);
const otherFile = getSourceFileOrError(program, _('/node_modules/test-package/other.js'));
expect(result.get(otherFile) !.sourceFile).toBe(otherFile);
expect(result.get(otherFile)!.sourceFile).toBe(otherFile);
});
it('should call detect on the decorator handlers with each class from the parsed file',
@ -192,20 +194,23 @@ runInEachFileSystem(() => {
it('should return an object containing the classes that were analyzed', () => {
const file1 = getSourceFileOrError(program, _('/node_modules/test-package/test.js'));
const compiledFile1 = result.get(file1) !;
const compiledFile1 = result.get(file1)!;
expect(compiledFile1.compiledClasses.length).toEqual(2);
expect(compiledFile1.compiledClasses[0]).toEqual(jasmine.objectContaining({
name: 'MyComponent', compilation: ['@Component (compiled)'],
name: 'MyComponent',
compilation: ['@Component (compiled)'],
} as unknown as CompiledClass));
expect(compiledFile1.compiledClasses[1]).toEqual(jasmine.objectContaining({
name: 'MyDirective', compilation: ['@Directive (compiled)'],
name: 'MyDirective',
compilation: ['@Directive (compiled)'],
} as unknown as CompiledClass));
const file2 = getSourceFileOrError(program, _('/node_modules/test-package/other.js'));
const compiledFile2 = result.get(file2) !;
const compiledFile2 = result.get(file2)!;
expect(compiledFile2.compiledClasses.length).toEqual(1);
expect(compiledFile2.compiledClasses[0]).toEqual(jasmine.objectContaining({
name: 'MyOtherComponent', compilation: ['@Component (compiled)'],
name: 'MyOtherComponent',
compilation: ['@Component (compiled)'],
} as unknown as CompiledClass));
});
@ -284,18 +289,18 @@ runInEachFileSystem(() => {
() => {
const file =
getSourceFileOrError(program, _('/node_modules/test-package/component.js'));
const analysis = result.get(file) !;
const analysis = result.get(file)!;
expect(analysis).toBeDefined();
const ImportedComponent =
analysis.compiledClasses.find(f => f.name === 'ImportedComponent') !;
analysis.compiledClasses.find(f => f.name === 'ImportedComponent')!;
expect(ImportedComponent).toBeDefined();
});
it('should analyze an internally defined component, which is not exported at all', () => {
const file = getSourceFileOrError(program, _('/node_modules/test-package/entrypoint.js'));
const analysis = result.get(file) !;
const analysis = result.get(file)!;
expect(analysis).toBeDefined();
const LocalComponent = analysis.compiledClasses.find(f => f.name === 'LocalComponent') !;
const LocalComponent = analysis.compiledClasses.find(f => f.name === 'LocalComponent')!;
expect(LocalComponent).toBeDefined();
});
});
@ -341,7 +346,7 @@ runInEachFileSystem(() => {
});
it('should ignore classes from an externally imported file', () => {
const file = program.getSourceFile(_('/node_modules/other/component.js')) !;
const file = program.getSourceFile(_('/node_modules/other/component.js'))!;
expect(result.has(file)).toBe(false);
});
});
@ -427,11 +432,15 @@ runInEachFileSystem(() => {
name = 'FakeDecoratorHandler';
precedence = HandlerPrecedence.PRIMARY;
detect(): undefined { throw new Error('detect should not have been called'); }
detect(): undefined {
throw new Error('detect should not have been called');
}
analyze(): AnalysisOutput<unknown> {
throw new Error('analyze should not have been called');
}
compile(): CompileResult { throw new Error('compile should not have been called'); }
compile(): CompileResult {
throw new Error('compile should not have been called');
}
}
const analyzer = setUpAnalyzer([{

View File

@ -62,7 +62,7 @@ runInEachFileSystem(() => {
const {host, compiler} = createMigrationHost({entryPoint, handlers: [handler]});
host.injectSyntheticDecorator(mockClazz, injectedDecorator);
const record = compiler.recordFor(mockClazz) !;
const record = compiler.recordFor(mockClazz)!;
expect(record).toBeDefined();
expect(record.traits.length).toBe(1);
expect(record.traits[0].detected.decorator).toBe(injectedDecorator);
@ -77,7 +77,7 @@ runInEachFileSystem(() => {
const decorator = createComponentDecorator(mockClazz, {selector: 'comp', exportAs: null});
host.injectSyntheticDecorator(mockClazz, decorator);
const record = compiler.recordFor(mockClazz) !;
const record = compiler.recordFor(mockClazz)!;
const migratedTrait = record.traits[0];
if (migratedTrait.state !== TraitState.ERRORED) {
return fail('Expected migrated class trait to be in an error state');
@ -120,7 +120,7 @@ runInEachFileSystem(() => {
host.injectSyntheticDecorator(myClass, injectedDecorator);
const decorators = host.getAllDecorators(myClass) !;
const decorators = host.getAllDecorators(myClass)!;
expect(decorators.length).toBe(2);
expect(decorators[0].name).toBe('Directive');
expect(decorators[1].name).toBe('InjectedDecorator');
@ -183,9 +183,13 @@ class DetectDecoratorHandler implements DecoratorHandler<unknown, unknown, unkno
return {trigger: node, decorator, metadata: {}};
}
analyze(node: ClassDeclaration): AnalysisOutput<unknown> { return {}; }
analyze(node: ClassDeclaration): AnalysisOutput<unknown> {
return {};
}
compile(node: ClassDeclaration): CompileResult|CompileResult[] { return []; }
compile(node: ClassDeclaration): CompileResult|CompileResult[] {
return [];
}
}
class DiagnosticProducingHandler implements DecoratorHandler<unknown, unknown, unknown> {
@ -201,5 +205,7 @@ class DiagnosticProducingHandler implements DecoratorHandler<unknown, unknown, u
return {diagnostics: [makeDiagnostic(9999, node, 'test diagnostic')]};
}
compile(node: ClassDeclaration): CompileResult|CompileResult[] { return []; }
compile(node: ClassDeclaration): CompileResult|CompileResult[] {
return [];
}
}

View File

@ -7,8 +7,8 @@
*/
import * as ts from 'typescript';
import {AbsoluteFsPath, absoluteFrom, getSourceFileOrError} from '../../../src/ngtsc/file_system';
import {TestFile, runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {absoluteFrom, AbsoluteFsPath, getSourceFileOrError} from '../../../src/ngtsc/file_system';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {getDeclaration} from '../../../src/ngtsc/testing';
import {loadTestFiles} from '../../../test/helpers';
import {ModuleWithProvidersAnalyses, ModuleWithProvidersAnalyzer} from '../../src/analysis/module_with_providers_analyzer';
@ -333,7 +333,7 @@ runInEachFileSystem(() => {
'test-package', 'esm2015', false, getRootFiles(TEST_PROGRAM),
getRootFiles(TEST_DTS_PROGRAM));
program = bundle.src.program;
dtsProgram = bundle.dts !;
dtsProgram = bundle.dts!;
const host = new Esm2015ReflectionHost(new MockLogger(), false, bundle.src, dtsProgram);
referencesRegistry = new NgccReferencesRegistry(host);
@ -367,8 +367,8 @@ runInEachFileSystem(() => {
const libraryModuleDeclaration = getDeclaration(
program, absoluteFrom('/node_modules/some-library/index.d.ts'), 'LibraryModule',
ts.isClassDeclaration);
expect(declarations.has(externalModuleDeclaration.name !)).toBe(true);
expect(declarations.has(libraryModuleDeclaration.name !)).toBe(false);
expect(declarations.has(externalModuleDeclaration.name!)).toBe(true);
expect(declarations.has(libraryModuleDeclaration.name!)).toBe(false);
});
it('should find declarations that have implicit return types', () => {
@ -414,13 +414,12 @@ runInEachFileSystem(() => {
analyses: ModuleWithProvidersAnalyses, fileName: AbsoluteFsPath) {
const file = getSourceFileOrError(dtsProgram.program, fileName);
const analysis = analyses.get(file);
return analysis ?
analysis.map(
info =>
[info.declaration.name !.getText(),
(info.ngModule.node as ts.ClassDeclaration).name !.getText(),
info.ngModule.viaModule]) :
[];
return analysis ? analysis.map(
info =>
[info.declaration.name!.getText(),
(info.ngModule.node as ts.ClassDeclaration).name!.getText(),
info.ngModule.viaModule]) :
[];
}
});
});
@ -536,7 +535,7 @@ runInEachFileSystem(() => {
'test-package', 'esm2015', false, getRootFiles(TEST_PROGRAM),
getRootFiles(TEST_DTS_PROGRAM));
const program = bundle.src.program;
const dtsProgram = bundle.dts !;
const dtsProgram = bundle.dts!;
const host = new Esm2015ReflectionHost(new MockLogger(), false, bundle.src, dtsProgram);
const referencesRegistry = new NgccReferencesRegistry(host);
@ -558,9 +557,9 @@ runInEachFileSystem(() => {
const libraryModuleDeclaration = getDeclaration(
program, absoluteFrom('/node_modules/some-library/index.d.ts'), 'LibraryModule',
ts.isClassDeclaration);
expect(declarations.has(explicitInternalModuleDeclaration.name !)).toBe(true);
expect(declarations.has(externalModuleDeclaration.name !)).toBe(true);
expect(declarations.has(libraryModuleDeclaration.name !)).toBe(false);
expect(declarations.has(explicitInternalModuleDeclaration.name!)).toBe(true);
expect(declarations.has(externalModuleDeclaration.name!)).toBe(true);
expect(declarations.has(libraryModuleDeclaration.name!)).toBe(false);
});
it('should track references even when typings have already been processed', () => {
@ -586,9 +585,9 @@ runInEachFileSystem(() => {
const libraryModuleDeclaration = getDeclaration(
program, absoluteFrom('/node_modules/some-library/index.d.ts'), 'LibraryModule',
ts.isClassDeclaration);
expect(declarations.has(explicitInternalModuleDeclaration.name !)).toBe(true);
expect(declarations.has(externalModuleDeclaration.name !)).toBe(true);
expect(declarations.has(libraryModuleDeclaration.name !)).toBe(false);
expect(declarations.has(explicitInternalModuleDeclaration.name!)).toBe(true);
expect(declarations.has(externalModuleDeclaration.name!)).toBe(true);
expect(declarations.has(libraryModuleDeclaration.name!)).toBe(false);
});
});
});

View File

@ -91,7 +91,7 @@ runInEachFileSystem(() => {
const record = compiler.recordFor(mockClazz);
expect(record).toBeDefined();
expect(record !.traits.length).toBe(1);
expect(record!.traits.length).toBe(1);
});
it('should add a new trait to an existing class record', () => {
@ -118,11 +118,11 @@ runInEachFileSystem(() => {
compiler.analyzeFile(entryPoint.src.file);
compiler.injectSyntheticDecorator(myClass, injectedDecorator);
const record = compiler.recordFor(myClass) !;
const record = compiler.recordFor(myClass)!;
expect(record).toBeDefined();
expect(record.traits.length).toBe(2);
expect(record.traits[0].detected.decorator !.name).toBe('Directive');
expect(record.traits[1].detected.decorator !.name).toBe('InjectedDecorator');
expect(record.traits[0].detected.decorator!.name).toBe('Directive');
expect(record.traits[1].detected.decorator!.name).toBe('InjectedDecorator');
});
it('should not add a weak handler when a primary handler already exists', () => {
@ -150,10 +150,10 @@ runInEachFileSystem(() => {
compiler.injectSyntheticDecorator(myClass, injectedDecorator);
const record = compiler.recordFor(myClass) !;
const record = compiler.recordFor(myClass)!;
expect(record).toBeDefined();
expect(record.traits.length).toBe(1);
expect(record.traits[0].detected.decorator !.name).toBe('Directive');
expect(record.traits[0].detected.decorator!.name).toBe('Directive');
});
it('should replace an existing weak handler when injecting a primary handler', () => {
@ -181,10 +181,10 @@ runInEachFileSystem(() => {
compiler.injectSyntheticDecorator(myClass, injectedDecorator);
const record = compiler.recordFor(myClass) !;
const record = compiler.recordFor(myClass)!;
expect(record).toBeDefined();
expect(record.traits.length).toBe(1);
expect(record.traits[0].detected.decorator !.name).toBe('InjectedDecorator');
expect(record.traits[0].detected.decorator!.name).toBe('InjectedDecorator');
});
it('should produce an error when a primary handler is added when a primary handler is already present',
@ -214,12 +214,11 @@ runInEachFileSystem(() => {
compiler.injectSyntheticDecorator(myClass, injectedDecorator);
const record = compiler.recordFor(myClass) !;
const record = compiler.recordFor(myClass)!;
expect(record).toBeDefined();
expect(record.metaDiagnostics).toBeDefined();
expect(record.metaDiagnostics !.length).toBe(1);
expect(record.metaDiagnostics ![0].code)
.toBe(ngErrorCode(ErrorCode.DECORATOR_COLLISION));
expect(record.metaDiagnostics!.length).toBe(1);
expect(record.metaDiagnostics![0].code).toBe(ngErrorCode(ErrorCode.DECORATOR_COLLISION));
expect(record.traits.length).toBe(0);
});
@ -233,7 +232,7 @@ runInEachFileSystem(() => {
const decorator = createComponentDecorator(mockClazz, {selector: 'comp', exportAs: null});
compiler.injectSyntheticDecorator(mockClazz, decorator);
const record = compiler.recordFor(mockClazz) !;
const record = compiler.recordFor(mockClazz)!;
const migratedTrait = record.traits[0];
if (migratedTrait.state !== TraitState.ERRORED) {
return fail('Expected migrated class trait to be in an error state');
@ -286,13 +285,12 @@ runInEachFileSystem(() => {
compiler.injectSyntheticDecorator(myClass, injectedDecorator);
const decorators = compiler.getAllDecorators(myClass) !;
const decorators = compiler.getAllDecorators(myClass)!;
expect(decorators.length).toBe(2);
expect(decorators[0].name).toBe('Directive');
expect(decorators[1].name).toBe('InjectedDecorator');
});
});
});
});
@ -302,7 +300,7 @@ class TestHandler implements DecoratorHandler<unknown, unknown, unknown> {
precedence = HandlerPrecedence.PRIMARY;
detect(node: ClassDeclaration, decorators: Decorator[]|null): DetectResult<unknown>|undefined {
this.log.push(`${this.name}:detect:${node.name.text}:${decorators !.map(d => d.name)}`);
this.log.push(`${this.name}:detect:${node.name.text}:${decorators!.map(d => d.name)}`);
return undefined;
}

View File

@ -7,8 +7,8 @@
*/
import * as ts from 'typescript';
import {AbsoluteFsPath, absoluteFrom} from '../../../src/ngtsc/file_system';
import {TestFile, runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {absoluteFrom, AbsoluteFsPath} from '../../../src/ngtsc/file_system';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {Reference} from '../../../src/ngtsc/imports';
import {getDeclaration} from '../../../src/ngtsc/testing';
import {loadTestFiles} from '../../../test/helpers/src/mock_file_loading';
@ -192,6 +192,6 @@ runInEachFileSystem(() => {
program: ts.Program, registry: NgccReferencesRegistry, fileName: AbsoluteFsPath,
componentName: string) {
const declaration = getDeclaration(program, fileName, componentName, ts.isClassDeclaration);
registry.add(null !, new Reference(declaration));
registry.add(null!, new Reference(declaration));
}
});

View File

@ -8,7 +8,7 @@
import * as ts from 'typescript';
import {absoluteFrom} from '../../../src/ngtsc/file_system';
import {TestFile, runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {Reference} from '../../../src/ngtsc/imports';
import {PartialEvaluator} from '../../../src/ngtsc/partial_evaluator';
import {TypeScriptReflectionHost} from '../../../src/ngtsc/reflection';
@ -44,19 +44,19 @@ runInEachFileSystem(() => {
getDeclaration(program, indexPath, 'someFunction', ts.isFunctionDeclaration);
const someVariableDecl =
getDeclaration(program, indexPath, 'someVariable', ts.isVariableDeclaration);
const testArrayExpression = testArrayDeclaration.initializer !;
const testArrayExpression = testArrayDeclaration.initializer!;
const reflectionHost = new TypeScriptReflectionHost(checker);
const evaluator = new PartialEvaluator(reflectionHost, checker, /* dependencyTracker */ null);
const registry = new NgccReferencesRegistry(reflectionHost);
const references = (evaluator.evaluate(testArrayExpression) as any[]).filter(isReference);
registry.add(null !, ...references);
registry.add(null!, ...references);
const map = registry.getDeclarationMap();
expect(map.size).toEqual(2);
expect(map.get(someClassDecl.name !) !.node).toBe(someClassDecl);
expect(map.get(someFunctionDecl.name !) !.node).toBe(someFunctionDecl);
expect(map.get(someClassDecl.name!)!.node).toBe(someClassDecl);
expect(map.get(someFunctionDecl.name!)!.node).toBe(someFunctionDecl);
expect(map.has(someVariableDecl.name as ts.Identifier)).toBe(false);
});
});

View File

@ -6,7 +6,7 @@
* found in the LICENSE file at https://angular.io/license
*/
import {absoluteFrom, getSourceFileOrError} from '../../../src/ngtsc/file_system';
import {TestFile, runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {loadTestFiles} from '../../../test/helpers';
import {SwitchMarkerAnalyzer} from '../../src/analysis/switch_marker_analyzer';
import {Esm2015ReflectionHost} from '../../src/host/esm2015_host';
@ -15,7 +15,6 @@ import {makeTestEntryPointBundle} from '../helpers/utils';
runInEachFileSystem(() => {
describe('SwitchMarkerAnalyzer', () => {
let _: typeof absoluteFrom;
let TEST_PROGRAM: TestFile[];
@ -87,14 +86,14 @@ runInEachFileSystem(() => {
expect(analysis.has(entrypoint)).toBe(false);
expect(analysis.has(a)).toBe(false);
expect(analysis.has(b)).toBe(true);
expect(analysis.get(b) !.sourceFile).toBe(b);
expect(analysis.get(b) !.declarations.map(decl => decl.getText())).toEqual([
expect(analysis.get(b)!.sourceFile).toBe(b);
expect(analysis.get(b)!.declarations.map(decl => decl.getText())).toEqual([
'factoryB = factory__PRE_R3__'
]);
expect(analysis.has(c)).toBe(true);
expect(analysis.get(c) !.sourceFile).toBe(c);
expect(analysis.get(c) !.declarations.map(decl => decl.getText())).toEqual([
expect(analysis.get(c)!.sourceFile).toBe(c);
expect(analysis.get(c)!.declarations.map(decl => decl.getText())).toEqual([
'factoryC = factory__PRE_R3__',
'factoryD = factory__PRE_R3__',
]);

View File

@ -387,7 +387,7 @@ runInEachFileSystem(() => {
reExportsWithoutRequire?: string[];
}
function commonJs(importsPerType: ImportsPerType | string[], exportNames: string[] = []): string {
function commonJs(importsPerType: ImportsPerType|string[], exportNames: string[] = []): string {
if (Array.isArray(importsPerType)) {
importsPerType = {varDeclaration: importsPerType};
}
@ -414,8 +414,9 @@ runInEachFileSystem(() => {
} = importsPerType;
// var foo = require('...');
importsOfTypeVarDeclaration.forEach(
p => { importStatements.push(`var ${pathToVarName(p)} = require('${p}');`); });
importsOfTypeVarDeclaration.forEach(p => {
importStatements.push(`var ${pathToVarName(p)} = require('${p}');`);
});
// var foo = require('...'), bar = require('...');
importsOfTypeVarDeclarations.forEach(pp => {
@ -424,8 +425,9 @@ runInEachFileSystem(() => {
});
// exports.foo = require('...');
importsOfTypePropAssignment.forEach(
p => { importStatements.push(`exports.${pathToVarName(p)} = require('${p}');`); });
importsOfTypePropAssignment.forEach(p => {
importStatements.push(`exports.${pathToVarName(p)} = require('${p}');`);
});
// module.exports = {foo: require('...')};
const propAssignments =
@ -434,15 +436,19 @@ runInEachFileSystem(() => {
importStatements.push(`module.exports = {${propAssignments}\n};`);
// require('...');
importsOfTypeForSideEffects.forEach(p => { importStatements.push(`require('${p}');`); });
importsOfTypeForSideEffects.forEach(p => {
importStatements.push(`require('${p}');`);
});
// __export(require('...'));
importsOfTypeReExportsWithEmittedHelper.forEach(
p => { importStatements.push(`__export(require('${p}'));`); });
importsOfTypeReExportsWithEmittedHelper.forEach(p => {
importStatements.push(`__export(require('${p}'));`);
});
// tslib_1.__exportStar(require('...'), exports);
importsOfTypeReExportsWithImportedHelper.forEach(
p => { importStatements.push(`tslib_1.__exportStar(require('${p}'), exports);`); });
importsOfTypeReExportsWithImportedHelper.forEach(p => {
importStatements.push(`tslib_1.__exportStar(require('${p}'), exports);`);
});
// var foo = require('...');
// __export(foo);

View File

@ -8,7 +8,7 @@
import {DepGraph} from 'dependency-graph';
import {AbsoluteFsPath, FileSystem, absoluteFrom, getFileSystem, relativeFrom} from '../../../src/ngtsc/file_system';
import {absoluteFrom, AbsoluteFsPath, FileSystem, getFileSystem, relativeFrom} from '../../../src/ngtsc/file_system';
import {runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {DependencyInfo} from '../../src/dependencies/dependency_host';
import {DependencyResolver, SortedEntryPointsInfo} from '../../src/dependencies/dependency_resolver';
@ -254,7 +254,8 @@ runInEachFileSystem(() => {
const result = resolver.sortEntryPointsByDependency([first]);
expect(result.entryPoints).toEqual([first]);
expect(logger.logs.warn).toEqual([[
`Entry point 'first' contains deep imports into '${_('/deep/one')}'. This is probably not a problem, but may cause the compilation of entry points to be out of order.`
`Entry point 'first' contains deep imports into '${
_('/deep/one')}'. This is probably not a problem, but may cause the compilation of entry points to be out of order.`
]]);
});
@ -292,14 +293,14 @@ runInEachFileSystem(() => {
const result = resolver.sortEntryPointsByDependency([testEntryPoint]);
expect(result.entryPoints).toEqual([testEntryPoint]);
expect(logger.logs.warn).toEqual([[
`Entry point 'test-package' contains deep imports into '${_('/project/node_modules/deeper/one')}'. This is probably not a problem, but may cause the compilation of entry points to be out of order.`
`Entry point 'test-package' contains deep imports into '${
_('/project/node_modules/deeper/one')}'. This is probably not a problem, but may cause the compilation of entry points to be out of order.`
]]);
});
it('should error if the entry point does not have a suitable format', () => {
expect(() => resolver.sortEntryPointsByDependency([
{ path: '/first', packageJson: {}, compiledByAngular: true } as EntryPoint
{path: '/first', packageJson: {}, compiledByAngular: true} as EntryPoint
])).toThrowError(`There is no appropriate source code format in '/first' entry-point.`);
});
@ -307,7 +308,8 @@ runInEachFileSystem(() => {
resolver = new DependencyResolver(fs, new MockLogger(), config, {esm2015: host}, host);
expect(() => resolver.sortEntryPointsByDependency([first]))
.toThrowError(
`Could not find a suitable format for computing dependencies of entry-point: '${first.path}'.`);
`Could not find a suitable format for computing dependencies of entry-point: '${
first.path}'.`);
});
it('should capture any dependencies that were ignored', () => {
@ -462,7 +464,7 @@ runInEachFileSystem(() => {
deps[entryPointPath].missing.forEach(
dep => missing.add(fs.isRooted(dep) ? absoluteFrom(dep) : relativeFrom(dep)));
if (deps[entryPointPath].deepImports) {
deps[entryPointPath].deepImports !.forEach(dep => deepImports.add(dep));
deps[entryPointPath].deepImports!.forEach(dep => deepImports.add(dep));
}
return {dependencies, missing, deepImports};
};

View File

@ -14,7 +14,6 @@ import {createDependencyInfo} from '../../src/dependencies/dependency_host';
import {DtsDependencyHost} from '../../src/dependencies/dts_dependency_host';
runInEachFileSystem(() => {
describe('DtsDependencyHost', () => {
let _: typeof absoluteFrom;
let host: DtsDependencyHost;

View File

@ -16,7 +16,6 @@ import {EsmDependencyHost, hasImportOrReexportStatements, isStringImportOrReexpo
import {ModuleResolver} from '../../src/dependencies/module_resolver';
runInEachFileSystem(() => {
describe('EsmDependencyHost', () => {
let _: typeof absoluteFrom;
let host: EsmDependencyHost;

View File

@ -251,8 +251,10 @@ runInEachFileSystem(() => {
exportNames.map(e => ` exports.${e.replace(/.+\./, '')} = ${e};`).join('\n');
return `
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports${commonJsRequires}) :
typeof define === 'function' && define.amd ? define('${moduleName}', ['exports'${amdDeps}], factory) :
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports${
commonJsRequires}) :
typeof define === 'function' && define.amd ? define('${moduleName}', ['exports'${
amdDeps}], factory) :
(factory(global.${moduleName}${globalParams}));
}(this, (function (exports${params}) { 'use strict';
${exportStatements}

View File

@ -5,8 +5,8 @@
* 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 {AbsoluteFsPath, FileSystem, absoluteFrom, getFileSystem, relative} from '../../../src/ngtsc/file_system';
import {TestFile, runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {absoluteFrom, AbsoluteFsPath, FileSystem, getFileSystem, relative} from '../../../src/ngtsc/file_system';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {loadTestFiles} from '../../../test/helpers';
import {DependencyResolver} from '../../src/dependencies/dependency_resolver';
import {DtsDependencyHost} from '../../src/dependencies/dts_dependency_host';

View File

@ -5,8 +5,8 @@
* 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 {AbsoluteFsPath, FileSystem, absoluteFrom, getFileSystem, relative} from '../../../src/ngtsc/file_system';
import {TestFile, runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {absoluteFrom, AbsoluteFsPath, FileSystem, getFileSystem, relative} from '../../../src/ngtsc/file_system';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {loadTestFiles} from '../../../test/helpers';
import {DependencyResolver} from '../../src/dependencies/dependency_resolver';
import {DtsDependencyHost} from '../../src/dependencies/dts_dependency_host';
@ -365,7 +365,6 @@ runInEachFileSystem(() => {
basePath: AbsoluteFsPath, entryPoints: EntryPoint[]): [string, string][] {
return entryPoints.map(x => [relative(basePath, x.package), relative(basePath, x.path)]);
}
});
describe('targetNeedsProcessingOrCleaning()', () => {

View File

@ -132,9 +132,12 @@ runInEachFileSystem(() => {
fs.resolve(projectDirectory, 'dist-1'),
]);
expect(logger.logs.warn).toEqual([
[`The basePath "${fs.resolve(projectDirectory, 'sub-folder/dist-2')}" computed from baseUrl "${projectDirectory}" and path mapping "sub-folder/dist-2" does not exist in the file-system.\n` +
[`The basePath "${
fs.resolve(projectDirectory, 'sub-folder/dist-2')}" computed from baseUrl "${
projectDirectory}" and path mapping "sub-folder/dist-2" does not exist in the file-system.\n` +
`It will not be scanned for entry-points.`],
[`The basePath "${fs.resolve(projectDirectory, 'libs')}" computed from baseUrl "${projectDirectory}" and path mapping "libs/*" does not exist in the file-system.\n` +
[`The basePath "${fs.resolve(projectDirectory, 'libs')}" computed from baseUrl "${
projectDirectory}" and path mapping "libs/*" does not exist in the file-system.\n` +
`It will not be scanned for entry-points.`],
]);
});

View File

@ -51,7 +51,7 @@ describe('ClusterExecutor', () => {
describe('(on cluster master)', () => {
beforeEach(() => runAsClusterMaster(true));
it('should log debug info about the executor', async() => {
it('should log debug info about the executor', async () => {
const anyFn: () => any = () => undefined;
await executor.execute(anyFn, anyFn);
@ -60,7 +60,7 @@ describe('ClusterExecutor', () => {
]);
});
it('should delegate to `ClusterMaster#run()`', async() => {
it('should delegate to `ClusterMaster#run()`', async () => {
const analyzeEntryPointsSpy = jasmine.createSpy('analyzeEntryPoints');
const createCompilerFnSpy = jasmine.createSpy('createCompilerFn');
@ -75,13 +75,13 @@ describe('ClusterExecutor', () => {
});
it('should call LockFile.write() and LockFile.remove() if master runner completes successfully',
async() => {
async () => {
const anyFn: () => any = () => undefined;
await executor.execute(anyFn, anyFn);
expect(lockFileLog).toEqual(['write()', 'remove()']);
});
it('should call LockFile.write() and LockFile.remove() if master runner fails', async() => {
it('should call LockFile.write() and LockFile.remove() if master runner fails', async () => {
const anyFn: () => any = () => undefined;
masterRunSpy.and.returnValue(Promise.reject(new Error('master runner error')));
let error = '';
@ -94,7 +94,7 @@ describe('ClusterExecutor', () => {
expect(lockFileLog).toEqual(['write()', 'remove()']);
});
it('should not call master runner if LockFile.write() fails', async() => {
it('should not call master runner if LockFile.write() fails', async () => {
const anyFn: () => any = () => undefined;
spyOn(mockLockFile, 'write').and.callFake(() => {
lockFileLog.push('write()');
@ -114,7 +114,7 @@ describe('ClusterExecutor', () => {
expect(masterRunSpy).not.toHaveBeenCalled();
});
it('should fail if LockFile.remove() fails', async() => {
it('should fail if LockFile.remove() fails', async () => {
const anyFn: () => any = () => undefined;
spyOn(mockLockFile, 'remove').and.callFake(() => {
lockFileLog.push('remove()');
@ -139,14 +139,14 @@ describe('ClusterExecutor', () => {
describe('(on cluster worker)', () => {
beforeEach(() => runAsClusterMaster(false));
it('should not log debug info about the executor', async() => {
it('should not log debug info about the executor', async () => {
const anyFn: () => any = () => undefined;
await executor.execute(anyFn, anyFn);
expect(mockLogger.logs.debug).toEqual([]);
});
it('should delegate to `ClusterWorker#run()`', async() => {
it('should delegate to `ClusterWorker#run()`', async () => {
const analyzeEntryPointsSpy = jasmine.createSpy('analyzeEntryPoints');
const createCompilerFnSpy = jasmine.createSpy('createCompilerFn');
@ -160,7 +160,7 @@ describe('ClusterExecutor', () => {
expect(createCompilerFnSpy).toHaveBeenCalledWith(jasmine.any(Function));
});
it('should not call LockFile.write() or LockFile.remove()', async() => {
it('should not call LockFile.write() or LockFile.remove()', async () => {
const anyFn: () => any = () => undefined;
await executor.execute(anyFn, anyFn);
expect(lockFileLog).toEqual([]);

View File

@ -39,8 +39,9 @@ runInEachFileSystem(() => {
isMaster => describe(`(on cluster ${isMaster ? 'master' : 'worker'})`, () => {
beforeEach(() => runAsClusterMaster(isMaster));
it('should return a `PackageJsonUpdate` instance',
() => { expect(updater.createUpdate()).toEqual(jasmine.any(PackageJsonUpdate)); });
it('should return a `PackageJsonUpdate` instance', () => {
expect(updater.createUpdate()).toEqual(jasmine.any(PackageJsonUpdate));
});
it('should wire up the `PackageJsonUpdate` with its `writeChanges()` method', () => {
const writeChangesSpy = spyOn(updater, 'writeChanges');

View File

@ -60,11 +60,9 @@ describe('ClusterWorker', () => {
onTaskCompleted(null as any, TaskProcessingOutcome.Processed, null);
expect(processSendSpy).toHaveBeenCalledTimes(1);
expect(processSendSpy).toHaveBeenCalledWith({
type: 'task-completed',
outcome: TaskProcessingOutcome.Processed,
message: null
});
expect(processSendSpy)
.toHaveBeenCalledWith(
{type: 'task-completed', outcome: TaskProcessingOutcome.Processed, message: null});
processSendSpy.calls.reset();
@ -137,7 +135,9 @@ describe('ClusterWorker', () => {
} as unknown as Task;
let err: string|Error;
compileFnSpy.and.callFake(() => { throw err; });
compileFnSpy.and.callFake(() => {
throw err;
});
worker.run();

View File

@ -14,8 +14,8 @@ import {EntryPoint} from '../../src/packages/entry_point';
*
* NOTE 1: The first task for each entry-point generates typings (which is similar to what happens
* in the actual code).
* NOTE 2: The `computeTaskDependencies()` implementation relies on the fact that tasks are sorted in such
* a way that a task can only depend upon earlier tasks (i.e. dependencies always come
* NOTE 2: The `computeTaskDependencies()` implementation relies on the fact that tasks are sorted
* in such a way that a task can only depend upon earlier tasks (i.e. dependencies always come
* before dependents in the list of tasks).
* To preserve this attribute, you need to ensure that entry-points will only depend on
* entry-points with a lower index. Take this into account when defining `entryPointDeps`.
@ -52,7 +52,7 @@ export function createTasksAndGraph(
graph.addNode(entryPoint.path);
for (let tIdx = 0; tIdx < tasksPerEntryPointCount; tIdx++) {
tasks.push({ entryPoint, formatProperty: `prop-${tIdx}`, processDts: tIdx === 0 } as Task);
tasks.push({entryPoint, formatProperty: `prop-${tIdx}`, processDts: tIdx === 0} as Task);
}
}

View File

@ -33,11 +33,13 @@ describe('SingleProcessExecutor', () => {
executor = new SingleProcessExecutorSync(mockLogger, locker, createTaskCompletedCallback);
});
const noTasks = () => ({ allTasksCompleted: true, getNextTask: () => null } as TaskQueue);
const noTasks = () => ({allTasksCompleted: true, getNextTask: () => null} as TaskQueue);
const oneTask = () => {
let tasksCount = 1;
return <TaskQueue>{
get allTasksCompleted() { return tasksCount === 0; },
get allTasksCompleted() {
return tasksCount === 0;
},
getNextTask() {
tasksCount--;
return {};
@ -55,7 +57,9 @@ describe('SingleProcessExecutor', () => {
});
it('should call LockFile.write() and LockFile.remove() if `analyzeEntryPoints` fails', () => {
const errorFn: () => never = () => { throw new Error('analyze error'); };
const errorFn: () => never = () => {
throw new Error('analyze error');
};
const createCompileFn: () => any = () => undefined;
let error: string = '';
try {
@ -68,7 +72,9 @@ describe('SingleProcessExecutor', () => {
});
it('should call LockFile.write() and LockFile.remove() if `createCompileFn` fails', () => {
const createErrorCompileFn: () => any = () => { throw new Error('compile error'); };
const createErrorCompileFn: () => any = () => {
throw new Error('compile error');
};
let error: string = '';
try {
executor.execute(oneTask, createErrorCompileFn);
@ -85,7 +91,9 @@ describe('SingleProcessExecutor', () => {
throw new Error('LockFile.write() error');
});
const analyzeFn: () => any = () => { lockFileLog.push('analyzeFn'); };
const analyzeFn: () => any = () => {
lockFileLog.push('analyzeFn');
};
const anyFn: () => any = () => undefined;
executor = new SingleProcessExecutorSync(mockLogger, locker, createTaskCompletedCallback);
let error = '';

View File

@ -77,9 +77,9 @@ describe('ParallelTaskQueue', () => {
it('should be `true`, when there are no unprocess or in-progress tasks', () => {
const {queue} = createQueue(3);
const task1 = queue.getNextTask() !;
const task2 = queue.getNextTask() !;
const task3 = queue.getNextTask() !;
const task1 = queue.getNextTask()!;
const task2 = queue.getNextTask()!;
const task3 = queue.getNextTask()!;
expect(queue.allTasksCompleted).toBe(false);
queue.markTaskCompleted(task1);
@ -266,8 +266,8 @@ describe('ParallelTaskQueue', () => {
it('should mark a task as completed', () => {
const {queue} = createQueue(2);
const task1 = queue.getNextTask() !;
const task2 = queue.getNextTask() !;
const task1 = queue.getNextTask()!;
const task2 = queue.getNextTask()!;
expect(queue.allTasksCompleted).toBe(false);
queue.markTaskCompleted(task1);
@ -327,7 +327,7 @@ describe('ParallelTaskQueue', () => {
processNextTask(queue2);
processNextTask(queue2);
const task = queue2.getNextTask() !;
const task = queue2.getNextTask()!;
expect(queue2.toString()).toContain(' All tasks completed: false\n');
@ -344,7 +344,7 @@ describe('ParallelTaskQueue', () => {
' - {entryPoint: entry-point-1, formatProperty: prop-0, processDts: true}\n' +
' - {entryPoint: entry-point-2, formatProperty: prop-0, processDts: true}\n');
const task1 = queue.getNextTask() !;
const task1 = queue.getNextTask()!;
expect(queue.toString())
.toContain(
' Unprocessed tasks (2): \n' +
@ -352,7 +352,7 @@ describe('ParallelTaskQueue', () => {
' - {entryPoint: entry-point-2, formatProperty: prop-0, processDts: true}\n');
queue.markTaskCompleted(task1);
const task2 = queue.getNextTask() !;
const task2 = queue.getNextTask()!;
expect(queue.toString())
.toContain(
' Unprocessed tasks (1): \n' +
@ -367,14 +367,14 @@ describe('ParallelTaskQueue', () => {
const {queue} = createQueue(3);
expect(queue.toString()).toContain(' In-progress tasks (0): \n');
const task1 = queue.getNextTask() !;
const task1 = queue.getNextTask()!;
expect(queue.toString())
.toContain(
' In-progress tasks (1): \n' +
' - {entryPoint: entry-point-0, formatProperty: prop-0, processDts: true}\n');
queue.markTaskCompleted(task1);
const task2 = queue.getNextTask() !;
const task2 = queue.getNextTask()!;
expect(queue.toString())
.toContain(
' In-progress tasks (1): \n' +

View File

@ -30,12 +30,10 @@ describe('SerialTaskQueue', () => {
const tasks: PartiallyOrderedTasks = [] as any;
const graph = new DepGraph<EntryPoint>();
for (let i = 0; i < taskCount; i++) {
const entryPoint = {
name: `entry-point-${i}`,
path: `/path/to/entry/point/${i}`
} as EntryPoint;
const entryPoint = {name: `entry-point-${i}`, path: `/path/to/entry/point/${i}`} as
EntryPoint;
tasks.push(
{ entryPoint: entryPoint, formatProperty: `prop-${i}`, processDts: i % 2 === 0 } as Task);
{entryPoint: entryPoint, formatProperty: `prop-${i}`, processDts: i % 2 === 0} as Task);
graph.addNode(entryPoint.path);
}
const dependencies = computeTaskDependencies(tasks, graph);
@ -140,7 +138,7 @@ describe('SerialTaskQueue', () => {
describe('markTaskCompleted()', () => {
it('should mark a task as completed, so that the next task can be picked', () => {
const {queue} = createQueue(3);
const task = queue.getNextTask() !;
const task = queue.getNextTask()!;
expect(() => queue.getNextTask()).toThrow();
@ -174,7 +172,7 @@ describe('SerialTaskQueue', () => {
processNextTask(queue2);
processNextTask(queue2);
const task = queue2.getNextTask() !;
const task = queue2.getNextTask()!;
expect(queue2.toString()).toContain(' All tasks completed: false\n');
@ -191,7 +189,7 @@ describe('SerialTaskQueue', () => {
' - {entryPoint: entry-point-1, formatProperty: prop-1, processDts: false}\n' +
' - {entryPoint: entry-point-2, formatProperty: prop-2, processDts: true}\n');
const task1 = queue.getNextTask() !;
const task1 = queue.getNextTask()!;
expect(queue.toString())
.toContain(
' Unprocessed tasks (2): \n' +
@ -199,7 +197,7 @@ describe('SerialTaskQueue', () => {
' - {entryPoint: entry-point-2, formatProperty: prop-2, processDts: true}\n');
queue.markTaskCompleted(task1);
const task2 = queue.getNextTask() !;
const task2 = queue.getNextTask()!;
expect(queue.toString())
.toContain(
' Unprocessed tasks (1): \n' +
@ -214,14 +212,14 @@ describe('SerialTaskQueue', () => {
const {queue} = createQueue(3);
expect(queue.toString()).toContain(' In-progress tasks (0): ');
const task1 = queue.getNextTask() !;
const task1 = queue.getNextTask()!;
expect(queue.toString())
.toContain(
' In-progress tasks (1): \n' +
' - {entryPoint: entry-point-0, formatProperty: prop-0, processDts: true}');
queue.markTaskCompleted(task1);
const task2 = queue.getNextTask() !;
const task2 = queue.getNextTask()!;
expect(queue.toString())
.toContain(
' In-progress tasks (1): \n' +
@ -253,7 +251,7 @@ describe('SerialTaskQueue', () => {
' In-progress tasks (0): ');
processNextTask(queue2);
const task = queue2.getNextTask() !;
const task = queue2.getNextTask()!;
expect(queue2.toString())
.toBe(
'SerialTaskQueue\n' +

View File

@ -15,10 +15,14 @@ export class MockLockFile implements LockFile {
constructor(
fs: FileSystem, private log: string[] = [], public path = fs.resolve('/lockfile'),
private pid = '1234') {}
write() { this.log.push('write()'); }
write() {
this.log.push('write()');
}
read(): string {
this.log.push('read()');
return this.pid;
}
remove() { this.log.push('remove()'); }
remove() {
this.log.push('remove()');
}
}

View File

@ -6,7 +6,7 @@
* found in the LICENSE file at https://angular.io/license
*/
import {LogLevel, Logger} from '../../src/logging/logger';
import {Logger, LogLevel} from '../../src/logging/logger';
export class MockLogger implements Logger {
constructor(public level = LogLevel.info) {}
@ -17,8 +17,16 @@ export class MockLogger implements Logger {
warn: [],
error: [],
};
debug(...args: string[]) { this.logs.debug.push(args); }
info(...args: string[]) { this.logs.info.push(args); }
warn(...args: string[]) { this.logs.warn.push(args); }
error(...args: string[]) { this.logs.error.push(args); }
debug(...args: string[]) {
this.logs.debug.push(args);
}
info(...args: string[]) {
this.logs.info.push(args);
}
warn(...args: string[]) {
this.logs.warn.push(args);
}
error(...args: string[]) {
this.logs.error.push(args);
}
}

View File

@ -7,7 +7,7 @@
*/
import * as ts from 'typescript';
import {AbsoluteFsPath, NgtscCompilerHost, absoluteFrom, getFileSystem} from '../../../src/ngtsc/file_system';
import {absoluteFrom, AbsoluteFsPath, getFileSystem, NgtscCompilerHost} from '../../../src/ngtsc/file_system';
import {TestFile} from '../../../src/ngtsc/file_system/testing';
import {BundleProgram, makeBundleProgram} from '../../src/packages/bundle_program';
import {NgccEntryPointConfig} from '../../src/packages/configuration';
@ -49,7 +49,12 @@ export function makeTestEntryPointBundle(
return {
entryPoint,
format,
rootDirs: [absoluteFrom('/')], src, dts, isCore, isFlatCore, enableI18nLegacyMessageIdFormat
rootDirs: [absoluteFrom('/')],
src,
dts,
isCore,
isFlatCore,
enableI18nLegacyMessageIdFormat
};
}

View File

@ -6,7 +6,7 @@
* found in the LICENSE file at https://angular.io/license
*/
import {absoluteFrom, getFileSystem} from '../../../src/ngtsc/file_system';
import {TestFile, runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {isNamedVariableDeclaration} from '../../../src/ngtsc/reflection';
import {getDeclaration} from '../../../src/ngtsc/testing';
import {loadFakeCore, loadTestFiles} from '../../../test/helpers';
@ -90,15 +90,15 @@ exports.AliasedDirective$1 = AliasedDirective$1;
const classNode = getDeclaration(
bundle.program, TOPLEVEL_DECORATORS_FILE.name, 'SomeDirective',
isNamedVariableDeclaration);
const decorators = host.getDecoratorsOfDeclaration(classNode) !;
const decorators = host.getDecoratorsOfDeclaration(classNode)!;
expect(decorators.length).toEqual(1);
const decorator = decorators[0];
expect(decorator.name).toEqual('Directive');
expect(decorator.identifier !.getText()).toEqual('core.Directive');
expect(decorator.identifier!.getText()).toEqual('core.Directive');
expect(decorator.import).toEqual({name: 'Directive', from: '@angular/core'});
expect(decorator.args !.map(arg => arg.getText())).toEqual([
expect(decorator.args!.map(arg => arg.getText())).toEqual([
'{ selector: \'[someDirective]\' }',
]);
});
@ -111,15 +111,15 @@ exports.AliasedDirective$1 = AliasedDirective$1;
const classNode = getDeclaration(
bundle.program, TOPLEVEL_DECORATORS_FILE.name, 'AliasedDirective$1',
isNamedVariableDeclaration);
const decorators = host.getDecoratorsOfDeclaration(classNode) !;
const decorators = host.getDecoratorsOfDeclaration(classNode)!;
expect(decorators.length).toEqual(1);
const decorator = decorators[0];
expect(decorator.name).toEqual('Directive');
expect(decorator.identifier !.getText()).toEqual('core.Directive');
expect(decorator.identifier!.getText()).toEqual('core.Directive');
expect(decorator.import).toEqual({name: 'Directive', from: '@angular/core'});
expect(decorator.args !.map(arg => arg.getText())).toEqual([
expect(decorator.args!.map(arg => arg.getText())).toEqual([
'{ selector: \'[someDirective]\' }',
]);
});

View File

@ -9,7 +9,7 @@
import * as ts from 'typescript';
import {absoluteFrom, getFileSystem, getSourceFileOrError} from '../../../src/ngtsc/file_system';
import {TestFile, runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {ClassMemberKind, Import, isNamedVariableDeclaration} from '../../../src/ngtsc/reflection';
import {getDeclaration} from '../../../src/ngtsc/testing';
import {loadFakeCore, loadTestFiles, loadTsLib} from '../../../test/helpers';
@ -168,16 +168,16 @@ runInEachFileSystem(() => {
const classNode = getDeclaration(
bundle.program, _('/some_directive.js'), 'SomeDirective',
isNamedVariableDeclaration);
const decorators = host.getDecoratorsOfDeclaration(classNode) !;
const decorators = host.getDecoratorsOfDeclaration(classNode)!;
expect(decorators).toBeDefined();
expect(decorators.length).toEqual(1);
const decorator = decorators[0];
expect(decorator.name).toEqual('Directive');
expect(decorator.identifier !.getText()).toEqual('Directive');
expect(decorator.identifier!.getText()).toEqual('Directive');
expect(decorator.import).toEqual({name: 'Directive', from: '@angular/core'});
expect(decorator.args !.map(arg => arg.getText())).toEqual([
expect(decorator.args!.map(arg => arg.getText())).toEqual([
'{ selector: \'[someDirective]\' }',
]);
});
@ -189,16 +189,16 @@ runInEachFileSystem(() => {
const classNode = getDeclaration(
bundle.program, _('/some_directive_ctor_parameters.js'), 'SomeDirective',
isNamedVariableDeclaration);
const decorators = host.getDecoratorsOfDeclaration(classNode) !;
const decorators = host.getDecoratorsOfDeclaration(classNode)!;
expect(decorators).toBeDefined();
expect(decorators.length).toEqual(1);
const decorator = decorators[0];
expect(decorator.name).toEqual('Directive');
expect(decorator.identifier !.getText()).toEqual('Directive');
expect(decorator.identifier!.getText()).toEqual('Directive');
expect(decorator.import).toEqual({name: 'Directive', from: '@angular/core'});
expect(decorator.args !.map(arg => arg.getText())).toEqual([
expect(decorator.args!.map(arg => arg.getText())).toEqual([
'{ selector: \'[someDirective]\' }',
]);
});
@ -210,16 +210,16 @@ runInEachFileSystem(() => {
const classNode = getDeclaration(
bundle.program, _('/node_modules/@angular/core/some_directive.js'), 'SomeDirective',
isNamedVariableDeclaration);
const decorators = host.getDecoratorsOfDeclaration(classNode) !;
const decorators = host.getDecoratorsOfDeclaration(classNode)!;
expect(decorators).toBeDefined();
expect(decorators.length).toEqual(1);
const decorator = decorators[0];
expect(decorator.name).toEqual('Directive');
expect(decorator.identifier !.getText()).toEqual('Directive');
expect(decorator.identifier!.getText()).toEqual('Directive');
expect(decorator.import).toEqual({name: 'Directive', from: './directives'});
expect(decorator.args !.map(arg => arg.getText())).toEqual([
expect(decorator.args!.map(arg => arg.getText())).toEqual([
'{ selector: \'[someDirective]\' }',
]);
});
@ -234,15 +234,15 @@ runInEachFileSystem(() => {
isNamedVariableDeclaration);
const members = host.getMembersOfClass(classNode);
const input1 = members.find(member => member.name === 'input1') !;
const input1 = members.find(member => member.name === 'input1')!;
expect(input1.kind).toEqual(ClassMemberKind.Property);
expect(input1.isStatic).toEqual(false);
expect(input1.decorators !.map(d => d.name)).toEqual(['Input']);
expect(input1.decorators!.map(d => d.name)).toEqual(['Input']);
const input2 = members.find(member => member.name === 'input2') !;
const input2 = members.find(member => member.name === 'input2')!;
expect(input2.kind).toEqual(ClassMemberKind.Property);
expect(input2.isStatic).toEqual(false);
expect(input1.decorators !.map(d => d.name)).toEqual(['Input']);
expect(input1.decorators!.map(d => d.name)).toEqual(['Input']);
});
it('should find decorated members on a class when mixing `ctorParameters` and `__decorate`',
@ -254,10 +254,10 @@ runInEachFileSystem(() => {
isNamedVariableDeclaration);
const members = host.getMembersOfClass(classNode);
const input1 = members.find(member => member.name === 'input1') !;
const input1 = members.find(member => member.name === 'input1')!;
expect(input1.kind).toEqual(ClassMemberKind.Property);
expect(input1.isStatic).toEqual(false);
expect(input1.decorators !.map(d => d.name)).toEqual(['Input']);
expect(input1.decorators!.map(d => d.name)).toEqual(['Input']);
});
it('should find non decorated properties on a class', () => {
@ -268,11 +268,11 @@ runInEachFileSystem(() => {
isNamedVariableDeclaration);
const members = host.getMembersOfClass(classNode);
const instanceProperty = members.find(member => member.name === 'instanceProperty') !;
const instanceProperty = members.find(member => member.name === 'instanceProperty')!;
expect(instanceProperty.kind).toEqual(ClassMemberKind.Property);
expect(instanceProperty.isStatic).toEqual(false);
expect(ts.isBinaryExpression(instanceProperty.implementation !)).toEqual(true);
expect(instanceProperty.value !.getText()).toEqual(`'instance'`);
expect(ts.isBinaryExpression(instanceProperty.implementation!)).toEqual(true);
expect(instanceProperty.value!.getText()).toEqual(`'instance'`);
});
it('should find static methods on a class', () => {
@ -283,10 +283,10 @@ runInEachFileSystem(() => {
isNamedVariableDeclaration);
const members = host.getMembersOfClass(classNode);
const staticMethod = members.find(member => member.name === 'staticMethod') !;
const staticMethod = members.find(member => member.name === 'staticMethod')!;
expect(staticMethod.kind).toEqual(ClassMemberKind.Method);
expect(staticMethod.isStatic).toEqual(true);
expect(ts.isMethodDeclaration(staticMethod.implementation !)).toEqual(true);
expect(ts.isMethodDeclaration(staticMethod.implementation!)).toEqual(true);
});
it('should find static properties on a class', () => {
@ -297,11 +297,11 @@ runInEachFileSystem(() => {
isNamedVariableDeclaration);
const members = host.getMembersOfClass(classNode);
const staticProperty = members.find(member => member.name === 'staticProperty') !;
const staticProperty = members.find(member => member.name === 'staticProperty')!;
expect(staticProperty.kind).toEqual(ClassMemberKind.Property);
expect(staticProperty.isStatic).toEqual(true);
expect(ts.isPropertyAccessExpression(staticProperty.implementation !)).toEqual(true);
expect(staticProperty.value !.getText()).toEqual(`'static'`);
expect(ts.isPropertyAccessExpression(staticProperty.implementation!)).toEqual(true);
expect(staticProperty.value!.getText()).toEqual(`'static'`);
});
it('should find static properties on a class that has an intermediate variable assignment',
@ -313,11 +313,11 @@ runInEachFileSystem(() => {
isNamedVariableDeclaration);
const members = host.getMembersOfClass(classNode);
const staticProperty = members.find(member => member.name === 'staticProperty') !;
const staticProperty = members.find(member => member.name === 'staticProperty')!;
expect(staticProperty.kind).toEqual(ClassMemberKind.Property);
expect(staticProperty.isStatic).toEqual(true);
expect(ts.isPropertyAccessExpression(staticProperty.implementation !)).toEqual(true);
expect(staticProperty.value !.getText()).toEqual(`'static'`);
expect(ts.isPropertyAccessExpression(staticProperty.implementation!)).toEqual(true);
expect(staticProperty.value!.getText()).toEqual(`'static'`);
});
it('should support decorators being used inside @angular/core', () => {
@ -329,10 +329,10 @@ runInEachFileSystem(() => {
isNamedVariableDeclaration);
const members = host.getMembersOfClass(classNode);
const input1 = members.find(member => member.name === 'input1') !;
const input1 = members.find(member => member.name === 'input1')!;
expect(input1.kind).toEqual(ClassMemberKind.Property);
expect(input1.isStatic).toEqual(false);
expect(input1.decorators !.map(d => d.name)).toEqual(['Input']);
expect(input1.decorators!.map(d => d.name)).toEqual(['Input']);
});
});
@ -346,10 +346,10 @@ runInEachFileSystem(() => {
const parameters = host.getConstructorParameters(classNode);
expect(parameters).toBeDefined();
expect(parameters !.map(parameter => parameter.name)).toEqual([
expect(parameters!.map(parameter => parameter.name)).toEqual([
'_viewContainer', '_template', 'injected'
]);
expectTypeValueReferencesForParameters(parameters !, [
expectTypeValueReferencesForParameters(parameters!, [
'ViewContainerRef',
'TemplateRef',
'String',
@ -366,20 +366,20 @@ runInEachFileSystem(() => {
const parameters = host.getConstructorParameters(classNode);
expect(parameters).toBeDefined();
expect(parameters !.map(parameter => parameter.name)).toEqual([
expect(parameters!.map(parameter => parameter.name)).toEqual([
'_viewContainer', '_template', 'injected'
]);
expectTypeValueReferencesForParameters(parameters !, [
expectTypeValueReferencesForParameters(parameters!, [
'ViewContainerRef',
'TemplateRef',
null,
]);
const decorators = parameters ![2].decorators !;
const decorators = parameters![2].decorators!;
expect(decorators.length).toEqual(1);
expect(decorators[0].name).toBe('Inject');
expect(decorators[0].import !.from).toBe('@angular/core');
expect(decorators[0].import !.name).toBe('Inject');
expect(decorators[0].import!.from).toBe('@angular/core');
expect(decorators[0].import!.name).toBe('Inject');
});
});
@ -390,8 +390,8 @@ runInEachFileSystem(() => {
const classNode = getDeclaration(
bundle.program, _('/some_directive.js'), 'SomeDirective',
isNamedVariableDeclaration);
const ctrDecorators = host.getConstructorParameters(classNode) !;
const identifierOfViewContainerRef = (ctrDecorators[0].typeValueReference !as{
const ctrDecorators = host.getConstructorParameters(classNode)!;
const identifierOfViewContainerRef = (ctrDecorators[0].typeValueReference! as {
local: true,
expression: ts.Identifier,
defaultImportStatement: null,
@ -401,8 +401,8 @@ runInEachFileSystem(() => {
bundle.program, _('/some_directive.js'), 'ViewContainerRef', ts.isClassDeclaration);
const actualDeclaration = host.getDeclarationOfIdentifier(identifierOfViewContainerRef);
expect(actualDeclaration).not.toBe(null);
expect(actualDeclaration !.node).toBe(expectedDeclarationNode);
expect(actualDeclaration !.viaModule).toBe(null);
expect(actualDeclaration!.node).toBe(expectedDeclarationNode);
expect(actualDeclaration!.viaModule).toBe(null);
});
it('should return the declaration of an externally defined identifier', () => {
@ -411,8 +411,8 @@ runInEachFileSystem(() => {
const classNode = getDeclaration(
bundle.program, _('/some_directive.js'), 'SomeDirective',
isNamedVariableDeclaration);
const classDecorators = host.getDecoratorsOfDeclaration(classNode) !;
const decoratorNode = classDecorators[0].node !;
const classDecorators = host.getDecoratorsOfDeclaration(classNode)!;
const decoratorNode = classDecorators[0].node!;
const identifierOfDirective =
ts.isCallExpression(decoratorNode) && ts.isIdentifier(decoratorNode.expression) ?
decoratorNode.expression :
@ -421,10 +421,10 @@ runInEachFileSystem(() => {
const expectedDeclarationNode = getDeclaration(
bundle.program, _('/node_modules/@angular/core/index.d.ts'), 'Directive',
isNamedVariableDeclaration);
const actualDeclaration = host.getDeclarationOfIdentifier(identifierOfDirective !);
const actualDeclaration = host.getDeclarationOfIdentifier(identifierOfDirective!);
expect(actualDeclaration).not.toBe(null);
expect(actualDeclaration !.node).toBe(expectedDeclarationNode);
expect(actualDeclaration !.viaModule).toBe('@angular/core');
expect(actualDeclaration!.node).toBe(expectedDeclarationNode);
expect(actualDeclaration!.viaModule).toBe('@angular/core');
});
});
@ -435,13 +435,13 @@ runInEachFileSystem(() => {
const ngModuleRef = findVariableDeclaration(
getSourceFileOrError(bundle.program, _('/ngmodule.js')), 'HttpClientXsrfModule_1');
const value = host.getVariableValue(ngModuleRef !);
const value = host.getVariableValue(ngModuleRef!);
expect(value).not.toBe(null);
if (!value || !ts.isClassExpression(value)) {
throw new Error(
`Expected value to be a class expression: ${value && value.getText()}.`);
}
expect(value.name !.text).toBe('HttpClientXsrfModule');
expect(value.name!.text).toBe('HttpClientXsrfModule');
});
it('should return null if the variable has no assignment', () => {
@ -449,7 +449,7 @@ runInEachFileSystem(() => {
const host = new Esm2015ReflectionHost(new MockLogger(), false, bundle);
const missingValue = findVariableDeclaration(
getSourceFileOrError(bundle.program, _('/ngmodule.js')), 'missingValue');
const value = host.getVariableValue(missingValue !);
const value = host.getVariableValue(missingValue!);
expect(value).toBe(null);
});
@ -458,7 +458,7 @@ runInEachFileSystem(() => {
const host = new Esm2015ReflectionHost(new MockLogger(), false, bundle);
const nonDecoratedVar = findVariableDeclaration(
getSourceFileOrError(bundle.program, _('/ngmodule.js')), 'nonDecoratedVar');
const value = host.getVariableValue(nonDecoratedVar !);
const value = host.getVariableValue(nonDecoratedVar!);
expect(value).toBe(null);
});
});
@ -468,7 +468,7 @@ runInEachFileSystem(() => {
const bundle = makeTestBundleProgram(_('/ngmodule.js'));
const host = new Esm2015ReflectionHost(new MockLogger(), false, bundle);
const classSymbol =
host.findClassSymbols(bundle.program.getSourceFile(_('/ngmodule.js')) !)[0];
host.findClassSymbols(bundle.program.getSourceFile(_('/ngmodule.js'))!)[0];
const endOfClass = host.getEndOfClass(classSymbol);
expect(endOfClass.getText())
.toMatch(
@ -479,7 +479,7 @@ runInEachFileSystem(() => {
});
function findVariableDeclaration(
node: ts.Node | undefined, variableName: string): ts.VariableDeclaration|undefined {
node: ts.Node|undefined, variableName: string): ts.VariableDeclaration|undefined {
if (!node) {
return;
}

View File

@ -8,7 +8,7 @@
import * as ts from 'typescript';
import {absoluteFrom, getFileSystem, getSourceFileOrError} from '../../../src/ngtsc/file_system';
import {TestFile, runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {ClassMemberKind, isNamedFunctionDeclaration, isNamedVariableDeclaration} from '../../../src/ngtsc/reflection';
import {getDeclaration} from '../../../src/ngtsc/testing';
import {loadFakeCore, loadTestFiles, loadTsLib} from '../../../test/helpers';
@ -227,19 +227,18 @@ export { AliasedDirective$1 };
const classNode = getDeclaration(
bundle.program, _('/some_directive.js'), 'SomeDirective',
isNamedVariableDeclaration);
const decorators = host.getDecoratorsOfDeclaration(classNode) !;
const decorators = host.getDecoratorsOfDeclaration(classNode)!;
expect(decorators).toBeDefined();
expect(decorators.length).toEqual(1);
const decorator = decorators[0];
expect(decorator.name).toEqual('Directive');
expect(decorator.identifier !.getText()).toEqual('Directive');
expect(decorator.identifier!.getText()).toEqual('Directive');
expect(decorator.import).toEqual({name: 'Directive', from: '@angular/core'});
expect(decorator.args !.map(arg => arg.getText())).toEqual([
expect(decorator.args!.map(arg => arg.getText())).toEqual([
'{ selector: \'[someDirective]\' }',
]);
});
it('should find the decorators on a minified class', () => {
@ -248,19 +247,18 @@ export { AliasedDirective$1 };
const classNode = getDeclaration(
bundle.program, _('/some_minified_directive.js'), 'SomeDirective',
isNamedVariableDeclaration);
const decorators = host.getDecoratorsOfDeclaration(classNode) !;
const decorators = host.getDecoratorsOfDeclaration(classNode)!;
expect(decorators).toBeDefined();
expect(decorators.length).toEqual(1);
const decorator = decorators[0];
expect(decorator.name).toEqual('Directive');
expect(decorator.identifier !.getText()).toEqual('Directive');
expect(decorator.identifier!.getText()).toEqual('Directive');
expect(decorator.import).toEqual({name: 'Directive', from: '@angular/core'});
expect(decorator.args !.map(arg => arg.getText())).toEqual([
expect(decorator.args!.map(arg => arg.getText())).toEqual([
'{ selector: \'[someDirective]\' }',
]);
});
it('should find the decorators on an aliased class', () => {
@ -269,16 +267,16 @@ export { AliasedDirective$1 };
const classNode = getDeclaration(
bundle.program, _('/some_aliased_directive.js'), 'AliasedDirective$1',
isNamedVariableDeclaration);
const decorators = host.getDecoratorsOfDeclaration(classNode) !;
const decorators = host.getDecoratorsOfDeclaration(classNode)!;
expect(decorators).toBeDefined();
expect(decorators.length).toEqual(1);
const decorator = decorators[0];
expect(decorator.name).toEqual('Directive');
expect(decorator.identifier !.getText()).toEqual('Directive');
expect(decorator.identifier!.getText()).toEqual('Directive');
expect(decorator.import).toEqual({name: 'Directive', from: '@angular/core'});
expect(decorator.args !.map(arg => arg.getText())).toEqual([
expect(decorator.args!.map(arg => arg.getText())).toEqual([
'{ selector: \'[someDirective]\' }',
]);
});
@ -290,16 +288,16 @@ export { AliasedDirective$1 };
const classNode = getDeclaration(
bundle.program, _('/some_directive_ctor_parameters.js'), 'SomeDirective',
isNamedVariableDeclaration);
const decorators = host.getDecoratorsOfDeclaration(classNode) !;
const decorators = host.getDecoratorsOfDeclaration(classNode)!;
expect(decorators).toBeDefined();
expect(decorators.length).toEqual(1);
const decorator = decorators[0];
expect(decorator.name).toEqual('Directive');
expect(decorator.identifier !.getText()).toEqual('Directive');
expect(decorator.identifier!.getText()).toEqual('Directive');
expect(decorator.import).toEqual({name: 'Directive', from: '@angular/core'});
expect(decorator.args !.map(arg => arg.getText())).toEqual([
expect(decorator.args!.map(arg => arg.getText())).toEqual([
'{ selector: \'[someDirective]\' }',
]);
});
@ -311,16 +309,16 @@ export { AliasedDirective$1 };
const classNode = getDeclaration(
bundle.program, _('/node_modules/@angular/core/some_directive.js'), 'SomeDirective',
isNamedVariableDeclaration);
const decorators = host.getDecoratorsOfDeclaration(classNode) !;
const decorators = host.getDecoratorsOfDeclaration(classNode)!;
expect(decorators).toBeDefined();
expect(decorators.length).toEqual(1);
const decorator = decorators[0];
expect(decorator.name).toEqual('Directive');
expect(decorator.identifier !.getText()).toEqual('Directive');
expect(decorator.identifier!.getText()).toEqual('Directive');
expect(decorator.import).toEqual({name: 'Directive', from: './directives'});
expect(decorator.args !.map(arg => arg.getText())).toEqual([
expect(decorator.args!.map(arg => arg.getText())).toEqual([
'{ selector: \'[someDirective]\' }',
]);
});
@ -333,13 +331,12 @@ export { AliasedDirective$1 };
const classNode = getDeclaration(
bundle.program, _('/some_minified_directive.js'), 'SomeDirective',
isNamedVariableDeclaration);
const innerNode =
getIifeBody(classNode) !.statements.find(isNamedFunctionDeclaration) !;
const innerNode = getIifeBody(classNode)!.statements.find(isNamedFunctionDeclaration)!;
const classSymbol = host.getClassSymbol(classNode);
expect(classSymbol).toBeDefined();
expect(classSymbol !.declaration.valueDeclaration).toBe(classNode);
expect(classSymbol !.implementation.valueDeclaration).toBe(innerNode);
expect(classSymbol!.declaration.valueDeclaration).toBe(classNode);
expect(classSymbol!.implementation.valueDeclaration).toBe(innerNode);
});
});
@ -352,15 +349,15 @@ export { AliasedDirective$1 };
isNamedVariableDeclaration);
const members = host.getMembersOfClass(classNode);
const input1 = members.find(member => member.name === 'input1') !;
const input1 = members.find(member => member.name === 'input1')!;
expect(input1.kind).toEqual(ClassMemberKind.Property);
expect(input1.isStatic).toEqual(false);
expect(input1.decorators !.map(d => d.name)).toEqual(['Input']);
expect(input1.decorators!.map(d => d.name)).toEqual(['Input']);
const input2 = members.find(member => member.name === 'input2') !;
const input2 = members.find(member => member.name === 'input2')!;
expect(input2.kind).toEqual(ClassMemberKind.Property);
expect(input2.isStatic).toEqual(false);
expect(input1.decorators !.map(d => d.name)).toEqual(['Input']);
expect(input1.decorators!.map(d => d.name)).toEqual(['Input']);
});
it('should find decorated members on a class when mixing `ctorParameters` and `__decorate`',
@ -372,10 +369,10 @@ export { AliasedDirective$1 };
isNamedVariableDeclaration);
const members = host.getMembersOfClass(classNode);
const input1 = members.find(member => member.name === 'input1') !;
const input1 = members.find(member => member.name === 'input1')!;
expect(input1.kind).toEqual(ClassMemberKind.Property);
expect(input1.isStatic).toEqual(false);
expect(input1.decorators !.map(d => d.name)).toEqual(['Input']);
expect(input1.decorators!.map(d => d.name)).toEqual(['Input']);
});
it('should find non decorated properties on a class', () => {
@ -386,11 +383,11 @@ export { AliasedDirective$1 };
isNamedVariableDeclaration);
const members = host.getMembersOfClass(classNode);
const instanceProperty = members.find(member => member.name === 'instanceProperty') !;
const instanceProperty = members.find(member => member.name === 'instanceProperty')!;
expect(instanceProperty.kind).toEqual(ClassMemberKind.Property);
expect(instanceProperty.isStatic).toEqual(false);
expect(ts.isBinaryExpression(instanceProperty.implementation !)).toEqual(true);
expect(instanceProperty.value !.getText()).toEqual(`'instance'`);
expect(ts.isBinaryExpression(instanceProperty.implementation!)).toEqual(true);
expect(instanceProperty.value!.getText()).toEqual(`'instance'`);
});
it('should find static methods on a class', () => {
@ -401,10 +398,10 @@ export { AliasedDirective$1 };
isNamedVariableDeclaration);
const members = host.getMembersOfClass(classNode);
const staticMethod = members.find(member => member.name === 'staticMethod') !;
const staticMethod = members.find(member => member.name === 'staticMethod')!;
expect(staticMethod.kind).toEqual(ClassMemberKind.Method);
expect(staticMethod.isStatic).toEqual(true);
expect(ts.isFunctionExpression(staticMethod.implementation !)).toEqual(true);
expect(ts.isFunctionExpression(staticMethod.implementation!)).toEqual(true);
});
it('should find static properties on a class', () => {
@ -415,11 +412,11 @@ export { AliasedDirective$1 };
isNamedVariableDeclaration);
const members = host.getMembersOfClass(classNode);
const staticProperty = members.find(member => member.name === 'staticProperty') !;
const staticProperty = members.find(member => member.name === 'staticProperty')!;
expect(staticProperty.kind).toEqual(ClassMemberKind.Property);
expect(staticProperty.isStatic).toEqual(true);
expect(ts.isPropertyAccessExpression(staticProperty.implementation !)).toEqual(true);
expect(staticProperty.value !.getText()).toEqual(`'static'`);
expect(ts.isPropertyAccessExpression(staticProperty.implementation!)).toEqual(true);
expect(staticProperty.value!.getText()).toEqual(`'static'`);
});
it('should support decorators being used inside @angular/core', () => {
@ -431,10 +428,10 @@ export { AliasedDirective$1 };
isNamedVariableDeclaration);
const members = host.getMembersOfClass(classNode);
const input1 = members.find(member => member.name === 'input1') !;
const input1 = members.find(member => member.name === 'input1')!;
expect(input1.kind).toEqual(ClassMemberKind.Property);
expect(input1.isStatic).toEqual(false);
expect(input1.decorators !.map(d => d.name)).toEqual(['Input']);
expect(input1.decorators!.map(d => d.name)).toEqual(['Input']);
});
});
describe('getConstructorParameters', () => {
@ -447,10 +444,10 @@ export { AliasedDirective$1 };
const parameters = host.getConstructorParameters(classNode);
expect(parameters).toBeDefined();
expect(parameters !.map(parameter => parameter.name)).toEqual([
expect(parameters!.map(parameter => parameter.name)).toEqual([
'_viewContainer', '_template', 'injected'
]);
expectTypeValueReferencesForParameters(parameters !, [
expectTypeValueReferencesForParameters(parameters!, [
'ViewContainerRef',
'TemplateRef',
'String',
@ -467,10 +464,10 @@ export { AliasedDirective$1 };
const parameters = host.getConstructorParameters(classNode);
expect(parameters).toBeDefined();
expect(parameters !.map(parameter => parameter.name)).toEqual([
expect(parameters!.map(parameter => parameter.name)).toEqual([
'_viewContainer', '_template', 'injected'
]);
expectTypeValueReferencesForParameters(parameters !, [
expectTypeValueReferencesForParameters(parameters!, [
'ViewContainerRef',
'TemplateRef',
null,
@ -485,7 +482,7 @@ export { AliasedDirective$1 };
bundle.program, _('/some_directive.js'), 'SomeDirective',
isNamedVariableDeclaration);
const parameters = host.getConstructorParameters(classNode);
const decorators = parameters ![2].decorators !;
const decorators = parameters![2].decorators!;
expect(decorators.length).toEqual(1);
expect(decorators[0].import).toEqual({name: 'Inject', from: '@angular/core'});
@ -522,7 +519,7 @@ export { AliasedDirective$1 };
const ngModuleDecorators = ngModuleClasses.map(s => host.getDecoratorsOfSymbol(s));
expect(ngModuleClasses.length).toEqual(1);
expect(ngModuleDecorators[0] !.map(d => d.name)).toEqual(['NgModule']);
expect(ngModuleDecorators[0]!.map(d => d.name)).toEqual(['NgModule']);
const someDirectiveFile = getSourceFileOrError(bundle.program, _('/some_directive.js'));
const someDirectiveClasses = host.findClassSymbols(someDirectiveFile);
@ -532,7 +529,7 @@ export { AliasedDirective$1 };
expect(someDirectiveDecorators.length).toEqual(3);
expect(someDirectiveDecorators[0]).toBe(null);
expect(someDirectiveDecorators[1]).toBe(null);
expect(someDirectiveDecorators[2] !.map(d => d.name)).toEqual(['Directive']);
expect(someDirectiveDecorators[2]!.map(d => d.name)).toEqual(['Directive']);
});
});
@ -543,8 +540,8 @@ export { AliasedDirective$1 };
const classNode = getDeclaration(
bundle.program, _('/some_directive.js'), 'SomeDirective',
isNamedVariableDeclaration);
const ctrDecorators = host.getConstructorParameters(classNode) !;
const identifierOfViewContainerRef = (ctrDecorators[0].typeValueReference !as{
const ctrDecorators = host.getConstructorParameters(classNode)!;
const identifierOfViewContainerRef = (ctrDecorators[0].typeValueReference! as {
local: true,
expression: ts.Identifier,
defaultImportStatement: null,
@ -555,8 +552,8 @@ export { AliasedDirective$1 };
isNamedVariableDeclaration);
const actualDeclaration = host.getDeclarationOfIdentifier(identifierOfViewContainerRef);
expect(actualDeclaration).not.toBe(null);
expect(actualDeclaration !.node).toBe(expectedDeclarationNode);
expect(actualDeclaration !.viaModule).toBe(null);
expect(actualDeclaration!.node).toBe(expectedDeclarationNode);
expect(actualDeclaration!.viaModule).toBe(null);
});
it('should return the declaration of an externally defined identifier', () => {
@ -565,8 +562,8 @@ export { AliasedDirective$1 };
const classNode = getDeclaration(
bundle.program, _('/some_directive.js'), 'SomeDirective',
isNamedVariableDeclaration);
const classDecorators = host.getDecoratorsOfDeclaration(classNode) !;
const decoratorNode = classDecorators[0].node !;
const classDecorators = host.getDecoratorsOfDeclaration(classNode)!;
const decoratorNode = classDecorators[0].node!;
const identifierOfDirective =
ts.isCallExpression(decoratorNode) && ts.isIdentifier(decoratorNode.expression) ?
@ -576,10 +573,10 @@ export { AliasedDirective$1 };
const expectedDeclarationNode = getDeclaration(
bundle.program, _('/node_modules/@angular/core/index.d.ts'), 'Directive',
isNamedVariableDeclaration);
const actualDeclaration = host.getDeclarationOfIdentifier(identifierOfDirective !);
const actualDeclaration = host.getDeclarationOfIdentifier(identifierOfDirective!);
expect(actualDeclaration).not.toBe(null);
expect(actualDeclaration !.node).toBe(expectedDeclarationNode);
expect(actualDeclaration !.viaModule).toBe('@angular/core');
expect(actualDeclaration!.node).toBe(expectedDeclarationNode);
expect(actualDeclaration!.viaModule).toBe('@angular/core');
});
it('should find the "actual" declaration of an aliased variable identifier', () => {
@ -589,9 +586,9 @@ export { AliasedDirective$1 };
getSourceFileOrError(bundle.program, _('/ngmodule.js')), 'HttpClientXsrfModule_1',
isNgModulePropertyAssignment);
const declaration = host.getDeclarationOfIdentifier(ngModuleRef !);
const declaration = host.getDeclarationOfIdentifier(ngModuleRef!);
expect(declaration).not.toBe(null);
expect(declaration !.node !.getText()).toContain('function HttpClientXsrfModule()');
expect(declaration!.node!.getText()).toContain('function HttpClientXsrfModule()');
});
});
describe('getVariableValue', () => {
@ -601,7 +598,7 @@ export { AliasedDirective$1 };
const ngModuleRef = findVariableDeclaration(
getSourceFileOrError(bundle.program, _('/ngmodule.js')), 'HttpClientXsrfModule_1');
const value = host.getVariableValue(ngModuleRef !);
const value = host.getVariableValue(ngModuleRef!);
expect(value).not.toBe(null);
if (!value || !ts.isFunctionDeclaration(value.parent)) {
throw new Error(
@ -615,7 +612,7 @@ export { AliasedDirective$1 };
const host = new Esm5ReflectionHost(new MockLogger(), false, bundle);
const missingValue = findVariableDeclaration(
getSourceFileOrError(bundle.program, _('/ngmodule.js')), 'missingValue');
const value = host.getVariableValue(missingValue !);
const value = host.getVariableValue(missingValue!);
expect(value).toBe(null);
});
@ -624,7 +621,7 @@ export { AliasedDirective$1 };
const host = new Esm5ReflectionHost(new MockLogger(), false, bundle);
const nonDecoratedVar = findVariableDeclaration(
getSourceFileOrError(bundle.program, _('/ngmodule.js')), 'nonDecoratedVar');
const value = host.getVariableValue(nonDecoratedVar !);
const value = host.getVariableValue(nonDecoratedVar!);
expect(value).toBe(null);
});
});
@ -634,7 +631,7 @@ export { AliasedDirective$1 };
const bundle = makeTestBundleProgram(_('/ngmodule.js'));
const host = new Esm5ReflectionHost(new MockLogger(), false, bundle);
const classSymbol =
host.findClassSymbols(bundle.program.getSourceFile(_('/ngmodule.js')) !)[0];
host.findClassSymbols(bundle.program.getSourceFile(_('/ngmodule.js'))!)[0];
const endOfClass = host.getEndOfClass(classSymbol);
expect(endOfClass.getText())
.toMatch(
@ -644,7 +641,7 @@ export { AliasedDirective$1 };
});
function findVariableDeclaration(
node: ts.Node | undefined, variableName: string): ts.VariableDeclaration|undefined {
node: ts.Node|undefined, variableName: string): ts.VariableDeclaration|undefined {
if (!node) {
return;
}
@ -656,7 +653,7 @@ export { AliasedDirective$1 };
});
function findIdentifier(
node: ts.Node | undefined, identifierName: string,
node: ts.Node|undefined, identifierName: string,
requireFn: (node: ts.Identifier) => boolean): ts.Identifier|undefined {
if (!node) {
return undefined;

View File

@ -7,7 +7,7 @@
*/
import {absoluteFrom} from '../../../src/ngtsc/file_system';
import {TestFile, runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {ClassMemberKind, isNamedVariableDeclaration} from '../../../src/ngtsc/reflection';
import {getDeclaration} from '../../../src/ngtsc/testing';
import {loadTestFiles} from '../../../test/helpers';
@ -81,16 +81,16 @@ runInEachFileSystem(() => {
const host = new UmdReflectionHost(new MockLogger(), false, bundle);
const classNode = getDeclaration(
bundle.program, SOME_DIRECTIVE_FILE.name, 'SomeDirective', isNamedVariableDeclaration);
const decorators = host.getDecoratorsOfDeclaration(classNode) !;
const decorators = host.getDecoratorsOfDeclaration(classNode)!;
expect(decorators).toBeDefined();
expect(decorators.length).toEqual(1);
const decorator = decorators[0];
expect(decorator.name).toEqual('Directive');
expect(decorator.identifier !.getText()).toEqual('core.Directive');
expect(decorator.identifier!.getText()).toEqual('core.Directive');
expect(decorator.import).toEqual({name: 'Directive', from: '@angular/core'});
expect(decorator.args !.map(arg => arg.getText())).toEqual([
expect(decorator.args!.map(arg => arg.getText())).toEqual([
'{ selector: \'[someDirective]\' }',
]);
});
@ -102,16 +102,16 @@ runInEachFileSystem(() => {
const classNode = getDeclaration(
bundle.program, SOME_DIRECTIVE_FILE.name, 'AliasedDirective$1',
isNamedVariableDeclaration);
const decorators = host.getDecoratorsOfDeclaration(classNode) !;
const decorators = host.getDecoratorsOfDeclaration(classNode)!;
expect(decorators).toBeDefined();
expect(decorators.length).toEqual(1);
const decorator = decorators[0];
expect(decorator.name).toEqual('Directive');
expect(decorator.identifier !.getText()).toEqual('core.Directive');
expect(decorator.identifier!.getText()).toEqual('core.Directive');
expect(decorator.import).toEqual({name: 'Directive', from: '@angular/core'});
expect(decorator.args !.map(arg => arg.getText())).toEqual([
expect(decorator.args!.map(arg => arg.getText())).toEqual([
'{ selector: \'[someDirective]\' }',
]);
});
@ -126,15 +126,15 @@ runInEachFileSystem(() => {
bundle.program, SOME_DIRECTIVE_FILE.name, 'SomeDirective', isNamedVariableDeclaration);
const members = host.getMembersOfClass(classNode);
const input1 = members.find(member => member.name === 'input1') !;
const input1 = members.find(member => member.name === 'input1')!;
expect(input1.kind).toEqual(ClassMemberKind.Property);
expect(input1.isStatic).toEqual(false);
expect(input1.decorators !.map(d => d.name)).toEqual(['Input']);
expect(input1.decorators!.map(d => d.name)).toEqual(['Input']);
const input2 = members.find(member => member.name === 'input2') !;
const input2 = members.find(member => member.name === 'input2')!;
expect(input2.kind).toEqual(ClassMemberKind.Property);
expect(input2.isStatic).toEqual(false);
expect(input1.decorators !.map(d => d.name)).toEqual(['Input']);
expect(input1.decorators!.map(d => d.name)).toEqual(['Input']);
});
describe('getConstructorParameters', () => {
@ -148,10 +148,10 @@ runInEachFileSystem(() => {
const parameters = host.getConstructorParameters(classNode);
expect(parameters).toBeDefined();
expect(parameters !.map(parameter => parameter.name)).toEqual([
expect(parameters!.map(parameter => parameter.name)).toEqual([
'_viewContainer', '_template', 'injected'
]);
expectTypeValueReferencesForParameters(parameters !, [
expectTypeValueReferencesForParameters(parameters!, [
'ViewContainerRef',
'TemplateRef',
null,

View File

@ -14,9 +14,8 @@ import {CtorParameter} from '../../../src/ngtsc/reflection';
* names.
*/
export function expectTypeValueReferencesForParameters(
parameters: CtorParameter[], expectedParams: (string | null)[],
fromModule: string | null = null) {
parameters !.forEach((param, idx) => {
parameters: CtorParameter[], expectedParams: (string|null)[], fromModule: string|null = null) {
parameters!.forEach((param, idx) => {
const expected = expectedParams[idx];
if (expected !== null) {
if (param.typeValueReference === null) {
@ -32,7 +31,7 @@ export function expectTypeValueReferencesForParameters(
expect(param.typeValueReference.expression.text).toEqual(expected);
}
} else if (param.typeValueReference !== null) {
expect(param.typeValueReference.moduleName).toBe(fromModule !);
expect(param.typeValueReference.moduleName).toBe(fromModule!);
expect(param.typeValueReference.name).toBe(expected);
}
}

View File

@ -8,8 +8,9 @@
/// <reference types="node" />
import * as os from 'os';
import {AbsoluteFsPath, FileSystem, absoluteFrom, getFileSystem, join} from '../../../src/ngtsc/file_system';
import {Folder, MockFileSystem, TestFile, runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {absoluteFrom, AbsoluteFsPath, FileSystem, getFileSystem, join} from '../../../src/ngtsc/file_system';
import {Folder, MockFileSystem, runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {loadStandardTestFiles, loadTestFiles} from '../../../test/helpers';
import {getLockFilePath} from '../../src/locking/lock_file';
import {mainNgcc} from '../../src/main';
@ -19,6 +20,7 @@ import {EntryPointManifestFile} from '../../src/packages/entry_point_manifest';
import {Transformer} from '../../src/packages/transformer';
import {DirectPackageJsonUpdater, PackageJsonUpdater} from '../../src/writing/package_json_updater';
import {MockLogger} from '../helpers/mock_logger';
import {compileIntoApf, compileIntoFlatEs5Package} from './util';
const testFiles = loadStandardTestFiles({fakeCore: false, rxjs: true});
@ -145,7 +147,8 @@ runInEachFileSystem(() => {
});
['esm5', 'esm2015'].forEach(target => {
it(`should be able to process spread operator inside objects for ${target} format (imported helpers)`,
it(`should be able to process spread operator inside objects for ${
target} format (imported helpers)`,
() => {
compileIntoApf(
'test-package', {
@ -184,7 +187,8 @@ runInEachFileSystem(() => {
expect(jsContents).toContain('ngcc0.ɵɵclassProp("a", true)("b", true)("c", false)');
});
it(`should be able to process emitted spread operator inside objects for ${target} format (emitted helpers)`,
it(`should be able to process emitted spread operator inside objects for ${
target} format (emitted helpers)`,
() => {
compileIntoApf(
'test-package', {
@ -326,7 +330,7 @@ runInEachFileSystem(() => {
});
const before = fs.readFile(_(`/node_modules/test-package/index.js`));
const originalProp = /ɵprov[^;]+/.exec(before) ![0];
const originalProp = /ɵprov[^;]+/.exec(before)![0];
mainNgcc({
basePath: '/node_modules',
targetEntryPointPath: 'test-package',
@ -496,7 +500,7 @@ runInEachFileSystem(() => {
});
describe('in async mode', () => {
it('should run ngcc without errors for fesm2015', async() => {
it('should run ngcc without errors for fesm2015', async () => {
const promise = mainNgcc({
basePath: '/node_modules',
propertiesToConsider: ['fesm2015'],
@ -507,7 +511,7 @@ runInEachFileSystem(() => {
await promise;
});
it('should reject, if some of the entry-points are unprocessable', async() => {
it('should reject, if some of the entry-points are unprocessable', async () => {
const createEntryPoint = (name: string, prop: EntryPointJsonProperty): TestFile[] => {
return [
{
@ -541,7 +545,7 @@ runInEachFileSystem(() => {
` - ${_('/dist/unprocessable-3')}`)));
});
it('should reject, if an error happens during processing', async() => {
it('should reject, if an error happens during processing', async () => {
spyOn(Transformer.prototype, 'transform').and.throwError('Test error.');
const promise = mainNgcc({
@ -651,7 +655,8 @@ runInEachFileSystem(() => {
markPropertiesAsProcessed('@angular/common/http/testing', SUPPORTED_FORMAT_PROPERTIES);
mainNgcc({
basePath: '/node_modules',
targetEntryPointPath: '@angular/common/http/testing', logger,
targetEntryPointPath: '@angular/common/http/testing',
logger,
});
expect(logger.logs.debug).toContain([
'The target entry-point has already been processed'
@ -665,7 +670,8 @@ runInEachFileSystem(() => {
mainNgcc({
basePath: '/node_modules',
targetEntryPointPath: '@angular/common/http/testing',
propertiesToConsider: ['fesm2015', 'esm5', 'esm2015'], logger,
propertiesToConsider: ['fesm2015', 'esm5', 'esm2015'],
logger,
});
expect(logger.logs.debug).not.toContain([
'The target entry-point has already been processed'
@ -682,7 +688,8 @@ runInEachFileSystem(() => {
basePath: '/node_modules',
targetEntryPointPath: '@angular/common/http/testing',
propertiesToConsider: ['esm5', 'esm2015'],
compileAllFormats: false, logger,
compileAllFormats: false,
logger,
});
expect(logger.logs.debug).not.toContain([
@ -699,7 +706,8 @@ runInEachFileSystem(() => {
targetEntryPointPath: '@angular/common/http/testing',
// Simulate a property that does not exist on the package.json and will be ignored.
propertiesToConsider: ['missing', 'esm2015', 'esm5'],
compileAllFormats: false, logger,
compileAllFormats: false,
logger,
});
expect(logger.logs.debug).toContain([
@ -717,7 +725,8 @@ runInEachFileSystem(() => {
targetEntryPointPath: '@angular/common/http/testing',
// Simulate a property that does not exist on the package.json and will be ignored.
propertiesToConsider: ['missing', 'esm2015', 'esm5'],
compileAllFormats: false, logger,
compileAllFormats: false,
logger,
});
expect(logger.logs.debug).toContain([
@ -752,7 +761,7 @@ runInEachFileSystem(() => {
// Now hack the files to look like it was processed by an outdated version of ngcc
const packageJson = loadPackage('test-package', _('/node_modules'));
packageJson.__processed_by_ivy_ngcc__ !.typings = '8.0.0';
packageJson.__processed_by_ivy_ngcc__!.typings = '8.0.0';
packageJson.main_ivy_ngcc = '__ivy_ngcc__/main.js';
fs.writeFile(_('/node_modules/test-package/package.json'), JSON.stringify(packageJson));
fs.writeFile(_('/node_modules/test-package/x.js'), 'processed content');
@ -838,7 +847,8 @@ runInEachFileSystem(() => {
// `fesm2015` and `es2015` map to the same file: `./fesm2015/common.js`
mainNgcc({
basePath: '/node_modules/@angular/common',
propertiesToConsider: ['fesm2015'], logger,
propertiesToConsider: ['fesm2015'],
logger,
});
expect(logs).not.toContain(['Skipping @angular/common : es2015 (already compiled).']);
@ -851,7 +861,8 @@ runInEachFileSystem(() => {
// Now, compiling `es2015` should be a no-op.
mainNgcc({
basePath: '/node_modules/@angular/common',
propertiesToConsider: ['es2015'], logger,
propertiesToConsider: ['es2015'],
logger,
});
expect(logs).toContain(['Skipping @angular/common : es2015 (already compiled).']);
@ -997,21 +1008,21 @@ runInEachFileSystem(() => {
expectNotToHaveProp(pkg, 'esm5_ivy_ngcc');
expectToHaveProp(pkg, 'fesm2015_ivy_ngcc');
expectNotToHaveProp(pkg, 'fesm5_ivy_ngcc');
expectToHaveProp(pkg.__processed_by_ivy_ngcc__ !, 'fesm2015');
expectToHaveProp(pkg.__processed_by_ivy_ngcc__!, 'fesm2015');
// Process `fesm5` and update `package.json`.
pkg = processFormatAndUpdatePackageJson('fesm5');
expectNotToHaveProp(pkg, 'esm5_ivy_ngcc');
expectToHaveProp(pkg, 'fesm2015_ivy_ngcc');
expectToHaveProp(pkg, 'fesm5_ivy_ngcc');
expectToHaveProp(pkg.__processed_by_ivy_ngcc__ !, 'fesm5');
expectToHaveProp(pkg.__processed_by_ivy_ngcc__!, 'fesm5');
// Process `esm5` and update `package.json`.
pkg = processFormatAndUpdatePackageJson('esm5');
expectToHaveProp(pkg, 'esm5_ivy_ngcc');
expectToHaveProp(pkg, 'fesm2015_ivy_ngcc');
expectToHaveProp(pkg, 'fesm5_ivy_ngcc');
expectToHaveProp(pkg.__processed_by_ivy_ngcc__ !, 'esm5');
expectToHaveProp(pkg.__processed_by_ivy_ngcc__!, 'esm5');
// Ensure the properties are in deterministic order (regardless of processing order).
const pkgKeys = stringifyKeys(pkg);
@ -1026,7 +1037,7 @@ runInEachFileSystem(() => {
// For example:
// - `fesm2015` <=> `es2015`
// - `fesm5` <=> `module`
expect(stringifyKeys(pkg.__processed_by_ivy_ngcc__ !))
expect(stringifyKeys(pkg.__processed_by_ivy_ngcc__!))
.toBe('|es2015|esm5|fesm2015|fesm5|module|typings|');
// Helpers
@ -1034,7 +1045,8 @@ runInEachFileSystem(() => {
expect(obj.hasOwnProperty(prop))
.toBe(
false,
`Expected object not to have property '${prop}': ${JSON.stringify(obj, null, 2)}`);
`Expected object not to have property '${prop}': ${
JSON.stringify(obj, null, 2)}`);
}
function expectToHaveProp(obj: object, prop: string) {
@ -1053,7 +1065,9 @@ runInEachFileSystem(() => {
return loadPackage('@angular/core');
}
function stringifyKeys(obj: object) { return `|${Object.keys(obj).join('|')}|`; }
function stringifyKeys(obj: object) {
return `|${Object.keys(obj).join('|')}|`;
}
});
});
@ -1206,7 +1220,8 @@ runInEachFileSystem(() => {
mainNgcc({
basePath: '/node_modules',
propertiesToConsider: ['es2015'],
errorOnFailedEntryPoint: false, logger,
errorOnFailedEntryPoint: false,
logger,
});
expect(logger.logs.error.length).toEqual(1);
const message = logger.logs.error[0][0];
@ -1236,7 +1251,8 @@ runInEachFileSystem(() => {
const logger = new MockLogger();
mainNgcc({
basePath: '/node_modules',
propertiesToConsider: ['esm2015'], logger,
propertiesToConsider: ['esm2015'],
logger,
});
expect(logger.logs.info).toContain(['Compiling @angular/common/http : esm2015 as esm2015']);
});
@ -1281,7 +1297,8 @@ runInEachFileSystem(() => {
mainNgcc({
basePath: '/dist',
propertiesToConsider: ['es2015'],
tsConfigPath: _('/tsconfig.app.json'), logger
tsConfigPath: _('/tsconfig.app.json'),
logger
});
expect(loadPackage('local-package', _('/dist')).__processed_by_ivy_ngcc__).toEqual({
es2015: '0.0.0-PLACEHOLDER',
@ -1316,7 +1333,8 @@ runInEachFileSystem(() => {
mainNgcc({
basePath: '/node_modules',
propertiesToConsider: ['es2015'],
pathMappings: {paths: {'*': ['dist/*']}, baseUrl: '/'}, logger
pathMappings: {paths: {'*': ['dist/*']}, baseUrl: '/'},
logger
});
expect(loadPackage('@angular/core').__processed_by_ivy_ngcc__).toEqual({
es2015: '0.0.0-PLACEHOLDER',
@ -1356,7 +1374,8 @@ runInEachFileSystem(() => {
mainNgcc({
basePath: '/dist',
propertiesToConsider: ['es2015'],
tsConfigPath: null, logger,
tsConfigPath: null,
logger,
});
expect(loadPackage('local-package', _('/dist')).__processed_by_ivy_ngcc__).toEqual({
es2015: '0.0.0-PLACEHOLDER',
@ -1821,7 +1840,7 @@ runInEachFileSystem(() => {
expect(jsContents).toContain('exports.ɵngExportɵFooModuleɵFoo = ɵngcc1.Foo;');
expect(dtsContents)
.toContain(`export {Foo as ɵngExportɵFooModuleɵFoo} from './directive';`);
expect(dtsContents.match(/ɵngExportɵFooModuleɵFoo/g) !.length).toBe(1);
expect(dtsContents.match(/ɵngExportɵFooModuleɵFoo/g)!.length).toBe(1);
expect(dtsContents).not.toContain(`ɵngExportɵFooModuleɵLocalDir`);
});
});

View File

@ -234,11 +234,21 @@ class MockCompilerHost implements ts.CompilerHost {
this.fs.writeFile(this.fs.resolve(fileName), data);
}
getCurrentDirectory(): string { return this.fs.pwd(); }
getCanonicalFileName(fileName: string): string { return fileName; }
useCaseSensitiveFileNames(): boolean { return true; }
getNewLine(): string { return '\n'; }
fileExists(fileName: string): boolean { return this.fs.exists(this.fs.resolve(fileName)); }
getCurrentDirectory(): string {
return this.fs.pwd();
}
getCanonicalFileName(fileName: string): string {
return fileName;
}
useCaseSensitiveFileNames(): boolean {
return true;
}
getNewLine(): string {
return '\n';
}
fileExists(fileName: string): boolean {
return this.fs.exists(this.fs.resolve(fileName));
}
readFile(fileName: string): string|undefined {
const abs = this.fs.resolve(fileName);
return this.fs.exists(abs) ? this.fs.readFile(abs) : undefined;

View File

@ -14,13 +14,13 @@ import {MockLogger} from '../helpers/mock_logger';
runInEachFileSystem(() => {
describe('AsyncLocker', () => {
describe('lock()', () => {
it('should guard the `fn()` with calls to `write()` and `remove()`', async() => {
it('should guard the `fn()` with calls to `write()` and `remove()`', async () => {
const fs = getFileSystem();
const log: string[] = [];
const lockFile = new MockLockFile(fs, log);
const locker = new AsyncLocker(lockFile, new MockLogger(), 100, 10);
await locker.lock(async() => {
await locker.lock(async () => {
log.push('fn() - before');
// This promise forces node to do a tick in this function, ensuring that we are truly
// testing an async scenario.
@ -31,7 +31,7 @@ runInEachFileSystem(() => {
});
it('should guard the `fn()` with calls to `write()` and `remove()`, even if it throws',
async() => {
async () => {
let error: string = '';
const fs = getFileSystem();
const log: string[] = [];
@ -39,7 +39,7 @@ runInEachFileSystem(() => {
const locker = new AsyncLocker(lockFile, new MockLogger(), 100, 10);
try {
await locker.lock(async() => {
await locker.lock(async () => {
log.push('fn()');
throw new Error('ERROR');
});
@ -50,7 +50,7 @@ runInEachFileSystem(() => {
expect(log).toEqual(['write()', 'fn()', 'remove()']);
});
it('should retry if another process is locking', async() => {
it('should retry if another process is locking', async () => {
const fs = getFileSystem();
const log: string[] = [];
const lockFile = new MockLockFile(fs, log);
@ -69,7 +69,7 @@ runInEachFileSystem(() => {
return lockFileContents;
});
const promise = locker.lock(async() => log.push('fn()'));
const promise = locker.lock(async () => log.push('fn()'));
// The lock is now waiting on the lock-file becoming free, so no `fn()` in the log.
expect(log).toEqual(['write()', 'read() => 188']);
expect(logger.logs.info).toEqual([[
@ -83,7 +83,7 @@ runInEachFileSystem(() => {
expect(log).toEqual(['write()', 'read() => 188', 'write()', 'fn()', 'remove()']);
});
it('should extend the retry timeout if the other process locking the file changes', async() => {
it('should extend the retry timeout if the other process locking the file changes', async () => {
const fs = getFileSystem();
const log: string[] = [];
const lockFile = new MockLockFile(fs, log);
@ -102,7 +102,7 @@ runInEachFileSystem(() => {
return lockFileContents;
});
const promise = locker.lock(async() => log.push('fn()'));
const promise = locker.lock(async () => log.push('fn()'));
// The lock is now waiting on the lock-file becoming free, so no `fn()` in the log.
expect(log).toEqual(['write()', 'read() => 188']);
expect(logger.logs.info).toEqual([[
@ -132,7 +132,7 @@ runInEachFileSystem(() => {
});
it('should error if another process does not release the lock-file before this times out',
async() => {
async () => {
const fs = getFileSystem();
const log: string[] = [];
const lockFile = new MockLockFile(fs, log);
@ -151,7 +151,7 @@ runInEachFileSystem(() => {
return lockFileContents;
});
const promise = locker.lock(async() => log.push('fn()'));
const promise = locker.lock(async () => log.push('fn()'));
// The lock is now waiting on the lock-file becoming free, so no `fn()` in the log.
expect(log).toEqual(['write()', 'read() => 188']);
@ -159,10 +159,11 @@ runInEachFileSystem(() => {
let error: Error;
await promise.catch(e => error = e);
expect(log).toEqual(['write()', 'read() => 188', 'write()', 'read() => 188']);
expect(error !.message)
expect(error!.message)
.toEqual(
`Timed out waiting 0.2s for another ngcc process, with id 188, to complete.\n` +
`(If you are sure no ngcc process is running then you should delete the lock-file at ${lockFile.path}.)`);
`(If you are sure no ngcc process is running then you should delete the lock-file at ${
lockFile.path}.)`);
});
});
});

View File

@ -23,7 +23,7 @@ runInEachFileSystem(() => {
class LockFileUnderTest extends LockFileWithChildProcess {
// Note that log is initialized in the `createUnlocker()` function that is called from
// super(), so we can't initialize it here.
log !: string[];
log!: string[];
constructor(fs: FileSystem) {
super(fs, new MockLogger());
fs.ensureDir(fs.dirname(this.path));
@ -47,7 +47,11 @@ runInEachFileSystem(() => {
const log = this.log;
// Normally this would fork a child process and return it.
// But we don't want to do that in these tests.
return <any>{disconnect() { log.push('unlocker.disconnect()'); }};
return <any>{
disconnect() {
log.push('unlocker.disconnect()');
}
};
}
}

View File

@ -5,7 +5,7 @@
* 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 {AbsoluteFsPath, FileSystem, absoluteFrom, getFileSystem} from '../../../../src/ngtsc/file_system';
import {absoluteFrom, AbsoluteFsPath, FileSystem, getFileSystem} from '../../../../src/ngtsc/file_system';
import {runInEachFileSystem} from '../../../../src/ngtsc/file_system/testing';
import {removeLockFile} from '../../../src/locking/lock_file_with_child_process/util';
import {MockLogger} from '../../helpers/mock_logger';
@ -24,8 +24,9 @@ runInEachFileSystem(() => {
});
describe('removeLockFile()', () => {
it('should do nothing if there is no file to remove',
() => { removeLockFile(fs, logger, absoluteFrom('/lockfile/path'), '1234'); });
it('should do nothing if there is no file to remove', () => {
removeLockFile(fs, logger, absoluteFrom('/lockfile/path'), '1234');
});
it('should do nothing if the pid does not match', () => {
fs.writeFile(lockFilePath, '888');

View File

@ -50,7 +50,9 @@ runInEachFileSystem(() => {
const lockFile = new MockLockFile(fs, log);
const locker = new SyncLocker(lockFile);
spyOn(lockFile, 'write').and.callFake(() => { throw {code: 'EEXIST'}; });
spyOn(lockFile, 'write').and.callFake(() => {
throw {code: 'EEXIST'};
});
spyOn(lockFile, 'read').and.returnValue('188');
expect(() => locker.lock(() => {}))
@ -58,7 +60,8 @@ runInEachFileSystem(() => {
`ngcc is already running at process with id 188.\n` +
`If you are running multiple builds in parallel then you should pre-process your node_modules via the command line ngcc tool before starting the builds;\n` +
`See https://v9.angular.io/guide/ivy#speeding-up-ngcc-compilation.\n` +
`(If you are sure no ngcc process is running then you should delete the lock-file at ${lockFile.path}.)`);
`(If you are sure no ngcc process is running then you should delete the lock-file at ${
lockFile.path}.)`);
});
});
});

View File

@ -7,14 +7,14 @@
*/
import * as ts from 'typescript';
import {AbsoluteFsPath, absoluteFrom, getFileSystem} from '../../../src/ngtsc/file_system';
import {TestFile, runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {absoluteFrom, AbsoluteFsPath, getFileSystem} from '../../../src/ngtsc/file_system';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {loadFakeCore, loadTestFiles} from '../../../test/helpers';
import {DecorationAnalyzer} from '../../src/analysis/decoration_analyzer';
import {NgccReferencesRegistry} from '../../src/analysis/ngcc_references_registry';
import {DecorationAnalyses} from '../../src/analysis/types';
import {Esm2015ReflectionHost} from '../../src/host/esm2015_host';
import {MissingInjectableMigration, getAngularCoreDecoratorName} from '../../src/migrations/missing_injectable_migration';
import {getAngularCoreDecoratorName, MissingInjectableMigration} from '../../src/migrations/missing_injectable_migration';
import {MockLogger} from '../helpers/mock_logger';
import {getRootFiles, makeTestEntryPointBundle} from '../helpers/utils';
@ -58,7 +58,7 @@ runInEachFileSystem(() => {
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'ServiceA')).toBe(true);
expect(hasInjectableDecorator(index, analysis, 'ServiceB')).toBe(true);
expect(hasInjectableDecorator(index, analysis, 'ServiceC')).toBe(false);
@ -66,7 +66,7 @@ runInEachFileSystem(() => {
});
function runTests(
type: 'NgModule' | 'Directive' | 'Component', propName: 'providers' | 'viewProviders') {
type: 'NgModule'|'Directive'|'Component', propName: 'providers'|'viewProviders') {
const args = type === 'Component' ? 'template: "", ' : '';
it(`should migrate type provider in ${type}`, () => {
@ -85,7 +85,7 @@ runInEachFileSystem(() => {
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'MyService')).toBe(true);
expect(hasInjectableDecorator(index, analysis, 'OtherService')).toBe(false);
});
@ -106,12 +106,12 @@ runInEachFileSystem(() => {
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'MyService')).toBe(true);
expect(hasInjectableDecorator(index, analysis, 'OtherService')).toBe(false);
});
it(`should migrate object literal provider with forwardRef in ${type}`, async() => {
it(`should migrate object literal provider with forwardRef in ${type}`, async () => {
const {program, analysis} = setUpAndAnalyzeProgram([{
name: INDEX_FILENAME,
contents: `
@ -121,12 +121,13 @@ runInEachFileSystem(() => {
export class TestClass {}
TestClass.decorators = [
{ type: ${type}, args: [{${args}${propName}: [{provide: forwardRef(() => MyService) }]}] }
{ type: ${type}, args: [{${args}${
propName}: [{provide: forwardRef(() => MyService) }]}] }
];
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'MyService')).toBe(true);
});
@ -140,12 +141,13 @@ runInEachFileSystem(() => {
export class TestClass {}
TestClass.decorators = [
{ type: ${type}, args: [{${args}${propName}: [{provide: MyService, useValue: null }]}] }
{ type: ${type}, args: [{${args}${
propName}: [{provide: MyService, useValue: null }]}] }
];
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'MyService')).toBe(false);
});
@ -159,12 +161,13 @@ runInEachFileSystem(() => {
export class TestClass {}
TestClass.decorators = [
{ type: ${type}, args: [{${args}${propName}: [{provide: MyService, useFactory: () => null }]}] }
{ type: ${type}, args: [{${args}${
propName}: [{provide: MyService, useFactory: () => null }]}] }
];
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'MyService')).toBe(false);
});
@ -189,7 +192,7 @@ runInEachFileSystem(() => {
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'MyService')).toBe(true);
expect(hasInjectableDecorator(index, analysis, 'MyToken')).toBe(false);
expect(hasInjectableDecorator(index, analysis, 'MyTokenAlias')).toBe(false);
@ -206,12 +209,13 @@ runInEachFileSystem(() => {
export class TestClass {}
TestClass.decorators = [
{ type: ${type}, args: [{${args}${propName}: [{provide: MyToken, useClass: MyService}]}] }
{ type: ${type}, args: [{${args}${
propName}: [{provide: MyToken, useClass: MyService}]}] }
];
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'MyService')).toBe(true);
expect(hasInjectableDecorator(index, analysis, 'MyToken')).toBe(false);
});
@ -234,7 +238,7 @@ runInEachFileSystem(() => {
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(getInjectableDecorators(index, analysis, 'MyService').length).toBe(1);
});
@ -256,7 +260,7 @@ runInEachFileSystem(() => {
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'MyService')).toBe(false);
});
@ -278,7 +282,7 @@ runInEachFileSystem(() => {
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'MyService')).toBe(false);
});
@ -300,7 +304,7 @@ runInEachFileSystem(() => {
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'MyService')).toBe(false);
});
@ -320,7 +324,7 @@ runInEachFileSystem(() => {
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'ServiceA')).toBe(true);
expect(hasInjectableDecorator(index, analysis, 'ServiceB')).toBe(true);
});
@ -348,7 +352,7 @@ runInEachFileSystem(() => {
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'ServiceA')).toBe(true);
expect(hasInjectableDecorator(index, analysis, 'ServiceB')).toBe(true);
expect(hasInjectableDecorator(index, analysis, 'ServiceC')).toBe(true);
@ -381,7 +385,7 @@ runInEachFileSystem(() => {
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'ServiceA')).toBe(true);
expect(hasInjectableDecorator(index, analysis, 'ServiceB')).toBe(true);
expect(hasInjectableDecorator(index, analysis, 'ServiceC')).toBe(true);
@ -407,7 +411,7 @@ runInEachFileSystem(() => {
`
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'ServiceA')).toBe(true);
expect(hasInjectableDecorator(index, analysis, 'ServiceB')).toBe(true);
expect(hasInjectableDecorator(index, analysis, 'ServiceC')).toBe(false);
@ -434,7 +438,7 @@ runInEachFileSystem(() => {
`
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(getInjectableDecorators(index, analysis, 'ServiceA').length).toBe(1);
expect(getInjectableDecorators(index, analysis, 'ServiceB').length).toBe(1);
});
@ -454,7 +458,7 @@ runInEachFileSystem(() => {
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'ServiceA')).toBe(false);
});
@ -481,7 +485,7 @@ runInEachFileSystem(() => {
}
]);
const index = program.getSourceFile(SERVICE_FILENAME) !;
const index = program.getSourceFile(SERVICE_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'MyService')).toBe(true);
});
@ -508,7 +512,7 @@ runInEachFileSystem(() => {
}
]);
const index = program.getSourceFile(SERVICE_FILENAME) !;
const index = program.getSourceFile(SERVICE_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'MyService')).toBe(false);
});
@ -527,7 +531,7 @@ runInEachFileSystem(() => {
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'MyService')).toBe(true);
});
@ -546,7 +550,7 @@ runInEachFileSystem(() => {
`,
}]);
const index = program.getSourceFile(INDEX_FILENAME) !;
const index = program.getSourceFile(INDEX_FILENAME)!;
expect(hasInjectableDecorator(index, analysis, 'MyService')).toBe(false);
});
}

View File

@ -6,8 +6,9 @@
* found in the LICENSE file at https://angular.io/license
*/
import * as ts from 'typescript';
import {AbsoluteFsPath, absoluteFrom, getFileSystem} from '../../../src/ngtsc/file_system';
import {TestFile, runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {absoluteFrom, AbsoluteFsPath, getFileSystem} from '../../../src/ngtsc/file_system';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {loadFakeCore, loadTestFiles} from '../../../test/helpers';
import {DecorationAnalyzer} from '../../src/analysis/decoration_analyzer';
import {NgccReferencesRegistry} from '../../src/analysis/ngcc_references_registry';
@ -34,7 +35,7 @@ runInEachFileSystem(() => {
`
}]);
expect(errors).toEqual([]);
const file = analysis.get(program.getSourceFile(INDEX_FILENAME) !);
const file = analysis.get(program.getSourceFile(INDEX_FILENAME)!);
expect(file).toBeUndefined();
});
@ -56,7 +57,7 @@ runInEachFileSystem(() => {
`
}]);
expect(errors).toEqual([]);
const file = analysis.get(program.getSourceFile(INDEX_FILENAME) !) !;
const file = analysis.get(program.getSourceFile(INDEX_FILENAME)!)!;
expect(file.compiledClasses.find(c => c.name === 'DerivedClass')).toBeDefined();
expect(file.compiledClasses.find(c => c.name === 'BaseClass')).toBeUndefined();
});
@ -81,15 +82,15 @@ runInEachFileSystem(() => {
`
}]);
expect(errors).toEqual([]);
const file = analysis.get(program.getSourceFile(INDEX_FILENAME) !) !;
const file = analysis.get(program.getSourceFile(INDEX_FILENAME)!)!;
expect(file.compiledClasses.find(c => c.name === 'DerivedClass')).toBeDefined();
const baseClass = file.compiledClasses.find(c => c.name === 'BaseClass') !;
expect(baseClass.decorators !.length).toEqual(1);
const decorator = baseClass.decorators ![0];
const baseClass = file.compiledClasses.find(c => c.name === 'BaseClass')!;
expect(baseClass.decorators!.length).toEqual(1);
const decorator = baseClass.decorators![0];
expect(decorator.name).toEqual('Directive');
expect(decorator.identifier).toBeNull('The decorator must be synthesized');
expect(decorator.import).toEqual({from: '@angular/core', name: 'Directive'});
expect(decorator.args !.length).toEqual(0);
expect(decorator.args!.length).toEqual(0);
});
it('should not add a decorator to a base class that is already decorated', () => {
@ -114,11 +115,11 @@ runInEachFileSystem(() => {
`
}]);
expect(errors).toEqual([]);
const file = analysis.get(program.getSourceFile(INDEX_FILENAME) !) !;
const file = analysis.get(program.getSourceFile(INDEX_FILENAME)!)!;
expect(file.compiledClasses.find(c => c.name === 'DerivedClass')).toBeDefined();
const baseClass = file.compiledClasses.find(c => c.name === 'BaseClass') !;
expect(baseClass.decorators !.length).toEqual(1);
const decorator = baseClass.decorators ![0];
const baseClass = file.compiledClasses.find(c => c.name === 'BaseClass')!;
expect(baseClass.decorators!.length).toEqual(1);
const decorator = baseClass.decorators![0];
expect(decorator.name).toEqual('Directive');
expect(decorator.identifier).not.toBeNull('The decorator must not be synthesized');
});
@ -145,25 +146,25 @@ runInEachFileSystem(() => {
`
}]);
expect(errors).toEqual([]);
const file = analysis.get(program.getSourceFile(INDEX_FILENAME) !) !;
const file = analysis.get(program.getSourceFile(INDEX_FILENAME)!)!;
expect(file.compiledClasses.find(c => c.name === 'DerivedClass')).toBeDefined();
expect(file.compiledClasses.find(c => c.name === 'RealBaseClass')).toBeUndefined();
const intermediateClass = file.compiledClasses.find(c => c.name === 'IntermediateClass') !;
expect(intermediateClass.decorators !.length).toEqual(1);
const intermediateDecorator = intermediateClass.decorators ![0];
const intermediateClass = file.compiledClasses.find(c => c.name === 'IntermediateClass')!;
expect(intermediateClass.decorators!.length).toEqual(1);
const intermediateDecorator = intermediateClass.decorators![0];
expect(intermediateDecorator.name).toEqual('Directive');
expect(intermediateDecorator.identifier).toBeNull('The decorator must be synthesized');
expect(intermediateDecorator.import).toEqual({from: '@angular/core', name: 'Directive'});
expect(intermediateDecorator.args !.length).toEqual(0);
expect(intermediateDecorator.args!.length).toEqual(0);
const baseClass = file.compiledClasses.find(c => c.name === 'BaseClass') !;
expect(baseClass.decorators !.length).toEqual(1);
const baseDecorator = baseClass.decorators ![0];
const baseClass = file.compiledClasses.find(c => c.name === 'BaseClass')!;
expect(baseClass.decorators!.length).toEqual(1);
const baseDecorator = baseClass.decorators![0];
expect(baseDecorator.name).toEqual('Directive');
expect(baseDecorator.identifier).toBeNull('The decorator must be synthesized');
expect(baseDecorator.import).toEqual({from: '@angular/core', name: 'Directive'});
expect(baseDecorator.args !.length).toEqual(0);
expect(baseDecorator.args!.length).toEqual(0);
});
it('should handle the base class being in a different file (same package) as the derived class',
@ -195,14 +196,14 @@ runInEachFileSystem(() => {
}
]);
expect(errors).toEqual([]);
const file = analysis.get(program.getSourceFile(BASE_FILENAME) !) !;
const baseClass = file.compiledClasses.find(c => c.name === 'BaseClass') !;
expect(baseClass.decorators !.length).toEqual(1);
const decorator = baseClass.decorators ![0];
const file = analysis.get(program.getSourceFile(BASE_FILENAME)!)!;
const baseClass = file.compiledClasses.find(c => c.name === 'BaseClass')!;
expect(baseClass.decorators!.length).toEqual(1);
const decorator = baseClass.decorators![0];
expect(decorator.name).toEqual('Directive');
expect(decorator.identifier).toBeNull('The decorator must be synthesized');
expect(decorator.import).toEqual({from: '@angular/core', name: 'Directive'});
expect(decorator.args !.length).toEqual(0);
expect(decorator.args!.length).toEqual(0);
});
it('should skip the base class if it is in a different package from the derived class', () => {

View File

@ -8,7 +8,7 @@
import {absoluteFrom, getFileSystem} from '../../../src/ngtsc/file_system';
import {runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
import {loadTestFiles} from '../../../test/helpers';
import {NGCC_VERSION, cleanPackageJson, hasBeenProcessed, markAsProcessed, needsCleaning} from '../../src/packages/build_marker';
import {cleanPackageJson, hasBeenProcessed, markAsProcessed, needsCleaning, NGCC_VERSION} from '../../src/packages/build_marker';
import {EntryPointPackageJson} from '../../src/packages/entry_point';
import {DirectPackageJsonUpdater} from '../../src/writing/package_json_updater';
@ -192,8 +192,9 @@ runInEachFileSystem(() => {
.toBe(false);
});
it('should return false if no markers exist',
() => { expect(hasBeenProcessed({name: 'test'}, 'module')).toBe(false); });
it('should return false if no markers exist', () => {
expect(hasBeenProcessed({name: 'test'}, 'module')).toBe(false);
});
});
describe('needsCleaning()', () => {

Some files were not shown because too many files have changed in this diff Show More