@bgord/tools 0.17.2 → 1.0.1

package/src/weight.vo.ts

@@ -1,87 +1,43 @@
-import { z } from "zod/v4";
-import { RoundToDecimal } from "./rounding.adapter";
+import type { DivisionFactorType } from "./division-factor.vo";
+import type { MultiplicationFactorType } from "./multiplication-factor.vo";
+import { RoundToNearest } from "./rounding.adapter";
 import type { RoundingPort } from "./rounding.port";
-
-export enum WeightUnit {
-  kg = "kg",
-  lb = "lb",
-}
-
-export const WeightNonFiniteError = { error: "weight.non_finite" } as const;
-export const WeightNegativeError = { error: "weight.negative" } as const;
-export const WeightNonPositiveError = { error: "weight.non_positive" } as const;
-export const WeightGramsNonNegativeError = { error: "weight.grams_non_negative" } as const;
-
-const WeightQuantityNumber = z
-  .number(WeightNonFiniteError)
-  .refine(Number.isFinite, WeightNonFiniteError)
-  .min(0, WeightNegativeError);
-
-const DivisionScalarNumber = z
-  .number(WeightNonFiniteError)
-  .refine(Number.isFinite, WeightNonFiniteError)
-  .gt(0, WeightNonPositiveError);
-
-const CanonicalGramsInteger = z
-  .number(WeightGramsNonNegativeError)
-  .int(WeightGramsNonNegativeError)
-  .min(0, WeightGramsNonNegativeError);
+import { WeightGrams } from "./weight-grams.vo";
 
 export class Weight {
   private static readonly GRAMS_PER_KILOGRAM = 1_000;
-  private static readonly POUNDS_PER_KILOGRAM = 2.2046226218487757;
-  private static readonly KILOGRAMS_PER_POUND = 1 / Weight.POUNDS_PER_KILOGRAM;
 
-  private constructor(private readonly grams: number) {}
+  private constructor(
+    private readonly grams: number,
+    private readonly rounding: RoundingPort = new RoundToNearest(),
+  ) {}
 
-  static fromKilograms(kilograms: number): Weight {
-    const kilogramsParsed = WeightQuantityNumber.parse(kilograms);
-    const gramsRounded = Math.round(kilogramsParsed * Weight.GRAMS_PER_KILOGRAM);
-    const grams = CanonicalGramsInteger.parse(gramsRounded);
+  static fromKilograms(kilograms: number, rounding: RoundingPort = new RoundToNearest()): Weight {
+    const grams = rounding.round(kilograms * Weight.GRAMS_PER_KILOGRAM);
 
-    return new Weight(grams);
+    return new Weight(WeightGrams.parse(grams), rounding);
   }
 
-  static fromPounds(pounds: number): Weight {
-    const poundsParsed = WeightQuantityNumber.parse(pounds);
-    const gramsRounded = Math.round(poundsParsed * Weight.KILOGRAMS_PER_POUND * Weight.GRAMS_PER_KILOGRAM);
-    const grams = CanonicalGramsInteger.parse(gramsRounded);
-
-    return new Weight(grams);
-  }
-
-  static fromGrams(grams: number): Weight {
-    const gramsParsed = WeightQuantityNumber.parse(grams);
-    const gramsRounded = Math.round(gramsParsed);
-    const integerGrams = CanonicalGramsInteger.parse(gramsRounded);
-
-    return new Weight(integerGrams);
+  static fromGrams(grams: number, rounding: RoundingPort = new RoundToNearest()): Weight {
+    return new Weight(WeightGrams.parse(grams), rounding);
   }
 
   static zero(): Weight {
     return new Weight(0);
   }
 
-  toGrams(): number {
+  get(): number {
     return this.grams;
   }
 
-  toKilograms(rounding?: RoundingPort): number {
+  toKilograms(): number {
     const kilograms = this.grams / Weight.GRAMS_PER_KILOGRAM;
 
-    return rounding ? rounding.round(kilograms) : kilograms;
+    return this.rounding.round(kilograms);
   }
 
-  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: RoundingPort = new RoundToDecimal(2)): string {
-    const value = unit === WeightUnit.kg ? this.toKilograms(rounding) : this.toPounds(rounding);
-
-    return `${value.toString()} ${unit}`;
+  format(): string {
+    return `${this.grams} g`;
   }
 
   add(other: Weight): Weight {
@@ -94,31 +50,22 @@ export class Weight {
     return new Weight(result < 0 ? 0 : result);
   }
 
-  multiply(factor: number): Weight {
-    const factorParsed = WeightQuantityNumber.parse(factor);
-    const gramsRounded = Math.round(this.grams * factorParsed);
-    const grams = CanonicalGramsInteger.parse(gramsRounded);
+  multiply(factor: MultiplicationFactorType): Weight {
+    const grams = this.rounding.round(this.grams * factor);
 
-    return new Weight(grams);
+    return new Weight(WeightGrams.parse(grams));
   }
 
-  divideByScalar(divisor: number): Weight {
-    const divisorParsed = DivisionScalarNumber.parse(divisor);
-    const gramsRounded = Math.round(this.grams / divisorParsed);
-    const grams = CanonicalGramsInteger.parse(gramsRounded);
+  divide(divisor: DivisionFactorType): Weight {
+    const grams = this.rounding.round(this.grams / divisor);
 
-    return new Weight(grams);
+    return new Weight(WeightGrams.parse(grams));
   }
 
   equals(other: Weight): boolean {
     return this.grams === other.grams;
   }
 
-  compare(other: Weight): -1 | 0 | 1 {
-    if (this.grams === other.grams) return 0;
-    return this.grams < other.grams ? -1 : 1;
-  }
-
   greaterThan(other: Weight): boolean {
     return this.grams > other.grams;
   }
@@ -139,15 +86,11 @@ export class Weight {
     return this.grams === 0;
   }
 
-  isPositive(): boolean {
-    return this.grams > 0;
-  }
-
-  toJSON(): { g: number } {
-    return { g: this.grams };
+  toString(): string {
+    return this.format();
   }
 
-  static fromJSON(input: { g: number }): Weight {
-    return Weight.fromGrams(input.g);
+  toJSON(): number {
+    return this.grams;
   }
 }

package/src/year-iso-id.vo.ts

@@ -1,10 +1,13 @@
 import { z } from "zod/v4";
 
-export const YearIsoIdError = { error: "year-iso-id.invalid" } as const;
+export const YearIsoIdError = { Type: "year.iso.id.type", BadChars: "year.iso.id.bad.chars" } as const;
+
+// Four digits
+const YEAR_ISO_ID_CHARS_WHITELIST = /^[0-9]{4}$/;
 
 export const YearIsoId = z
-  .string(YearIsoIdError)
-  .regex(/^\d{4}$/, YearIsoIdError)
-  .refine((value) => Number.isInteger(Number(value)), YearIsoIdError);
+  .string(YearIsoIdError.Type)
+  .regex(YEAR_ISO_ID_CHARS_WHITELIST, YearIsoIdError.BadChars)
+  .brand("YearIsoId");
 
 export type YearIsoIdType = z.infer<typeof YearIsoId>;

package/src/year.vo.ts

@@ -3,59 +3,53 @@ import { DateRange } from "./date-range.vo";
 import { Timestamp, type TimestampType } from "./timestamp.vo";
 import { YearIsoId, type YearIsoIdType } from "./year-iso-id.vo";
 
-export const YearInvalidIntegerError = "year.invalid_integer" as const;
-export const YearOutOfRangeError = "year.out_of_range" as const;
-
 export class Year extends DateRange {
-  toIsoId(): YearIsoIdType {
-    return String(getYear(this.getStart())) as YearIsoIdType;
-  }
-
-  isLeapYear(): boolean {
-    const year = getYear(this.getStart());
+  static fromTimestamp(timestamp: TimestampType): Year {
+    const start = Timestamp.parse(startOfYear(timestamp).getTime());
+    const end = Timestamp.parse(endOfYear(timestamp).getTime());
 
-    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+    return new Year(start, end);
   }
 
-  previous(): Year {
-    const shifted = addYears(new Date(this.getStart()), -1).getTime();
+  static fromNow(now: TimestampType): Year {
+    return Year.fromTimestamp(now);
+  }
 
-    return Year.fromTimestamp(Timestamp.parse(shifted));
+  static fromNumber(candidate: number): Year {
+    return Year.fromIsoId(YearIsoId.parse(String(candidate)));
   }
 
-  next(): Year {
-    const shifted = addYears(new Date(this.getStart()), 1).getTime();
+  static fromIsoId(isoId: YearIsoIdType): Year {
+    const reference = Date.UTC(Number(isoId));
 
-    return Year.fromTimestamp(Timestamp.parse(shifted));
+    return Year.fromTimestamp(Timestamp.parse(reference));
   }
 
-  shift(count: number): Year {
-    const shifted = addYears(new Date(this.getStart()), count).getTime();
-
-    return Year.fromTimestamp(Timestamp.parse(shifted));
+  toIsoId(): YearIsoIdType {
+    return YearIsoId.parse(String(getYear(this.getStart())));
   }
 
-  static fromTimestamp(timestamp: TimestampType): Year {
-    const start = Timestamp.parse(startOfYear(timestamp).getTime());
-    const end = Timestamp.parse(endOfYear(timestamp).getTime());
+  isLeapYear(): boolean {
+    const year = getYear(this.getStart());
 
-    return new Year(start, end);
+    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
   }
 
-  static fromNow(now: TimestampType): Year {
-    return Year.fromTimestamp(now);
+  previous(): Year {
+    return this.shift(-1);
   }
 
-  static fromNumber(value: number): Year {
-    if (!Number.isInteger(value)) throw new Error(YearInvalidIntegerError);
-    if (value < 0 || value > 9999) throw new Error(YearOutOfRangeError);
+  next(): Year {
+    return this.shift(1);
+  }
 
-    const reference = Timestamp.parse(Date.UTC(value, 0, 1, 0, 0, 0, 0));
+  shift(count: number): Year {
+    const shifted = addYears(this.getStart(), count).getTime();
 
-    return Year.fromTimestamp(reference);
+    return Year.fromTimestamp(Timestamp.parse(shifted));
   }
 
-  static fromIsoId(isoId: YearIsoIdType): Year {
-    return Year.fromNumber(Number(YearIsoId.parse(isoId)));
+  toString(): string {
+    return this.toIsoId();
   }
 }

package/src/z-score.service.ts

@@ -3,7 +3,7 @@ import { PopulationStandardDeviation } from "./population-standard-deviation.ser
 import { RoundToDecimal } from "./rounding.adapter";
 import type { RoundingPort } from "./rounding.port";
 
-export const ZScoreMinValuesError = "zscore.min.values" as const;
+export const ZScoreError = { NotEnoughValues: "z.score.not.enough.values" } as const;
 
 export class ZScore {
   private readonly mean: number;
@@ -13,7 +13,7 @@ export class ZScore {
     values: number[],
     private readonly rounding: RoundingPort = new RoundToDecimal(2),
   ) {
-    if (values.length < 2) throw new Error(ZScoreMinValuesError);
+    if (values.length < 2) throw new Error(ZScoreError.NotEnoughValues);
 
     this.mean = Mean.calculate(values);
     this.standardDeviation = PopulationStandardDeviation.calculate(values);

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

@@ -1,25 +0,0 @@
-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 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?: RoundingPort);
-    static fromPairs(pairs: SLRPairType[], rounding?: RoundingPort): SimpleLinearRegression;
-    predict(x: SLRPairType["x"], rounding?: RoundingPort): SLRPredictionType;
-    inspect(): SimpleLinearRegression["params"];
-}

package/dist/streak-calculator.service.d.ts

@@ -1,13 +0,0 @@
-type DateType = string;
-export type StreakType = {
-    cutoff: DateType;
-    dates: DateType[];
-    streak: number;
-};
-export declare class StreakCalculator {
-    private readonly cutoff;
-    constructor(now?: Date);
-    calculate(inputDates: DateType[]): StreakType;
-    static format(date: Date | number): DateType;
-}
-export {};

package/dist/streak-calculator.service.js

@@ -1,22 +0,0 @@
-import { format, subDays } from "date-fns";
-export class StreakCalculator {
-    cutoff;
-    constructor(now = new Date()) {
-        this.cutoff = StreakCalculator.format(now);
-    }
-    calculate(inputDates) {
-        const dates = Array.from(new Set(inputDates));
-        const datesSet = new Set(dates);
-        let streak = 0;
-        let cursor = this.cutoff;
-        while (datesSet.has(cursor)) {
-            streak++;
-            const cursorDate = new Date(`${cursor}T00:00:00Z`);
-            cursor = StreakCalculator.format(subDays(cursorDate, 1));
-        }
-        return { cutoff: this.cutoff, dates, streak };
-    }
-    static format(date) {
-        return format(date, "yyyy-MM-dd");
-    }
-}

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

@@ -1,69 +0,0 @@
-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 static readonly DEFAULT_ROUNDING: RoundingPort = new RoundToNearest();
-
-  private readonly params: SLRParamsType;
-  private readonly rounding: RoundingPort;
-
-  constructor(params: SLRParamsType, rounding?: RoundingPort) {
-    this.params = params;
-    this.rounding = rounding ?? SimpleLinearRegression.DEFAULT_ROUNDING;
-  }
-
-  static fromPairs(pairs: SLRPairType[], rounding?: RoundingPort): SimpleLinearRegression {
-    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(SLRModelCreationError);
-
-    const b = (sumXY - (sumX * sumY) / count) / bDenominator;
-    const a = (sumY - b * sumX) / count;
-
-    return new SimpleLinearRegression({ a, b }, rounding);
-  }
-
-  predict(x: SLRPairType["x"], rounding?: RoundingPort): SLRPredictionType {
-    const chosen = rounding ?? this.rounding;
-    const prediction = this.params.b * x + this.params.a;
-
-    return chosen.round(prediction);
-  }
-
-  inspect(): SimpleLinearRegression["params"] {
-    return this.params;
-  }
-}

package/src/streak-calculator.service.ts

@@ -1,32 +0,0 @@
-import { format, subDays } from "date-fns";
-
-type DateType = string;
-export type StreakType = { cutoff: DateType; dates: DateType[]; streak: number };
-
-export class StreakCalculator {
-  private readonly cutoff: DateType;
-
-  constructor(now: Date = new Date()) {
-    this.cutoff = StreakCalculator.format(now);
-  }
-
-  calculate(inputDates: DateType[]): StreakType {
-    const dates = Array.from(new Set(inputDates));
-    const datesSet = new Set(dates);
-
-    let streak = 0;
-    let cursor = this.cutoff;
-
-    while (datesSet.has(cursor)) {
-      streak++;
-      const cursorDate = new Date(`${cursor}T00:00:00Z`);
-      cursor = StreakCalculator.format(subDays(cursorDate, 1));
-    }
-
-    return { cutoff: this.cutoff, dates, streak };
-  }
-
-  static format(date: Date | number): DateType {
-    return format(date, "yyyy-MM-dd");
-  }
-}