@bgord/tools 0.14.3 → 0.15.1

package/dist/min-max-scaler.service.d.ts

@@ -1,4 +1,4 @@
-import { type RoundingStrategy } from "./rounding.service";
+import type { RoundingPort } from "./rounding.port";
 type MinMaxScalerValueType = number;
 type MinMaxScalerConfigType = {
     min: MinMaxScalerValueType;
@@ -7,27 +7,35 @@ type MinMaxScalerConfigType = {
         lower: MinMaxScalerValueType;
         upper: MinMaxScalerValueType;
     };
-    rounding?: RoundingStrategy;
+    rounding?: RoundingPort;
+};
+export declare const MinMaxInvalidMinMaxError: "minmax.invalid.minmax";
+export declare const MinMaxInvalidBoundError: "minmax.invalid.bound";
+export declare const MinMaxValueOutOfRangeError: "minmax.value.out.of.range";
+export declare const MinMaxScaledOutOfBoundsError: "minmax.scaled.out.of.bounds";
+export declare const MinMaxEmptyArrayError: "minmax.empty.array";
+type ScaleResult = {
+    original: MinMaxScalerValueType;
+    scaled: MinMaxScalerValueType;
+    isMin: boolean;
+    isMax: boolean;
+};
+type DescaleResult = {
+    original: MinMaxScalerValueType;
+    scaled: MinMaxScalerValueType;
+    isLowerBound: boolean;
+    isUpperBound: boolean;
 };
 export declare class MinMaxScaler {
+    private static readonly DEFAULT_ROUNDING;
     private readonly min;
     private readonly max;
     private readonly lower;
     private readonly upper;
     private readonly rounding;
     constructor(config: MinMaxScalerConfigType);
-    scale(value: MinMaxScalerValueType): {
-        original: number;
-        scaled: number;
-        isMin: boolean;
-        isMax: boolean;
-    };
-    descale(scaled: MinMaxScalerValueType): {
-        original: number;
-        scaled: number;
-        isLowerBound: boolean;
-        isUpperBound: boolean;
-    };
+    scale(value: MinMaxScalerValueType): ScaleResult;
+    descale(scaled: MinMaxScalerValueType): DescaleResult;
     static getMinMax(values: MinMaxScalerValueType[]): {
         min: number;
         max: number;

package/dist/min-max-scaler.service.js

@@ -1,19 +1,24 @@
-import { RoundToDecimal } from "./rounding.service";
+import { RoundToDecimal } from "./rounding.adapter";
+export const MinMaxInvalidMinMaxError = "minmax.invalid.minmax";
+export const MinMaxInvalidBoundError = "minmax.invalid.bound";
+export const MinMaxValueOutOfRangeError = "minmax.value.out.of.range";
+export const MinMaxScaledOutOfBoundsError = "minmax.scaled.out.of.bounds";
+export const MinMaxEmptyArrayError = "minmax.empty.array";
 export class MinMaxScaler {
+    static DEFAULT_ROUNDING = new RoundToDecimal(2);
     min;
     max;
     lower;
     upper;
     rounding;
     constructor(config) {
-        const rounding = config.rounding ?? new RoundToDecimal(2);
         const lower = config.bound?.lower ?? 0;
         const upper = config.bound?.upper ?? 1;
         if (config.max - config.min < 0)
-            throw new Error("Invalid MinMaxScaler min-max config");
+            throw new Error(MinMaxInvalidMinMaxError);
         if (upper - lower <= 0)
-            throw new Error("Invalid MinMaxScaler bound config");
-        this.rounding = rounding;
+            throw new Error(MinMaxInvalidBoundError);
+        this.rounding = config.rounding ?? MinMaxScaler.DEFAULT_ROUNDING;
         this.min = config.min;
         this.max = config.max;
         this.lower = lower;
@@ -22,14 +27,10 @@ export class MinMaxScaler {
     scale(value) {
         const { min, max, lower, upper } = this;
         if (value < min || value > max)
-            throw new Error("Value out of min/max range");
-        if (min === max)
-            return {
-                original: value,
-                scaled: (lower + upper) / 2,
-                isMin: value === min,
-                isMax: value === max,
-            };
+            throw new Error(MinMaxValueOutOfRangeError);
+        if (min === max) {
+            return { original: value, scaled: (lower + upper) / 2, isMin: value === min, isMax: value === max };
+        }
         const result = ((value - min) / (max - min)) * (upper - lower) + lower;
         return {
             original: value,
@@ -41,7 +42,7 @@ export class MinMaxScaler {
     descale(scaled) {
         const { min, max, lower, upper } = this;
         if (scaled < lower || scaled > upper)
-            throw new Error("Scaled value out of bounds");
+            throw new Error(MinMaxScaledOutOfBoundsError);
         const result = ((scaled - lower) / (upper - lower)) * (max - min) + min;
         return {
             original: this.rounding.round(result),
@@ -52,7 +53,7 @@ export class MinMaxScaler {
     }
     static getMinMax(values) {
         if (values.length === 0)
-            throw new Error("An empty array supplied");
+            throw new Error(MinMaxEmptyArrayError);
         return { min: Math.min(...values), max: Math.max(...values) };
     }
 }

package/dist/minute.vo.d.ts

@@ -1,16 +1,15 @@
 import type { TimestampType } from "./timestamp.vo";
+export declare const MinuteValueError: "invalid.minute";
 export declare class Minute {
     private readonly value;
     static readonly ZERO: Minute;
     static readonly MAX: Minute;
     constructor(candidate: number);
-    static fromUtcTimestamp(timestamp: TimestampType): Minute;
-    get(): {
-        raw: number;
-        formatted: string;
-    };
+    static fromEpochMs(timestamp: TimestampType): Minute;
+    get(): number;
+    toString(): string;
     equals(another: Minute): boolean;
     isAfter(another: Minute): boolean;
     isBefore(another: Minute): boolean;
-    static list(): Minute[];
+    static list(): readonly Minute[];
 }

package/dist/minute.vo.js

@@ -1,33 +1,33 @@
+export const MinuteValueError = "invalid.minute";
 export class Minute {
     value;
     static ZERO = new Minute(0);
     static MAX = new Minute(59);
     constructor(candidate) {
-        if (!Number.isInteger(candidate))
-            throw new Error("Invalid minute");
-        if (candidate < 0)
-            throw new Error("Invalid minute");
-        if (candidate >= 60)
-            throw new Error("Invalid minute");
+        if (!Number.isInteger(candidate) || candidate < 0 || candidate >= 60) {
+            throw new Error(MinuteValueError);
+        }
         this.value = candidate;
     }
-    static fromUtcTimestamp(timestamp) {
-        const minutes = new Date(timestamp).getUTCMinutes();
-        return new Minute(minutes);
+    static fromEpochMs(timestamp) {
+        return new Minute(new Date(timestamp).getUTCMinutes());
     }
     get() {
-        return { raw: this.value, formatted: this.value.toString().padStart(2, "0") };
+        return this.value;
+    }
+    toString() {
+        return this.value.toString().padStart(2, "0");
     }
     equals(another) {
-        return this.value === another.get().raw;
+        return this.value === another.value;
     }
     isAfter(another) {
-        return this.value > another.get().raw;
+        return this.value > another.value;
     }
     isBefore(another) {
-        return this.value < another.get().raw;
+        return this.value < another.value;
     }
     static list() {
-        return Array.from({ length: 60 }).map((_, index) => new Minute(index));
+        return Array.from({ length: 60 }, (_, index) => new Minute(index));
     }
 }

package/dist/money.vo.d.ts

@@ -1,5 +1,15 @@
 import { z } from "zod/v4";
-import { type RoundingStrategy } from "./rounding.service";
+import type { RoundingPort } from "./rounding.port";
+export declare const MoneyAmountInvalidError: {
+    readonly error: "money.amount.invalid";
+};
+export declare const MoneyMultiplicationFactorInvalidError: {
+    readonly error: "money.multiplication-factor.invalid";
+};
+export declare const MoneyDivisionFactorInvalidError: {
+    readonly error: "money.division-factor.invalid";
+};
+export declare const MoneySubtractLessThanZeroError: "money.subtract.less.than.zero";
 export declare const MoneyAmount: z.core.$ZodBranded<z.ZodNumber, "MoneyAmount">;
 export type MoneyAmountType = z.infer<typeof MoneyAmount>;
 export declare const MoneyMultiplicationFactor: z.core.$ZodBranded<z.ZodNumber, "MoneyMultiplicationFactor">;
@@ -8,9 +18,10 @@ export declare const MoneyDivisionFactor: z.core.$ZodBranded<z.ZodNumber, "Money
 export type MoneyDivisionFactorType = z.infer<typeof MoneyDivisionFactor>;
 export declare class Money {
     private static readonly ZERO;
+    private static readonly DEFAULT_ROUNDING;
     private readonly amount;
     private readonly rounding;
-    constructor(value?: number, rounding?: RoundingStrategy);
+    constructor(value?: number, rounding?: RoundingPort);
     getAmount(): MoneyAmountType;
     add(money: Money): Money;
     multiply(factor: MoneyMultiplicationFactorType): Money;

package/dist/money.vo.js

@@ -1,26 +1,32 @@
 import { z } from "zod/v4";
-import { RoundToNearest } from "./rounding.service";
+import { RoundToNearest } from "./rounding.adapter";
+export const MoneyAmountInvalidError = { error: "money.amount.invalid" };
+export const MoneyMultiplicationFactorInvalidError = {
+    error: "money.multiplication-factor.invalid",
+};
+export const MoneyDivisionFactorInvalidError = { error: "money.division-factor.invalid" };
+export const MoneySubtractLessThanZeroError = "money.subtract.less.than.zero";
 export const MoneyAmount = z
-    .number()
-    .int({ message: "money.amount.invalid" })
-    .min(0, { message: "money.amount.invalid" })
+    .number(MoneyAmountInvalidError)
+    .int(MoneyAmountInvalidError)
+    .min(0, MoneyAmountInvalidError)
     .brand("MoneyAmount");
 export const MoneyMultiplicationFactor = z
-    .number()
-    .min(0, { message: "money.multiplication-factor.invalid" })
+    .number(MoneyMultiplicationFactorInvalidError)
+    .min(0, MoneyMultiplicationFactorInvalidError)
     .brand("MoneyMultiplicationFactor");
 export const MoneyDivisionFactor = z
-    .number()
-    .min(0, { message: "money.division-factor.invalid" })
-    .refine((value) => value !== 0, { message: "money.division-factor.invalid" })
+    .number(MoneyDivisionFactorInvalidError)
+    .gt(0, MoneyDivisionFactorInvalidError)
     .brand("MoneyDivisionFactor");
 export class Money {
     static ZERO = 0;
+    static DEFAULT_ROUNDING = new RoundToNearest();
     amount;
     rounding;
     constructor(value = Money.ZERO, rounding) {
         this.amount = MoneyAmount.parse(value);
-        this.rounding = rounding ?? new RoundToNearest();
+        this.rounding = rounding ?? Money.DEFAULT_ROUNDING;
     }
     getAmount() {
         return this.amount;
@@ -36,7 +42,7 @@ export class Money {
     subtract(money) {
         const result = this.rounding.round(this.amount - money.getAmount());
         if (result < Money.ZERO)
-            throw new Error("Less than zero");
+            throw new Error(MoneySubtractLessThanZeroError);
         return new Money(MoneyAmount.parse(result), this.rounding);
     }
     divide(factor) {
@@ -56,8 +62,7 @@ export class Money {
         return this.amount === Money.ZERO;
     }
     format() {
-        const result = this.amount / 100;
-        const whole = Math.floor(result);
+        const whole = Math.floor(this.amount / 100);
         const fraction = this.amount % 100;
         const fractionFormatted = fraction.toString().padStart(2, "0");
         return `${whole}.${fractionFormatted}`;

package/dist/outlier-detector.service.d.ts

@@ -1,6 +1,7 @@
+export declare const OutlierDetectorMinValuesError: "outlier.detector.min.values";
 export declare class OutlierDetector {
     private readonly zScore;
     private readonly threshold;
     constructor(values: number[], threshold: number);
-    check(value: number): boolean;
+    isInlier(value: number): boolean;
 }

package/dist/outlier-detector.service.js

@@ -1,14 +1,16 @@
 import { ZScore } from "./z-score.service";
+export const OutlierDetectorMinValuesError = "outlier.detector.min.values";
 export class OutlierDetector {
     zScore;
     threshold;
     constructor(values, threshold) {
         if (values.length < 2)
-            throw new Error("At least two values are needed");
+            throw new Error(OutlierDetectorMinValuesError);
         this.zScore = new ZScore(values);
         this.threshold = Math.abs(threshold);
     }
-    check(value) {
-        return this.zScore.calculate(value) <= this.threshold;
+    isInlier(value) {
+        const score = this.zScore.calculate(value);
+        return Math.abs(score) <= this.threshold;
     }
 }

package/dist/percentage.service.d.ts

@@ -1,4 +1,5 @@
-import { type RoundingStrategy } from "./rounding.service";
+import type { RoundingPort } from "./rounding.port";
+export declare const PercentageInvalidDenominatorError: "percentage.invalid.denominator";
 export declare class Percentage {
-    static of(numerator: number, denominator: number, rounding?: RoundingStrategy): number;
+    static of(numerator: number, denominator: number, rounding?: RoundingPort): number;
 }

package/dist/percentage.service.js

@@ -1,8 +1,9 @@
-import { RoundToNearest } from "./rounding.service";
+import { RoundToNearest } from "./rounding.adapter";
+export const PercentageInvalidDenominatorError = "percentage.invalid.denominator";
 export class Percentage {
     static of(numerator, denominator, rounding = new RoundToNearest()) {
         if (denominator === 0)
-            throw new Error("Invalid denominator");
+            throw new Error(PercentageInvalidDenominatorError);
         if (numerator === 0)
             return 0;
         return rounding.round((numerator / denominator) * 100);

package/dist/population-standard-deviation.service.d.ts

@@ -1,4 +1,5 @@
-import { type RoundingStrategy } from "./rounding.service";
+import type { RoundingPort } from "./rounding.port";
+export declare const PopulationStandardDeviationMinValuesError: "population.standard.deviation.min.values";
 export declare class PopulationStandardDeviation {
-    static calculate(values: number[], rounding?: RoundingStrategy): number;
+    static calculate(values: number[], rounding?: RoundingPort): number;
 }

package/dist/population-standard-deviation.service.js

@@ -1,15 +1,16 @@
 import { Mean } from "./mean.service";
-import { RoundToDecimal } from "./rounding.service";
+import { RoundToDecimal } from "./rounding.adapter";
 import { Sum } from "./sum.service";
+export const PopulationStandardDeviationMinValuesError = "population.standard.deviation.min.values";
 export class PopulationStandardDeviation {
     static calculate(values, rounding = new RoundToDecimal(2)) {
         if (values.length < 2)
-            throw new Error("At least two values are needed");
+            throw new Error(PopulationStandardDeviationMinValuesError);
         const mean = Mean.calculate(values);
-        const n = values.length;
+        const count = values.length;
         const squaredDifferences = values.map((value) => (value - mean) ** 2);
         const sumOfSquaredDifferences = Sum.of(squaredDifferences);
-        const variance = sumOfSquaredDifferences / n;
+        const variance = sumOfSquaredDifferences / count;
         return rounding.round(Math.sqrt(variance));
     }
 }

package/dist/random.service.d.ts

@@ -2,7 +2,13 @@ type RandomGenerateConfigType = {
     min: number;
     max: number;
 };
+export declare const RandomMinNotIntegerError: "random.min.not.integer";
+export declare const RandomMaxNotIntegerError: "random.max.not.integer";
+export declare const RandomMinEqualsMaxError: "random.min.equals.max";
+export declare const RandomMinGreaterThanMaxError: "random.min.greater.than.max";
 export declare class Random {
+    private static readonly DEFAULT_MIN;
+    private static readonly DEFAULT_MAX;
     static generate(config?: RandomGenerateConfigType): number;
 }
 export {};

package/dist/random.service.js

@@ -1,15 +1,21 @@
+export const RandomMinNotIntegerError = "random.min.not.integer";
+export const RandomMaxNotIntegerError = "random.max.not.integer";
+export const RandomMinEqualsMaxError = "random.min.equals.max";
+export const RandomMinGreaterThanMaxError = "random.min.greater.than.max";
 export class Random {
+    static DEFAULT_MIN = 0;
+    static DEFAULT_MAX = 1;
     static generate(config) {
-        const min = config?.min ?? 0;
-        const max = config?.max ?? 1;
+        const min = config ? config.min : Random.DEFAULT_MIN;
+        const max = config ? config.max : Random.DEFAULT_MAX;
         if (!Number.isInteger(min))
-            throw new Error("Minimum value is not an integer");
+            throw new Error(RandomMinNotIntegerError);
         if (!Number.isInteger(max))
-            throw new Error("Maximum value is not an integer");
+            throw new Error(RandomMaxNotIntegerError);
         if (min === max)
-            throw new Error("Minimum and maximum values cannot be equal");
+            throw new Error(RandomMinEqualsMaxError);
         if (min > max)
-            throw new Error("Minimum value cannot be greater than maximum value");
+            throw new Error(RandomMinGreaterThanMaxError);
         return Math.floor(Math.random() * (max - min + 1)) + min;
     }
 }

package/dist/rounding.adapter.d.ts

@@ -0,0 +1,16 @@
+import type { RoundingPort } from "./rounding.port";
+export declare class RoundToNearest implements RoundingPort {
+    round(value: number): number;
+}
+export declare class RoundUp implements RoundingPort {
+    round(value: number): number;
+}
+export declare class RoundDown implements RoundingPort {
+    round(value: number): number;
+}
+export declare const RoundingDecimalsError: "invalid.rounding.decimals";
+export declare class RoundToDecimal implements RoundingPort {
+    private readonly decimals;
+    constructor(decimals: number);
+    round(value: number): number;
+}

package/dist/{rounding.service.js → rounding.adapter.js}

@@ -1,25 +1,26 @@
-export class RoundingStrategy {
-}
-export class RoundToNearest extends RoundingStrategy {
+export class RoundToNearest {
     round(value) {
         return Math.round(value);
     }
 }
-export class RoundUp extends RoundingStrategy {
+export class RoundUp {
     round(value) {
         return Math.ceil(value);
     }
 }
-export class RoundDown extends RoundingStrategy {
+export class RoundDown {
     round(value) {
         return Math.floor(value);
     }
 }
-export class RoundToDecimal extends RoundingStrategy {
+export const RoundingDecimalsError = "invalid.rounding.decimals";
+export class RoundToDecimal {
     decimals;
     constructor(decimals) {
-        super();
         this.decimals = decimals;
+        if (!Number.isInteger(decimals) || decimals < 0 || decimals > 100) {
+            throw new Error(RoundingDecimalsError);
+        }
     }
     round(value) {
         return Number.parseFloat(value.toFixed(this.decimals));

package/dist/rounding.port.d.ts

@@ -0,0 +1,3 @@
+export interface RoundingPort {
+    round(value: number): number;
+}

package/dist/rounding.port.js

@@ -0,0 +1 @@
+export {};

package/dist/simple-linear-regression.service.d.ts

@@ -1,4 +1,4 @@
-import { type RoundingStrategy } from "./rounding.service";
+import type { RoundingPort } from "./rounding.port";
 export type SLRPairType = {
     x: number;
     y: number;
@@ -8,11 +8,18 @@ export type SLRParamsType = {
     b: number;
 };
 export type SLRPredictionType = number;
+export declare const SLRMinPairsError: "slr.min.pairs";
+export declare const SLRSumXTooBigError: "slr.sum.x.too.big";
+export declare const SLRSumYTooBigError: "slr.sum.y.too.big";
+export declare const SLRSumXSquaredTooBigError: "slr.sum.x.squared.too.big";
+export declare const SLRSumXTimesYTooBigError: "slr.sum.x.times.y.too.big";
+export declare const SLRModelCreationError: "slr.model.creation";
 export declare class SimpleLinearRegression {
+    private static readonly DEFAULT_ROUNDING;
     private readonly params;
     private readonly rounding;
-    constructor(params: SLRParamsType, rounding?: RoundingStrategy);
-    static fromPairs(pairs: SLRPairType[], rounding?: RoundingStrategy): SimpleLinearRegression;
-    predict(x: SLRPairType["x"], strategy?: RoundingStrategy): SLRPredictionType;
+    constructor(params: SLRParamsType, rounding?: RoundingPort);
+    static fromPairs(pairs: SLRPairType[], rounding?: RoundingPort): SimpleLinearRegression;
+    predict(x: SLRPairType["x"], rounding?: RoundingPort): SLRPredictionType;
     inspect(): SimpleLinearRegression["params"];
 }

package/dist/simple-linear-regression.service.js

@@ -1,43 +1,52 @@
-import { RoundToNearest } from "./rounding.service";
-import { Sum } from "./sum.service";
+import { RoundToNearest } from "./rounding.adapter";
+export const SLRMinPairsError = "slr.min.pairs";
+export const SLRSumXTooBigError = "slr.sum.x.too.big";
+export const SLRSumYTooBigError = "slr.sum.y.too.big";
+export const SLRSumXSquaredTooBigError = "slr.sum.x.squared.too.big";
+export const SLRSumXTimesYTooBigError = "slr.sum.x.times.y.too.big";
+export const SLRModelCreationError = "slr.model.creation";
 export class SimpleLinearRegression {
+    static DEFAULT_ROUNDING = new RoundToNearest();
     params;
-    rounding = new RoundToNearest();
+    rounding;
     constructor(params, rounding) {
         this.params = params;
-        this.rounding = rounding ?? this.rounding;
+        this.rounding = rounding ?? SimpleLinearRegression.DEFAULT_ROUNDING;
     }
     static fromPairs(pairs, rounding) {
-        const n = pairs.length;
-        if (n < 2)
-            throw new Error("At least two pairs needed");
-        const x = pairs.map((pair) => pair.x);
-        const y = pairs.map((pair) => pair.y);
-        const xx = x.map((x) => x ** 2);
-        const xy = pairs.map((pair) => pair.x * pair.y);
-        const sX = Sum.of(x);
-        if (sX >= Number.MAX_SAFE_INTEGER)
-            throw new Error("Sum of x values is too big");
-        const sY = Sum.of(y);
-        if (sY >= Number.MAX_SAFE_INTEGER)
-            throw new Error("Sum of y values is too big");
-        const sSX = Sum.of(xx);
-        if (sSX >= Number.MAX_SAFE_INTEGER)
-            throw new Error("Sum of x squared values is too big");
-        const sXY = Sum.of(xy);
-        if (sXY >= Number.MAX_SAFE_INTEGER)
-            throw new Error("Sum of x times y values is too big");
-        const bDenominator = sSX - sX ** 2 / n;
+        const count = pairs.length;
+        if (count < 2)
+            throw new Error(SLRMinPairsError);
+        let sumX = 0;
+        let sumY = 0;
+        let sumXX = 0;
+        let sumXY = 0;
+        for (let index = 0; index < count; index++) {
+            const pair = pairs[index];
+            sumX += pair.x;
+            sumY += pair.y;
+            sumXX += pair.x * pair.x;
+            sumXY += pair.x * pair.y;
+        }
+        if (Math.abs(sumX) >= Number.MAX_SAFE_INTEGER)
+            throw new Error(SLRSumXTooBigError);
+        if (Math.abs(sumY) >= Number.MAX_SAFE_INTEGER)
+            throw new Error(SLRSumYTooBigError);
+        if (Math.abs(sumXY) >= Number.MAX_SAFE_INTEGER)
+            throw new Error(SLRSumXTimesYTooBigError);
+        if (Math.abs(sumXX) >= Number.MAX_SAFE_INTEGER)
+            throw new Error(SLRSumXSquaredTooBigError);
+        const bDenominator = sumXX - sumX ** 2 / count;
         if (bDenominator === 0)
-            throw new Error("Unable to create the model");
-        const b = (sXY - (sX * sY) / n) / bDenominator;
-        const a = (sY - b * sX) / n;
+            throw new Error(SLRModelCreationError);
+        const b = (sumXY - (sumX * sumY) / count) / bDenominator;
+        const a = (sumY - b * sumX) / count;
         return new SimpleLinearRegression({ a, b }, rounding);
     }
-    predict(x, strategy) {
-        const rounding = strategy ?? this.rounding;
+    predict(x, rounding) {
+        const chosen = rounding ?? this.rounding;
         const prediction = this.params.b * x + this.params.a;
-        return rounding.round(prediction);
+        return chosen.round(prediction);
     }
     inspect() {
         return this.params;

package/dist/size.vo.js

@@ -1,5 +1,5 @@
 import { z } from "zod/v4";
-import { RoundToDecimal } from "./rounding.service";
+import { RoundToDecimal } from "./rounding.adapter";
 export var SizeUnit;
 (function (SizeUnit) {
     SizeUnit["b"] = "b";

package/dist/stopwatch.service.d.ts

@@ -1,11 +1,11 @@
 import { type TimestampType } from "./timestamp.vo";
+export declare const StopwatchStateError: "stopwatch.already.stopped";
 export type StopwatchResultType = {
     durationMs: TimestampType;
 };
 export declare class Stopwatch {
     private readonly startMs;
     private state;
-    private stopMs;
     constructor(startMs: TimestampType);
     stop(): StopwatchResultType;
 }

package/dist/stopwatch.service.js

@@ -4,18 +4,17 @@ var StopwatchState;
     StopwatchState["started"] = "started";
     StopwatchState["stopped"] = "stopped";
 })(StopwatchState || (StopwatchState = {}));
+export const StopwatchStateError = "stopwatch.already.stopped";
 export class Stopwatch {
     startMs;
     state = StopwatchState.started;
-    stopMs;
     constructor(startMs) {
         this.startMs = startMs;
     }
     stop() {
         if (this.state === StopwatchState.stopped)
-            throw new Error("Stopwatch is already stopped");
+            throw new Error(StopwatchStateError);
         this.state = StopwatchState.stopped;
-        this.stopMs = Timestamp.parse(Date.now());
-        return { durationMs: Timestamp.parse(this.stopMs - this.startMs) };
+        return { durationMs: Timestamp.parse(Date.now() - this.startMs) };
     }
 }

package/dist/sum.service.d.ts

@@ -1,3 +1,4 @@
 export declare class Sum {
-    static of(values: number[]): number;
+    static of(values: readonly number[]): number;
+    static precise(values: readonly number[]): number;
 }