@angular/compiler-cli 11.2.5 → 11.2.9

package/src/ngtsc/perf/src/api.d.ts

@@ -6,10 +6,305 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/perf/src/api" />
-import { DeclarationNode } from '../../reflection';
+/**
+ * A phase of compilation for which time is tracked in a distinct bucket.
+ */
+export declare enum PerfPhase {
+    /**
+     * The "default" phase which tracks time not spent in any other phase.
+     */
+    Unaccounted = 0,
+    /**
+     * Time spent setting up the compiler, before a TypeScript program is created.
+     *
+     * This includes operations like configuring the `ts.CompilerHost` and any wrappers.
+     */
+    Setup = 1,
+    /**
+     * Time spent in `ts.createProgram`, including reading and parsing `ts.SourceFile`s in the
+     * `ts.CompilerHost`.
+     *
+     * This might be an incremental program creation operation.
+     */
+    TypeScriptProgramCreate = 2,
+    /**
+     * Time spent reconciling the contents of an old `ts.Program` with the new incremental one.
+     *
+     * Only present in incremental compilations.
+     */
+    Reconciliation = 3,
+    /**
+     * Time spent updating an `NgCompiler` instance with a resource-only change.
+     *
+     * Only present in incremental compilations where the change was resource-only.
+     */
+    ResourceUpdate = 4,
+    /**
+     * Time spent calculating the plain TypeScript diagnostics (structural and semantic).
+     */
+    TypeScriptDiagnostics = 5,
+    /**
+     * Time spent in Angular analysis of individual classes in the program.
+     */
+    Analysis = 6,
+    /**
+     * Time spent in Angular global analysis (synthesis of analysis information into a complete
+     * understanding of the program).
+     */
+    Resolve = 7,
+    /**
+     * Time spent building the import graph of the program in order to perform cycle detection.
+     */
+    CycleDetection = 8,
+    /**
+     * Time spent generating the text of Type Check Blocks in order to perform template type checking.
+     */
+    TcbGeneration = 9,
+    /**
+     * Time spent updating the `ts.Program` with new Type Check Block code.
+     */
+    TcbUpdateProgram = 10,
+    /**
+     * Time spent by TypeScript performing its emit operations, including downleveling and writing
+     * output files.
+     */
+    TypeScriptEmit = 11,
+    /**
+     * Time spent by Angular performing code transformations of ASTs as they're about to be emitted.
+     *
+     * This includes the actual code generation step for templates, and occurs during the emit phase
+     * (but is tracked separately from `TypeScriptEmit` time).
+     */
+    Compile = 12,
+    /**
+     * Time spent performing a `TemplateTypeChecker` autocompletion operation.
+     */
+    TtcAutocompletion = 13,
+    /**
+     * Time spent computing template type-checking diagnostics.
+     */
+    TtcDiagnostics = 14,
+    /**
+     * Time spent getting a `Symbol` from the `TemplateTypeChecker`.
+     */
+    TtcSymbol = 15,
+    /**
+     * Time spent by the Angular Language Service calculating a "get references" or a renaming
+     * operation.
+     */
+    LsReferencesAndRenames = 16,
+    /**
+     * Time spent by the Angular Language Service calculating a "quick info" operation.
+     */
+    LsQuickInfo = 17,
+    /**
+     * Time spent by the Angular Language Service calculating a "get type definition" or "get
+     * definition" operation.
+     */
+    LsDefinition = 18,
+    /**
+     * Time spent by the Angular Language Service calculating a "get completions" (AKA autocomplete)
+     * operation.
+     */
+    LsCompletions = 19,
+    /**
+     * Time spent by the Angular Language Service calculating a "view template typecheck block"
+     * operation.
+     */
+    LsTcb = 20,
+    /**
+     * Time spent by the Angular Language Service calculating diagnostics.
+     */
+    LsDiagnostics = 21,
+    /**
+     * Time spent by the Angular Language Service calculating a "get component locations for template"
+     * operation.
+     */
+    LsComponentLocations = 22,
+    /**
+     * Tracks the number of `PerfPhase`s, and must appear at the end of the list.
+     */
+    LAST = 23
+}
+/**
+ * Represents some occurrence during compilation, and is tracked with a counter.
+ */
+export declare enum PerfEvent {
+    /**
+     * Counts the number of `.d.ts` files in the program.
+     */
+    InputDtsFile = 0,
+    /**
+     * Counts the number of non-`.d.ts` files in the program.
+     */
+    InputTsFile = 1,
+    /**
+     * An `@Component` class was analyzed.
+     */
+    AnalyzeComponent = 2,
+    /**
+     * An `@Directive` class was analyzed.
+     */
+    AnalyzeDirective = 3,
+    /**
+     * An `@Injectable` class was analyzed.
+     */
+    AnalyzeInjectable = 4,
+    /**
+     * An `@NgModule` class was analyzed.
+     */
+    AnalyzeNgModule = 5,
+    /**
+     * An `@Pipe` class was analyzed.
+     */
+    AnalyzePipe = 6,
+    /**
+     * A trait was analyzed.
+     *
+     * In theory, this should be the sum of the `Analyze` counters for each decorator type.
+     */
+    TraitAnalyze = 7,
+    /**
+     * A trait had a prior analysis available from an incremental program, and did not need to be
+     * re-analyzed.
+     */
+    TraitReuseAnalysis = 8,
+    /**
+     * A `ts.SourceFile` directly changed between the prior program and a new incremental compilation.
+     */
+    SourceFilePhysicalChange = 9,
+    /**
+     * A `ts.SourceFile` did not physically changed, but according to the file dependency graph, has
+     * logically changed between the prior program and a new incremental compilation.
+     */
+    SourceFileLogicalChange = 10,
+    /**
+     * A `ts.SourceFile` has not logically changed and all of its analysis results were thus available
+     * for reuse.
+     */
+    SourceFileReuseAnalysis = 11,
+    /**
+     * A Type Check Block (TCB) was generated.
+     */
+    GenerateTcb = 12,
+    /**
+     * A Type Check Block (TCB) could not be generated because inlining was disabled, and the block
+     * would've required inlining.
+     */
+    SkipGenerateTcbNoInline = 13,
+    /**
+     * A `.ngtypecheck.ts` file could be reused from the previous program and did not need to be
+     * regenerated.
+     */
+    ReuseTypeCheckFile = 14,
+    /**
+     * The template type-checking program required changes and had to be updated in an incremental
+     * step.
+     */
+    UpdateTypeCheckProgram = 15,
+    /**
+     * The compiler was able to prove that a `ts.SourceFile` did not need to be re-emitted.
+     */
+    EmitSkipSourceFile = 16,
+    /**
+     * A `ts.SourceFile` was emitted.
+     */
+    EmitSourceFile = 17,
+    /**
+     * Tracks the number of `PrefEvent`s, and must appear at the end of the list.
+     */
+    LAST = 18
+}
+/**
+ * Represents a checkpoint during compilation at which the memory usage of the compiler should be
+ * recorded.
+ */
+export declare enum PerfCheckpoint {
+    /**
+     * The point at which the `PerfRecorder` was created, and ideally tracks memory used before any
+     * compilation structures are created.
+     */
+    Initial = 0,
+    /**
+     * The point just after the `ts.Program` has been created.
+     */
+    TypeScriptProgramCreate = 1,
+    /**
+     * The point just before Angular analysis starts.
+     *
+     * In the main usage pattern for the compiler, TypeScript diagnostics have been calculated at this
+     * point, so the `ts.TypeChecker` has fully ingested the current program, all `ts.Type` structures
+     * and `ts.Symbol`s have been created.
+     */
+    PreAnalysis = 2,
+    /**
+     * The point just after Angular analysis completes.
+     */
+    Analysis = 3,
+    /**
+     * The point just after Angular resolution is complete.
+     */
+    Resolve = 4,
+    /**
+     * The point just after Type Check Blocks (TCBs) have been generated.
+     */
+    TtcGeneration = 5,
+    /**
+     * The point just after the template type-checking program has been updated with any new TCBs.
+     */
+    TtcUpdateProgram = 6,
+    /**
+     * The point just before emit begins.
+     *
+     * In the main usage pattern for the compiler, all template type-checking diagnostics have been
+     * requested at this point.
+     */
+    PreEmit = 7,
+    /**
+     * The point just after the program has been fully emitted.
+     */
+    Emit = 8,
+    /**
+     * Tracks the number of `PerfCheckpoint`s, and must appear at the end of the list.
+     */
+    LAST = 9
+}
+/**
+ * Records timing, memory, or counts at specific points in the compiler's operation.
+ */
 export interface PerfRecorder {
-    readonly enabled: boolean;
-    mark(name: string, node?: DeclarationNode, category?: string, detail?: string): void;
-    start(name: string, node?: DeclarationNode, category?: string, detail?: string): number;
-    stop(span: number): void;
+    /**
+     * Set the current phase of compilation.
+     *
+     * Time spent in the previous phase will be accounted to that phase. The caller is responsible for
+     * exiting the phase when work that should be tracked within it is completed, and either returning
+     * to the previous phase or transitioning to the next one directly.
+     *
+     * In general, prefer using `inPhase()` to instrument a section of code, as it automatically
+     * handles entering and exiting the phase. `phase()` should only be used when the former API
+     * cannot be cleanly applied to a particular operation.
+     *
+     * @returns the previous phase
+     */
+    phase(phase: PerfPhase): PerfPhase;
+    /**
+     * Run `fn` in the given `PerfPhase` and return the result.
+     *
+     * Enters `phase` before executing the given `fn`, then exits the phase and returns the result.
+     * Prefer this API to `phase()` where possible.
+     */
+    inPhase<T>(phase: PerfPhase, fn: () => T): T;
+    /**
+     * Record the memory usage of the compiler at the given checkpoint.
+     */
+    memory(after: PerfCheckpoint): void;
+    /**
+     * Record that a specific event has occurred, possibly more than once.
+     */
+    eventCount(event: PerfEvent, incrementBy?: number): void;
+    /**
+     * Return the `PerfRecorder` to an empty state (clear all tracked statistics) and reset the zero
+     * point to the current time.
+     */
+    reset(): void;
 }

package/src/ngtsc/perf/src/api.js

@@ -16,5 +16,272 @@
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PerfCheckpoint = exports.PerfEvent = exports.PerfPhase = void 0;
+    /**
+     * A phase of compilation for which time is tracked in a distinct bucket.
+     */
+    var PerfPhase;
+    (function (PerfPhase) {
+        /**
+         * The "default" phase which tracks time not spent in any other phase.
+         */
+        PerfPhase[PerfPhase["Unaccounted"] = 0] = "Unaccounted";
+        /**
+         * Time spent setting up the compiler, before a TypeScript program is created.
+         *
+         * This includes operations like configuring the `ts.CompilerHost` and any wrappers.
+         */
+        PerfPhase[PerfPhase["Setup"] = 1] = "Setup";
+        /**
+         * Time spent in `ts.createProgram`, including reading and parsing `ts.SourceFile`s in the
+         * `ts.CompilerHost`.
+         *
+         * This might be an incremental program creation operation.
+         */
+        PerfPhase[PerfPhase["TypeScriptProgramCreate"] = 2] = "TypeScriptProgramCreate";
+        /**
+         * Time spent reconciling the contents of an old `ts.Program` with the new incremental one.
+         *
+         * Only present in incremental compilations.
+         */
+        PerfPhase[PerfPhase["Reconciliation"] = 3] = "Reconciliation";
+        /**
+         * Time spent updating an `NgCompiler` instance with a resource-only change.
+         *
+         * Only present in incremental compilations where the change was resource-only.
+         */
+        PerfPhase[PerfPhase["ResourceUpdate"] = 4] = "ResourceUpdate";
+        /**
+         * Time spent calculating the plain TypeScript diagnostics (structural and semantic).
+         */
+        PerfPhase[PerfPhase["TypeScriptDiagnostics"] = 5] = "TypeScriptDiagnostics";
+        /**
+         * Time spent in Angular analysis of individual classes in the program.
+         */
+        PerfPhase[PerfPhase["Analysis"] = 6] = "Analysis";
+        /**
+         * Time spent in Angular global analysis (synthesis of analysis information into a complete
+         * understanding of the program).
+         */
+        PerfPhase[PerfPhase["Resolve"] = 7] = "Resolve";
+        /**
+         * Time spent building the import graph of the program in order to perform cycle detection.
+         */
+        PerfPhase[PerfPhase["CycleDetection"] = 8] = "CycleDetection";
+        /**
+         * Time spent generating the text of Type Check Blocks in order to perform template type checking.
+         */
+        PerfPhase[PerfPhase["TcbGeneration"] = 9] = "TcbGeneration";
+        /**
+         * Time spent updating the `ts.Program` with new Type Check Block code.
+         */
+        PerfPhase[PerfPhase["TcbUpdateProgram"] = 10] = "TcbUpdateProgram";
+        /**
+         * Time spent by TypeScript performing its emit operations, including downleveling and writing
+         * output files.
+         */
+        PerfPhase[PerfPhase["TypeScriptEmit"] = 11] = "TypeScriptEmit";
+        /**
+         * Time spent by Angular performing code transformations of ASTs as they're about to be emitted.
+         *
+         * This includes the actual code generation step for templates, and occurs during the emit phase
+         * (but is tracked separately from `TypeScriptEmit` time).
+         */
+        PerfPhase[PerfPhase["Compile"] = 12] = "Compile";
+        /**
+         * Time spent performing a `TemplateTypeChecker` autocompletion operation.
+         */
+        PerfPhase[PerfPhase["TtcAutocompletion"] = 13] = "TtcAutocompletion";
+        /**
+         * Time spent computing template type-checking diagnostics.
+         */
+        PerfPhase[PerfPhase["TtcDiagnostics"] = 14] = "TtcDiagnostics";
+        /**
+         * Time spent getting a `Symbol` from the `TemplateTypeChecker`.
+         */
+        PerfPhase[PerfPhase["TtcSymbol"] = 15] = "TtcSymbol";
+        /**
+         * Time spent by the Angular Language Service calculating a "get references" or a renaming
+         * operation.
+         */
+        PerfPhase[PerfPhase["LsReferencesAndRenames"] = 16] = "LsReferencesAndRenames";
+        /**
+         * Time spent by the Angular Language Service calculating a "quick info" operation.
+         */
+        PerfPhase[PerfPhase["LsQuickInfo"] = 17] = "LsQuickInfo";
+        /**
+         * Time spent by the Angular Language Service calculating a "get type definition" or "get
+         * definition" operation.
+         */
+        PerfPhase[PerfPhase["LsDefinition"] = 18] = "LsDefinition";
+        /**
+         * Time spent by the Angular Language Service calculating a "get completions" (AKA autocomplete)
+         * operation.
+         */
+        PerfPhase[PerfPhase["LsCompletions"] = 19] = "LsCompletions";
+        /**
+         * Time spent by the Angular Language Service calculating a "view template typecheck block"
+         * operation.
+         */
+        PerfPhase[PerfPhase["LsTcb"] = 20] = "LsTcb";
+        /**
+         * Time spent by the Angular Language Service calculating diagnostics.
+         */
+        PerfPhase[PerfPhase["LsDiagnostics"] = 21] = "LsDiagnostics";
+        /**
+         * Time spent by the Angular Language Service calculating a "get component locations for template"
+         * operation.
+         */
+        PerfPhase[PerfPhase["LsComponentLocations"] = 22] = "LsComponentLocations";
+        /**
+         * Tracks the number of `PerfPhase`s, and must appear at the end of the list.
+         */
+        PerfPhase[PerfPhase["LAST"] = 23] = "LAST";
+    })(PerfPhase = exports.PerfPhase || (exports.PerfPhase = {}));
+    /**
+     * Represents some occurrence during compilation, and is tracked with a counter.
+     */
+    var PerfEvent;
+    (function (PerfEvent) {
+        /**
+         * Counts the number of `.d.ts` files in the program.
+         */
+        PerfEvent[PerfEvent["InputDtsFile"] = 0] = "InputDtsFile";
+        /**
+         * Counts the number of non-`.d.ts` files in the program.
+         */
+        PerfEvent[PerfEvent["InputTsFile"] = 1] = "InputTsFile";
+        /**
+         * An `@Component` class was analyzed.
+         */
+        PerfEvent[PerfEvent["AnalyzeComponent"] = 2] = "AnalyzeComponent";
+        /**
+         * An `@Directive` class was analyzed.
+         */
+        PerfEvent[PerfEvent["AnalyzeDirective"] = 3] = "AnalyzeDirective";
+        /**
+         * An `@Injectable` class was analyzed.
+         */
+        PerfEvent[PerfEvent["AnalyzeInjectable"] = 4] = "AnalyzeInjectable";
+        /**
+         * An `@NgModule` class was analyzed.
+         */
+        PerfEvent[PerfEvent["AnalyzeNgModule"] = 5] = "AnalyzeNgModule";
+        /**
+         * An `@Pipe` class was analyzed.
+         */
+        PerfEvent[PerfEvent["AnalyzePipe"] = 6] = "AnalyzePipe";
+        /**
+         * A trait was analyzed.
+         *
+         * In theory, this should be the sum of the `Analyze` counters for each decorator type.
+         */
+        PerfEvent[PerfEvent["TraitAnalyze"] = 7] = "TraitAnalyze";
+        /**
+         * A trait had a prior analysis available from an incremental program, and did not need to be
+         * re-analyzed.
+         */
+        PerfEvent[PerfEvent["TraitReuseAnalysis"] = 8] = "TraitReuseAnalysis";
+        /**
+         * A `ts.SourceFile` directly changed between the prior program and a new incremental compilation.
+         */
+        PerfEvent[PerfEvent["SourceFilePhysicalChange"] = 9] = "SourceFilePhysicalChange";
+        /**
+         * A `ts.SourceFile` did not physically changed, but according to the file dependency graph, has
+         * logically changed between the prior program and a new incremental compilation.
+         */
+        PerfEvent[PerfEvent["SourceFileLogicalChange"] = 10] = "SourceFileLogicalChange";
+        /**
+         * A `ts.SourceFile` has not logically changed and all of its analysis results were thus available
+         * for reuse.
+         */
+        PerfEvent[PerfEvent["SourceFileReuseAnalysis"] = 11] = "SourceFileReuseAnalysis";
+        /**
+         * A Type Check Block (TCB) was generated.
+         */
+        PerfEvent[PerfEvent["GenerateTcb"] = 12] = "GenerateTcb";
+        /**
+         * A Type Check Block (TCB) could not be generated because inlining was disabled, and the block
+         * would've required inlining.
+         */
+        PerfEvent[PerfEvent["SkipGenerateTcbNoInline"] = 13] = "SkipGenerateTcbNoInline";
+        /**
+         * A `.ngtypecheck.ts` file could be reused from the previous program and did not need to be
+         * regenerated.
+         */
+        PerfEvent[PerfEvent["ReuseTypeCheckFile"] = 14] = "ReuseTypeCheckFile";
+        /**
+         * The template type-checking program required changes and had to be updated in an incremental
+         * step.
+         */
+        PerfEvent[PerfEvent["UpdateTypeCheckProgram"] = 15] = "UpdateTypeCheckProgram";
+        /**
+         * The compiler was able to prove that a `ts.SourceFile` did not need to be re-emitted.
+         */
+        PerfEvent[PerfEvent["EmitSkipSourceFile"] = 16] = "EmitSkipSourceFile";
+        /**
+         * A `ts.SourceFile` was emitted.
+         */
+        PerfEvent[PerfEvent["EmitSourceFile"] = 17] = "EmitSourceFile";
+        /**
+         * Tracks the number of `PrefEvent`s, and must appear at the end of the list.
+         */
+        PerfEvent[PerfEvent["LAST"] = 18] = "LAST";
+    })(PerfEvent = exports.PerfEvent || (exports.PerfEvent = {}));
+    /**
+     * Represents a checkpoint during compilation at which the memory usage of the compiler should be
+     * recorded.
+     */
+    var PerfCheckpoint;
+    (function (PerfCheckpoint) {
+        /**
+         * The point at which the `PerfRecorder` was created, and ideally tracks memory used before any
+         * compilation structures are created.
+         */
+        PerfCheckpoint[PerfCheckpoint["Initial"] = 0] = "Initial";
+        /**
+         * The point just after the `ts.Program` has been created.
+         */
+        PerfCheckpoint[PerfCheckpoint["TypeScriptProgramCreate"] = 1] = "TypeScriptProgramCreate";
+        /**
+         * The point just before Angular analysis starts.
+         *
+         * In the main usage pattern for the compiler, TypeScript diagnostics have been calculated at this
+         * point, so the `ts.TypeChecker` has fully ingested the current program, all `ts.Type` structures
+         * and `ts.Symbol`s have been created.
+         */
+        PerfCheckpoint[PerfCheckpoint["PreAnalysis"] = 2] = "PreAnalysis";
+        /**
+         * The point just after Angular analysis completes.
+         */
+        PerfCheckpoint[PerfCheckpoint["Analysis"] = 3] = "Analysis";
+        /**
+         * The point just after Angular resolution is complete.
+         */
+        PerfCheckpoint[PerfCheckpoint["Resolve"] = 4] = "Resolve";
+        /**
+         * The point just after Type Check Blocks (TCBs) have been generated.
+         */
+        PerfCheckpoint[PerfCheckpoint["TtcGeneration"] = 5] = "TtcGeneration";
+        /**
+         * The point just after the template type-checking program has been updated with any new TCBs.
+         */
+        PerfCheckpoint[PerfCheckpoint["TtcUpdateProgram"] = 6] = "TtcUpdateProgram";
+        /**
+         * The point just before emit begins.
+         *
+         * In the main usage pattern for the compiler, all template type-checking diagnostics have been
+         * requested at this point.
+         */
+        PerfCheckpoint[PerfCheckpoint["PreEmit"] = 7] = "PreEmit";
+        /**
+         * The point just after the program has been fully emitted.
+         */
+        PerfCheckpoint[PerfCheckpoint["Emit"] = 8] = "Emit";
+        /**
+         * Tracks the number of `PerfCheckpoint`s, and must appear at the end of the list.
+         */
+        PerfCheckpoint[PerfCheckpoint["LAST"] = 9] = "LAST";
+    })(PerfCheckpoint = exports.PerfCheckpoint || (exports.PerfCheckpoint = {}));
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcGlsZXItY2xpL3NyYy9uZ3RzYy9wZXJmL3NyYy9hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7RGVjbGFyYXRpb25Ob2RlfSBmcm9tICcuLi8uLi9yZWZsZWN0aW9uJztcblxuZXhwb3J0IGludGVyZmFjZSBQZXJmUmVjb3JkZXIge1xuICByZWFkb25seSBlbmFibGVkOiBib29sZWFuO1xuXG4gIG1hcmsobmFtZTogc3RyaW5nLCBub2RlPzogRGVjbGFyYXRpb25Ob2RlLCBjYXRlZ29yeT86IHN0cmluZywgZGV0YWlsPzogc3RyaW5nKTogdm9pZDtcbiAgc3RhcnQobmFtZTogc3RyaW5nLCBub2RlPzogRGVjbGFyYXRpb25Ob2RlLCBjYXRlZ29yeT86IHN0cmluZywgZGV0YWlsPzogc3RyaW5nKTogbnVtYmVyO1xuICBzdG9wKHNwYW46IG51bWJlcik6IHZvaWQ7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/perf/src/api.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;IAEH;;OAEG;IACH,IAAY,SA2IX;IA3ID,WAAY,SAAS;QACnB;;WAEG;QACH,uDAAW,CAAA;QAEX;;;;WAIG;QACH,2CAAK,CAAA;QAEL;;;;;WAKG;QACH,+EAAuB,CAAA;QAEvB;;;;WAIG;QACH,6DAAc,CAAA;QAEd;;;;WAIG;QACH,6DAAc,CAAA;QAEd;;WAEG;QACH,2EAAqB,CAAA;QAErB;;WAEG;QACH,iDAAQ,CAAA;QAER;;;WAGG;QACH,+CAAO,CAAA;QAEP;;WAEG;QACH,6DAAc,CAAA;QAEd;;WAEG;QACH,2DAAa,CAAA;QAEb;;WAEG;QACH,kEAAgB,CAAA;QAEhB;;;WAGG;QACH,8DAAc,CAAA;QAEd;;;;;WAKG;QACH,gDAAO,CAAA;QAEP;;WAEG;QACH,oEAAiB,CAAA;QAEjB;;WAEG;QACH,8DAAc,CAAA;QAEd;;WAEG;QACH,oDAAS,CAAA;QAET;;;WAGG;QACH,8EAAsB,CAAA;QAEtB;;WAEG;QACH,wDAAW,CAAA;QAEX;;;WAGG;QACH,0DAAY,CAAA;QAEZ;;;WAGG;QACH,4DAAa,CAAA;QAEb;;;WAGG;QACH,4CAAK,CAAA;QAEL;;WAEG;QACH,4DAAa,CAAA;QAEb;;;WAGG;QACH,0EAAoB,CAAA;QAEpB;;WAEG;QACH,0CAAI,CAAA;IACN,CAAC,EA3IW,SAAS,GAAT,iBAAS,KAAT,iBAAS,QA2IpB;IAED;;OAEG;IACH,IAAY,SAuGX;IAvGD,WAAY,SAAS;QACnB;;WAEG;QACH,yDAAY,CAAA;QAEZ;;WAEG;QACH,uDAAW,CAAA;QAEX;;WAEG;QACH,iEAAgB,CAAA;QAEhB;;WAEG;QACH,iEAAgB,CAAA;QAEhB;;WAEG;QACH,mEAAiB,CAAA;QAEjB;;WAEG;QACH,+DAAe,CAAA;QAEf;;WAEG;QACH,uDAAW,CAAA;QAEX;;;;WAIG;QACH,yDAAY,CAAA;QAEZ;;;WAGG;QACH,qEAAkB,CAAA;QAElB;;WAEG;QACH,iFAAwB,CAAA;QAExB;;;WAGG;QACH,gFAAuB,CAAA;QAEvB;;;WAGG;QACH,gFAAuB,CAAA;QAEvB;;WAEG;QACH,wDAAW,CAAA;QAEX;;;WAGG;QACH,gFAAuB,CAAA;QAEvB;;;WAGG;QACH,sEAAkB,CAAA;QAElB;;;WAGG;QACH,8EAAsB,CAAA;QAEtB;;WAEG;QACH,sEAAkB,CAAA;QAElB;;WAEG;QACH,8DAAc,CAAA;QAEd;;WAEG;QACH,0CAAI,CAAA;IACN,CAAC,EAvGW,SAAS,GAAT,iBAAS,KAAT,iBAAS,QAuGpB;IAED;;;OAGG;IACH,IAAY,cA0DX;IA1DD,WAAY,cAAc;QACxB;;;WAGG;QACH,yDAAO,CAAA;QAEP;;WAEG;QACH,yFAAuB,CAAA;QAEvB;;;;;;WAMG;QACH,iEAAW,CAAA;QAEX;;WAEG;QACH,2DAAQ,CAAA;QAER;;WAEG;QACH,yDAAO,CAAA;QAEP;;WAEG;QACH,qEAAa,CAAA;QAEb;;WAEG;QACH,2EAAgB,CAAA;QAEhB;;;;;WAKG;QACH,yDAAO,CAAA;QAEP;;WAEG;QACH,mDAAI,CAAA;QAEJ;;WAEG;QACH,mDAAI,CAAA;IACN,CAAC,EA1DW,cAAc,GAAd,sBAAc,KAAd,sBAAc,QA0DzB","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * A phase of compilation for which time is tracked in a distinct bucket.\n */\nexport enum PerfPhase {\n  /**\n   * The \"default\" phase which tracks time not spent in any other phase.\n   */\n  Unaccounted,\n\n  /**\n   * Time spent setting up the compiler, before a TypeScript program is created.\n   *\n   * This includes operations like configuring the `ts.CompilerHost` and any wrappers.\n   */\n  Setup,\n\n  /**\n   * Time spent in `ts.createProgram`, including reading and parsing `ts.SourceFile`s in the\n   * `ts.CompilerHost`.\n   *\n   * This might be an incremental program creation operation.\n   */\n  TypeScriptProgramCreate,\n\n  /**\n   * Time spent reconciling the contents of an old `ts.Program` with the new incremental one.\n   *\n   * Only present in incremental compilations.\n   */\n  Reconciliation,\n\n  /**\n   * Time spent updating an `NgCompiler` instance with a resource-only change.\n   *\n   * Only present in incremental compilations where the change was resource-only.\n   */\n  ResourceUpdate,\n\n  /**\n   * Time spent calculating the plain TypeScript diagnostics (structural and semantic).\n   */\n  TypeScriptDiagnostics,\n\n  /**\n   * Time spent in Angular analysis of individual classes in the program.\n   */\n  Analysis,\n\n  /**\n   * Time spent in Angular global analysis (synthesis of analysis information into a complete\n   * understanding of the program).\n   */\n  Resolve,\n\n  /**\n   * Time spent building the import graph of the program in order to perform cycle detection.\n   */\n  CycleDetection,\n\n  /**\n   * Time spent generating the text of Type Check Blocks in order to perform template type checking.\n   */\n  TcbGeneration,\n\n  /**\n   * Time spent updating the `ts.Program` with new Type Check Block code.\n   */\n  TcbUpdateProgram,\n\n  /**\n   * Time spent by TypeScript performing its emit operations, including downleveling and writing\n   * output files.\n   */\n  TypeScriptEmit,\n\n  /**\n   * Time spent by Angular performing code transformations of ASTs as they're about to be emitted.\n   *\n   * This includes the actual code generation step for templates, and occurs during the emit phase\n   * (but is tracked separately from `TypeScriptEmit` time).\n   */\n  Compile,\n\n  /**\n   * Time spent performing a `TemplateTypeChecker` autocompletion operation.\n   */\n  TtcAutocompletion,\n\n  /**\n   * Time spent computing template type-checking diagnostics.\n   */\n  TtcDiagnostics,\n\n  /**\n   * Time spent getting a `Symbol` from the `TemplateTypeChecker`.\n   */\n  TtcSymbol,\n\n  /**\n   * Time spent by the Angular Language Service calculating a \"get references\" or a renaming\n   * operation.\n   */\n  LsReferencesAndRenames,\n\n  /**\n   * Time spent by the Angular Language Service calculating a \"quick info\" operation.\n   */\n  LsQuickInfo,\n\n  /**\n   * Time spent by the Angular Language Service calculating a \"get type definition\" or \"get\n   * definition\" operation.\n   */\n  LsDefinition,\n\n  /**\n   * Time spent by the Angular Language Service calculating a \"get completions\" (AKA autocomplete)\n   * operation.\n   */\n  LsCompletions,\n\n  /**\n   * Time spent by the Angular Language Service calculating a \"view template typecheck block\"\n   * operation.\n   */\n  LsTcb,\n\n  /**\n   * Time spent by the Angular Language Service calculating diagnostics.\n   */\n  LsDiagnostics,\n\n  /**\n   * Time spent by the Angular Language Service calculating a \"get component locations for template\"\n   * operation.\n   */\n  LsComponentLocations,\n\n  /**\n   * Tracks the number of `PerfPhase`s, and must appear at the end of the list.\n   */\n  LAST,\n}\n\n/**\n * Represents some occurrence during compilation, and is tracked with a counter.\n */\nexport enum PerfEvent {\n  /**\n   * Counts the number of `.d.ts` files in the program.\n   */\n  InputDtsFile,\n\n  /**\n   * Counts the number of non-`.d.ts` files in the program.\n   */\n  InputTsFile,\n\n  /**\n   * An `@Component` class was analyzed.\n   */\n  AnalyzeComponent,\n\n  /**\n   * An `@Directive` class was analyzed.\n   */\n  AnalyzeDirective,\n\n  /**\n   * An `@Injectable` class was analyzed.\n   */\n  AnalyzeInjectable,\n\n  /**\n   * An `@NgModule` class was analyzed.\n   */\n  AnalyzeNgModule,\n\n  /**\n   * An `@Pipe` class was analyzed.\n   */\n  AnalyzePipe,\n\n  /**\n   * A trait was analyzed.\n   *\n   * In theory, this should be the sum of the `Analyze` counters for each decorator type.\n   */\n  TraitAnalyze,\n\n  /**\n   * A trait had a prior analysis available from an incremental program, and did not need to be\n   * re-analyzed.\n   */\n  TraitReuseAnalysis,\n\n  /**\n   * A `ts.SourceFile` directly changed between the prior program and a new incremental compilation.\n   */\n  SourceFilePhysicalChange,\n\n  /**\n   * A `ts.SourceFile` did not physically changed, but according to the file dependency graph, has\n   * logically changed between the prior program and a new incremental compilation.\n   */\n  SourceFileLogicalChange,\n\n  /**\n   * A `ts.SourceFile` has not logically changed and all of its analysis results were thus available\n   * for reuse.\n   */\n  SourceFileReuseAnalysis,\n\n  /**\n   * A Type Check Block (TCB) was generated.\n   */\n  GenerateTcb,\n\n  /**\n   * A Type Check Block (TCB) could not be generated because inlining was disabled, and the block\n   * would've required inlining.\n   */\n  SkipGenerateTcbNoInline,\n\n  /**\n   * A `.ngtypecheck.ts` file could be reused from the previous program and did not need to be\n   * regenerated.\n   */\n  ReuseTypeCheckFile,\n\n  /**\n   * The template type-checking program required changes and had to be updated in an incremental\n   * step.\n   */\n  UpdateTypeCheckProgram,\n\n  /**\n   * The compiler was able to prove that a `ts.SourceFile` did not need to be re-emitted.\n   */\n  EmitSkipSourceFile,\n\n  /**\n   * A `ts.SourceFile` was emitted.\n   */\n  EmitSourceFile,\n\n  /**\n   * Tracks the number of `PrefEvent`s, and must appear at the end of the list.\n   */\n  LAST,\n}\n\n/**\n * Represents a checkpoint during compilation at which the memory usage of the compiler should be\n * recorded.\n */\nexport enum PerfCheckpoint {\n  /**\n   * The point at which the `PerfRecorder` was created, and ideally tracks memory used before any\n   * compilation structures are created.\n   */\n  Initial,\n\n  /**\n   * The point just after the `ts.Program` has been created.\n   */\n  TypeScriptProgramCreate,\n\n  /**\n   * The point just before Angular analysis starts.\n   *\n   * In the main usage pattern for the compiler, TypeScript diagnostics have been calculated at this\n   * point, so the `ts.TypeChecker` has fully ingested the current program, all `ts.Type` structures\n   * and `ts.Symbol`s have been created.\n   */\n  PreAnalysis,\n\n  /**\n   * The point just after Angular analysis completes.\n   */\n  Analysis,\n\n  /**\n   * The point just after Angular resolution is complete.\n   */\n  Resolve,\n\n  /**\n   * The point just after Type Check Blocks (TCBs) have been generated.\n   */\n  TtcGeneration,\n\n  /**\n   * The point just after the template type-checking program has been updated with any new TCBs.\n   */\n  TtcUpdateProgram,\n\n  /**\n   * The point just before emit begins.\n   *\n   * In the main usage pattern for the compiler, all template type-checking diagnostics have been\n   * requested at this point.\n   */\n  PreEmit,\n\n  /**\n   * The point just after the program has been fully emitted.\n   */\n  Emit,\n\n  /**\n   * Tracks the number of `PerfCheckpoint`s, and must appear at the end of the list.\n   */\n  LAST,\n}\n\n/**\n * Records timing, memory, or counts at specific points in the compiler's operation.\n */\nexport interface PerfRecorder {\n  /**\n   * Set the current phase of compilation.\n   *\n   * Time spent in the previous phase will be accounted to that phase. The caller is responsible for\n   * exiting the phase when work that should be tracked within it is completed, and either returning\n   * to the previous phase or transitioning to the next one directly.\n   *\n   * In general, prefer using `inPhase()` to instrument a section of code, as it automatically\n   * handles entering and exiting the phase. `phase()` should only be used when the former API\n   * cannot be cleanly applied to a particular operation.\n   *\n   * @returns the previous phase\n   */\n  phase(phase: PerfPhase): PerfPhase;\n\n  /**\n   * Run `fn` in the given `PerfPhase` and return the result.\n   *\n   * Enters `phase` before executing the given `fn`, then exits the phase and returns the result.\n   * Prefer this API to `phase()` where possible.\n   */\n  inPhase<T>(phase: PerfPhase, fn: () => T): T;\n\n  /**\n   * Record the memory usage of the compiler at the given checkpoint.\n   */\n  memory(after: PerfCheckpoint): void;\n\n  /**\n   * Record that a specific event has occurred, possibly more than once.\n   */\n  eventCount(event: PerfEvent, incrementBy?: number): void;\n\n  /**\n   * Return the `PerfRecorder` to an empty state (clear all tracked statistics) and reset the zero\n   * point to the current time.\n   */\n  reset(): void;\n}\n"]}

package/src/ngtsc/perf/src/noop.d.ts

@@ -1,3 +1,10 @@
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/perf/src/noop" />
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
 import { PerfRecorder } from './api';
 export declare const NOOP_PERF_RECORDER: PerfRecorder;

package/src/ngtsc/perf/src/noop.js

@@ -4,19 +4,34 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/src/ngtsc/perf/src/noop", ["require", "exports"], factory);
+        define("@angular/compiler-cli/src/ngtsc/perf/src/noop", ["require", "exports", "@angular/compiler-cli/src/ngtsc/perf/src/api"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.NOOP_PERF_RECORDER = void 0;
-    exports.NOOP_PERF_RECORDER = {
-        enabled: false,
-        mark: function (name, node, category, detail) { },
-        start: function (name, node, category, detail) {
-            return 0;
-        },
-        stop: function (span) { },
-    };
+    /**
+     * @license
+     * Copyright Google LLC All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    var api_1 = require("@angular/compiler-cli/src/ngtsc/perf/src/api");
+    var NoopPerfRecorder = /** @class */ (function () {
+        function NoopPerfRecorder() {
+        }
+        NoopPerfRecorder.prototype.eventCount = function () { };
+        NoopPerfRecorder.prototype.memory = function () { };
+        NoopPerfRecorder.prototype.phase = function () {
+            return api_1.PerfPhase.Unaccounted;
+        };
+        NoopPerfRecorder.prototype.inPhase = function (phase, fn) {
+            return fn();
+        };
+        NoopPerfRecorder.prototype.reset = function () { };
+        return NoopPerfRecorder;
+    }());
+    exports.NOOP_PERF_RECORDER = new NoopPerfRecorder();
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9vcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyLWNsaS9zcmMvbmd0c2MvcGVyZi9zcmMvbm9vcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7SUFXYSxRQUFBLGtCQUFrQixHQUFpQjtRQUM5QyxPQUFPLEVBQUUsS0FBSztRQUNkLElBQUksRUFBRSxVQUFDLElBQVksRUFBRSxJQUFxQixFQUFFLFFBQWlCLEVBQUUsTUFBZSxJQUFZLENBQUM7UUFDM0YsS0FBSyxFQUFFLFVBQUMsSUFBWSxFQUFFLElBQXFCLEVBQUUsUUFBaUIsRUFBRSxNQUFlO1lBQzdFLE9BQU8sQ0FBQyxDQUFDO1FBQ1gsQ0FBQztRQUNELElBQUksRUFBRSxVQUFDLElBQWtCLElBQVksQ0FBQztLQUN2QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5pbXBvcnQge0RlY2xhcmF0aW9uTm9kZX0gZnJvbSAnLi4vLi4vcmVmbGVjdGlvbic7XG5cbmltcG9ydCB7UGVyZlJlY29yZGVyfSBmcm9tICcuL2FwaSc7XG5cbmV4cG9ydCBjb25zdCBOT09QX1BFUkZfUkVDT1JERVI6IFBlcmZSZWNvcmRlciA9IHtcbiAgZW5hYmxlZDogZmFsc2UsXG4gIG1hcms6IChuYW1lOiBzdHJpbmcsIG5vZGU6IERlY2xhcmF0aW9uTm9kZSwgY2F0ZWdvcnk/OiBzdHJpbmcsIGRldGFpbD86IHN0cmluZyk6IHZvaWQgPT4ge30sXG4gIHN0YXJ0OiAobmFtZTogc3RyaW5nLCBub2RlOiBEZWNsYXJhdGlvbk5vZGUsIGNhdGVnb3J5Pzogc3RyaW5nLCBkZXRhaWw/OiBzdHJpbmcpOiBudW1iZXIgPT4ge1xuICAgIHJldHVybiAwO1xuICB9LFxuICBzdG9wOiAoc3BhbjogbnVtYmVyfGZhbHNlKTogdm9pZCA9PiB7fSxcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9vcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyLWNsaS9zcmMvbmd0c2MvcGVyZi9zcmMvbm9vcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7SUFBQTs7Ozs7O09BTUc7SUFDSCxvRUFBOEM7SUFFOUM7UUFBQTtRQWNBLENBQUM7UUFiQyxxQ0FBVSxHQUFWLGNBQW9CLENBQUM7UUFFckIsaUNBQU0sR0FBTixjQUFnQixDQUFDO1FBRWpCLGdDQUFLLEdBQUw7WUFDRSxPQUFPLGVBQVMsQ0FBQyxXQUFXLENBQUM7UUFDL0IsQ0FBQztRQUVELGtDQUFPLEdBQVAsVUFBVyxLQUFnQixFQUFFLEVBQVc7WUFDdEMsT0FBTyxFQUFFLEVBQUUsQ0FBQztRQUNkLENBQUM7UUFFRCxnQ0FBSyxHQUFMLGNBQWUsQ0FBQztRQUNsQix1QkFBQztJQUFELENBQUMsQUFkRCxJQWNDO0lBR1ksUUFBQSxrQkFBa0IsR0FBaUIsSUFBSSxnQkFBZ0IsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5pbXBvcnQge1BlcmZQaGFzZSwgUGVyZlJlY29yZGVyfSBmcm9tICcuL2FwaSc7XG5cbmNsYXNzIE5vb3BQZXJmUmVjb3JkZXIgaW1wbGVtZW50cyBQZXJmUmVjb3JkZXIge1xuICBldmVudENvdW50KCk6IHZvaWQge31cblxuICBtZW1vcnkoKTogdm9pZCB7fVxuXG4gIHBoYXNlKCk6IFBlcmZQaGFzZSB7XG4gICAgcmV0dXJuIFBlcmZQaGFzZS5VbmFjY291bnRlZDtcbiAgfVxuXG4gIGluUGhhc2U8VD4ocGhhc2U6IFBlcmZQaGFzZSwgZm46ICgpID0+IFQpOiBUIHtcbiAgICByZXR1cm4gZm4oKTtcbiAgfVxuXG4gIHJlc2V0KCk6IHZvaWQge31cbn1cblxuXG5leHBvcnQgY29uc3QgTk9PUF9QRVJGX1JFQ09SREVSOiBQZXJmUmVjb3JkZXIgPSBuZXcgTm9vcFBlcmZSZWNvcmRlcigpO1xuIl19