@bgord/tools 0.14.3 → 0.15.0

package/src/image.vo.ts

@@ -1,7 +1,22 @@
 import { z } from "zod/v4";
 
-export const ImageWidth = z.number().int().positive().max(10000).brand("image-width");
-export type WidthType = z.infer<typeof ImageWidth>;
+export const ImageWidthError = { error: "invalid.image.width" } as const;
+export const ImageHeightError = { error: "invalid.image.height" } as const;
 
-export const ImageHeight = z.number().int().positive().max(10000).brand("image-height");
-export type HeightType = z.infer<typeof ImageHeight>;
+export const ImageWidth = z
+  .number(ImageWidthError)
+  .int(ImageWidthError)
+  .positive(ImageWidthError)
+  .max(10_000, ImageWidthError)
+  .brand("image-width");
+
+export type ImageWidthType = z.infer<typeof ImageWidth>;
+
+export const ImageHeight = z
+  .number(ImageHeightError)
+  .int(ImageHeightError)
+  .positive(ImageHeightError)
+  .max(10_000, ImageHeightError)
+  .brand("image-height");
+
+export type ImageHeightType = z.infer<typeof ImageHeight>;

package/src/index.ts

@@ -5,7 +5,6 @@ export * from "./clock.vo";
 export * from "./date-calculator.service";
 export * from "./date-formatter.service";
 export * from "./date-range.vo";
-export * from "./dates-of-the-week.vo";
 export * from "./day.vo";
 export * from "./day-iso-id.vo";
 export * from "./directory-path-absolute.vo";
@@ -50,7 +49,8 @@ export * from "./rate-limiter.service";
 export * from "./relative-date.vo";
 export * from "./reordering.service";
 export * from "./revision.vo";
-export * from "./rounding.service";
+export * from "./rounding.adapter";
+export * from "./rounding.port";
 export * from "./simple-linear-regression.service";
 export * from "./size.vo";
 export * from "./stepper.service";

package/src/language.vo.ts

@@ -1,7 +1,11 @@
 import { z } from "zod/v4";
 
+export const LanguageError = { error: "invalid.language" } as const;
+
 export const Language = z
-  .string()
-  .length(2)
-  .regex(/^[a-z]{2}$/, { message: "invalid_language" });
+  .string(LanguageError)
+  .length(2, LanguageError)
+  .regex(/^[a-z]{2}$/, LanguageError)
+  .brand("Language");
+
 export type LanguageType = z.infer<typeof Language>;

package/src/mean.service.ts

@@ -1,12 +1,20 @@
-import { type RoundingStrategy, RoundToDecimal } from "./rounding.service";
+import { RoundToDecimal } from "./rounding.adapter";
+import type { RoundingPort } from "./rounding.port";
 import { Sum } from "./sum.service";
 
+export const MeanEmptyValuesError = "mean.values.empty" as const;
+
 export class Mean {
-  static calculate(values: number[], rounding: RoundingStrategy = new RoundToDecimal(2)): number {
-    if (values.length === 0) throw new Error("Values should not be empty");
+  private static readonly DEFAULT_ROUNDING: RoundingPort = new RoundToDecimal(2);
+
+  static calculate(values: number[], rounding?: RoundingPort): number {
+    if (values.length === 0) throw new Error(MeanEmptyValuesError);
+
+    const sum = Sum.of(values);
+    const mean = sum / values.length;
 
-    const mean = Sum.of(values) / values.length;
+    const chosen = rounding ?? Mean.DEFAULT_ROUNDING;
 
-    return rounding.round(mean);
+    return chosen.round(mean);
   }
 }

package/src/min-max-scaler.service.ts

@@ -1,50 +1,66 @@
-import { type RoundingStrategy, RoundToDecimal } from "./rounding.service";
+import { RoundToDecimal } from "./rounding.adapter";
+import type { RoundingPort } from "./rounding.port";
 
 type MinMaxScalerValueType = number;
+
 type MinMaxScalerConfigType = {
   min: MinMaxScalerValueType;
   max: MinMaxScalerValueType;
   bound?: { lower: MinMaxScalerValueType; upper: MinMaxScalerValueType };
-  rounding?: RoundingStrategy;
+  rounding?: RoundingPort;
+};
+
+export const MinMaxInvalidMinMaxError = "minmax.invalid.minmax" as const;
+export const MinMaxInvalidBoundError = "minmax.invalid.bound" as const;
+export const MinMaxValueOutOfRangeError = "minmax.value.out.of.range" as const;
+export const MinMaxScaledOutOfBoundsError = "minmax.scaled.out.of.bounds" as const;
+export const MinMaxEmptyArrayError = "minmax.empty.array" as const;
+
+type ScaleResult = {
+  original: MinMaxScalerValueType;
+  scaled: MinMaxScalerValueType;
+  isMin: boolean;
+  isMax: boolean;
+};
+
+type DescaleResult = {
+  original: MinMaxScalerValueType;
+  scaled: MinMaxScalerValueType;
+  isLowerBound: boolean;
+  isUpperBound: boolean;
 };
 
 export class MinMaxScaler {
+  private static readonly DEFAULT_ROUNDING: RoundingPort = new RoundToDecimal(2);
+
   private readonly min: MinMaxScalerValueType;
   private readonly max: MinMaxScalerValueType;
   private readonly lower: MinMaxScalerValueType;
   private readonly upper: MinMaxScalerValueType;
-
-  private readonly rounding: RoundingStrategy;
+  private readonly rounding: RoundingPort;
 
   constructor(config: MinMaxScalerConfigType) {
-    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");
-    if (upper - lower <= 0) throw new Error("Invalid MinMaxScaler bound config");
-
-    this.rounding = rounding;
+    if (config.max - config.min < 0) throw new Error(MinMaxInvalidMinMaxError);
+    if (upper - lower <= 0) throw new Error(MinMaxInvalidBoundError);
 
+    this.rounding = config.rounding ?? MinMaxScaler.DEFAULT_ROUNDING;
     this.min = config.min;
     this.max = config.max;
     this.lower = lower;
     this.upper = upper;
   }
 
-  scale(value: MinMaxScalerValueType) {
+  scale(value: MinMaxScalerValueType): ScaleResult {
     const { min, max, lower, upper } = this;
 
-    if (value < min || value > max) throw new Error("Value out of min/max range");
+    if (value < min || value > max) throw new Error(MinMaxValueOutOfRangeError);
 
-    if (min === max)
-      return {
-        original: value,
-        scaled: (lower + upper) / 2,
-        isMin: value === min,
-        isMax: value === max,
-      };
+    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;
 
@@ -56,10 +72,10 @@ export class MinMaxScaler {
     };
   }
 
-  descale(scaled: MinMaxScalerValueType) {
+  descale(scaled: MinMaxScalerValueType): DescaleResult {
     const { min, max, lower, upper } = this;
 
-    if (scaled < lower || scaled > upper) throw new Error("Scaled value out of bounds");
+    if (scaled < lower || scaled > upper) throw new Error(MinMaxScaledOutOfBoundsError);
 
     const result = ((scaled - lower) / (upper - lower)) * (max - min) + min;
 
@@ -71,9 +87,8 @@ export class MinMaxScaler {
     };
   }
 
-  static getMinMax(values: MinMaxScalerValueType[]) {
-    if (values.length === 0) throw new Error("An empty array supplied");
-
+  static getMinMax(values: MinMaxScalerValueType[]): { min: number; max: number } {
+    if (values.length === 0) throw new Error(MinMaxEmptyArrayError);
     return { min: Math.min(...values), max: Math.max(...values) };
   }
 }

package/src/minute.vo.ts

@@ -1,42 +1,45 @@
 import type { TimestampType } from "./timestamp.vo";
 
+export const MinuteValueError = "invalid.minute" as const;
+
 export class Minute {
   private readonly value: number;
 
   static readonly ZERO = new Minute(0);
-
   static readonly MAX = new Minute(59);
 
   constructor(candidate: number) {
-    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: TimestampType): Minute {
-    const minutes = new Date(timestamp).getUTCMinutes();
-    return new Minute(minutes);
+  static fromEpochMs(timestamp: TimestampType): Minute {
+    return new Minute(new Date(timestamp).getUTCMinutes());
+  }
+
+  get(): number {
+    return this.value;
   }
 
-  get() {
-    return { raw: this.value, formatted: this.value.toString().padStart(2, "0") };
+  toString(): string {
+    return this.value.toString().padStart(2, "0");
   }
 
   equals(another: Minute): boolean {
-    return this.value === another.get().raw;
+    return this.value === another.value;
   }
 
   isAfter(another: Minute): boolean {
-    return this.value > another.get().raw;
+    return this.value > another.value;
   }
 
   isBefore(another: Minute): boolean {
-    return this.value < another.get().raw;
+    return this.value < another.value;
   }
 
-  static list() {
-    return Array.from({ length: 60 }).map((_, index) => new Minute(index));
+  static list(): readonly Minute[] {
+    return Array.from({ length: 60 }, (_, index) => new Minute(index));
   }
 }

package/src/money.vo.ts

@@ -1,66 +1,72 @@
 import { z } from "zod/v4";
-import { type RoundingStrategy, RoundToNearest } from "./rounding.service";
+import { RoundToNearest } from "./rounding.adapter";
+import type { RoundingPort } from "./rounding.port";
+
+export const MoneyAmountInvalidError = { error: "money.amount.invalid" } as const;
+export const MoneyMultiplicationFactorInvalidError = {
+  error: "money.multiplication-factor.invalid",
+} as const;
+export const MoneyDivisionFactorInvalidError = { error: "money.division-factor.invalid" } as const;
+export const MoneySubtractLessThanZeroError = "money.subtract.less.than.zero" as const;
 
 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 type MoneyAmountType = z.infer<typeof MoneyAmount>;
 
 export const MoneyMultiplicationFactor = z
-  .number()
-  .min(0, { message: "money.multiplication-factor.invalid" })
+  .number(MoneyMultiplicationFactorInvalidError)
+  .min(0, MoneyMultiplicationFactorInvalidError)
   .brand("MoneyMultiplicationFactor");
 
 export type MoneyMultiplicationFactorType = z.infer<typeof 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 type MoneyDivisionFactorType = z.infer<typeof MoneyDivisionFactor>;
 
 export class Money {
   private static readonly ZERO = 0;
+  private static readonly DEFAULT_ROUNDING: RoundingPort = new RoundToNearest();
 
   private readonly amount: MoneyAmountType;
+  private readonly rounding: RoundingPort;
 
-  private readonly rounding: RoundingStrategy;
-
-  constructor(value: number = Money.ZERO, rounding?: RoundingStrategy) {
+  constructor(value: number = Money.ZERO, rounding?: RoundingPort) {
     this.amount = MoneyAmount.parse(value);
-    this.rounding = rounding ?? new RoundToNearest();
+    this.rounding = rounding ?? Money.DEFAULT_ROUNDING;
   }
 
   getAmount(): MoneyAmountType {
     return this.amount;
   }
 
-  add(money: Money) {
+  add(money: Money): Money {
     const result = this.rounding.round(this.amount + money.getAmount());
 
     return new Money(MoneyAmount.parse(result), this.rounding);
   }
 
-  multiply(factor: MoneyMultiplicationFactorType) {
+  multiply(factor: MoneyMultiplicationFactorType): Money {
     const result = this.rounding.round(this.amount * factor);
 
     return new Money(MoneyAmount.parse(result), this.rounding);
   }
 
-  subtract(money: Money) {
+  subtract(money: Money): Money {
     const result = this.rounding.round(this.amount - money.getAmount());
 
-    if (result < Money.ZERO) throw new Error("Less than zero");
-
+    if (result < Money.ZERO) throw new Error(MoneySubtractLessThanZeroError);
     return new Money(MoneyAmount.parse(result), this.rounding);
   }
 
-  divide(factor: MoneyDivisionFactorType) {
+  divide(factor: MoneyDivisionFactorType): Money {
     const result = this.rounding.round(this.amount / factor);
 
     return new Money(MoneyAmount.parse(result), this.rounding);
@@ -83,10 +89,7 @@ export class Money {
   }
 
   format(): string {
-    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");
 

package/src/outlier-detector.service.ts

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

package/src/percentage.service.ts

@@ -1,12 +1,11 @@
-import { type RoundingStrategy, RoundToNearest } from "./rounding.service";
+import { RoundToNearest } from "./rounding.adapter";
+import type { RoundingPort } from "./rounding.port";
+
+export const PercentageInvalidDenominatorError = "percentage.invalid.denominator" as const;
 
 export class Percentage {
-  static of(
-    numerator: number,
-    denominator: number,
-    rounding: RoundingStrategy = new RoundToNearest(),
-  ): number {
-    if (denominator === 0) throw new Error("Invalid denominator");
+  static of(numerator: number, denominator: number, rounding: RoundingPort = new RoundToNearest()): number {
+    if (denominator === 0) throw new Error(PercentageInvalidDenominatorError);
     if (numerator === 0) return 0;
     return rounding.round((numerator / denominator) * 100);
   }

package/src/population-standard-deviation.service.ts

@@ -1,18 +1,21 @@
 import { Mean } from "./mean.service";
-import { type RoundingStrategy, RoundToDecimal } from "./rounding.service";
+import { RoundToDecimal } from "./rounding.adapter";
+import type { RoundingPort } from "./rounding.port";
 import { Sum } from "./sum.service";
 
+export const PopulationStandardDeviationMinValuesError = "population.standard.deviation.min.values" as const;
+
 export class PopulationStandardDeviation {
-  static calculate(values: number[], rounding: RoundingStrategy = new RoundToDecimal(2)): number {
-    if (values.length < 2) throw new Error("At least two values are needed");
+  static calculate(values: number[], rounding: RoundingPort = new RoundToDecimal(2)): number {
+    if (values.length < 2) 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/src/random.service.ts

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

package/src/relative-date.vo.ts

@@ -11,7 +11,6 @@ export class RelativeDate {
 
   static falsy(timestampMs: Falsy<TimestampType>): RelativeDateType | null {
     if (!timestampMs) return null;
-
     return RelativeDate._format(timestampMs);
   }
 

package/src/rounding.adapter.ts

@@ -0,0 +1,33 @@
+import type { RoundingPort } from "./rounding.port";
+
+export class RoundToNearest implements RoundingPort {
+  round(value: number): number {
+    return Math.round(value);
+  }
+}
+
+export class RoundUp implements RoundingPort {
+  round(value: number): number {
+    return Math.ceil(value);
+  }
+}
+
+export class RoundDown implements RoundingPort {
+  round(value: number): number {
+    return Math.floor(value);
+  }
+}
+
+export const RoundingDecimalsError = "invalid.rounding.decimals" as const;
+
+export class RoundToDecimal implements RoundingPort {
+  constructor(private readonly decimals: number) {
+    if (!Number.isInteger(decimals) || decimals < 0 || decimals > 100) {
+      throw new Error(RoundingDecimalsError);
+    }
+  }
+
+  round(value: number): number {
+    return Number.parseFloat(value.toFixed(this.decimals));
+  }
+}

package/src/rounding.port.ts

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

package/src/simple-linear-regression.service.ts

@@ -1,56 +1,66 @@
-import { type RoundingStrategy, RoundToNearest } from "./rounding.service";
-import { Sum } from "./sum.service";
+import { RoundToNearest } from "./rounding.adapter";
+import type { RoundingPort } from "./rounding.port";
 
 export type SLRPairType = { x: number; y: number };
 export type SLRParamsType = { a: number; b: number };
 export type SLRPredictionType = number;
 
+export const SLRMinPairsError = "slr.min.pairs" as const;
+export const SLRSumXTooBigError = "slr.sum.x.too.big" as const;
+export const SLRSumYTooBigError = "slr.sum.y.too.big" as const;
+export const SLRSumXSquaredTooBigError = "slr.sum.x.squared.too.big" as const;
+export const SLRSumXTimesYTooBigError = "slr.sum.x.times.y.too.big" as const;
+export const SLRModelCreationError = "slr.model.creation" as const;
+
 export class SimpleLinearRegression {
-  private readonly rounding: RoundingStrategy = new RoundToNearest();
+  private static readonly DEFAULT_ROUNDING: RoundingPort = new RoundToNearest();
 
-  constructor(
-    private readonly params: SLRParamsType,
-    rounding?: RoundingStrategy,
-  ) {
-    this.rounding = rounding ?? this.rounding;
-  }
+  private readonly params: SLRParamsType;
+  private readonly rounding: RoundingPort;
 
-  static fromPairs(pairs: SLRPairType[], rounding?: RoundingStrategy) {
-    const n = pairs.length;
+  constructor(params: SLRParamsType, rounding?: RoundingPort) {
+    this.params = params;
+    this.rounding = rounding ?? SimpleLinearRegression.DEFAULT_ROUNDING;
+  }
 
-    if (n < 2) throw new Error("At least two pairs needed");
+  static fromPairs(pairs: SLRPairType[], rounding?: RoundingPort): SimpleLinearRegression {
+    const count = pairs.length;
 
-    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);
+    if (count < 2) throw new Error(SLRMinPairsError);
 
-    const sX = Sum.of(x);
-    if (sX >= Number.MAX_SAFE_INTEGER) throw new Error("Sum of x values is too big");
+    let sumX = 0;
+    let sumY = 0;
+    let sumXX = 0;
+    let sumXY = 0;
 
-    const sY = Sum.of(y);
-    if (sY >= Number.MAX_SAFE_INTEGER) throw new Error("Sum of y values is too big");
+    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;
+    }
 
-    const sSX = Sum.of(xx);
-    if (sSX >= Number.MAX_SAFE_INTEGER) throw new Error("Sum of x squared values is too big");
+    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 sXY = Sum.of(xy);
-    if (sXY >= Number.MAX_SAFE_INTEGER) throw new Error("Sum of x times y values is too big");
+    const bDenominator = sumXX - sumX ** 2 / count;
 
-    const bDenominator = sSX - sX ** 2 / n;
-    if (bDenominator === 0) throw new Error("Unable to create the model");
+    if (bDenominator === 0) throw new Error(SLRModelCreationError);
 
-    const b = (sXY - (sX * sY) / n) / bDenominator;
-    const a = (sY - b * sX) / n;
+    const b = (sumXY - (sumX * sumY) / count) / bDenominator;
+    const a = (sumY - b * sumX) / count;
 
     return new SimpleLinearRegression({ a, b }, rounding);
   }
 
-  predict(x: SLRPairType["x"], strategy?: RoundingStrategy): SLRPredictionType {
-    const rounding = strategy ?? this.rounding;
+  predict(x: SLRPairType["x"], rounding?: RoundingPort): SLRPredictionType {
+    const chosen = rounding ?? this.rounding;
     const prediction = this.params.b * x + this.params.a;
 
-    return rounding.round(prediction);
+    return chosen.round(prediction);
   }
 
   inspect(): SimpleLinearRegression["params"] {

package/src/size.vo.ts

@@ -1,5 +1,5 @@
 import { z } from "zod/v4";
-import { RoundToDecimal } from "./rounding.service";
+import { RoundToDecimal } from "./rounding.adapter";
 
 export enum SizeUnit {
   b = "b",

package/src/stopwatch.service.ts

@@ -1,26 +1,24 @@
 import { Timestamp, type TimestampType } from "./timestamp.vo";
-import type { Falsy } from "./ts-utils";
 
 enum StopwatchState {
   started = "started",
   stopped = "stopped",
 }
 
+export const StopwatchStateError = "stopwatch.already.stopped" as const;
+
 export type StopwatchResultType = { durationMs: TimestampType };
 
 export class Stopwatch {
   private state: StopwatchState = StopwatchState.started;
 
-  private stopMs: Falsy<TimestampType>;
-
   constructor(private readonly startMs: TimestampType) {}
 
   stop(): StopwatchResultType {
-    if (this.state === StopwatchState.stopped) throw new Error("Stopwatch is already stopped");
+    if (this.state === StopwatchState.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) };
   }
 }