@bgord/tools 0.14.2 → 0.15.0

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) };
   }
 }

package/src/sum.service.ts

@@ -1,5 +1,19 @@
 export class Sum {
-  static of(values: number[]): number {
+  static of(values: readonly number[]): number {
     return values.reduce((sum, x) => sum + x, 0);
   }
+
+  static precise(values: readonly number[]): number {
+    let runningTotal = 0;
+    let roundingCompensation = 0;
+
+    for (const currentValue of values) {
+      const correctedAddend = currentValue - roundingCompensation;
+      const tentativeTotal = runningTotal + correctedAddend;
+      roundingCompensation = tentativeTotal - runningTotal - correctedAddend;
+      runningTotal = tentativeTotal;
+    }
+
+    return runningTotal;
+  }
 }

package/src/time.service.ts

@@ -1,4 +1,4 @@
-import { RoundToDecimal } from "./rounding.service";
+import { RoundToDecimal } from "./rounding.adapter";
 import type { TimestampType } from "./timestamp.vo";
 
 const rounding = new RoundToDecimal(2);

package/src/timestamp.vo.ts

@@ -1,4 +1,12 @@
 import { z } from "zod/v4";
 
-export const Timestamp = z.number().int().gte(0).brand("Timestamp");
+export const TimestampError = { error: "invalid.timestamp" } as const;
+
+export const Timestamp = z
+  .number(TimestampError)
+  .int(TimestampError)
+  .gte(0, TimestampError)
+  .lte(Number.MAX_SAFE_INTEGER, TimestampError)
+  .brand("Timestamp");
+
 export type TimestampType = z.infer<typeof Timestamp>;

package/src/timezone.vo.ts

@@ -1,20 +1,20 @@
 import { z } from "zod/v4";
 
+export const TimezoneError = { error: "timezone.invalid" } as const;
+
 export const Timezone = z
-  .string()
-  .min(1)
-  .refine(
-    (value) => {
-      try {
-        const date = new Date();
-        const formatter = new Intl.DateTimeFormat("en-US", { timeZone: value });
-        formatter.format(date);
-        return true;
-      } catch (_error) {
-        return false;
-      }
-    },
-    { message: "timezone.invalid" },
-  )
+  .string(TimezoneError)
+  .min(1, TimezoneError)
+  .refine((value) => {
+    try {
+      const date = new Date();
+      const formatter = new Intl.DateTimeFormat("en-US", { timeZone: value });
+      formatter.format(date);
+      return true;
+    } catch (_error) {
+      return false;
+    }
+  }, TimezoneError)
   .brand("Timezone");
+
 export type TimezoneType = z.infer<typeof Timezone>;

package/src/visually-unambiguous-characters-generator.service.ts

@@ -1,7 +1,6 @@
 import { Random } from "./random.service";
 
 export class VisuallyUnambiguousCharactersGenerator {
-  // prettier-ignore
   static chars = [
     "a",
     "b",

package/src/weight.vo.ts

@@ -1,5 +1,6 @@
 import { z } from "zod/v4";
-import { type RoundingStrategy, RoundToDecimal } from "./rounding.service";
+import { RoundToDecimal } from "./rounding.adapter";
+import type { RoundingPort } from "./rounding.port";
 
 const FiniteNumericValue = z.number().refine(Number.isFinite, { message: "Expected a finite number" });
 const NonNegativeNumericValue = FiniteNumericValue.min(0, { message: "Must be greater than or equal to 0" });
@@ -49,17 +50,17 @@ export class Weight {
     return this.grams;
   }
 
-  toKilograms(rounding?: RoundingStrategy): number {
+  toKilograms(rounding?: RoundingPort): number {
     const kilograms = this.grams / Weight.GRAMS_PER_KILOGRAM;
     return rounding ? rounding.round(kilograms) : kilograms;
   }
 
-  toPounds(rounding?: RoundingStrategy): number {
+  toPounds(rounding?: RoundingPort): number {
     const pounds = (this.grams / Weight.GRAMS_PER_KILOGRAM) * Weight.POUNDS_PER_KILOGRAM;
     return rounding ? rounding.round(pounds) : pounds;
   }
 
-  format(unit: WeightUnit, rounding: RoundingStrategy = new RoundToDecimal(2)): string {
+  format(unit: WeightUnit, rounding: RoundingPort = new RoundToDecimal(2)): string {
     const value = { [WeightUnit.kg]: this.toKilograms(rounding), [WeightUnit.lb]: this.toPounds(rounding) }[
       unit
     ];

package/src/z-score.service.ts

@@ -1,6 +1,9 @@
 import { Mean } from "./mean.service";
 import { PopulationStandardDeviation } from "./population-standard-deviation.service";
-import { type RoundingStrategy, RoundToDecimal } from "./rounding.service";
+import { RoundToDecimal } from "./rounding.adapter";
+import type { RoundingPort } from "./rounding.port";
+
+export const ZScoreMinValuesError = "zscore.min.values" as const;
 
 export class ZScore {
   private readonly mean: number;
@@ -8,9 +11,9 @@ export class ZScore {
 
   constructor(
     values: number[],
-    private readonly rounding: RoundingStrategy = new RoundToDecimal(2),
+    private readonly rounding: RoundingPort = new RoundToDecimal(2),
   ) {
-    if (values.length < 2) throw new Error("At least two values are needed");
+    if (values.length < 2) throw new Error(ZScoreMinValuesError);
 
     this.mean = Mean.calculate(values);
     this.standardDeviation = PopulationStandardDeviation.calculate(values);

package/dist/dates-of-the-week.vo.d.ts

@@ -1,9 +0,0 @@
-export declare enum DayOfTheWeekEnum {
-    Monday = 1,
-    Tuesday = 2,
-    Wednesday = 3,
-    Thursday = 4,
-    Friday = 5,
-    Saturday = 6,
-    Sunday = 0
-}

package/dist/dates-of-the-week.vo.js

@@ -1,10 +0,0 @@
-export var DayOfTheWeekEnum;
-(function (DayOfTheWeekEnum) {
-    DayOfTheWeekEnum[DayOfTheWeekEnum["Monday"] = 1] = "Monday";
-    DayOfTheWeekEnum[DayOfTheWeekEnum["Tuesday"] = 2] = "Tuesday";
-    DayOfTheWeekEnum[DayOfTheWeekEnum["Wednesday"] = 3] = "Wednesday";
-    DayOfTheWeekEnum[DayOfTheWeekEnum["Thursday"] = 4] = "Thursday";
-    DayOfTheWeekEnum[DayOfTheWeekEnum["Friday"] = 5] = "Friday";
-    DayOfTheWeekEnum[DayOfTheWeekEnum["Saturday"] = 6] = "Saturday";
-    DayOfTheWeekEnum[DayOfTheWeekEnum["Sunday"] = 0] = "Sunday";
-})(DayOfTheWeekEnum || (DayOfTheWeekEnum = {}));

package/dist/rounding.service.d.ts

@@ -1,17 +0,0 @@
-export declare abstract class RoundingStrategy {
-    abstract round(value: number): number;
-}
-export declare class RoundToNearest extends RoundingStrategy {
-    round(value: number): number;
-}
-export declare class RoundUp extends RoundingStrategy {
-    round(value: number): number;
-}
-export declare class RoundDown extends RoundingStrategy {
-    round(value: number): number;
-}
-export declare class RoundToDecimal extends RoundingStrategy {
-    private readonly decimals;
-    constructor(decimals: number);
-    round(value: number): number;
-}

package/src/dates-of-the-week.vo.ts

@@ -1,9 +0,0 @@
-export enum DayOfTheWeekEnum {
-  Monday = 1,
-  Tuesday = 2,
-  Wednesday = 3,
-  Thursday = 4,
-  Friday = 5,
-  Saturday = 6,
-  Sunday = 0,
-}

package/src/rounding.service.ts

@@ -1,31 +0,0 @@
-export abstract class RoundingStrategy {
-  abstract round(value: number): number;
-}
-
-export class RoundToNearest extends RoundingStrategy {
-  round(value: number): number {
-    return Math.round(value);
-  }
-}
-
-export class RoundUp extends RoundingStrategy {
-  round(value: number): number {
-    return Math.ceil(value);
-  }
-}
-
-export class RoundDown extends RoundingStrategy {
-  round(value: number): number {
-    return Math.floor(value);
-  }
-}
-
-export class RoundToDecimal extends RoundingStrategy {
-  constructor(private readonly decimals: number) {
-    super();
-  }
-
-  round(value: number): number {
-    return Number.parseFloat(value.toFixed(this.decimals));
-  }
-}