@digitraffic/common 2026.3.17-1 → 2026.3.26-1-beta

package/dist/utils/geometry.js

@@ -0,0 +1,154 @@
+import * as geoJsonValidator from "geojson-validation";
+import { logger } from "../aws/runtime/dt-logger-default.js";
+export const SRID_WGS84 = 4326;
+/**
+ * Creates WKT geometry from GeoJSON geometry
+ * @param geometry GeoJson geometry to convert to WKT
+ */
+export function createGeometry(geometry) {
+    if (geometry.type === "LineString") {
+        const coordinates = linestring(geometry.coordinates);
+        return `LINESTRING(${coordinates})`;
+    }
+    else if (geometry.type === "Point") {
+        const coordinates = coordinatePair(geometry.coordinates);
+        return `POINT(${coordinates})`;
+    }
+    else if (geometry.type === "Polygon") {
+        const coordinates = polygon(geometry.coordinates);
+        return `POLYGON(${coordinates})`;
+    }
+    else if (geometry.type === "MultiPolygon") {
+        const coordinates = multiPolygon(geometry.coordinates);
+        return `MULTIPOLYGON(${coordinates})`;
+    }
+    logger.error({
+        method: "Geometry.createGeometry",
+        message: `Unsupported locationType ${geometry.type}`,
+    });
+    return "POLYGON EMPTY";
+}
+function linestring(coordinates) {
+    return coordinates.map((c) => coordinatePair(c)).join(",");
+}
+function polygon(coordinates) {
+    const list = coordinates.map((c) => linestring(c)).join(",");
+    return `(${list})`;
+}
+function multiPolygon(coordinates) {
+    const list = coordinates.map((c) => polygon(c)).join(",");
+    return `(${list})`;
+}
+function coordinatePair(coordinate) {
+    return `${coordinate[0]} ${coordinate[1]}`;
+}
+/**
+ * Create a GeoJSON FeatureCollection from a list of GeoJSON features with a 'last updated' property.
+ * Geometry is nullable. According to the GeoJSON specification, if coordinates are unavailable,
+ * the value of geometry should be null.
+ * @param features List of Features
+ * @param lastUpdated Last updated date
+ */
+export function createFeatureCollection(features, lastUpdated) {
+    return {
+        type: "FeatureCollection",
+        lastUpdated: lastUpdated,
+        features: features,
+    };
+}
+export function isValidGeoJson(json) {
+    // Tests complain about this method returning type string[] which is obviously wrong. Therefore, this casting.
+    return geoJsonValidator.valid(json);
+}
+export function isFeatureCollection(json) {
+    // Tests complain about this method returning type string[] which is obviously wrong. Therefore, this casting.
+    return geoJsonValidator.isFeatureCollection(json);
+}
+const DEGREES_TO_RADIANS = 0.017453292519943295; // = Math.PI / 180
+const EARTH_RADIUS_KM = 6371;
+/**
+ * Returns the distance between two WGS84 points in kilometers. Doesn't take in account altitude.
+ * Based on the following Stack Overflow question:
+ * http://stackoverflow.com/questions/27928/calculate-distance-between-two-latitude-longitude-points-haversine-formula,
+ * which is based on https://en.wikipedia.org/wiki/Haversine_formula (error rate: ~0.55%).
+ * @param fromXLon first point longitude
+ * @param fromYLat first point latitude
+ * @param toXLon second point longitude
+ * @param toYLat second point latitude
+ */
+function distanceBetweenWGS84PointsInKm(fromXLon, fromYLat, toXLon, toYLat) {
+    const diffLat = toRadians(toYLat - fromYLat);
+    const diffLon = toRadians(toXLon - fromXLon);
+    const a = Math.sin(diffLat / 2) * Math.sin(diffLat / 2) +
+        Math.cos(toRadians(fromYLat)) *
+            Math.cos(toRadians(toYLat)) *
+            Math.sin(diffLon / 2) *
+            Math.sin(diffLon / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return EARTH_RADIUS_KM * c;
+}
+/**
+ * Returns the distance between two WGS84 GeoJSON positions in kilometers. Doesn't take in account altitude.
+ * Based on the following Stack Overflow question:
+ * http://stackoverflow.com/questions/27928/calculate-distance-between-two-latitude-longitude-points-haversine-formula,
+ * which is based on https://en.wikipedia.org/wiki/Haversine_formula (error rate: ~0.55%).
+ * @param pos1 first position
+ * @param pos2 second position
+ */
+export function distanceBetweenPositionsInKm(pos1, pos2) {
+    const [pos10, pos11] = pos1;
+    const [pos20, pos21] = pos2;
+    if (pos1.length > 3 ||
+        pos2.length > 3 ||
+        !pos10 ||
+        !pos11 ||
+        !pos20 ||
+        !pos21) {
+        throw Error(`Illegal Positions ${pos1.toString()} and ${pos2.toString()}. Both must have length between 2 or 3.`);
+    }
+    return distanceBetweenWGS84PointsInKm(pos10, pos11, pos20, pos21);
+}
+export function areDistinctPositions(previous, next) {
+    return previous[0] !== next[0] || previous[1] !== next[1];
+}
+/**
+ * Calculates distance between two GeoJSON points (WGS84)
+ * @param pos1
+ * @param pos2
+ */
+export function distanceBetweenPositionsInM(pos1, pos2) {
+    return distanceBetweenPositionsInKm(pos1, pos2) * 1000; // km -> m
+}
+export function createGmlLineString(geometry, srsName = "EPSG:4326") {
+    const posList = createPosList(geometry);
+    return {
+        srsName,
+        posList,
+    };
+}
+function createPosList(geometry) {
+    if (geometry.type === "Point") {
+        return positionToList(geometry.coordinates);
+    }
+    else if (geometry.type === "LineString") {
+        return lineStringToList(geometry.coordinates);
+    }
+    else if (geometry.type === "Polygon") {
+        return polygonToList(geometry.coordinates);
+    }
+    throw new Error(`unknown geometry type ${JSON.stringify(geometry)}`);
+}
+function polygonToList(positions, precision = 8) {
+    return positions.map((p) => lineStringToList(p, precision)).join(" ");
+}
+function lineStringToList(positions, precision = 8) {
+    return positions.map((p) => positionToList(p, precision)).join(" ");
+}
+export function positionToList(position, precision = 8) {
+    return position.map((n) => n.toPrecision(precision)).join(" ");
+}
+// Converts numeric degrees to radians
+function toRadians(angdeg) {
+    return angdeg * DEGREES_TO_RADIANS;
+}
+//# sourceMappingURL=geometry.js.map

package/dist/utils/lambda-proxy-event.d.ts

@@ -0,0 +1,9 @@
+import type { APIGatewayProxyEvent } from "aws-lambda";
+/**
+ * Parses query parameters from an APIGatewayProxyEvent, allowing certain fields to always be treated as arrays (multiValueQueryStringParameters).
+ * As APIGatewayProxyEvent can have both single and multi-value query parameters, this function merges them appropriately mixed in both variables.
+ * e.g. multiValueQueryStringParameters contains always values from queryStringParameters.
+ * @param event APIGatewayProxyEvent from lambda proxy integration handler
+ * @param multiValueQueryParameters fields that are multi-value query parameters
+ */
+export declare function parseQueryParams<T extends Record<string, unknown>>(event: APIGatewayProxyEvent, multiValueQueryParameters?: readonly string[]): T;

package/dist/utils/lambda-proxy-event.js

@@ -0,0 +1,31 @@
+/**
+ * Parses query parameters from an APIGatewayProxyEvent, allowing certain fields to always be treated as arrays (multiValueQueryStringParameters).
+ * As APIGatewayProxyEvent can have both single and multi-value query parameters, this function merges them appropriately mixed in both variables.
+ * e.g. multiValueQueryStringParameters contains always values from queryStringParameters.
+ * @param event APIGatewayProxyEvent from lambda proxy integration handler
+ * @param multiValueQueryParameters fields that are multi-value query parameters
+ */
+export function parseQueryParams(event, multiValueQueryParameters = []) {
+    const multi = event.multiValueQueryStringParameters ?? {};
+    const single = event.queryStringParameters ?? {};
+    const keys = new Set([...Object.keys(single), ...Object.keys(multi)]);
+    const result = {};
+    for (const key of keys) {
+        const multiVal = multi[key];
+        const singleVal = single[key];
+        let values;
+        if (Array.isArray(multiVal)) {
+            values = multiVal;
+        }
+        else if (typeof singleVal === "string") {
+            values = [singleVal];
+        }
+        else {
+            continue;
+        }
+        const forceArray = multiValueQueryParameters.includes(key);
+        result[key] = forceArray ? values : values.length > 1 ? values : values[0];
+    }
+    return result;
+}
+//# sourceMappingURL=lambda-proxy-event.js.map

package/dist/utils/logging.d.ts

@@ -0,0 +1,40 @@
+import { DtLogger } from "../aws/runtime/dt-logger.js";
+/**
+ * Curried version of logException.
+ *
+ * @example <caption>Using default configuration</caption>
+ * Promise.reject(x).catch(createExceptionLogger())
+ *
+ * @example <caption>Providing external logger and requiring stack</caption>
+ * import {logger} from "@digitraffic/common/dist/aws/runtime/dt-logger-default"
+ * Promise.reject(x).catch(createExceptionLogger(logger, true))
+ *
+ * @param [logger=undefined] - DtLogger to use. If not given, will create a new instance of DtLogger
+ * @param [includeStack=false] - Define if the stack trace should be logged.
+ * @returns Logger that logs the error without rethrowing.
+ * @see {@link logException}
+ */
+export declare function createExceptionLogger(logger?: DtLogger | undefined, includeStack?: boolean): (error: unknown) => void;
+/**
+ * Log given exception with level ERROR to given logger.
+ *
+ * @param logger - DtLogger to use
+ * @param error - Error or string to log
+ * @param [includeStack=true] - Include stack in the message, default false
+ * @returns Logs the error without rethrowing
+ * @see {@link DtLogger.log}
+ * @see {@link createExceptionLogger} for a curried setup
+ */
+export declare function logException(logger: DtLogger, error: unknown, includeStack?: boolean): void;
+/**
+ * Truncate string at the end if it exceeds max length.
+ * @param str
+ * @param max
+ */
+export declare function truncateEnd(str: string, max?: number): string;
+/**
+ * Truncate string in the middle if it exceeds max length.
+ * @param str
+ * @param max
+ */
+export declare function truncateMiddle(str: string, max?: number): string;

package/dist/utils/logging.js

@@ -0,0 +1,88 @@
+import { DtLogger } from "../aws/runtime/dt-logger.js";
+import { getEnvVariableOrElse } from "./utils.js";
+const functionName = getEnvVariableOrElse("AWS_LAMBDA_FUNCTION_NAME", "test");
+/**
+ * Curried version of logException.
+ *
+ * @example <caption>Using default configuration</caption>
+ * Promise.reject(x).catch(createExceptionLogger())
+ *
+ * @example <caption>Providing external logger and requiring stack</caption>
+ * import {logger} from "@digitraffic/common/dist/aws/runtime/dt-logger-default"
+ * Promise.reject(x).catch(createExceptionLogger(logger, true))
+ *
+ * @param [logger=undefined] - DtLogger to use. If not given, will create a new instance of DtLogger
+ * @param [includeStack=false] - Define if the stack trace should be logged.
+ * @returns Logger that logs the error without rethrowing.
+ * @see {@link logException}
+ */
+export function createExceptionLogger(logger = undefined, includeStack = false) {
+    let thatLogger;
+    if (logger) {
+        thatLogger = logger;
+    }
+    else {
+        thatLogger = new DtLogger();
+    }
+    return (error) => {
+        logException(thatLogger, error, includeStack);
+    };
+}
+/**
+ * Log given exception with level ERROR to given logger.
+ *
+ * @param logger - DtLogger to use
+ * @param error - Error or string to log
+ * @param [includeStack=true] - Include stack in the message, default false
+ * @returns Logs the error without rethrowing
+ * @see {@link DtLogger.log}
+ * @see {@link createExceptionLogger} for a curried setup
+ */
+export function logException(logger, error, includeStack = false) {
+    const message = error instanceof Error
+        ? error.message
+        : typeof error === "string"
+            ? error
+            : JSON.stringify(error);
+    const stack = error instanceof Error && includeStack ? error.stack : undefined;
+    logger.error({
+        type: "Error",
+        method: `${functionName}.logException`,
+        message: `error=${message}`,
+        stack,
+    });
+}
+/**
+ * Truncate string at the end if it exceeds max length.
+ * @param str
+ * @param max
+ */
+export function truncateEnd(str, max = 1000) {
+    if (!str) {
+        return "";
+    }
+    const truncate = str.length - max;
+    const markerLen = `[TRUNCATED ${truncate} CHARS]`.length;
+    if (str.length <= max || truncate <= markerLen) {
+        return str;
+    }
+    return `${str.slice(0, max).trim()} [TRUNCATED ${str.length - max} CHARS]`;
+}
+/**
+ * Truncate string in the middle if it exceeds max length.
+ * @param str
+ * @param max
+ */
+export function truncateMiddle(str, max = 1000) {
+    if (!str) {
+        return "";
+    }
+    const truncate = str.length - max;
+    const markerLen = `[TRUNCATED ${truncate} CHARS]`.length;
+    if (str.length <= max || truncate <= markerLen) {
+        return str;
+    }
+    const half = Math.floor(max / 2);
+    return `${str.slice(0, half).trim()} [TRUNCATED ${str.length - max} CHARS] ${str.slice(str.length - half).trim()}`;
+}
+//# sourceMappingURL=logging.js.map

package/dist/utils/retry.d.ts

@@ -0,0 +1,33 @@
+export declare enum RetryLogError {
+    LOG_ALL_AS_ERRORS = 0,
+    LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS = 1,
+    NO_LOGGING = 2
+}
+export type TimeoutFn = (retryCount: number) => number;
+export type RetryPredicate = (error: unknown) => boolean;
+/**
+ * Utility timeout functions for "retry" function.
+ */
+export declare const timeoutFunctions: {
+    noTimeout: (_: number) => number;
+    exponentialTimeout: (retryCount: number) => number;
+};
+/**
+ * Utility retry predicates for "retry" function.
+ */
+export declare const retryPredicates: {
+    retryBasedOnStatusCode: (error: unknown) => boolean;
+    alwaysRetry: (_: unknown) => boolean;
+};
+export declare let retryCount: number;
+/**
+ * Utility function for retrying async functions.
+ * @param asyncFn Function
+ * @param retries Amount of retries, default is 3. If set to <= 0, no retries will be done. Using non-finite numbers will throw an error. The maximum allowed retry count is 100.
+ * @param logError Logging options
+ * @param timeoutBetweenRetries A function that returns the timeout between retries in milliseconds. Default is a function returning 0. The function is called with the current retry count.
+ * @param retryPredicate A function that returns true if the error should be retried. Default is a function that always returns true. The function is called with the error object.
+ * @return Promise return value
+ */
+export declare function retry<T>(asyncFn: () => Promise<T>, retries?: number, logError?: RetryLogError, timeoutBetweenRetries?: TimeoutFn, retryPredicate?: RetryPredicate): Promise<T>;
+export declare function retryRequest<T>(request: (...args: unknown[]) => Promise<T>, ...args: unknown[]): Promise<T>;

package/dist/utils/retry.js

@@ -0,0 +1,135 @@
+import { logger } from "../aws/runtime/dt-logger-default.js";
+import { AsyncTimeoutError } from "../types/async-timeout-error.js";
+import { HttpError } from "../types/http-error.js";
+export var RetryLogError;
+(function (RetryLogError) {
+    RetryLogError[RetryLogError["LOG_ALL_AS_ERRORS"] = 0] = "LOG_ALL_AS_ERRORS";
+    RetryLogError[RetryLogError["LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS"] = 1] = "LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS";
+    RetryLogError[RetryLogError["NO_LOGGING"] = 2] = "NO_LOGGING";
+})(RetryLogError || (RetryLogError = {}));
+/**
+ * Utility timeout functions for "retry" function.
+ */
+export const timeoutFunctions = (() => ({
+    noTimeout: (_) => {
+        return 0;
+    },
+    exponentialTimeout: (retryCount) => {
+        return 2 ** retryCount * 1000;
+    },
+}))();
+/**
+ * Utility retry predicates for "retry" function.
+ */
+export const retryPredicates = (() => {
+    const retryStatusCodes = new Set([
+        // service might return 403 for no apparent reason
+        403,
+        // Opensearch responds 429, if you make too many requests too fast
+        429,
+    ]);
+    return {
+        retryBasedOnStatusCode: (error) => {
+            if (error instanceof HttpError) {
+                return retryStatusCodes.has(error.statusCode);
+            }
+            return false;
+        },
+        alwaysRetry: (_) => {
+            return true;
+        },
+    };
+})();
+function readPossibleErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return "Something else than an Error object was thrown";
+}
+// Tämä muuttuja on testejä varten määritelty täällä.
+export let retryCount = 0;
+async function retryRecursive(asyncFn, retries, retryCountInj, logError, timeoutBetweenRetries, retryPredicate) {
+    const asyncFnTimeout = 30 * 60 * 1000; // 30 minutes
+    if (!Number.isFinite(retries)) {
+        throw new Error("Only finite numbers are supported");
+    }
+    if (retries > 100) {
+        throw new Error("Exceeded the maximum retry count of 100");
+    }
+    try {
+        // NOTE, a Promise cannot be cancelled. So if the asyncFn calls multiple async/await paris and the first one takes 31 minutes to complete,
+        // then the rest of async/await pairs will be called even though AsyncTimeoutError is already thrown.
+        const result = await Promise.race([
+            asyncFn(),
+            new Promise((_resolve, reject) => setTimeout(() => reject(new AsyncTimeoutError()), asyncFnTimeout)),
+        ]);
+        return result;
+    }
+    catch (error) {
+        const remainingRetries = retries - 1;
+        if (logError === RetryLogError.LOG_ALL_AS_ERRORS) {
+            logger.error({
+                message: readPossibleErrorMessage(error),
+                method: "retry.retryRecursive",
+            });
+        }
+        else if (logError === RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS) {
+            if (remainingRetries < 0) {
+                logger.error({
+                    message: readPossibleErrorMessage(error),
+                    method: "retry.retryRecursive",
+                });
+            }
+            else {
+                logger.warn({
+                    message: readPossibleErrorMessage(error),
+                    method: "retry.retryRecursive",
+                });
+            }
+        }
+        if (remainingRetries < 0) {
+            logger.warn({
+                message: "No retries left",
+                method: "retry.retryRecursive",
+            });
+            throw new Error("No retries left");
+        }
+        logger.warn({
+            message: `Retrying with remaining retries ${remainingRetries}`,
+            method: "retry.retryRecursive",
+        });
+        if (retryPredicate(error)) {
+            retryCountInj++;
+            retryCount = retryCountInj;
+            const milliseconds = timeoutBetweenRetries(retryCountInj);
+            if (milliseconds > 0) {
+                await new Promise((resolve) => setTimeout(resolve, milliseconds));
+            }
+            return retryRecursive(asyncFn, remainingRetries, retryCountInj, logError, timeoutBetweenRetries, retryPredicate);
+        }
+        else {
+            throw new Error("Retry predicate failed");
+        }
+    }
+}
+/**
+ * Utility function for retrying async functions.
+ * @param asyncFn Function
+ * @param retries Amount of retries, default is 3. If set to <= 0, no retries will be done. Using non-finite numbers will throw an error. The maximum allowed retry count is 100.
+ * @param logError Logging options
+ * @param timeoutBetweenRetries A function that returns the timeout between retries in milliseconds. Default is a function returning 0. The function is called with the current retry count.
+ * @param retryPredicate A function that returns true if the error should be retried. Default is a function that always returns true. The function is called with the error object.
+ * @return Promise return value
+ */
+export async function retry(asyncFn, retries = 3, logError = RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS, timeoutBetweenRetries = timeoutFunctions.noTimeout, retryPredicate = retryPredicates.alwaysRetry) {
+    retryCount = 0;
+    return retryRecursive(asyncFn, retries, 0, logError, timeoutBetweenRetries, retryPredicate);
+}
+function wrapArgsToFn(fn, ...args) {
+    return async () => await fn(...args);
+}
+export async function retryRequest(request, ...args) {
+    const asyncFn = wrapArgsToFn(request, ...args);
+    return retry(asyncFn, 5, RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS, timeoutFunctions.exponentialTimeout, retryPredicates.retryBasedOnStatusCode);
+}
+//# sourceMappingURL=retry.js.map

package/dist/utils/slack.d.ts

@@ -0,0 +1,5 @@
+export declare class SlackApi {
+    private readonly url;
+    constructor(url: string);
+    notify(text: string): Promise<void>;
+}

package/dist/utils/slack.js

@@ -0,0 +1,24 @@
+import ky from "ky";
+import { logger } from "../aws/runtime/dt-logger-default.js";
+import { logException } from "./logging.js";
+export class SlackApi {
+    url;
+    constructor(url) {
+        this.url = url;
+    }
+    async notify(text) {
+        try {
+            logger.info({
+                method: "SlackApi.notify",
+                message: "Sending slack notification",
+            });
+            await ky.post(this.url, {
+                json: { text: text },
+            });
+        }
+        catch (error) {
+            logException(logger, error);
+        }
+    }
+}
+//# sourceMappingURL=slack.js.map

package/dist/utils/stop-watch.d.ts

@@ -0,0 +1,46 @@
+import type { DtLogger, LoggerMethodType } from "../aws/runtime/dt-logger.js";
+export interface TaskPeriod {
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+}
+export interface TaskRecord {
+    taskName: string;
+    periods: TaskPeriod[];
+    totalDuration: number;
+    isRunning: boolean;
+}
+export type ReadonlyTaskRecord = Readonly<{
+    taskName: string;
+    periods: ReadonlyArray<Readonly<TaskPeriod>>;
+    totalDuration: number;
+    isRunning: boolean;
+}>;
+export declare class StopWatch {
+    private tasks;
+    private static readonly DEFAULT_TASK_NAME;
+    static createStarted(taskName?: string): StopWatch;
+    getDuration(taskName?: string): number;
+    start(taskName?: string): this;
+    stop(taskName?: string): this;
+    /**
+     * If task is running, records does not include duration of current period.
+     * @param taskName
+     */
+    getTask(taskName: string): ReadonlyTaskRecord | undefined;
+    /**
+     * If task is running, records does not include duration of current period.
+     */
+    getTasks(): ReadonlyTaskRecord[];
+    /**
+     * Removes one or all tasks.
+     * @param taskName if given resets only that task otherwise clears all.
+     */
+    reset(taskName?: string): this;
+    /**
+     * Logs all tasks and their durations. If there is also default task, logs that too with <code>task: method</code>.
+     * @param method
+     * @param level
+     */
+    logTasks(method: LoggerMethodType, level?: keyof Pick<DtLogger, "debug" | "info" | "warn" | "error">): void;
+}

package/dist/utils/stop-watch.js

@@ -0,0 +1,114 @@
+import { logger } from "../aws/runtime/dt-logger-default.js";
+export class StopWatch {
+    tasks = new Map();
+    static DEFAULT_TASK_NAME = "DEFAULT_INTERNAL_TASK";
+    static createStarted(taskName = StopWatch.DEFAULT_TASK_NAME) {
+        const sw = new StopWatch();
+        sw.start(taskName);
+        return sw;
+    }
+    getDuration(taskName = StopWatch.DEFAULT_TASK_NAME) {
+        const task = this.getTask(taskName);
+        if (!task) {
+            return 0;
+        }
+        let duration = task.totalDuration;
+        if (task.isRunning) {
+            // If the task is running, last period is ongoing
+            const currentPeriod = task.periods[task.periods.length - 1];
+            if (currentPeriod) {
+                duration += Date.now() - currentPeriod.startTime;
+            }
+        }
+        return duration;
+    }
+    start(taskName = StopWatch.DEFAULT_TASK_NAME) {
+        const now = Date.now();
+        let task = this.tasks.get(taskName);
+        if (!task) {
+            // create a new one
+            task = {
+                taskName,
+                periods: [],
+                totalDuration: 0,
+                isRunning: false,
+            };
+            this.tasks.set(taskName, task);
+        }
+        // if already running, stop it and start new
+        if (task.isRunning) {
+            this.stop(taskName);
+        }
+        // start a new period
+        task.periods.push({ startTime: now });
+        task.isRunning = true;
+        return this;
+    }
+    stop(taskName = StopWatch.DEFAULT_TASK_NAME) {
+        const now = Date.now();
+        const task = this.tasks.get(taskName);
+        if (!task) {
+            throw new Error(`Task "${taskName}" not found`);
+        }
+        if (!task.isRunning) {
+            return this; // nothing to stop
+        }
+        const currentPeriod = task.periods[task.periods.length - 1];
+        if (!currentPeriod || currentPeriod.endTime) {
+            throw new Error(`Task "${taskName}" is not currently running`);
+        }
+        currentPeriod.endTime = now;
+        currentPeriod.duration = now - currentPeriod.startTime;
+        task.totalDuration += currentPeriod.duration;
+        task.isRunning = false;
+        return this;
+    }
+    /**
+     * If task is running, records does not include duration of current period.
+     * @param taskName
+     */
+    getTask(taskName) {
+        return this.tasks.get(taskName);
+    }
+    /**
+     * If task is running, records does not include duration of current period.
+     */
+    getTasks() {
+        return Array.from(this.tasks.values()).filter((task) => task.taskName !== StopWatch.DEFAULT_TASK_NAME);
+    }
+    /**
+     * Removes one or all tasks.
+     * @param taskName if given resets only that task otherwise clears all.
+     */
+    reset(taskName) {
+        if (taskName) {
+            this.tasks.delete(taskName);
+        }
+        else {
+            this.tasks.clear();
+        }
+        return this;
+    }
+    /**
+     * Logs all tasks and their durations. If there is also default task, logs that too with <code>task: method</code>.
+     * @param method
+     * @param level
+     */
+    logTasks(method, level = "info") {
+        for (const task of this.getTasks()) {
+            logger[level]({
+                method,
+                customTask: task.taskName,
+                tookMs: this.getDuration(task.taskName),
+            });
+        }
+        if (this.getTask(StopWatch.DEFAULT_TASK_NAME)) {
+            logger[level]({
+                method,
+                customTask: method,
+                tookMs: this.getDuration(StopWatch.DEFAULT_TASK_NAME),
+            });
+        }
+    }
+}
+//# sourceMappingURL=stop-watch.js.map