@amazon/vinyl-util 1.0.0

package/dist/types/ts3.7/logging/Logger.d.ts

@@ -0,0 +1,66 @@
+import { ReadonlyEventHost } from '../event/EventHost';
+import { EventHostImpl } from '../event/EventHost';
+import { LogTarget } from '../logging/LogTarget';
+export declare enum LogLevel {
+    VERBOSE = 0,
+    DEBUG = 1,
+    INFO = 2,
+    WARN = 3,
+    ERROR = 4,
+    NONE = 5
+}
+export interface LogEvent {
+    readonly messages: any[];
+    readonly target: LogTarget;
+    readonly level: LogLevel;
+}
+export interface LogEventMap {
+    readonly log: LogEvent;
+}
+/**
+ * The interface for a basic logger implementation.
+ */
+export interface Logger extends ReadonlyEventHost<LogEventMap> {
+    logLevel: LogLevel;
+    log(target: LogTarget, level: LogLevel, ...messages: readonly any[]): void;
+}
+export declare class LoggerImpl extends EventHostImpl<LogEventMap> implements Logger {
+    logLevel: LogLevel;
+    get [Symbol.toStringTag](): string;
+    constructor(logLevel?: LogLevel);
+    log(target: LogTarget, level: LogLevel, ...messages: readonly any[]): void;
+}
+/**
+ * A global reference to the logger.
+ * @private
+ */
+export declare const loggerRef: import("../global/globalRegistry").GlobalRef<Logger>;
+/**
+ * Returns the current log level.
+ */
+export declare function getLogLevel(): LogLevel;
+/**
+ * Sets the current log level.
+ *
+ * @param value
+ */
+export declare function setLogLevel(value: LogLevel): void;
+export declare function log(target: LogTarget, level: LogLevel, ...messages: readonly any[]): void;
+export declare function logVerbose(target: LogTarget, ...messages: readonly any[]): void;
+export declare function logDebug(target: LogTarget, ...messages: readonly any[]): void;
+export declare function logInfo(target: LogTarget, ...messages: readonly any[]): void;
+export declare function logWarn(target: LogTarget, ...messages: readonly any[]): void;
+export declare function logError(target: LogTarget, ...messages: readonly any[]): void;
+/**
+ * From a case-insensitive string, returns the log level.
+ * Possible values match to the keys in {@link LogLevel}.
+ *
+ * @param str
+ */
+export declare function parseLogLevel(str: string): LogLevel | null;
+/**
+ * Returns the log level as a lowercase string.
+ * E.g. stringifyLogLevel(LogLevel.DEBUG) returns 'debug'
+ */
+export declare function stringifyLogLevel(logLevel: LogLevel): string;
+//# sourceMappingURL=Logger.d.ts.map

package/dist/types/ts3.7/logging/VinylLogging.d.ts

@@ -0,0 +1,9 @@
+import { ConsoleLogHandler } from './ConsoleLogHandler';
+import { HistoryLogHandler } from './HistoryLogHandler';
+export declare const historyLogHandler: import("../global/globalRegistry").GlobalRef<HistoryLogHandler | undefined>;
+export declare const consoleLogHandler: import("../global/globalRegistry").GlobalRef<ConsoleLogHandler | undefined>;
+/**
+ * Initializes vinyl logging.
+ */
+export declare function initializeLogging(): void;
+//# sourceMappingURL=VinylLogging.d.ts.map

package/dist/types/ts3.7/logging/getLogLevelFromSearch.d.ts

@@ -0,0 +1,8 @@
+import { LogLevel } from '../logging/Logger';
+/**
+ * Returns the current vinyl logging level, as set by the querystring parameter: vinylLogLevel.
+ * @param search
+ * @param defaultLevel
+ */
+export declare function getLogLevelFromSearch(search?: string, defaultLevel?: LogLevel): LogLevel;
+//# sourceMappingURL=getLogLevelFromSearch.d.ts.map

package/dist/types/ts3.7/logging/logTimer.d.ts

@@ -0,0 +1,10 @@
+import { LogTarget } from '../logging/LogTarget';
+/**
+ * Creates a timer that logs elapsed time when called.
+ *
+ * @param target - The log target
+ * @param message - Message to log with the elapsed time
+ * @returns Function that logs the elapsed time since creation
+ */
+export declare function logTimer(target: LogTarget, message: string): () => void;
+//# sourceMappingURL=logTimer.d.ts.map

package/dist/types/ts3.7/network/RequestError.d.ts

@@ -0,0 +1,26 @@
+import { ReportableError } from '../error/ReportableError';
+import { RequestErrorEvent } from './RequesterImplEventMap';
+import { Json } from '../util/serialization/json';
+/**
+ * An error reported from a service response.
+ */
+export declare class RequestError extends ReportableError {
+    /**
+     * When the request failure is a !ok response, this will be set.
+     */
+    readonly response: Response | null;
+    readonly info: RequestErrorEvent;
+    get [Symbol.toStringTag](): string;
+    private static getErrorMessage;
+    /**
+     * 500 errors are external service errors, all other errors are considered internal.
+     */
+    static getErrorOrigin(info: RequestErrorEvent): string;
+    constructor(
+    /**
+     * When the request failure is a !ok response, this will be set.
+     */
+    response: Response | null, info: RequestErrorEvent);
+    toJSON(): Json;
+}
+//# sourceMappingURL=RequestError.d.ts.map

package/dist/types/ts3.7/network/RequestInterceptor.d.ts

@@ -0,0 +1,14 @@
+export interface MutableRequestParams {
+    input: string;
+    init: Omit<RequestInit, 'signal'>;
+}
+/**
+ * Mutates a request before it's made.
+ * A request interceptor can be set in Vinyl dependencies. It will be called immediately before a request is made.
+ * The interceptor may modify the request, for example to add headers, change caching, or client-side redirection.
+ * Example to disable caching:
+ *
+ * `(params) => { params.init.cache = 'no-cache' }`
+ */
+export type RequestInterceptor = (params: MutableRequestParams) => void;
+//# sourceMappingURL=RequestInterceptor.d.ts.map

package/dist/types/ts3.7/network/Requester.d.ts

@@ -0,0 +1,84 @@
+import { ReadonlyAbort } from '../util/async/Abort';
+import { Maybe } from '../util/type';
+/**
+ * Init options for the request.
+ *
+ * This mirrors the fetch init parameter omitting `signal`. For request cancellation, use
+ * `abort` on RequestOptions.
+ */
+export type RequestInitOptions = Readonly<Omit<RequestInit, 'signal'>>;
+/**
+ * Encapsulates the parameters needed to make a request.
+ */
+export interface RequestParams {
+    readonly input: RequestInfo | Readonly<URL>;
+    readonly init?: Maybe<Readonly<RequestInitOptions>>;
+    readonly requestOptions?: Maybe<RequestOptions>;
+}
+/**
+ * An abstraction to fetching resources.
+ * Implementations may have retry or throttling behaviors.
+ */
+export interface Requester {
+    /**
+     * Requests a resource.
+     *
+     * Note: Unlike `window.fetch`, the returned promise is expected to reject if the
+     * response is !ok.
+     */
+    request(input: RequestInfo | Readonly<URL>, init?: Maybe<RequestInitOptions>, requestOptions?: Maybe<RequestOptions>): Promise<Response>;
+}
+/**
+ * Configuration for a fetch request.
+ */
+export interface RequestOptions {
+    /**
+     * If supplied, will cancel the request on abort.
+     */
+    readonly abort?: Maybe<ReadonlyAbort>;
+    /**
+     * Determines how error responses are read and reported.
+     */
+    readonly readErrorBody?: ErrorBodyType;
+    /**
+     * The service id is used to obtain a service controller for that service.
+     * If nullish, then empty service metrics will be used.
+     */
+    readonly serviceId?: Maybe<string>;
+}
+export declare enum ErrorBodyType {
+    DISABLED = 0,
+    TEXT = 1,
+    JSON = 2
+}
+/**
+ * The signature of `window.fetch`. Provided as a dependency for testing.
+ */
+export type Fetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+/**
+ * Capped exponential backoff timing with jitter.
+ *
+ * The timing follows the equation:
+ * `distribution() * min(interval * pow(exponentBase, failureCount), max)`
+ */
+export interface BackoffOptions {
+    /**
+     * The maximum time to wait between tries, in seconds, regardless of how many consecutive
+     * failures.
+     */
+    readonly maxTime: number;
+    /**
+     * The interval in seconds, multiplied by `pow(exponentBase, failureCount)`.
+     */
+    readonly interval: number;
+    /**
+     * pow(exponentBase, failureCount)
+     */
+    readonly exponentBase: number;
+    /**
+     * The distribution function to randomize request retry timing.
+     * This is to prevent all users from making retries at the same time.
+     */
+    readonly distribution: () => number;
+}
+//# sourceMappingURL=Requester.d.ts.map

package/dist/types/ts3.7/network/RequesterImpl.d.ts

@@ -0,0 +1,116 @@
+import { EventHostImpl } from '../event/EventHost';
+import { NetworkMetricsController } from './metrics/NetworkMetricsController';
+import { BackoffOptions, Fetch, Requester, RequestInitOptions, RequestOptions } from './Requester';
+import { RequesterImplEventMap } from './RequesterImplEventMap';
+import { Maybe, PartialDeep } from '../util/type';
+/**
+ * Request impl options configuring retry and timeout behavior.
+ */
+export interface RequesterImplOptions {
+    /**
+     * Retry configuration.
+     */
+    readonly retryOptions: RetryOptions;
+    /**
+     * The timeout (in seconds) before the request is aborted.
+     */
+    readonly timeout: number;
+}
+export interface RetryOptions {
+    /**
+     * The maximum number of retries for a single request.
+     * Default: 1
+     * For requests with side effects, this should be set to 0.
+     *
+     * "Various studies have collected data which shows that one max retry is sufficient to
+     * achieve 99.999% success. The idea is that a truly transient failure should succeed on
+     * the first retry.  And if the retry fails then it is likely more than a transient failure
+     * and additional retries are exhausting resources in the system for no benefit."
+     */
+    readonly retries: number;
+    /**
+     * The number of consecutive failures before retries are no longer attempted, only tries.
+     */
+    readonly retryFailureCutoff: number;
+    /**
+     * Retry backoff timing.
+     */
+    readonly retryBackoff: BackoffOptions;
+    /**
+     * First try backoff timing.
+     */
+    readonly tryBackoff: BackoffOptions;
+    /**
+     * If there is a retry-after header, add the returned amount of time (in seconds) to prevent
+     * clustered retry behavior.
+     */
+    readonly retryAfterJitter: () => number;
+    /**
+     * Given the network status code, returns true if the fetch should retry.
+     */
+    readonly shouldRetry: (status: number) => boolean;
+}
+/**
+ * The minimum amount of time to leave for network calls. If the `max try time -
+ * timeout` is less than this value, an IllegalArgumentError will be thrown.
+ */
+export declare const MIN_SERVICE_TIME = 10;
+/**
+ * Distribute requests across the last 50% of the exponential back-off time
+ */
+export declare function defaultBackoffDistribution(): number;
+/**
+ * Calculates the timer delay according to an exponential back off strategy.
+ *
+ * @param failedCount The number of times the service has consecutively failed.
+ * @param options Retry timing options (default values from:
+ *   `defaultRetryOptions`)
+ *
+ * @returns The delay to retry a network request in seconds. This will be clamped
+ *   between 1 and `options.maxRetryTime`.
+ */
+export declare function getBackoffTime(failedCount: number, options: BackoffOptions): number;
+/**
+ * Dependencies for {@link RequesterImpl}
+ */
+export interface RequesterImplDeps {
+    readonly fetch: Fetch;
+    readonly networkMetricsController: NetworkMetricsController;
+}
+export declare const RetryStrategy: {
+    readonly NO_RETRIES: RetryOptions;
+    readonly ONE_RETRY: RetryOptions;
+};
+/**
+ * A quality of service wrapper to `global.fetch`.
+ * Handles retries, network status, and emits events that may be used in reporting or metrics.
+ */
+export declare class RequesterImpl extends EventHostImpl<RequesterImplEventMap> implements Requester {
+    protected readonly deps: RequesterImplDeps;
+    get [Symbol.toStringTag](): string;
+    /**
+     * Default values for fetch options.
+     */
+    private _options;
+    constructor(deps: RequesterImplDeps);
+    get options(): RequesterImplOptions;
+    /**
+     * Applies the given partial configuration.
+     *
+     * @param newOptions
+     */
+    configure(newOptions: PartialDeep<RequesterImplOptions>): void;
+    request(input: RequestInfo | Readonly<URL>, init?: Maybe<RequestInitOptions>, requestOptions?: Maybe<RequestOptions>): Promise<Response>;
+    /**
+     * Executes a single fetch.
+     * If the request is aborted via `requestInfo.init.signal` the promise will be rejected with
+     * the abort reason.
+     *
+     * @throws RequestError
+     * @private
+     */
+    private doRequest;
+    private reportMetricsEntry;
+}
+export declare const nativeFetchRef: import("../global/globalRegistry").GlobalRef<Fetch>;
+//# sourceMappingURL=RequesterImpl.d.ts.map

package/dist/types/ts3.7/network/RequesterImplEventMap.d.ts

@@ -0,0 +1,230 @@
+import { Timestamp } from '../util/date/date';
+import { ErrorBodyType } from '../network/Requester';
+/**
+ * Events {@link RequesterImpl} emits.
+ */
+export interface RequesterImplEventMap {
+    /**
+     * A request has been requested.
+     * This is emitted immediately when {@link Requester.request} is called.
+     */
+    readonly request: RequestEvent;
+    /**
+     * A request attempt has begun. For implementations with retry behavior, this is expected to be
+     * emitted for each try.
+     */
+    readonly requestAttemptStart: RequestAttemptStartEvent;
+    /**
+     * A request attempt has completed.
+     */
+    readonly requestAttemptComplete: RequestCompletedEvent;
+    /**
+     * The request promise is about to settle.
+     */
+    readonly requestComplete: RequestCompletedEvent;
+}
+export interface RequestEvent {
+    /**
+     * Information about the request.
+     */
+    readonly requestInfo: FetchRequestInfo;
+}
+export interface RequestAttemptStartEvent {
+    /**
+     * Information about the request.
+     */
+    readonly requestInfo: FetchRequestInfo;
+    /**
+     * Information about the current attempt.
+     */
+    readonly attemptInfo: RequestAttemptInfo;
+}
+/**
+ * When a request has been made, information about the request is gathered for logging.
+ */
+export interface FetchRequestInfo {
+    /**
+     * The identifier for the request. The request id for the `requesting` event will match its
+     * corresponding `requestComplete` event.
+     */
+    readonly requestId: string;
+    /**
+     * The input parameter passed to `request`.
+     */
+    readonly input: RequestInfo | URL;
+    /**
+     * The init parameter passed to `request`.
+     */
+    readonly init: RequestInit;
+    /**
+     * The maximum number of retries.
+     */
+    readonly maxRetries: number;
+    /**
+     * Options the request is using.
+     */
+    readonly requestOptions: {
+        /**
+         * The resolved service id.
+         */
+        readonly serviceId: string | null;
+        /**
+         * Determines how error responses are read and reported.
+         */
+        readonly readErrorBody: ErrorBodyType;
+    };
+    /**
+     * The timestamp the request was originally requested.
+     */
+    readonly timestamp: Timestamp;
+}
+/**
+ * Information about the current try.
+ */
+export interface RequestAttemptInfo {
+    /**
+     * The current try (1 = first).
+     */
+    readonly currentTry: number;
+    /**
+     * The timestamp the actual request attempt began. This will be after awaiting network
+     * availability.
+     */
+    readonly timestamp: Timestamp;
+}
+/**
+ * Information about a request completion, either from a successful response or a failure.
+ */
+export type RequestCompletedEvent = RequestSuccessEvent | RequestErrorEvent;
+export interface RequestCompletedEventBase {
+    /**
+     * True if the request was successful.
+     */
+    readonly ok: boolean;
+    /**
+     * The local timestamp of the request result or error.
+     */
+    readonly timestamp: Timestamp;
+    /**
+     * Information about the request.
+     */
+    readonly requestInfo: FetchRequestInfo;
+}
+export interface RequestSuccessEvent extends RequestCompletedEventBase {
+    /**
+     * The response was successful.
+     */
+    readonly ok: true;
+    /**
+     * The serializable and loggable response.
+     */
+    readonly responseInfo: ResponseInfo;
+    /**
+     * Information about the current attempt.
+     */
+    readonly attemptInfo: RequestAttemptInfo;
+}
+export declare enum RequestFailureType {
+    /**
+     * The request has been aborted.
+     */
+    ABORT = "abort",
+    /**
+     * The request failed due to a caught internal error.
+     */
+    INTERNAL = "internal",
+    /**
+     * The request failed with a caught error.
+     */
+    NETWORK = "network",
+    /**
+     * An `!ok` response was received.
+     */
+    RESPONSE = "response"
+}
+export type RequestErrorEvent = RequestCaughtErrorEvent | RequestNetworkErrorEvent | RequestResponseErrorEvent;
+export interface RequestErrorEventBase extends RequestCompletedEventBase {
+    /**
+     * The request failed.
+     */
+    readonly ok: false;
+    /**
+     * The failure type.
+     */
+    readonly type: RequestFailureType;
+    /**
+     * If false, the request will not be retried, even if there are more tries remaining.
+     *
+     * This will be false if the error is an internal error, retries have been exhausted or the
+     * response did not pass the `shouldRetry` filter.
+     */
+    readonly willRetry: boolean;
+    /**
+     * The timestamp of the next try.
+     * If `willRetry` is true, the request will try again at this timestamp.
+     */
+    readonly retryAfter: Timestamp | null;
+    /**
+     * The caught or rejected reason.
+     */
+    readonly reason: any;
+}
+export interface RequestCaughtErrorEvent extends RequestErrorEventBase {
+    readonly type: RequestFailureType.INTERNAL | RequestFailureType.ABORT;
+    /**
+     * Caught errors will not be retried.
+     */
+    readonly willRetry: false;
+}
+export interface RequestNetworkErrorEvent extends RequestErrorEventBase {
+    readonly type: RequestFailureType.NETWORK;
+    /**
+     * Information about the current attempt.
+     */
+    readonly attemptInfo: RequestAttemptInfo;
+}
+export interface RequestResponseErrorEvent extends RequestErrorEventBase {
+    readonly type: RequestFailureType.RESPONSE;
+    /**
+     * The serializable and loggable response.
+     */
+    readonly responseInfo: ResponseInfo;
+    /**
+     * Information about the current attempt.
+     */
+    readonly attemptInfo: RequestAttemptInfo;
+}
+/**
+ * Serializable response metadata, excluding the body.
+ */
+export interface ResponseInfo {
+    /**
+     * True if status is in the 200–299 range.
+     */
+    readonly ok: boolean;
+    /**
+     * True if the response resulted from a redirect.
+     */
+    readonly redirected: boolean;
+    /**
+     * HTTP status code (e.g. 200).
+     */
+    readonly status: number;
+    /**
+     * HTTP status text (e.g. "OK").
+     */
+    readonly statusText: string;
+    /**
+     * Type of response (e.g. "basic", "cors").
+     */
+    readonly type: ResponseType;
+    /**
+     * Final resolved URL of the response.
+     */
+    readonly url: string;
+    /**
+     * Size of the response body in bytes, or null if unknown.
+     */
+    readonly contentLength: number | null;
+}
+//# sourceMappingURL=RequesterImplEventMap.d.ts.map

package/dist/types/ts3.7/network/browser/NetworkInformation.d.ts

@@ -0,0 +1,48 @@
+export interface NetworkInformationEventMap {
+    readonly change: Event;
+}
+export type NetworkInformationEffectiveType = 'slow-2g' | '2g' | '3g' | '4g';
+export type NetworkInformationType = 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | 'unknown';
+/**
+ * Provides information about the system’s current network connection,
+ * such as estimated bandwidth, round-trip time, and connection type.
+ * Also exposes events for monitoring changes to the network state.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/NetworkInformation
+ */
+export interface NetworkInformation extends EventTarget {
+    /**
+     * Approximate downlink speed in megabits per second.
+     * Rounded to the nearest 25 kbps, based on recent throughput
+     * over active connections. May be undefined if no estimate is available.
+     */
+    readonly downlink: number | undefined;
+    /**
+     * A string describing the general quality of the connection
+     * (for example, "4g", "3g"). Determined from both downlink
+     * and latency estimates.
+     */
+    readonly effectiveType: NetworkInformationEffectiveType;
+    /**
+     * Estimated round-trip latency of the current connection in milliseconds,
+     * rounded to the nearest multiple of 25 ms.
+     */
+    readonly rtt: number;
+    /**
+     * Indicates whether the user has requested reduced data usage
+     * in the user agent’s settings.
+     */
+    readonly saveData: boolean;
+    /**
+     * Type of underlying network connection in use
+     * (for example, "wifi", "cellular"). May be omitted if unknown.
+     */
+    readonly type?: NetworkInformationType;
+    addEventListener<K extends keyof NetworkInformationEventMap>(type: K, listener: (this: NetworkInformation, ev: NetworkInformationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof NetworkInformationEventMap>(type: K, listener: (this: NetworkInformation, ev: NetworkInformationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+}
+/**
+ * Returns the browser's NetworkInformation interface, if it's defined.
+ */
+export declare function getNetworkInformation(): NetworkInformation | undefined;
+//# sourceMappingURL=NetworkInformation.d.ts.map

package/dist/types/ts3.7/network/createRequester.d.ts

@@ -0,0 +1,12 @@
+import { Requester } from './Requester';
+import { RequesterImplDeps, RequesterImplOptions } from './RequesterImpl';
+import { Maybe, PartialDeep } from '../util/type';
+/**
+ * Creates a default Requester implementation with optional configuration or dependency overrides.
+ * The new Requester is watched for global logging and network metrics.
+ *
+ * @param options
+ * @param deps
+ */
+export declare function createRequester(options?: Maybe<PartialDeep<RequesterImplOptions>>, deps?: Partial<RequesterImplDeps>): Requester;
+//# sourceMappingURL=createRequester.d.ts.map

package/dist/types/ts3.7/network/logging/networkLoggingHandler.d.ts

@@ -0,0 +1,14 @@
+import { Disposable } from '../../core/disposable';
+import { ReadonlyEventHost } from '../../event/EventHost';
+import { RequesterImplEventMap } from '../../network/RequesterImplEventMap';
+import { LogTarget } from '../../logging/LogTarget';
+/**
+ * Logs all network events.
+ *
+ * @param requester The event host with request events to observe.
+ * @return Returns a disposable handle to remove all added handlers.
+ */
+export declare function networkLoggingHandler(requester: ReadonlyEventHost<RequesterImplEventMap>): Disposable & {
+    readonly target: LogTarget;
+};
+//# sourceMappingURL=networkLoggingHandler.d.ts.map

package/dist/types/ts3.7/network/metrics/NetworkMetricsController.d.ts

@@ -0,0 +1,41 @@
+import { ReadonlyEventHost } from '../../event/EventHost';
+import { AnyRecord, Maybe } from '../../util/type';
+import { NetworkMetrics, NetworkMetricsEntry, NetworkTransferEntry, ServiceMetrics } from './networkMetricsModel';
+export interface NetworkMetricsEventMap {
+    /**
+     * The network metrics state has changed.
+     */
+    readonly metricsChange: AnyRecord;
+}
+export interface ReadonlyNetworkMetricsController extends ReadonlyEventHost<NetworkMetricsEventMap> {
+    /**
+     * The current metrics state.
+     * The returned object is static at the time of request.
+     */
+    readonly metrics: NetworkMetrics;
+    /**
+     * Returns metrics for the given service id.
+     * If the service id is nullish, or there is no history for the given service, empty service
+     * metrics will be returned.
+     *
+     * The returned object is static at the time of request.
+     *
+     * @param serviceId
+     */
+    getServiceMetrics(serviceId: Maybe<string>): ServiceMetrics;
+}
+export interface NetworkMetricsController extends ReadonlyNetworkMetricsController {
+    /**
+     * Adds information about a completed settled request.
+     * Note: This does not update estimated bandwidth.
+     * @param entry
+     */
+    addMetricsEntry(entry: NetworkMetricsEntry): void;
+    /**
+     * Adds information about a completed downlink content transfer.
+     *
+     * @param entry
+     */
+    addDownlinkTransferEntry(entry: NetworkTransferEntry): void;
+}
+//# sourceMappingURL=NetworkMetricsController.d.ts.map