@bgord/tools 1.2.19 → 1.2.21

package/src/mime.vo.ts

@@ -1,50 +0,0 @@
-import * as mime from "mime-types";
-import { Extension, type ExtensionType } from "./extension.vo";
-import { MimeValue } from "./mime-value.vo";
-
-export const MimeError = { NotAccepted: "mime.not.accepted" };
-
-export class Mime {
-  private constructor(
-    readonly type: string,
-    readonly subtype: string,
-  ) {}
-
-  static fromString(candidate: string): Mime {
-    const { type, subtype } = MimeValue.parse(candidate.split(";")[0].trim());
-
-    return new Mime(type, subtype);
-  }
-
-  static fromExtension(extension: ExtensionType): Mime {
-    return Mime.fromString(String(mime.contentType(extension)));
-  }
-
-  isSatisfiedBy(another: Mime): boolean {
-    if (!(this.type === another.type || this.type === "*")) return false;
-    return this.subtype === another.subtype || this.subtype === "*";
-  }
-
-  toExtension(): ExtensionType {
-    return Extension.parse(mime.extension(this.toString()));
-  }
-
-  toString(): string {
-    return `${this.type}/${this.subtype}`;
-  }
-
-  toJSON(): { type: string; subtype: string } {
-    return { type: this.type, subtype: this.subtype };
-  }
-}
-
-export const MIMES = {
-  csv: Mime.fromString("text/csv"),
-  text: Mime.fromString("text/plain"),
-  markdown: Mime.fromString("text/markdown"),
-  pdf: Mime.fromString("application/pdf"),
-  png: Mime.fromString("image/png"),
-  jpeg: Mime.fromString("image/jpeg"),
-  webp: Mime.fromString("image/webp"),
-  zip: Mime.fromString("application/zip"),
-};

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

@@ -1,96 +0,0 @@
-import type { RoundingStrategy } from "./rounding.strategy";
-import { RoundingDecimalStrategy } from "./rounding-decimal.strategy";
-
-type MinMaxScalerValueType = number;
-
-type MinMaxScalerConfigType = {
-  min: MinMaxScalerValueType;
-  max: MinMaxScalerValueType;
-  bound?: { lower: MinMaxScalerValueType; upper: MinMaxScalerValueType };
-  rounding?: RoundingStrategy;
-};
-
-type ScaleResult = {
-  original: MinMaxScalerValueType;
-  scaled: MinMaxScalerValueType;
-  isMin: boolean;
-  isMax: boolean;
-};
-
-type DescaleResult = {
-  original: MinMaxScalerValueType;
-  scaled: MinMaxScalerValueType;
-  isLowerBound: boolean;
-  isUpperBound: boolean;
-};
-
-export const MinMaxScalerError = {
-  InvalidMinMax: "min.max.scaler.invalid.min.max",
-  InvalidBound: "min.max.scaler.invalid.bound",
-  ValueOutOfRange: "min.max.scaler.value.out.of.range",
-  ScaledOutOfBounds: "min.max.scaler.scaled.out.of.bounds",
-  EmptyArray: "min.max.scaler.empty.array",
-};
-
-export class MinMaxScaler {
-  private static readonly DEFAULT_ROUNDING: RoundingStrategy = new RoundingDecimalStrategy(2);
-
-  private readonly min: MinMaxScalerValueType;
-  private readonly max: MinMaxScalerValueType;
-  private readonly lower: MinMaxScalerValueType;
-  private readonly upper: MinMaxScalerValueType;
-  private readonly rounding: RoundingStrategy;
-
-  constructor(config: MinMaxScalerConfigType) {
-    const lower = config.bound?.lower ?? 0;
-    const upper = config.bound?.upper ?? 1;
-
-    if (config.max - config.min < 0) throw new Error(MinMaxScalerError.InvalidMinMax);
-    if (upper - lower <= 0) throw new Error(MinMaxScalerError.InvalidBound);
-
-    this.rounding = config.rounding ?? MinMaxScaler.DEFAULT_ROUNDING;
-    this.min = config.min;
-    this.max = config.max;
-    this.lower = lower;
-    this.upper = upper;
-  }
-
-  scale(value: MinMaxScalerValueType): ScaleResult {
-    const { min, max, lower, upper } = this;
-
-    if (value < min || value > max) throw new Error(MinMaxScalerError.ValueOutOfRange);
-
-    if (min === max) {
-      return { original: value, scaled: (lower + upper) / 2, isMin: true, isMax: true };
-    }
-
-    const result = ((value - min) / (max - min)) * (upper - lower) + lower;
-
-    return {
-      original: value,
-      scaled: this.rounding.round(result),
-      isMin: value === min,
-      isMax: value === max,
-    };
-  }
-
-  descale(scaled: MinMaxScalerValueType): DescaleResult {
-    const { min, max, lower, upper } = this;
-
-    if (scaled < lower || scaled > upper) throw new Error(MinMaxScalerError.ScaledOutOfBounds);
-
-    const result = ((scaled - lower) / (upper - lower)) * (max - min) + min;
-
-    return {
-      original: this.rounding.round(result),
-      scaled,
-      isLowerBound: scaled === lower,
-      isUpperBound: scaled === upper,
-    };
-  }
-
-  static getMinMax(values: MinMaxScalerValueType[]): { min: number; max: number } {
-    if (values.length === 0) throw new Error(MinMaxScalerError.EmptyArray);
-    return { min: Math.min(...values), max: Math.max(...values) };
-  }
-}

package/src/minute-schema.vo.ts

@@ -1,14 +0,0 @@
-import { z } from "zod/v4";
-
-export const MinuteSchemaError = { Type: "minute.schema.error", Invalid: "minute.schema.invalid" };
-
-// Stryker disable all
-export const MinuteSchema = z
-  // Stryker restore all
-  .number(MinuteSchemaError.Type)
-  .int(MinuteSchemaError.Type)
-  .gte(0, MinuteSchemaError.Invalid)
-  .lte(59, MinuteSchemaError.Invalid)
-  .brand("MinuteSchema");
-
-export type MinuteSchemaType = z.infer<typeof MinuteSchema>;

package/src/minute.vo.ts

@@ -1,59 +0,0 @@
-import { MinuteSchema, type MinuteSchemaType } from "./minute-schema.vo";
-import { Timestamp } from "./timestamp.vo";
-import type { TimestampValueType } from "./timestamp-value.vo";
-
-export class Minute {
-  private constructor(private readonly value: MinuteSchemaType) {}
-
-  static fromValue(candidate: number): Minute {
-    return new Minute(MinuteSchema.parse(candidate));
-  }
-
-  static fromValueSafe(candidate: MinuteSchemaType) {
-    return new Minute(candidate);
-  }
-
-  static fromTimestamp(timestamp: Timestamp): Minute {
-    return new Minute(MinuteSchema.parse(new Date(timestamp.ms).getUTCMinutes()));
-  }
-
-  static fromTimestampValue(timestamp: TimestampValueType): Minute {
-    return Minute.fromTimestamp(Timestamp.fromValue(timestamp));
-  }
-
-  static zero(): Minute {
-    return Minute.fromValue(0);
-  }
-
-  static max(): Minute {
-    return Minute.fromValue(59);
-  }
-
-  get(): MinuteSchemaType {
-    return this.value;
-  }
-
-  equals(another: Minute): boolean {
-    return this.value === another.value;
-  }
-
-  isBefore(another: Minute): boolean {
-    return this.value < another.value;
-  }
-
-  isAfter(another: Minute): boolean {
-    return this.value > another.value;
-  }
-
-  static list(): readonly Minute[] {
-    return Array.from({ length: 60 }, (_, index) => Minute.fromValue(index));
-  }
-
-  toString(): string {
-    return this.value.toString().padStart(2, "0");
-  }
-
-  toJSON(): number {
-    return this.value;
-  }
-}

package/src/money-amount.vo.ts

@@ -1,13 +0,0 @@
-import { z } from "zod/v4";
-
-export const MoneyAmountError = { Type: "money.amount.type", Invalid: "money.amount.invalid" };
-
-// Stryker disable all
-export const MoneyAmount = z
-  // Stryker restore all
-  .number(MoneyAmountError.Type)
-  .int(MoneyAmountError.Type)
-  .min(0, MoneyAmountError.Invalid)
-  .brand("MoneyAmount");
-
-export type MoneyAmountType = z.infer<typeof MoneyAmount>;

package/src/money.vo.ts

@@ -1,83 +0,0 @@
-import type { DivisionFactorType } from "./division-factor.vo";
-import { MoneyAmount, type MoneyAmountType } from "./money-amount.vo";
-import type { MultiplicationFactorType } from "./multiplication-factor.vo";
-import type { RoundingStrategy } from "./rounding.strategy";
-import { RoundingDownStrategy } from "./rounding-down.strategy";
-import { RoundingToNearestStrategy } from "./rounding-to-nearest.strategy";
-
-export const MoneyError = { SubtractResultLessThanZero: "money.subtract.result.less.than.zero" };
-
-export class Money {
-  private static readonly ZERO = MoneyAmount.parse(0);
-
-  private constructor(
-    private readonly amount: MoneyAmountType,
-    private readonly rounding: RoundingStrategy = new RoundingToNearestStrategy(),
-  ) {}
-
-  static fromAmount(candidate: number, rounding?: RoundingStrategy): Money {
-    return new Money(MoneyAmount.parse(candidate), rounding);
-  }
-
-  static fromAmountSafe(candidate: MoneyAmountType, rounding?: RoundingStrategy): Money {
-    return new Money(candidate, rounding);
-  }
-
-  static zero(): Money {
-    return Money.fromAmount(0);
-  }
-
-  getAmount(): MoneyAmountType {
-    return this.amount;
-  }
-
-  add(money: Money): Money {
-    return new Money(MoneyAmount.parse(this.amount + money.getAmount()), this.rounding);
-  }
-
-  multiply(factor: MultiplicationFactorType): Money {
-    return new Money(MoneyAmount.parse(this.rounding.round(this.amount * factor)), this.rounding);
-  }
-
-  subtract(money: Money): Money {
-    const result = this.amount - money.getAmount();
-
-    if (result < Money.ZERO) throw new Error(MoneyError.SubtractResultLessThanZero);
-    return new Money(MoneyAmount.parse(this.rounding.round(result)), this.rounding);
-  }
-
-  divide(factor: DivisionFactorType): Money {
-    return new Money(MoneyAmount.parse(this.rounding.round(this.amount / factor)), this.rounding);
-  }
-
-  equals(another: Money): boolean {
-    return this.amount === another.getAmount();
-  }
-
-  isGreaterThan(another: Money): boolean {
-    return this.amount > another.getAmount();
-  }
-
-  isLessThan(another: Money): boolean {
-    return this.amount < another.getAmount();
-  }
-
-  isZero(): boolean {
-    return this.amount === Money.ZERO;
-  }
-
-  format(): string {
-    const whole = new RoundingDownStrategy().round(this.amount / 100);
-    const fraction = this.amount % 100;
-
-    return `${whole}.${fraction.toString().padStart(2, "0")}`;
-  }
-
-  toString(): string {
-    return this.format();
-  }
-
-  toJSON(): number {
-    return this.amount;
-  }
-}

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

@@ -1,24 +0,0 @@
-import { z } from "zod/v4";
-
-export const MonthIsoIdError = {
-  Type: "month.iso.id.type",
-  BadChars: "month.iso.id.bad.chars",
-  Invalid: "month.iso.id.invalid",
-};
-
-// Four digits, hyphen, two digits
-const MONTH_ISO_ID_CHARS_WHITELIST = /^\d{4}-\d{2}$/;
-
-// Stryker disable all
-export const MonthIsoId = z
-  // Stryker restore all
-  .string(MonthIsoIdError.Type)
-  .regex(MONTH_ISO_ID_CHARS_WHITELIST, MonthIsoIdError.BadChars)
-  .refine((value) => {
-    const month = value.split("-").map(Number)[1];
-
-    return month >= 1 && month <= 12;
-  }, MonthIsoIdError.Invalid)
-  .brand("MonthIsoId");
-
-export type MonthIsoIdType = z.infer<typeof MonthIsoId>;

package/src/month.vo.ts

@@ -1,53 +0,0 @@
-import { endOfMonth, format, getMonth, setMonth, startOfMonth } from "date-fns";
-import { DateRange } from "./date-range.vo";
-import { Integer, type IntegerType } from "./integer.vo";
-import { MonthIsoId, type MonthIsoIdType } from "./month-iso-id.vo";
-import { Timestamp } from "./timestamp.vo";
-import type { TimestampValueType } from "./timestamp-value.vo";
-
-export class Month extends DateRange {
-  static fromTimestamp(timestamp: Timestamp): Month {
-    const start = Timestamp.fromNumber(startOfMonth(timestamp.ms).getTime());
-    const end = Timestamp.fromNumber(endOfMonth(timestamp.ms).getTime());
-
-    return new Month(start, end);
-  }
-
-  static fromTimestampValue(timestamp: TimestampValueType): Month {
-    return Month.fromTimestamp(Timestamp.fromValue(timestamp));
-  }
-
-  static fromNow(now: Timestamp): Month {
-    return Month.fromTimestamp(now);
-  }
-
-  static fromIsoId(iso: MonthIsoIdType): Month {
-    const [year, month] = MonthIsoId.parse(iso).split("-").map(Number);
-
-    const reference = setMonth(Date.UTC(year), month - 1).getTime();
-
-    return Month.fromTimestamp(Timestamp.fromNumber(reference));
-  }
-
-  toIsoId(): MonthIsoIdType {
-    return MonthIsoId.parse(format(this.getStart().ms, "yyyy-MM"));
-  }
-
-  previous(): Month {
-    return this.shift(Integer.parse(-1));
-  }
-
-  next(): Month {
-    return this.shift(Integer.parse(1));
-  }
-
-  shift(count: IntegerType): Month {
-    const shifted = setMonth(this.getStart().ms, getMonth(this.getStart().ms) + count).getTime();
-
-    return Month.fromTimestamp(Timestamp.fromNumber(shifted));
-  }
-
-  toString(): string {
-    return this.toIsoId();
-  }
-}

package/src/multiplication-factor.vo.ts

@@ -1,15 +0,0 @@
-import { z } from "zod/v4";
-
-export const MultiplicationFactorError = {
-  Type: "multiplication.factor.type",
-  Invalid: "multiplication.factor.invalid",
-};
-
-// Stryker disable all
-export const MultiplicationFactor = z
-  // Stryker restore all
-  .number(MultiplicationFactorError.Type)
-  .min(0, MultiplicationFactorError.Invalid)
-  .brand("MultiplicationFactor");
-
-export type MultiplicationFactorType = z.infer<typeof MultiplicationFactor>;

package/src/noop.service.ts

@@ -1,3 +0,0 @@
-export function noop() {}
-
-export async function anoop() {}

package/src/notification-template.vo.ts

@@ -1,10 +0,0 @@
-export class NotificationTemplate {
-  constructor(
-    private readonly subject: string,
-    private readonly message: string,
-  ) {}
-
-  get() {
-    return { subject: this.subject, html: this.message };
-  }
-}

package/src/object-key.vo.ts

@@ -1,36 +0,0 @@
-import { z } from "zod/v4";
-
-export const ObjectKeyError = {
-  Type: "object.key.type",
-  LeadingSlash: "object.key.leading.slash",
-  Empty: "object.key.empty",
-  TooLong: "object.key.too.long",
-  BadChars: "object.key.bad.chars",
-  DotSegments: "object.key.dot.segments",
-};
-
-// Lowercase letters, digits, dots, underscores, and hyphens
-const OBJECT_KEY_SEGMENT_CHARS_WHITELIST = /^[a-z0-9._-]+$/;
-
-const DOT_SEGMENTS = [".", ".."];
-
-// Stryker disable all
-export const ObjectKey = z
-  // Stryker restore all
-  .string(ObjectKeyError.Type)
-  .min(1, ObjectKeyError.Empty)
-  .max(256, ObjectKeyError.TooLong)
-  .refine((value) => !value.startsWith("/"), ObjectKeyError.LeadingSlash)
-  // Allow only known characters for users/avatars/1234567890/avatar.png segments
-  .refine(
-    (value) => value.split("/").every((segment) => OBJECT_KEY_SEGMENT_CHARS_WHITELIST.test(segment)),
-    ObjectKeyError.BadChars,
-  )
-  // Reject object keys like users/./avatar.png or users/../avatar.png
-  .refine(
-    (value) => value.split("/").every((segment) => !DOT_SEGMENTS.includes(segment)),
-    ObjectKeyError.DotSegments,
-  )
-  .brand("ObjectKey");
-
-export type ObjectKeyType = z.infer<typeof ObjectKey>;

package/src/outlier-detector.service.ts

@@ -1,21 +0,0 @@
-import { ZScore } from "./z-score.service";
-
-export const OutlierDetectorError = { NotEnoughValues: "outlier.detector.not.enough.values" };
-
-export class OutlierDetector {
-  private readonly zScore: ZScore;
-  private readonly threshold: number;
-
-  constructor(values: number[], threshold: number) {
-    if (values.length < 2) throw new Error(OutlierDetectorError.NotEnoughValues);
-
-    this.zScore = new ZScore(values);
-    this.threshold = Math.abs(threshold);
-  }
-
-  isInlier(value: number): boolean {
-    const score = this.zScore.calculate(value);
-
-    return Math.abs(score) <= this.threshold;
-  }
-}

package/src/package-version-schema.vo.ts

@@ -1,23 +0,0 @@
-import { z } from "zod/v4";
-
-export const PackageVersionSchemaError = {
-  Type: "package.version.schema.error",
-  BadChars: "package.version.schema.bad.chars",
-};
-
-// v, 1-4 digits, dot, 1-4 digits, dot, 1-4 digits - () for capturing groups
-const PACKAGE_VERSIONS_CHARS_WHITELIST = /^v([0-9]{1,4})\.([0-9]{1,4})\.([0-9]{1,4})$/;
-
-// Stryker disable all
-export const PackageVersionSchema = z
-  // Stryker restore all
-  .string(PackageVersionSchemaError.Type)
-  .regex(PACKAGE_VERSIONS_CHARS_WHITELIST, PackageVersionSchemaError.BadChars)
-  .transform((value) => {
-    const match = PACKAGE_VERSIONS_CHARS_WHITELIST.exec(value)!;
-
-    return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) };
-  })
-  .brand("PackageVersionSchema");
-
-export type PackageVersionSchemaType = z.infer<typeof PackageVersionSchema>;

package/src/package-version.vo.ts

@@ -1,66 +0,0 @@
-import { PackageVersionSchema, type PackageVersionSchemaType } from "./package-version-schema.vo";
-
-export class PackageVersion {
-  constructor(
-    private readonly major: number,
-    private readonly minor: number,
-    private readonly patch: number,
-  ) {}
-
-  static fromVersionString(candidate: string): PackageVersion {
-    const version = PackageVersionSchema.parse(candidate);
-
-    return new PackageVersion(version.major, version.minor, version.patch);
-  }
-
-  static fromVersionStringSafe(candidate: PackageVersionSchemaType): PackageVersion {
-    return new PackageVersion(candidate.major, candidate.minor, candidate.patch);
-  }
-
-  static fromString(candidate: string): PackageVersion {
-    const version = PackageVersionSchema.parse(`v${candidate}`);
-
-    return new PackageVersion(version.major, version.minor, version.patch);
-  }
-
-  private compareTo(another: PackageVersion): -1 | 0 | 1 {
-    if (this.major > another.major) return 1;
-    if (this.major < another.major) return -1;
-
-    if (this.minor > another.minor) return 1;
-    if (this.minor < another.minor) return -1;
-
-    if (this.patch > another.patch) return 1;
-    if (this.patch < another.patch) return -1;
-
-    return 0;
-  }
-
-  equals(another: PackageVersion): boolean {
-    return this.compareTo(another) === 0;
-  }
-
-  isGreaterThan(another: PackageVersion): boolean {
-    return this.compareTo(another) === 1;
-  }
-
-  isGreaterThanOrEqual(another: PackageVersion): boolean {
-    return this.compareTo(another) !== -1;
-  }
-
-  isSmallerThan(another: PackageVersion): boolean {
-    return this.compareTo(another) === -1;
-  }
-
-  isSmallerThanOrEqual(another: PackageVersion): boolean {
-    return this.compareTo(another) !== 1;
-  }
-
-  toString(): string {
-    return `${this.major}.${this.minor}.${this.patch}`;
-  }
-
-  toJSON(): { major: number; minor: number; patch: number } {
-    return { major: this.major, minor: this.minor, patch: this.patch };
-  }
-}

package/src/pagination-page.vo.ts

@@ -1,11 +0,0 @@
-import { z } from "zod/v4";
-
-export const PaginationPageError = { Type: "pagination.page.type" };
-
-export const Page = z.coerce
-  .number(PaginationPageError.Type)
-  .int(PaginationPageError.Type)
-  .transform((value) => (value <= 0 ? 1 : value))
-  .default(1);
-
-export type PageType = z.infer<typeof Page>;

package/src/pagination-skip.vo.ts

@@ -1,10 +0,0 @@
-import { z } from "zod/v4";
-
-export const PaginationSkipError = { Type: "pagination.skip.type", Invalid: "pagination.skip.invalid" };
-
-export const Skip = z
-  .number(PaginationSkipError.Type)
-  .int(PaginationSkipError.Type)
-  .gte(0, PaginationSkipError.Invalid);
-
-export type SkipType = z.infer<typeof Skip>;

package/src/pagination-take.vo.ts

@@ -1,10 +0,0 @@
-import { z } from "zod/v4";
-
-export const PaginationTakeError = { Type: "pagination.take.type", Invalid: "pagination.take.invalid" };
-
-export const Take = z
-  .number(PaginationTakeError.Type)
-  .int(PaginationTakeError.Type)
-  .gte(1, PaginationTakeError.Invalid);
-
-export type TakeType = z.infer<typeof Take>;