@bgord/tools 1.2.19 → 1.2.21

package/src/sum.service.ts

@@ -1,19 +0,0 @@
-export class Sum {
-  static of(values: readonly number[]): number {
-    return values.reduce((sum, x) => sum + x, 0);
-  }
-
-  static precise(values: readonly number[]): number {
-    let sum = 0;
-    let compensation = 0;
-
-    for (const value of values) {
-      const adjusted = value - compensation;
-      const temporary = sum + adjusted;
-      compensation = temporary - sum - adjusted;
-      sum = temporary;
-    }
-
-    return sum;
-  }
-}

package/src/thousands-separator.service.ts

@@ -1,10 +0,0 @@
-export class ThousandsSeparator {
-  private static DEFAULT_SEPARATOR = " ";
-
-  static format(value: number, separator = ThousandsSeparator.DEFAULT_SEPARATOR): string {
-    // B - not a word boundary, prevents inserting at the very start
-    // (?=([0-9]{3})+(?![0-9])) - positive lookahead, find three digits
-    // (?![0-9]) - negative lookahead, the next character is not a digit
-    return value.toString().replace(/\B(?=([0-9]{3})+(?![0-9]))/g, separator);
-  }
-}

package/src/time-zone-offset-value.vo.ts

@@ -1,21 +0,0 @@
-import { z } from "zod/v4";
-
-export const TimeZoneOffsetValueError = {
-  Type: "time.zone.offset.value.type",
-  Min: "time.zone.offset.value.min",
-  Max: "time.zone.offset.value.max",
-};
-
-// Stryker disable all
-export const TimeZoneOffsetValue = z.coerce
-  // Stryker restore all
-  .number(TimeZoneOffsetValueError.Type)
-  .int(TimeZoneOffsetValueError.Type)
-  // UTC+14 (Kiribati)
-  .min(-840, TimeZoneOffsetValueError.Min)
-  // UTC-12 (Baker Island)
-  .max(720, TimeZoneOffsetValueError.Max)
-  .default(0) // Default to UTC if missing or invalid
-  .brand("TimeZoneOffsetValue");
-
-export type TimeZoneOffsetValueType = z.infer<typeof TimeZoneOffsetValue>;

package/src/timestamp-value.vo.ts

@@ -1,13 +0,0 @@
-import { z } from "zod/v4";
-
-export const TimestampValueError = { Invalid: "timestamp.invalid" };
-
-// Stryker disable all
-export const TimestampValue = z
-  // Stryker restore all
-  .number(TimestampValueError.Invalid)
-  .int(TimestampValueError.Invalid)
-  .gte(0, TimestampValueError.Invalid)
-  .brand("TimestampValue");
-
-export type TimestampValueType = z.infer<typeof TimestampValue>;

package/src/timestamp.vo.ts

@@ -1,66 +0,0 @@
-import { Duration } from "./duration.service";
-import { TimestampValue, type TimestampValueType } from "./timestamp-value.vo";
-
-export class Timestamp {
-  constructor(private readonly value: TimestampValueType) {}
-
-  static fromValue(value: TimestampValueType): Timestamp {
-    return new Timestamp(value);
-  }
-
-  static fromNumber(value: number): Timestamp {
-    return new Timestamp(TimestampValue.parse(value));
-  }
-
-  static fromDate(value: Date): Timestamp {
-    return Timestamp.fromNumber(value.getTime());
-  }
-
-  static fromDateLike(value: string): Timestamp {
-    return Timestamp.fromNumber(new Date(value).getTime());
-  }
-
-  add(duration: Duration): Timestamp {
-    return Timestamp.fromNumber(this.value + duration.ms);
-  }
-
-  subtract(duration: Duration): Timestamp {
-    return Timestamp.fromNumber(this.value - duration.ms);
-  }
-
-  difference(another: Timestamp): Duration {
-    return Duration.Ms(this.value - another.value);
-  }
-
-  isBefore(another: Timestamp): boolean {
-    return this.value < another.value;
-  }
-
-  isBeforeOrEqual(another: Timestamp): boolean {
-    return this.value <= another.value;
-  }
-
-  isAfter(another: Timestamp): boolean {
-    return this.value > another.value;
-  }
-
-  isAfterOrEqual(another: Timestamp): boolean {
-    return this.value >= another.value;
-  }
-
-  equals(another: Timestamp): boolean {
-    return this.value === another.value;
-  }
-
-  get ms(): TimestampValueType {
-    return this.value;
-  }
-
-  toJSON(): TimestampValueType {
-    return this.value;
-  }
-
-  toString(): string {
-    return this.value.toString();
-  }
-}

package/src/timezone.vo.ts

@@ -1,26 +0,0 @@
-import { z } from "zod/v4";
-
-export const TimezoneError = {
-  Type: "timezone.type",
-  Empty: "timezone.empty",
-  TooLong: "timezone.too.long",
-  Invalid: "timezone.invalid",
-};
-
-// Stryker disable all
-export const Timezone = z
-  // Stryker restore all
-  .string(TimezoneError.Type)
-  .min(1, TimezoneError.Empty)
-  .max(128, TimezoneError.TooLong)
-  .refine((value) => {
-    try {
-      new Intl.DateTimeFormat("en-US", { timeZone: value }).format(Date.now());
-      return true;
-    } catch {
-      return false;
-    }
-  }, TimezoneError.Invalid)
-  .brand("Timezone");
-
-export type TimezoneType = z.infer<typeof Timezone>;

package/src/ts-utils.ts

@@ -1,3 +0,0 @@
-export type Constructor<T> = new (...args: any[]) => T;
-export type Falsy<T> = T | null | undefined;
-export type Nullable<T> = T | null;

package/src/url-with-slash.vo.ts

@@ -1,12 +0,0 @@
-import { z } from "zod/v4";
-
-export const UrlWithSlashError = { Invalid: "url.with.slash.invalid" };
-
-// Stryker disable all
-export const UrlWithSlash = z
-  // Stryker disable all
-  .url(UrlWithSlashError.Invalid)
-  .refine((value) => value.endsWith("/"), UrlWithSlashError.Invalid)
-  .brand("UrlWithSlash");
-
-export type UrlWithSlashType = z.infer<typeof UrlWithSlash>;

package/src/url-without-slash.vo.ts

@@ -1,12 +0,0 @@
-import { z } from "zod/v4";
-
-export const UrlWithoutSlashError = { Invalid: "url.without.slash.invalid" };
-
-// Stryker disable all
-export const UrlWithoutSlash = z
-  // Stryker restore all
-  .url(UrlWithoutSlashError.Invalid)
-  .refine((value) => !value.endsWith("/"), UrlWithoutSlashError.Invalid)
-  .brand("UrlWithoutSlash");
-
-export type UrlWithoutSlashType = z.infer<typeof UrlWithoutSlash>;

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

@@ -1,39 +0,0 @@
-import { Random } from "./random.service";
-
-export class VisuallyUnambiguousCharactersGenerator {
-  static chars = [
-    "a",
-    "b",
-    "c",
-    "d",
-    "e",
-    "f",
-    "h",
-    "i",
-    "j",
-    "k",
-    "m",
-    "n",
-    "o",
-    "p",
-    "r",
-    "s",
-    "t",
-    "w",
-    "x",
-    "y",
-    "3",
-    "4",
-  ];
-
-  static generate(length = 1): string {
-    return Array.from({ length })
-      .map(
-        () =>
-          VisuallyUnambiguousCharactersGenerator.chars[
-            Random.generate({ min: 0, max: VisuallyUnambiguousCharactersGenerator.chars.length - 1 })
-          ],
-      )
-      .join("");
-  }
-}

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

@@ -1,28 +0,0 @@
-import { getISOWeeksInYear } from "date-fns";
-import { z } from "zod/v4";
-
-export const WeekIsoIdError = {
-  Type: "week.iso.id.type",
-  BadChars: "week.iso.id.bad.chars",
-  Invalid: "week.iso.id.invalid",
-};
-
-// Four digits, hypen, W, followed by two digits
-const WEEK_ISO_ID_CHARS_WHITELIST = /^[0-9]{4}-W[0-9]{2}$/;
-
-// Stryker disable all
-export const WeekIsoId = z
-  // Stryker restore all
-  .string(WeekIsoIdError.Type)
-  .regex(WEEK_ISO_ID_CHARS_WHITELIST, WeekIsoIdError.BadChars)
-  .refine((value) => {
-    const [year, week] = value.split("-W").map(Number);
-    // ISO-8601 rule: Jan 4 is always in week 01 of the ISO week-year.
-    const weeksInYear = getISOWeeksInYear(Date.UTC(year, 0, 4));
-
-    if (week < 1) return false;
-    return week <= weeksInYear;
-  }, WeekIsoIdError.Invalid)
-  .brand("WeekIsoId");
-
-export type WeekIsoIdType = z.infer<typeof WeekIsoId>;

package/src/week.vo.ts

@@ -1,57 +0,0 @@
-import { addWeeks, endOfISOWeek, getISOWeek, getISOWeekYear, setISOWeek, startOfISOWeek } from "date-fns";
-import { DateRange } from "./date-range.vo";
-import { Integer, type IntegerType } from "./integer.vo";
-import { Timestamp } from "./timestamp.vo";
-import type { TimestampValueType } from "./timestamp-value.vo";
-import { WeekIsoId, type WeekIsoIdType } from "./week-iso-id.vo";
-
-export class Week extends DateRange {
-  static fromTimestamp(timestamp: Timestamp): Week {
-    const start = Timestamp.fromNumber(startOfISOWeek(timestamp.ms).getTime());
-    const end = Timestamp.fromNumber(endOfISOWeek(timestamp.ms).getTime());
-
-    return new Week(start, end);
-  }
-
-  static fromTimestampValue(timestamp: TimestampValueType): Week {
-    return Week.fromTimestamp(Timestamp.fromValue(timestamp));
-  }
-
-  static fromNow(now: Timestamp): Week {
-    return Week.fromTimestamp(now);
-  }
-
-  static fromIsoId(isoId: WeekIsoIdType): Week {
-    const [year, week] = WeekIsoId.parse(isoId).split("-W").map(Number);
-
-    // ISO-8601 rule: Jan 4 is always in week 01 of the ISO week-year.
-    const reference = setISOWeek(Date.UTC(year, 0, 4), week).getTime();
-
-    return Week.fromTimestamp(Timestamp.fromNumber(reference));
-  }
-
-  toIsoId(): WeekIsoIdType {
-    const year = getISOWeekYear(this.getStart().ms);
-    const week = getISOWeek(this.getStart().ms);
-
-    return WeekIsoId.parse(`${year}-W${String(week).padStart(2, "0")}`);
-  }
-
-  previous(): Week {
-    return this.shift(Integer.parse(-1));
-  }
-
-  next(): Week {
-    return this.shift(Integer.parse(1));
-  }
-
-  shift(count: IntegerType): Week {
-    const shifted = addWeeks(this.getStart().ms, count).getTime();
-
-    return Week.fromTimestamp(Timestamp.fromNumber(shifted));
-  }
-
-  toString(): string {
-    return this.toIsoId();
-  }
-}

package/src/weekday.vo.ts

@@ -1,119 +0,0 @@
-import { Timestamp } from "./timestamp.vo";
-import type { TimestampValueType } from "./timestamp-value.vo";
-
-export type WeekdayFormatter = (value: Weekday["value"]) => string;
-
-export enum WeekdayFormatterEnum {
-  FULL = "FULL", // "Sunday"
-  SHORT = "SHORT", // "Sun"
-  ISO_NUMBER = "ISO_NUMBER", // Monday=1 ... Sunday=7
-  ZERO_BASED_NUMBER = "ZERO_BASED_NUMBER", // Sunday=0 ... Saturday=6 (JS)
-}
-
-export const WeekdayValueError = { Invalid: "weekday.invalid" };
-
-const FULL_NAMES: readonly string[] = [
-  "Sunday",
-  "Monday",
-  "Tuesday",
-  "Wednesday",
-  "Thursday",
-  "Friday",
-  "Saturday",
-] as const;
-
-const SHORT_NAMES: readonly string[] = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"] as const;
-
-export const WeekdayFormatters: Record<WeekdayFormatterEnum, WeekdayFormatter> = {
-  FULL: (value) => FULL_NAMES[value],
-  SHORT: (value) => SHORT_NAMES[value],
-  ISO_NUMBER: (value) => (value === 0 ? 7 : value).toString(), // ISO-8601: Mon=1..Sun=7
-  ZERO_BASED_NUMBER: (value) => value.toString(), // JS getUTCDay(): Sun=0..Sat=6
-} as const;
-
-export class Weekday {
-  // 0..6 (Sun..Sat)
-  private readonly value: number;
-
-  // default formatter used by toString()/format() when no runtime formatter given
-  private readonly formatter: WeekdayFormatter;
-
-  static readonly SUNDAY = new Weekday(0);
-  static readonly MONDAY = new Weekday(1);
-  static readonly TUESDAY = new Weekday(2);
-  static readonly WEDNESDAY = new Weekday(3);
-  static readonly THURSDAY = new Weekday(4);
-  static readonly FRIDAY = new Weekday(5);
-  static readonly SATURDAY = new Weekday(6);
-
-  constructor(candidate: number, formatter?: WeekdayFormatter) {
-    if (!Number.isInteger(candidate) || candidate < 0 || candidate > 6) {
-      throw new Error(WeekdayValueError.Invalid);
-    }
-
-    this.value = candidate;
-    this.formatter = formatter ?? WeekdayFormatters.FULL;
-  }
-
-  static fromTimestamp(timestamp: Timestamp, formatter?: WeekdayFormatter): Weekday {
-    const dayZeroBased = new Date(timestamp.ms).getUTCDay(); // 0..6
-    return new Weekday(dayZeroBased, formatter);
-  }
-
-  static fromTimestampValue(timestamp: TimestampValueType): Weekday {
-    return Weekday.fromTimestamp(Timestamp.fromValue(timestamp));
-  }
-
-  get(): number {
-    return this.value;
-  }
-
-  format(): string {
-    return this.formatter(this.value);
-  }
-
-  toString(): string {
-    return this.format();
-  }
-
-  equals(another: Weekday): boolean {
-    return this.value === another.value;
-  }
-
-  /** ISO-8601 weekday number: Monday=1 ... Sunday=7 */
-  toIsoNumber(): number {
-    return this.value === 0 ? 7 : this.value;
-  }
-
-  isMonday(): boolean {
-    return this.value === 1;
-  }
-  isTuesday(): boolean {
-    return this.value === 2;
-  }
-  isWednesday(): boolean {
-    return this.value === 3;
-  }
-  isThursday(): boolean {
-    return this.value === 4;
-  }
-  isFriday(): boolean {
-    return this.value === 5;
-  }
-  isSaturday(): boolean {
-    return this.value === 6;
-  }
-  isSunday(): boolean {
-    return this.value === 0;
-  }
-
-  static list(formatter?: WeekdayFormatter): readonly Weekday[] {
-    return Array.from({ length: 7 }, (_, index) => new Weekday(index, formatter));
-  }
-
-  static listMondayFirst(formatter?: WeekdayFormatter): readonly Weekday[] {
-    const [Sunday, ...rest] = Weekday.list(formatter);
-
-    return [...rest, Sunday];
-  }
-}

package/src/weight-grams.vo.ts

@@ -1,13 +0,0 @@
-import { z } from "zod/v4";
-
-export const WeightGramsError = { Type: "weight.grams.type", Invalid: "weight.grams.invalid" };
-
-// Stryker disable all
-export const WeightGrams = z
-  // Stryker restore all
-  .number(WeightGramsError.Type)
-  .int(WeightGramsError.Type)
-  .gte(0, WeightGramsError.Invalid)
-  .brand("WeightGrams");
-
-export type WeightGramsType = z.infer<typeof WeightGrams>;

package/src/weight.vo.ts

@@ -1,91 +0,0 @@
-import type { DivisionFactorType } from "./division-factor.vo";
-import type { MultiplicationFactorType } from "./multiplication-factor.vo";
-import type { RoundingStrategy } from "./rounding.strategy";
-import { RoundingToNearestStrategy } from "./rounding-to-nearest.strategy";
-import { WeightGrams, type WeightGramsType } from "./weight-grams.vo";
-
-export class Weight {
-  private static readonly GRAMS_PER_KILOGRAM = 1_000;
-
-  private constructor(
-    private readonly grams: WeightGramsType,
-    private readonly rounding: RoundingStrategy = new RoundingToNearestStrategy(),
-  ) {}
-
-  static fromKilograms(
-    kilograms: number,
-    rounding: RoundingStrategy = new RoundingToNearestStrategy(),
-  ): Weight {
-    const grams = rounding.round(kilograms * Weight.GRAMS_PER_KILOGRAM);
-
-    return new Weight(WeightGrams.parse(grams), rounding);
-  }
-
-  static fromGrams(grams: number, rounding: RoundingStrategy = new RoundingToNearestStrategy()): Weight {
-    return new Weight(WeightGrams.parse(grams), rounding);
-  }
-
-  static zero(): Weight {
-    return new Weight(WeightGrams.parse(0));
-  }
-
-  get(): number {
-    return this.grams;
-  }
-
-  toKilograms(): number {
-    const kilograms = this.grams / Weight.GRAMS_PER_KILOGRAM;
-
-    return this.rounding.round(kilograms);
-  }
-
-  format(): string {
-    return `${this.grams} g`;
-  }
-
-  add(other: Weight): Weight {
-    return new Weight(WeightGrams.parse(this.grams + other.grams));
-  }
-
-  subtract(other: Weight): Weight {
-    const result = this.grams - other.grams;
-
-    return new Weight(WeightGrams.parse(Math.max(0, result)), this.rounding);
-  }
-
-  multiply(factor: MultiplicationFactorType): Weight {
-    const grams = this.rounding.round(this.grams * factor);
-
-    return new Weight(WeightGrams.parse(grams));
-  }
-
-  divide(divisor: DivisionFactorType): Weight {
-    const grams = this.rounding.round(this.grams / divisor);
-
-    return new Weight(WeightGrams.parse(grams));
-  }
-
-  equals(other: Weight): boolean {
-    return this.grams === other.grams;
-  }
-
-  greaterThan(other: Weight): boolean {
-    return this.grams > other.grams;
-  }
-
-  lessThan(other: Weight): boolean {
-    return this.grams < other.grams;
-  }
-
-  isZero(): boolean {
-    return this.grams === 0;
-  }
-
-  toString(): string {
-    return this.format();
-  }
-
-  toJSON(): number {
-    return this.grams;
-  }
-}

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

@@ -1,15 +0,0 @@
-import { z } from "zod/v4";
-
-export const YearIsoIdError = { Type: "year.iso.id.type", BadChars: "year.iso.id.bad.chars" };
-
-// Four digits
-const YEAR_ISO_ID_CHARS_WHITELIST = /^[0-9]{4}$/;
-
-// Stryker disable all
-export const YearIsoId = z
-  // Stryker restore all
-  .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

@@ -1,63 +0,0 @@
-import { addYears, endOfYear, getYear, startOfYear } from "date-fns";
-import { DateRange } from "./date-range.vo";
-import { Integer, type IntegerType } from "./integer.vo";
-import { Timestamp } from "./timestamp.vo";
-import type { TimestampValueType } from "./timestamp-value.vo";
-import { YearIsoId, type YearIsoIdType } from "./year-iso-id.vo";
-
-export class Year extends DateRange {
-  static fromTimestamp(timestamp: Timestamp): Year {
-    const start = Timestamp.fromNumber(startOfYear(timestamp.ms).getTime());
-    const end = Timestamp.fromNumber(endOfYear(timestamp.ms).getTime());
-
-    return new Year(start, end);
-  }
-
-  static fromTimestampValue(timestamp: TimestampValueType): Year {
-    return Year.fromTimestamp(Timestamp.fromValue(timestamp));
-  }
-
-  static fromNow(now: Timestamp): Year {
-    return Year.fromTimestamp(now);
-  }
-
-  static fromNumber(candidate: number): Year {
-    return Year.fromIsoId(YearIsoId.parse(String(candidate)));
-  }
-
-  static fromIsoId(isoId: YearIsoIdType): Year {
-    const reference = Date.UTC(Number(isoId));
-
-    return Year.fromTimestamp(Timestamp.fromNumber(reference));
-  }
-
-  toIsoId(): YearIsoIdType {
-    return YearIsoId.parse(String(getYear(this.getStart().ms)));
-  }
-
-  isLeapYear(): boolean {
-    const year = getYear(this.getStart().ms);
-
-    if (year % 400 === 0) return true;
-    if (year % 100 === 0) return false;
-    return year % 4 === 0;
-  }
-
-  previous(): Year {
-    return this.shift(Integer.parse(-1));
-  }
-
-  next(): Year {
-    return this.shift(Integer.parse(1));
-  }
-
-  shift(count: IntegerType): Year {
-    const shifted = addYears(this.getStart().ms, count).getTime();
-
-    return Year.fromTimestamp(Timestamp.fromNumber(shifted));
-  }
-
-  toString(): string {
-    return this.toIsoId();
-  }
-}

package/src/z-score.service.ts

@@ -1,25 +0,0 @@
-import { Mean } from "./mean.service";
-import { PopulationStandardDeviation } from "./population-standard-deviation.service";
-import type { RoundingStrategy } from "./rounding.strategy";
-import { RoundingDecimalStrategy } from "./rounding-decimal.strategy";
-
-export const ZScoreError = { NotEnoughValues: "z.score.not.enough.values" };
-
-export class ZScore {
-  private readonly mean: number;
-  private readonly standardDeviation: number;
-
-  constructor(
-    values: number[],
-    private readonly rounding: RoundingStrategy = new RoundingDecimalStrategy(2),
-  ) {
-    if (values.length < 2) throw new Error(ZScoreError.NotEnoughValues);
-
-    this.mean = Mean.calculate(values);
-    this.standardDeviation = PopulationStandardDeviation.calculate(values);
-  }
-
-  calculate(value: number): number {
-    return this.rounding.round((value - this.mean) / this.standardDeviation);
-  }
-}