@sha1n/about-time 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Shai Nagar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,97 @@
+[![CI](https://github.com/sha1n/about-time/actions/workflows/ci.yml/badge.svg)](https://github.com/sha1n/about-time/actions/workflows/ci.yml)
+[![Coverage](https://github.com/sha1n/about-time/actions/workflows/coverage.yml/badge.svg)](https://github.com/sha1n/about-time/actions/workflows/coverage.yml)
+![GitHub](https://img.shields.io/github/license/sha1n/about-time)
+![npm type definitions](https://img.shields.io/npm/types/@sha1n/about-time)
+![npm](https://img.shields.io/npm/v/@sha1n/about-time)
+
+
+# About-Time
+
+A set of essential time related utilities.
+
+- [About-Time](#about-time)
+  - [Install](#install)
+  - [Delay](#delay)
+  - [Sleep](#sleep)
+  - [Stopwatch](#stopwatch)
+  - [Until / Eventually](#until--eventually)
+  - [Retry](#retry)
+    - [RetryPolicy](#retrypolicy)
+      - [Simple retry policy](#simple-retry-policy)
+      - [Fixed retry policy](#fixed-retry-policy)
+      - [Exponential backoff retry policy](#exponential-backoff-retry-policy)
+    - [RetryAround](#retryaround)
+    - [Retriable](#retriable)
+
+
+## Install
+```bash
+npm i @sha1n/about-time
+```
+
+## Delay
+```ts
+// Execute a function with delay and return it's value
+await delay(action, 10, TimeUnit.Milliseconds);
+```
+
+## Sleep
+```ts
+// Pause execution for a specified amount of time
+await sleep(10, TimeUnit.Seconds);
+```
+
+## Stopwatch
+```ts
+// Measure time between actions
+const elapsed = stopwatch();
+    
+// do stuff here...
+
+const elapsed1 = elapsed(TimeUnit.Milliseconds);
+
+// do more stuff here...
+
+const elapsed2 = elapsed(TimeUnit.Seconds);
+```
+
+## Until / Eventually
+```ts
+// Wait for a condition to become true
+await until(condition, {timeout: 1, units: TimeUnit.Minute});
+await eventually(condition, {timeout: 1, units: TimeUnit.Minute});
+```
+
+## Retry
+
+### RetryPolicy
+#### Simple retry policy
+```ts
+// 3 retries with 10 seconds wait between each
+const retryPolicy = simpleRetryPolicy(3, 10, TimeUnit.Seconds);
+```
+
+#### Fixed retry policy
+```ts
+// 4 retries after 3, then after 10, 50 and 100 milliseconds
+const retryPolicy = fixedRetryPolicy([3, 10, 50, 100], TimeUnit.Milliseconds);
+```
+
+#### Exponential backoff retry policy
+```ts
+// 10 retries, starting with 10 milliseconds and then exponentially increases the delay based on the default power value without a limit.
+const retryPolicy = exponentialBackoffRetryPolicy(/* count = */10, /* opts?: { exponential?: number, limit?: number, units?: TimeUnit }*/);
+```
+
+### RetryAround
+Executes the given function with the retries based on the specified policy.
+```ts
+const result = await retryAround(action, retryPolicy);
+```
+
+### Retriable
+Wraps a given function with `retryAround` with the specified policy.
+```ts
+const retriableAction = retriable(action, retryPolicy);
+const result = await retriableAction();
+```

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib/timeunit"), exports);
+__exportStar(require("./lib/utilities"), exports);
+__exportStar(require("./lib/retry"), exports);

package/dist/lib/retry.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exponentialBackoffRetryPolicy = exports.simpleRetryPolicy = exports.fixedRetryPolicy = exports.retriable = exports.retryAround = void 0;
+const timeunit_1 = require("./timeunit");
+const utilities_1 = require("./utilities");
+class SimpleRetryPolicy {
+    constructor(count, interval, units) {
+        this.count = count;
+        this.interval = (0, timeunit_1.toMilliseconds)(interval, units);
+    }
+    *intervals() {
+        let count = this.count;
+        while (count > 0) {
+            count -= 1;
+            yield this.interval;
+        }
+        return;
+    }
+}
+class ExponentialBackoffRetryPolicy {
+    constructor(count, exponential = 2, limit = Infinity, units = timeunit_1.TimeUnit.Milliseconds) {
+        this.count = count;
+        this.exponential = exponential;
+        this.limit = limit;
+        this.units = units;
+    }
+    *intervals() {
+        let index = 0;
+        while (index < this.count) {
+            const interval = Math.round((Math.pow(this.exponential, index) - 1) / 2);
+            yield Math.min(this.limit, interval) * this.units;
+            index += 1;
+        }
+        return;
+    }
+}
+class FixedRetryPolicy {
+    constructor(intervals, units) {
+        this._intervals = intervals.reduceRight((result, v) => {
+            result.push((0, timeunit_1.toMilliseconds)(v, units));
+            return result;
+        }, []);
+    }
+    *intervals() {
+        const intervals = [...this._intervals];
+        while (intervals.length > 0) {
+            yield intervals.pop();
+        }
+        return;
+    }
+}
+function simpleRetryPolicy(count, interval, opts) {
+    return Object.freeze(new SimpleRetryPolicy(count, interval, opts === null || opts === void 0 ? void 0 : opts.units));
+}
+exports.simpleRetryPolicy = simpleRetryPolicy;
+function fixedRetryPolicy(intervals, opts) {
+    return Object.freeze(new FixedRetryPolicy(intervals, opts === null || opts === void 0 ? void 0 : opts.units));
+}
+exports.fixedRetryPolicy = fixedRetryPolicy;
+function exponentialBackoffRetryPolicy(count, opts) {
+    return Object.freeze(new ExponentialBackoffRetryPolicy(count, opts === null || opts === void 0 ? void 0 : opts.exponential, opts === null || opts === void 0 ? void 0 : opts.limit, opts === null || opts === void 0 ? void 0 : opts.units));
+}
+exports.exponentialBackoffRetryPolicy = exponentialBackoffRetryPolicy;
+async function retryAround(action, policy) {
+    let next;
+    const intervals = policy.intervals()[Symbol.iterator]();
+    do {
+        try {
+            return await action();
+        }
+        catch (e) {
+            next = intervals.next();
+            if (next.done) {
+                throw e;
+            }
+            await (0, utilities_1.sleep)(next.value);
+        }
+    } while (!next.done);
+    throw new Error('Unexpected error. This is most likely a bug.');
+}
+exports.retryAround = retryAround;
+function retriable(action, policy) {
+    return () => {
+        return retryAround(action, policy);
+    };
+}
+exports.retriable = retriable;

package/dist/lib/timeunit.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMilliseconds = exports.TimeUnit = void 0;
+var TimeUnit;
+(function (TimeUnit) {
+    TimeUnit[TimeUnit["Milliseconds"] = 1] = "Milliseconds";
+    TimeUnit[TimeUnit["Millisecond"] = 1] = "Millisecond";
+    TimeUnit[TimeUnit["Seconds"] = 1000] = "Seconds";
+    TimeUnit[TimeUnit["Second"] = 1000] = "Second";
+    TimeUnit[TimeUnit["Minutes"] = 60000] = "Minutes";
+    TimeUnit[TimeUnit["Minute"] = 60000] = "Minute";
+    TimeUnit[TimeUnit["Hours"] = 3600000] = "Hours";
+    TimeUnit[TimeUnit["Hour"] = 3600000] = "Hour";
+    TimeUnit[TimeUnit["Days"] = 86400000] = "Days";
+    TimeUnit[TimeUnit["Day"] = 86400000] = "Day";
+})(TimeUnit || (TimeUnit = {}));
+exports.TimeUnit = TimeUnit;
+/**
+ * Converts time value in other units to milliseconds.
+ *
+ * @param time a time value to be converted
+ * @param units the units of time
+ * @returns the time value in milliseconds
+ */
+function toMilliseconds(time, units) {
+    return time * (units ? units : 1);
+}
+exports.toMilliseconds = toMilliseconds;

package/dist/lib/utilities.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventually = exports.until = exports.stopwatch = exports.delay = exports.sleep = void 0;
+const timeunit_1 = require("./timeunit");
+/**
+ * Zzzz...
+ *
+ * @param time time to sleep
+ * @param units the units on time
+ * @returns a promise that resolves when the specified time has elapsed.
+ */
+function sleep(time, units) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, (0, timeunit_1.toMilliseconds)(time, units));
+    });
+}
+exports.sleep = sleep;
+/**
+ * Delays the execution of the specified action and returns its value.
+ *
+ * @param action a function to execute with delay
+ * @param time time to sleep
+ * @param units the units on time
+ * @returns a promise that resolves when the specified time has elapsed.
+ */
+function delay(action, time, units) {
+    const delayMs = (0, timeunit_1.toMilliseconds)(time, units);
+    return new Promise((resolve, reject) => {
+        setTimeout(() => Promise.resolve(action()).then(resolve, reject), delayMs);
+    });
+}
+exports.delay = delay;
+/**
+ * Return a function that returns the elapsed time relative to this call.
+ * @returns a function
+ */
+function stopwatch() {
+    const startTime = Date.now();
+    return (units) => {
+        return (Date.now() - startTime) / (units || timeunit_1.TimeUnit.Milliseconds);
+    };
+}
+exports.stopwatch = stopwatch;
+/**
+ * Awaits a specified condition to evaluate to true with or without a timeout.
+ *
+ * @param condition the condition to wait for
+ * @param opts options that control evaluation intervals and timeout
+ * @returns a promise that resolves when the condition becomes true, or rejects when a set timeout is crossed.
+ */
+async function until(condition, opts) {
+    if (condition()) {
+        return;
+    }
+    const defaultInterval = 50;
+    const deadline = opts
+        ? Date.now() + (0, timeunit_1.toMilliseconds)(opts.timeout, opts.units)
+        : Number.MAX_VALUE;
+    const interval = (opts === null || opts === void 0 ? void 0 : opts.interval)
+        ? (0, timeunit_1.toMilliseconds)(opts.interval, opts.units)
+        : defaultInterval;
+    return new Promise((resolve, reject) => {
+        const handle = setInterval(() => {
+            if (Date.now() > deadline) {
+                clearInterval(handle);
+                reject(new Error('Timeout'));
+            }
+            if (condition()) {
+                clearInterval(handle);
+                resolve();
+            }
+        }, interval);
+    });
+}
+exports.until = until;
+/**
+ * Alias to `until`
+ */
+const eventually = until;
+exports.eventually = eventually;

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/timeunit';
+export * from './lib/utilities';
+export * from './lib/retry';

package/dist/types/lib/retry.d.ts

@@ -0,0 +1,18 @@
+import { TimeUnit } from './timeunit';
+interface RetryPolicy {
+    intervals(): Iterable<number>;
+}
+declare function simpleRetryPolicy(count: number, interval: number, opts?: {
+    units?: TimeUnit;
+}): RetryPolicy;
+declare function fixedRetryPolicy(intervals: number[], opts?: {
+    units?: TimeUnit;
+}): RetryPolicy;
+declare function exponentialBackoffRetryPolicy(count: number, opts?: {
+    exponential?: number;
+    limit?: number;
+    units?: TimeUnit;
+}): RetryPolicy;
+declare function retryAround<T>(action: () => T | Promise<T>, policy: RetryPolicy): Promise<T>;
+declare function retriable<T>(action: () => T | Promise<T>, policy: RetryPolicy): () => Promise<T>;
+export { RetryPolicy, retryAround, retriable, fixedRetryPolicy, simpleRetryPolicy, exponentialBackoffRetryPolicy };

package/dist/types/lib/timeunit.d.ts

@@ -0,0 +1,21 @@
+declare enum TimeUnit {
+    Milliseconds = 1,
+    Millisecond = 1,
+    Seconds = 1000,
+    Second = 1000,
+    Minutes = 60000,
+    Minute = 60000,
+    Hours = 3600000,
+    Hour = 3600000,
+    Days = 86400000,
+    Day = 86400000
+}
+/**
+ * Converts time value in other units to milliseconds.
+ *
+ * @param time a time value to be converted
+ * @param units the units of time
+ * @returns the time value in milliseconds
+ */
+declare function toMilliseconds(time: number, units?: TimeUnit): number;
+export { TimeUnit, toMilliseconds };

package/dist/types/lib/utilities.d.ts

@@ -0,0 +1,40 @@
+import { TimeUnit } from './timeunit';
+/**
+ * Zzzz...
+ *
+ * @param time time to sleep
+ * @param units the units on time
+ * @returns a promise that resolves when the specified time has elapsed.
+ */
+declare function sleep(time: number, units?: TimeUnit): Promise<void>;
+/**
+ * Delays the execution of the specified action and returns its value.
+ *
+ * @param action a function to execute with delay
+ * @param time time to sleep
+ * @param units the units on time
+ * @returns a promise that resolves when the specified time has elapsed.
+ */
+declare function delay<T>(action: () => T | Promise<T>, time: number, units?: TimeUnit): Promise<T>;
+/**
+ * Return a function that returns the elapsed time relative to this call.
+ * @returns a function
+ */
+declare function stopwatch(): (units?: TimeUnit) => number;
+/**
+ * Awaits a specified condition to evaluate to true with or without a timeout.
+ *
+ * @param condition the condition to wait for
+ * @param opts options that control evaluation intervals and timeout
+ * @returns a promise that resolves when the condition becomes true, or rejects when a set timeout is crossed.
+ */
+declare function until(condition: () => boolean, opts?: {
+    interval?: number;
+    timeout: number;
+    units?: TimeUnit;
+}): Promise<void>;
+/**
+ * Alias to `until`
+ */
+declare const eventually: typeof until;
+export { sleep, delay, stopwatch, until, eventually };

package/index.ts

@@ -0,0 +1,3 @@
+export * from './lib/timeunit';
+export * from './lib/utilities';
+export * from './lib/retry';

package/lib/retry.ts

@@ -0,0 +1,139 @@
+import { TimeUnit, toMilliseconds } from './timeunit';
+import { sleep } from './utilities';
+
+interface RetryPolicy {
+  intervals(): Iterable<number>;
+}
+
+class SimpleRetryPolicy implements RetryPolicy {
+  private readonly interval: number;
+
+  constructor(
+    private readonly count: number,
+    interval: number,
+    units?: TimeUnit
+  ) {
+    this.interval = toMilliseconds(interval, units);
+  }
+
+  *intervals(): Iterable<number> {
+    let count = this.count;
+    while (count > 0) {
+      count -= 1;
+      yield this.interval;
+    }
+
+    return;
+  }
+}
+
+class ExponentialBackoffRetryPolicy implements RetryPolicy {
+  constructor(
+    private readonly count: number,
+    private readonly exponential = 2,
+    private readonly limit = Infinity,
+    private readonly units = TimeUnit.Milliseconds
+  ) {}
+
+  *intervals(): Iterable<number> {
+    let index = 0;
+
+    while (index < this.count) {
+      const interval = Math.round((Math.pow(this.exponential, index) - 1) / 2);
+      yield Math.min(this.limit, interval) * this.units;
+      index += 1;
+    }
+
+    return;
+  }
+}
+
+class FixedRetryPolicy implements RetryPolicy {
+  private _intervals: number[];
+
+  constructor(intervals: number[], units?: TimeUnit) {
+    this._intervals = intervals.reduceRight((result, v) => {
+      result.push(toMilliseconds(v, units));
+      return result;
+    }, []);
+  }
+
+  *intervals(): Iterable<number> {
+    const intervals = [...this._intervals];
+    while (intervals.length > 0) {
+      yield intervals.pop();
+    }
+
+    return;
+  }
+}
+
+function simpleRetryPolicy(
+  count: number,
+  interval: number,
+  opts?: { units?: TimeUnit }
+): RetryPolicy {
+  return Object.freeze(new SimpleRetryPolicy(count, interval, opts?.units));
+}
+
+function fixedRetryPolicy(
+  intervals: number[],
+  opts?: { units?: TimeUnit }
+): RetryPolicy {
+  return Object.freeze(new FixedRetryPolicy(intervals, opts?.units));
+}
+
+function exponentialBackoffRetryPolicy(
+  count: number,
+  opts?: { exponential?: number; limit?: number; units?: TimeUnit }
+): RetryPolicy {
+  return Object.freeze(
+    new ExponentialBackoffRetryPolicy(
+      count,
+      opts?.exponential,
+      opts?.limit,
+      opts?.units
+    )
+  );
+}
+
+async function retryAround<T>(
+  action: () => T | Promise<T>,
+  policy: RetryPolicy
+): Promise<T> {
+  let next: IteratorResult<number, undefined>;
+  const intervals = policy.intervals()[Symbol.iterator]();
+  do {
+    try {
+      return await action();
+    } catch (e) {
+      next = intervals.next();
+
+      if (next.done) {
+        throw e;
+      }
+
+      await sleep(next.value);
+    }
+  } while (!next.done);
+
+  throw new Error('Unexpected error. This is most likely a bug.');
+}
+
+function retriable<T>(
+  action: () => T | Promise<T>,
+  policy: RetryPolicy
+): () => Promise<T> {
+  return () => {
+    return retryAround(action, policy);
+  };
+}
+
+export {
+  RetryPolicy,
+  retryAround,
+  retriable,
+  fixedRetryPolicy,
+  simpleRetryPolicy,
+  exponentialBackoffRetryPolicy
+};

package/lib/timeunit.ts

@@ -0,0 +1,25 @@
+enum TimeUnit {
+  Milliseconds = 1,
+  Millisecond = Milliseconds,
+  Seconds = 1000,
+  Second = Seconds,
+  Minutes = 1000 * 60,
+  Minute = Minutes,
+  Hours = 1000 * 60 * 60,
+  Hour = Hours,
+  Days = 1000 * 60 * 60 * 24,
+  Day = Days
+}
+
+/**
+ * Converts time value in other units to milliseconds.
+ *
+ * @param time a time value to be converted
+ * @param units the units of time
+ * @returns the time value in milliseconds
+ */
+function toMilliseconds(time: number, units?: TimeUnit): number {
+  return time * (units ? units : 1);
+}
+
+export { TimeUnit, toMilliseconds };

package/lib/utilities.ts

@@ -0,0 +1,90 @@
+import { TimeUnit, toMilliseconds } from './timeunit';
+
+/**
+ * Zzzz...
+ *
+ * @param time time to sleep
+ * @param units the units on time
+ * @returns a promise that resolves when the specified time has elapsed.
+ */
+function sleep(time: number, units?: TimeUnit): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, toMilliseconds(time, units));
+  });
+}
+
+/**
+ * Delays the execution of the specified action and returns its value.
+ *
+ * @param action a function to execute with delay
+ * @param time time to sleep
+ * @param units the units on time
+ * @returns a promise that resolves when the specified time has elapsed.
+ */
+function delay<T>(
+  action: () => T | Promise<T>,
+  time: number,
+  units?: TimeUnit
+): Promise<T> {
+  const delayMs = toMilliseconds(time, units);
+  return new Promise((resolve, reject) => {
+    setTimeout(() => Promise.resolve(action()).then(resolve, reject), delayMs);
+  });
+}
+
+/**
+ * Return a function that returns the elapsed time relative to this call.
+ * @returns a function
+ */
+function stopwatch(): (units?: TimeUnit) => number {
+  const startTime = Date.now();
+
+  return (units?: TimeUnit) => {
+    return (Date.now() - startTime) / (units || TimeUnit.Milliseconds);
+  };
+}
+
+/**
+ * Awaits a specified condition to evaluate to true with or without a timeout.
+ *
+ * @param condition the condition to wait for
+ * @param opts options that control evaluation intervals and timeout
+ * @returns a promise that resolves when the condition becomes true, or rejects when a set timeout is crossed.
+ */
+async function until(
+  condition: () => boolean,
+  opts?: { interval?: number; timeout: number; units?: TimeUnit }
+): Promise<void> {
+  if (condition()) {
+    return;
+  }
+
+  const defaultInterval = 50;
+  const deadline = opts
+    ? Date.now() + toMilliseconds(opts.timeout, opts.units)
+    : Number.MAX_VALUE;
+  const interval = opts?.interval
+    ? toMilliseconds(opts.interval, opts.units)
+    : defaultInterval;
+
+  return new Promise<void>((resolve, reject) => {
+    const handle = setInterval(() => {
+      if (Date.now() > deadline) {
+        clearInterval(handle);
+        reject(new Error('Timeout'));
+      }
+
+      if (condition()) {
+        clearInterval(handle);
+        resolve();
+      }
+    }, interval);
+  });
+}
+
+/**
+ * Alias to `until`
+ */
+const eventually = until;
+
+export { sleep, delay, stopwatch, until, eventually };

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@sha1n/about-time",
+  "version": "0.0.1",
+  "description": "A set of essential time related utilities",
+  "repository": "https://github.com/sha1n/about-time",
+  "author": "Shai Nagar",
+  "license": "MIT",
+  "types": "./dist/types",
+  "main": "./dist",
+  "exports": "./dist/index.js",
+  "scripts": {
+    "clean": "rm -rf ./dist",
+    "prebuild": "yarn run clean",
+    "build": "tsc",
+    "test": "DEBUG=error:* jest --coverage",
+    "lint": "eslint --fix --ext .js,.ts .",
+    "posttest": "npm run lint -s",
+    "prepublish": "yarn run build"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/chance": "^1.1.3",
+    "@types/jest": "^27.4.0",
+    "@types/node": "^17.0.8",
+    "@typescript-eslint/eslint-plugin": "^5.1.0",
+    "@typescript-eslint/parser": "^5.1.0",
+    "chance": "^1.1.8",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.25.2",
+    "eslint-plugin-jest": "^25.7.0",
+    "eslint-plugin-no-floating-promise": "^1.0.2",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "eslint-plugin-unused-imports": "^1.1.5",
+    "jest": "~27.4.7",
+    "jest-environment-node": "^27.2.0",
+    "jest-extended": "^1.1.0",
+    "jest-html-reporters": "^3.0.3",
+    "jest-mock-extended": "^2.0.4",
+    "jest-summary-reporter": "^0.0.2",
+    "prettier": "^2.4.1",
+    "ts-jest": "^27.1.3",
+    "ts-node": "^10.4.0",
+    "typescript": "^4.5.4"
+  }
+}