@angular/compiler-cli 11.2.5 → 11.2.9

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

@@ -0,0 +1,58 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/perf/src/recorder" />
+import { PerfCheckpoint, PerfEvent, PerfPhase, PerfRecorder } from './api';
+/**
+ * Serializable performance data for the compilation, using string names.
+ */
+export interface PerfResults {
+    events: Record<string, number>;
+    phases: Record<string, number>;
+    memory: Record<string, number>;
+}
+/**
+ * A `PerfRecorder` that actively tracks performance statistics.
+ */
+export declare class ActivePerfRecorder implements PerfRecorder {
+    private zeroTime;
+    private counters;
+    private phaseTime;
+    private bytes;
+    private currentPhase;
+    private currentPhaseEntered;
+    /**
+     * Creates an `ActivePerfRecoder` with its zero point set to the current time.
+     */
+    static zeroedToNow(): ActivePerfRecorder;
+    private constructor();
+    reset(): void;
+    memory(after: PerfCheckpoint): void;
+    phase(phase: PerfPhase): PerfPhase;
+    inPhase<T>(phase: PerfPhase, fn: () => T): T;
+    eventCount(counter: PerfEvent, incrementBy?: number): void;
+    /**
+     * Return the current performance metrics as a serializable object.
+     */
+    finalize(): PerfResults;
+}
+/**
+ * A `PerfRecorder` that delegates to a target `PerfRecorder` which can be updated later.
+ *
+ * `DelegatingPerfRecorder` is useful when a compiler class that needs a `PerfRecorder` can outlive
+ * the current compilation. This is true for most compiler classes as resource-only changes reuse
+ * the same `NgCompiler` for a new compilation.
+ */
+export declare class DelegatingPerfRecorder implements PerfRecorder {
+    target: PerfRecorder;
+    constructor(target: PerfRecorder);
+    eventCount(counter: PerfEvent, incrementBy?: number): void;
+    phase(phase: PerfPhase): PerfPhase;
+    inPhase<T>(phase: PerfPhase, fn: () => T): T;
+    memory(after: PerfCheckpoint): void;
+    reset(): void;
+}

package/src/ngtsc/perf/src/recorder.js

@@ -0,0 +1,143 @@
+/**
+ * @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
+ */
+/// <reference types="node" />
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/src/ngtsc/perf/src/recorder", ["require", "exports", "@angular/compiler-cli/src/ngtsc/perf/src/api", "@angular/compiler-cli/src/ngtsc/perf/src/clock"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DelegatingPerfRecorder = exports.ActivePerfRecorder = void 0;
+    var api_1 = require("@angular/compiler-cli/src/ngtsc/perf/src/api");
+    var clock_1 = require("@angular/compiler-cli/src/ngtsc/perf/src/clock");
+    /**
+     * A `PerfRecorder` that actively tracks performance statistics.
+     */
+    var ActivePerfRecorder = /** @class */ (function () {
+        function ActivePerfRecorder(zeroTime) {
+            this.zeroTime = zeroTime;
+            this.currentPhase = api_1.PerfPhase.Unaccounted;
+            this.currentPhaseEntered = this.zeroTime;
+            this.counters = Array(api_1.PerfEvent.LAST).fill(0);
+            this.phaseTime = Array(api_1.PerfPhase.LAST).fill(0);
+            this.bytes = Array(api_1.PerfCheckpoint.LAST).fill(0);
+            // Take an initial memory snapshot before any other compilation work begins.
+            this.memory(api_1.PerfCheckpoint.Initial);
+        }
+        /**
+         * Creates an `ActivePerfRecoder` with its zero point set to the current time.
+         */
+        ActivePerfRecorder.zeroedToNow = function () {
+            return new ActivePerfRecorder(clock_1.mark());
+        };
+        ActivePerfRecorder.prototype.reset = function () {
+            this.counters = Array(api_1.PerfEvent.LAST).fill(0);
+            this.phaseTime = Array(api_1.PerfPhase.LAST).fill(0);
+            this.bytes = Array(api_1.PerfCheckpoint.LAST).fill(0);
+            this.zeroTime = clock_1.mark();
+            this.currentPhase = api_1.PerfPhase.Unaccounted;
+            this.currentPhaseEntered = this.zeroTime;
+        };
+        ActivePerfRecorder.prototype.memory = function (after) {
+            this.bytes[after] = process.memoryUsage().heapUsed;
+        };
+        ActivePerfRecorder.prototype.phase = function (phase) {
+            var previous = this.currentPhase;
+            this.phaseTime[this.currentPhase] += clock_1.timeSinceInMicros(this.currentPhaseEntered);
+            this.currentPhase = phase;
+            this.currentPhaseEntered = clock_1.mark();
+            return previous;
+        };
+        ActivePerfRecorder.prototype.inPhase = function (phase, fn) {
+            var previousPhase = this.phase(phase);
+            try {
+                return fn();
+            }
+            finally {
+                this.phase(previousPhase);
+            }
+        };
+        ActivePerfRecorder.prototype.eventCount = function (counter, incrementBy) {
+            if (incrementBy === void 0) { incrementBy = 1; }
+            this.counters[counter] += incrementBy;
+        };
+        /**
+         * Return the current performance metrics as a serializable object.
+         */
+        ActivePerfRecorder.prototype.finalize = function () {
+            // Track the last segment of time spent in `this.currentPhase` in the time array.
+            this.phase(api_1.PerfPhase.Unaccounted);
+            var results = {
+                events: {},
+                phases: {},
+                memory: {},
+            };
+            for (var i = 0; i < this.phaseTime.length; i++) {
+                if (this.phaseTime[i] > 0) {
+                    results.phases[api_1.PerfPhase[i]] = this.phaseTime[i];
+                }
+            }
+            for (var i = 0; i < this.phaseTime.length; i++) {
+                if (this.counters[i] > 0) {
+                    results.events[api_1.PerfEvent[i]] = this.counters[i];
+                }
+            }
+            for (var i = 0; i < this.bytes.length; i++) {
+                if (this.bytes[i] > 0) {
+                    results.memory[api_1.PerfCheckpoint[i]] = this.bytes[i];
+                }
+            }
+            return results;
+        };
+        return ActivePerfRecorder;
+    }());
+    exports.ActivePerfRecorder = ActivePerfRecorder;
+    /**
+     * A `PerfRecorder` that delegates to a target `PerfRecorder` which can be updated later.
+     *
+     * `DelegatingPerfRecorder` is useful when a compiler class that needs a `PerfRecorder` can outlive
+     * the current compilation. This is true for most compiler classes as resource-only changes reuse
+     * the same `NgCompiler` for a new compilation.
+     */
+    var DelegatingPerfRecorder = /** @class */ (function () {
+        function DelegatingPerfRecorder(target) {
+            this.target = target;
+        }
+        DelegatingPerfRecorder.prototype.eventCount = function (counter, incrementBy) {
+            this.target.eventCount(counter, incrementBy);
+        };
+        DelegatingPerfRecorder.prototype.phase = function (phase) {
+            return this.target.phase(phase);
+        };
+        DelegatingPerfRecorder.prototype.inPhase = function (phase, fn) {
+            // Note: this doesn't delegate to `this.target.inPhase` but instead is implemented manually here
+            // to avoid adding an additional frame of noise to the stack when debugging.
+            var previousPhase = this.target.phase(phase);
+            try {
+                return fn();
+            }
+            finally {
+                this.target.phase(previousPhase);
+            }
+        };
+        DelegatingPerfRecorder.prototype.memory = function (after) {
+            this.target.memory(after);
+        };
+        DelegatingPerfRecorder.prototype.reset = function () {
+            this.target.reset();
+        };
+        return DelegatingPerfRecorder;
+    }());
+    exports.DelegatingPerfRecorder = DelegatingPerfRecorder;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recorder.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/perf/src/recorder.ts"],"names":[],"mappings":"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","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/// <reference types=\"node\" />\n\nimport {PerfCheckpoint, PerfEvent, PerfPhase, PerfRecorder} from './api';\nimport {HrTime, mark, timeSinceInMicros} from './clock';\n\n/**\n * Serializable performance data for the compilation, using string names.\n */\nexport interface PerfResults {\n  events: Record<string, number>;\n  phases: Record<string, number>;\n  memory: Record<string, number>;\n}\n\n/**\n * A `PerfRecorder` that actively tracks performance statistics.\n */\nexport class ActivePerfRecorder implements PerfRecorder {\n  private counters: number[];\n  private phaseTime: number[];\n  private bytes: number[];\n\n  private currentPhase = PerfPhase.Unaccounted;\n  private currentPhaseEntered = this.zeroTime;\n\n  /**\n   * Creates an `ActivePerfRecoder` with its zero point set to the current time.\n   */\n  static zeroedToNow(): ActivePerfRecorder {\n    return new ActivePerfRecorder(mark());\n  }\n\n  private constructor(private zeroTime: HrTime) {\n    this.counters = Array(PerfEvent.LAST).fill(0);\n    this.phaseTime = Array(PerfPhase.LAST).fill(0);\n    this.bytes = Array(PerfCheckpoint.LAST).fill(0);\n\n    // Take an initial memory snapshot before any other compilation work begins.\n    this.memory(PerfCheckpoint.Initial);\n  }\n\n  reset(): void {\n    this.counters = Array(PerfEvent.LAST).fill(0);\n    this.phaseTime = Array(PerfPhase.LAST).fill(0);\n    this.bytes = Array(PerfCheckpoint.LAST).fill(0);\n    this.zeroTime = mark();\n    this.currentPhase = PerfPhase.Unaccounted;\n    this.currentPhaseEntered = this.zeroTime;\n  }\n\n  memory(after: PerfCheckpoint): void {\n    this.bytes[after] = process.memoryUsage().heapUsed;\n  }\n\n  phase(phase: PerfPhase): PerfPhase {\n    const previous = this.currentPhase;\n    this.phaseTime[this.currentPhase] += timeSinceInMicros(this.currentPhaseEntered);\n    this.currentPhase = phase;\n    this.currentPhaseEntered = mark();\n    return previous;\n  }\n\n  inPhase<T>(phase: PerfPhase, fn: () => T): T {\n    const previousPhase = this.phase(phase);\n    try {\n      return fn();\n    } finally {\n      this.phase(previousPhase);\n    }\n  }\n\n  eventCount(counter: PerfEvent, incrementBy: number = 1): void {\n    this.counters[counter] += incrementBy;\n  }\n\n  /**\n   * Return the current performance metrics as a serializable object.\n   */\n  finalize(): PerfResults {\n    // Track the last segment of time spent in `this.currentPhase` in the time array.\n    this.phase(PerfPhase.Unaccounted);\n\n    const results: PerfResults = {\n      events: {},\n      phases: {},\n      memory: {},\n    };\n\n    for (let i = 0; i < this.phaseTime.length; i++) {\n      if (this.phaseTime[i] > 0) {\n        results.phases[PerfPhase[i]] = this.phaseTime[i];\n      }\n    }\n\n    for (let i = 0; i < this.phaseTime.length; i++) {\n      if (this.counters[i] > 0) {\n        results.events[PerfEvent[i]] = this.counters[i];\n      }\n    }\n\n    for (let i = 0; i < this.bytes.length; i++) {\n      if (this.bytes[i] > 0) {\n        results.memory[PerfCheckpoint[i]] = this.bytes[i];\n      }\n    }\n\n    return results;\n  }\n}\n\n/**\n * A `PerfRecorder` that delegates to a target `PerfRecorder` which can be updated later.\n *\n * `DelegatingPerfRecorder` is useful when a compiler class that needs a `PerfRecorder` can outlive\n * the current compilation. This is true for most compiler classes as resource-only changes reuse\n * the same `NgCompiler` for a new compilation.\n */\nexport class DelegatingPerfRecorder implements PerfRecorder {\n  constructor(public target: PerfRecorder) {}\n\n  eventCount(counter: PerfEvent, incrementBy?: number): void {\n    this.target.eventCount(counter, incrementBy);\n  }\n\n  phase(phase: PerfPhase): PerfPhase {\n    return this.target.phase(phase);\n  }\n\n  inPhase<T>(phase: PerfPhase, fn: () => T): T {\n    // Note: this doesn't delegate to `this.target.inPhase` but instead is implemented manually here\n    // to avoid adding an additional frame of noise to the stack when debugging.\n    const previousPhase = this.target.phase(phase);\n    try {\n      return fn();\n    } finally {\n      this.target.phase(previousPhase);\n    }\n  }\n\n  memory(after: PerfCheckpoint): void {\n    this.target.memory(after);\n  }\n\n  reset(): void {\n    this.target.reset();\n  }\n}\n"]}

package/src/ngtsc/program.d.ts

@@ -41,8 +41,6 @@ export declare class NgtscProgram implements api.Program {
     private reuseTsProgram;
     private closureCompilerEnabled;
     private host;
-    private perfRecorder;
-    private perfTracker;
     private incrementalStrategy;
     constructor(rootNames: ReadonlyArray<string>, options: NgCompilerOptions, delegateHost: api.CompilerHost, oldProgram?: NgtscProgram);
     getTsProgram(): ts.Program;