@bgord/tools 1.2.19 → 1.2.21

package/src/pagination.service.ts

@@ -1,73 +0,0 @@
-import { Page, type PageType } from "./pagination-page.vo";
-import { Skip, type SkipType } from "./pagination-skip.vo";
-import { Take, type TakeType } from "./pagination-take.vo";
-import { RoundingUpStrategy } from "./rounding-up.strategy";
-
-export type PaginationType = { values: { take: TakeType; skip: SkipType }; page: PageType };
-export type PaginationValuesType = Record<string, unknown>;
-export type TotalType = number;
-export type ExhaustedType = boolean;
-export type PaginationExhaustedConfig = { total: TotalType; pagination: PaginationType };
-export type PaginationPrepareConfigType<T> = { total: TotalType; pagination: PaginationType; result: T[] };
-
-export class Pagination {
-  static parse(values: PaginationValuesType, _take: TakeType): PaginationType {
-    const page = Page.parse(values.page);
-    const take = Take.parse(_take);
-
-    const skip = Skip.parse((page - 1) * take);
-
-    return { values: { take, skip }, page };
-  }
-
-  static prepare<T>(config: PaginationPrepareConfigType<T>): Paged<T> {
-    const exhausted = Pagination.isExhausted(config);
-
-    const currentPage = config.pagination.page;
-    const lastPage = Pagination.getLastPage(config);
-
-    const previousPage = currentPage > 1 ? Page.parse(currentPage - 1) : undefined;
-    const nextPage = currentPage < lastPage ? Page.parse(currentPage + 1) : undefined;
-
-    return {
-      result: config.result,
-      meta: { exhausted, currentPage, previousPage, nextPage, lastPage, total: config.total },
-    };
-  }
-
-  static isExhausted(config: PaginationExhaustedConfig): ExhaustedType {
-    return Pagination.getLastPage(config) <= config.pagination.page;
-  }
-
-  private static getLastPage(config: PaginationExhaustedConfig): PageType {
-    return Page.parse(new RoundingUpStrategy().round(config.total / config.pagination.values.take));
-  }
-
-  static empty = {
-    result: [],
-    meta: {
-      exhausted: true,
-      currentPage: 1,
-      previousPage: undefined,
-      nextPage: undefined,
-      lastPage: 1,
-      total: 0,
-    },
-  };
-
-  static getFirstPage(input: { take: TakeType }): PaginationType {
-    return { values: { take: Take.parse(input.take), skip: Skip.parse(0) }, page: Page.parse(1) };
-  }
-}
-
-export type Paged<T> = {
-  result: T[];
-  meta: {
-    exhausted: ExhaustedType;
-    currentPage: PageType;
-    previousPage: PageType | undefined;
-    nextPage: PageType | undefined;
-    lastPage: PageType;
-    total: TotalType;
-  };
-};

package/src/percentage.service.ts

@@ -1,15 +0,0 @@
-import type { RoundingStrategy } from "./rounding.strategy";
-import { RoundingToNearestStrategy } from "./rounding-to-nearest.strategy";
-
-export const PercentageError = { InvalidDenominator: "percentage.invalid.denominator" };
-
-export class Percentage {
-  static of(
-    numerator: number,
-    denominator: number,
-    rounding: RoundingStrategy = new RoundingToNearestStrategy(),
-  ): number {
-    if (denominator === 0) throw new Error(PercentageError.InvalidDenominator);
-    return rounding.round((numerator / denominator) * 100);
-  }
-}

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

@@ -1,23 +0,0 @@
-import { Mean } from "./mean.service";
-import type { RoundingStrategy } from "./rounding.strategy";
-import { RoundingDecimalStrategy } from "./rounding-decimal.strategy";
-import { Sum } from "./sum.service";
-
-export const PopulationStandardDeviationError = {
-  NotEnoughValues: "population.standard.deviation.not.enough.values",
-};
-
-export class PopulationStandardDeviation {
-  static calculate(values: number[], rounding: RoundingStrategy = new RoundingDecimalStrategy(2)): number {
-    if (values.length < 2) throw new Error(PopulationStandardDeviationError.NotEnoughValues);
-
-    const mean = Mean.calculate(values);
-    const count = values.length;
-
-    const squaredDifferences = values.map((value) => (value - mean) ** 2);
-
-    const variance = Sum.of(squaredDifferences) / count;
-
-    return rounding.round(Math.sqrt(variance));
-  }
-}

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

@@ -1,15 +0,0 @@
-import { z } from "zod/v4";
-
-export const QuarterIsoIdError = {
-  Type: "quarter.iso.id.type",
-  BadChars: "quarter.iso.id.bad.chars",
-};
-
-// Stryker disable all
-export const QuarterIsoId = z
-  // Stryker restore all
-  .string(QuarterIsoIdError.Type)
-  .regex(/^\d{4}-Q[1-4]$/, QuarterIsoIdError.BadChars)
-  .brand("QuarterIsoId");
-
-export type QuarterIsoIdType = z.infer<typeof QuarterIsoId>;

package/src/quarter.vo.ts

@@ -1,41 +0,0 @@
-import { endOfQuarter, getQuarter, getYear, setQuarter, startOfQuarter } from "date-fns";
-import { DateRange } from "./date-range.vo";
-import { QuarterIsoId, type QuarterIsoIdType } from "./quarter-iso-id.vo";
-import { Timestamp } from "./timestamp.vo";
-import type { TimestampValueType } from "./timestamp-value.vo";
-
-export class Quarter extends DateRange {
-  static fromTimestamp(timestamp: Timestamp): Quarter {
-    const start = Timestamp.fromNumber(startOfQuarter(timestamp.ms).getTime());
-    const end = Timestamp.fromNumber(endOfQuarter(timestamp.ms).getTime());
-
-    return new Quarter(start, end);
-  }
-
-  static fromTimestampValue(timestamp: TimestampValueType): Quarter {
-    return Quarter.fromTimestamp(Timestamp.fromValue(timestamp));
-  }
-
-  static fromNow(now: Timestamp): Quarter {
-    return Quarter.fromTimestamp(now);
-  }
-
-  static fromIsoId(isoId: QuarterIsoIdType): Quarter {
-    const [year, quarter] = QuarterIsoId.parse(isoId).split("-Q").map(Number);
-
-    const reference = setQuarter(Date.UTC(year), quarter).getTime();
-
-    return Quarter.fromTimestamp(Timestamp.fromNumber(reference));
-  }
-
-  toIsoId(): QuarterIsoIdType {
-    const year = getYear(this.getStart().ms);
-    const quarter = getQuarter(this.getStart().ms);
-
-    return QuarterIsoId.parse(`${year}-Q${quarter}`);
-  }
-
-  toString(): string {
-    return this.toIsoId();
-  }
-}

package/src/random.service.ts

@@ -1,19 +0,0 @@
-import { RoundingDownStrategy } from "./rounding-down.strategy";
-
-type RandomGenerateConfigType = { min: number; max: number };
-
-export const RandomError = { MinMax: "random.min.max" };
-
-export class Random {
-  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 (min >= max) throw new Error(RandomError.MinMax);
-
-    return new RoundingDownStrategy().round(Math.random() * (max - min + 1)) + min;
-  }
-}

package/src/rate-limiter.service.ts

@@ -1,30 +0,0 @@
-import type { Duration } from "./duration.service";
-import type { Timestamp } from "./timestamp.vo";
-
-type RateLimiterResultSuccessType = { allowed: true };
-type RateLimiterResultErrorType = { allowed: false; remaining: Duration };
-type RateLimiterResultType = RateLimiterResultSuccessType | RateLimiterResultErrorType;
-
-export class RateLimiter {
-  private lastInvocation: Timestamp | null = null;
-
-  constructor(private readonly duration: Duration) {}
-
-  verify(now: Timestamp): RateLimiterResultType {
-    if (this.lastInvocation == null) {
-      this.lastInvocation = now;
-
-      return { allowed: true };
-    }
-
-    const nextAllowedTimestamp = this.lastInvocation.add(this.duration);
-
-    if (nextAllowedTimestamp.isBeforeOrEqual(now)) {
-      this.lastInvocation = now;
-
-      return { allowed: true };
-    }
-
-    return { allowed: false, remaining: nextAllowedTimestamp.difference(now) };
-  }
-}

package/src/relative-date.vo.ts

@@ -1,21 +0,0 @@
-import { DateFormatters } from "./date-formatter.service";
-import type { Timestamp } from "./timestamp.vo";
-import type { TimestampValueType } from "./timestamp-value.vo";
-import type { Falsy } from "./ts-utils";
-
-type RelativeDateType = { raw: TimestampValueType; relative: string };
-
-export class RelativeDate {
-  static truthy(timestamp: Timestamp): RelativeDateType {
-    return RelativeDate._format(timestamp);
-  }
-
-  static falsy(timestamp: Falsy<Timestamp>): RelativeDateType | null {
-    if (!timestamp) return null;
-    return RelativeDate._format(timestamp);
-  }
-
-  private static _format(timestamp: Timestamp): RelativeDateType {
-    return { raw: timestamp.ms, relative: DateFormatters.relative(timestamp.ms) };
-  }
-}

package/src/reordering-item-position-value.vo.ts

@@ -1,10 +0,0 @@
-import { z } from "zod/v4";
-
-export const ReorderingItemPositionValueError = { Invalid: "reordering.position.type" };
-
-export const ReorderingItemPositionValue = z
-  .number(ReorderingItemPositionValueError.Invalid)
-  .int(ReorderingItemPositionValueError.Invalid)
-  .min(0, ReorderingItemPositionValueError.Invalid);
-
-export type ReorderingItemPositionValueType = z.infer<typeof ReorderingItemPositionValue>;

package/src/reordering.service.ts

@@ -1,163 +0,0 @@
-// Stryker disable all
-import { z } from "zod/v4";
-import { DoublyLinkedList, Node } from "./dll.service";
-import {
-  ReorderingItemPositionValue,
-  type ReorderingItemPositionValueType,
-} from "./reordering-item-position-value.vo";
-
-export const ReorderingError = {
-  CannotFindItem: "reordering.cannot.find.item",
-  CannotFindCurrent: "reordering.cannot.find.current",
-  CannotFindTarget: "reordering.cannot.find.target",
-};
-
-const ReorderingIdError = { Type: "reordering.id.type" };
-
-export const ReorderingId = z.string(ReorderingIdError.Type).min(1, ReorderingIdError.Type);
-export type ReorderingItemIdType = z.infer<typeof ReorderingId>;
-
-export const Reordering = z.object({
-  correlationId: ReorderingId,
-  id: ReorderingId,
-  position: ReorderingItemPositionValue,
-});
-export type ReorderingType = z.infer<typeof Reordering>;
-
-export type WithReorderingPositionValue<T> = T & { position: ReorderingItemPositionValueType };
-
-export class ReorderingPosition {
-  readonly value: ReorderingItemPositionValueType;
-
-  constructor(value: ReorderingItemPositionValueType) {
-    this.value = ReorderingItemPositionValue.parse(value);
-  }
-
-  eq(another: ReorderingPosition): boolean {
-    return this.value === another.value;
-  }
-}
-
-class ReorderingItem {
-  constructor(
-    readonly id: ReorderingItemIdType,
-    readonly position: ReorderingPosition,
-  ) {}
-
-  eq(anotherItemId: ReorderingItem["id"]): boolean {
-    return this.id === anotherItemId;
-  }
-}
-
-enum ReorderingTransferDirection {
-  upwards = "upwards",
-  downwards = "downwards",
-  noop = "noop",
-}
-
-export class ReorderingTransfer {
-  readonly id: ReorderingItem["id"];
-  readonly to: ReorderingPosition;
-
-  constructor(config: { id: ReorderingItem["id"]; to: ReorderingItemPositionValueType }) {
-    const id = config.id;
-    const to = new ReorderingPosition(config.to);
-
-    this.id = id;
-    this.to = to;
-  }
-
-  getDirection(currentPosition: ReorderingPosition): ReorderingTransferDirection {
-    if (this.to.value === currentPosition.value) return ReorderingTransferDirection.noop;
-    if (this.to.value > currentPosition.value) return ReorderingTransferDirection.downwards;
-    return ReorderingTransferDirection.upwards;
-  }
-}
-
-export class ReorderingCalculator {
-  private dll: DoublyLinkedList<ReorderingItem>;
-
-  constructor() {
-    this.dll = DoublyLinkedList.fromArray<ReorderingItem>([]);
-  }
-
-  static fromArray(ids: ReorderingItem["id"][]) {
-    const reordering = new ReorderingCalculator();
-    for (const id of ids) {
-      reordering.add(id);
-    }
-    return reordering;
-  }
-
-  add(id: ReorderingItem["id"]): ReorderingItem {
-    const size = this.dll.getSize();
-    const position = new ReorderingPosition(ReorderingItemPositionValue.parse(size));
-    const item = new ReorderingItem(id, position);
-    const node = new Node(item);
-    this.dll.append(node);
-    return item;
-  }
-
-  delete(id: ReorderingItem["id"]) {
-    const node = this.dll.find((x) => x.data.eq(id));
-    if (!node) throw new Error(ReorderingError.CannotFindItem);
-
-    this.dll.remove(node);
-    this.recalculate();
-  }
-
-  transfer(transfer: ReorderingTransfer): ReturnType<ReorderingCalculator["read"]> {
-    const current = this.dll.find((node) => node.data.eq(transfer.id));
-    if (!current) throw new Error(ReorderingError.CannotFindCurrent);
-
-    const target = this.dll.find((node) => node.data.position.eq(transfer.to));
-    if (!target) throw new Error(ReorderingError.CannotFindTarget);
-
-    const direction = transfer.getDirection(current.data.position);
-    if (direction === ReorderingTransferDirection.noop) return this.read();
-
-    // remove first to avoid temporary invalid duplicates of positions
-    this.dll.remove(current);
-
-    if (direction === ReorderingTransferDirection.upwards) {
-      this.dll.insertBefore(current, target);
-    } else {
-      this.dll.insertAfter(current, target);
-    }
-
-    this.recalculate();
-    return this.read();
-  }
-
-  read() {
-    const ids = Array.from(this.dll).map((node) => node.data.id);
-    const items = Array.from(this.dll).map((node) => node.data);
-    return { ids, items };
-  }
-
-  private recalculate() {
-    let index = 0;
-    for (const node of this.dll) {
-      const id = node.data.id;
-      const position = new ReorderingPosition(ReorderingItemPositionValue.parse(index));
-      node.data = new ReorderingItem(id, position);
-      index += 1;
-    }
-  }
-}
-
-export class ReorderingIntegrator {
-  static appendPosition(reordering: ReorderingType[]) {
-    return function <T extends { id: ReorderingItemIdType }>(item: T): WithReorderingPositionValue<T> {
-      const found = reordering.find((x) => x.id === item.id);
-      const positionValue = ReorderingItemPositionValue.parse(found?.position ?? 0);
-      return { ...item, position: positionValue };
-    };
-  }
-
-  static sortByPosition() {
-    return (a: WithReorderingPositionValue<unknown>, b: WithReorderingPositionValue<unknown>) =>
-      a.position - b.position;
-  }
-}
-// Stryker restore all

package/src/revision-value.vo.ts

@@ -1,10 +0,0 @@
-import { z } from "zod/v4";
-
-export const RevisionValueError = { Type: "revision.value.type", Invalid: "revision.value.invalid" };
-
-export const RevisionValue = z
-  .number(RevisionValueError.Type)
-  .int(RevisionValueError.Type)
-  .min(0, RevisionValueError.Invalid);
-
-export type RevisionValueType = z.infer<typeof RevisionValue>;

package/src/revision.vo.ts

@@ -1,44 +0,0 @@
-import type { ETag, WeakETag } from "./etags.vo";
-import { RevisionValue, type RevisionValueType } from "./revision-value.vo";
-
-export const RevisionError = { Missing: "revision.missing", Mismatch: "revision.mismatch" };
-
-export class Revision {
-  static readonly INITIAL: RevisionValueType = RevisionValue.parse(0);
-
-  readonly value: RevisionValueType;
-
-  constructor(value: unknown) {
-    this.value = RevisionValue.parse(value);
-  }
-
-  equals(another: RevisionValueType): boolean {
-    return this.value === another;
-  }
-
-  validate(another: RevisionValueType): void {
-    if (!this.equals(another)) throw new Error(RevisionError.Mismatch);
-  }
-
-  next(): Revision {
-    return new Revision(this.value + 1);
-  }
-
-  static fromETag(etag: ETag | null): Revision {
-    if (!etag) throw new Error(RevisionError.Missing);
-    return new Revision(etag.revision);
-  }
-
-  static fromWeakETag(weakEtag: WeakETag | null): Revision {
-    if (!weakEtag) throw new Error(RevisionError.Missing);
-    return new Revision(weakEtag.revision);
-  }
-
-  toString(): string {
-    return this.value.toString();
-  }
-
-  toJSON(): number {
-    return this.value;
-  }
-}

package/src/rounding-decimal.strategy.ts

@@ -1,25 +0,0 @@
-import { z } from "zod/v4";
-import type { RoundingStrategy } from "./rounding.strategy";
-
-export const RoundingDecimalError = { Type: "rounding.decimal.type", Invalid: "rounding.decimal.invalid" };
-
-// Stryker disable all
-export const RoundingDecimal = z
-  // Stryker restore all
-  .number(RoundingDecimalError.Type)
-  .int(RoundingDecimalError.Invalid)
-  .min(1, RoundingDecimalError.Invalid)
-  .max(100, RoundingDecimalError.Invalid)
-  .brand("RoundingDecimal");
-
-export class RoundingDecimalStrategy implements RoundingStrategy {
-  private readonly decimals: number;
-
-  constructor(candidate: number) {
-    this.decimals = RoundingDecimal.parse(candidate);
-  }
-
-  round(value: number): number {
-    return Number.parseFloat(value.toFixed(this.decimals));
-  }
-}

package/src/rounding-down.strategy.ts

@@ -1,7 +0,0 @@
-import type { RoundingStrategy } from "./rounding.strategy";
-
-export class RoundingDownStrategy implements RoundingStrategy {
-  round(value: number): number {
-    return Math.floor(value);
-  }
-}

package/src/rounding-to-nearest.strategy.ts

@@ -1,7 +0,0 @@
-import type { RoundingStrategy } from "./rounding.strategy";
-
-export class RoundingToNearestStrategy implements RoundingStrategy {
-  round(value: number): number {
-    return Math.round(value);
-  }
-}

package/src/rounding-up.strategy.ts

@@ -1,7 +0,0 @@
-import type { RoundingStrategy } from "./rounding.strategy";
-
-export class RoundingUpStrategy implements RoundingStrategy {
-  round(value: number): number {
-    return Math.ceil(value);
-  }
-}

package/src/rounding.strategy.ts

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

package/src/size-bytes.vo.ts

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

package/src/size.vo.ts

@@ -1,113 +0,0 @@
-import { RoundingDecimalStrategy } from "./rounding-decimal.strategy";
-import { RoundingUpStrategy } from "./rounding-up.strategy";
-import { SizeBytes, type SizeBytesType } from "./size-bytes.vo";
-
-enum SizeUnitEnum {
-  b = "b",
-  kB = "kB",
-  MB = "MB",
-  GB = "GB",
-}
-
-type SizeConfigType = { unit: SizeUnitEnum; value: number };
-
-export class Size {
-  private readonly unit: SizeUnitEnum;
-  private readonly bytes: SizeBytesType;
-
-  private static readonly KB_MULTIPLIER = 1024;
-  private static readonly MB_MULTIPLIER = 1024 * Size.KB_MULTIPLIER;
-  private static readonly GB_MULTIPLIER = 1024 * Size.MB_MULTIPLIER;
-
-  private static readonly CONVERT_ROUND = new RoundingUpStrategy();
-  private static readonly FORMAT_ROUND = new RoundingDecimalStrategy(2);
-
-  private constructor(config: SizeConfigType) {
-    this.unit = config.unit;
-    this.bytes = this.calculateBytes(config.value, config.unit);
-  }
-
-  static fromBytes(value: SizeConfigType["value"]): Size {
-    return new Size({ value, unit: SizeUnitEnum.b });
-  }
-
-  static fromKb(value: SizeConfigType["value"]): Size {
-    return new Size({ value, unit: SizeUnitEnum.kB });
-  }
-
-  static fromMB(value: SizeConfigType["value"]): Size {
-    return new Size({ value, unit: SizeUnitEnum.MB });
-  }
-
-  static fromGB(value: SizeConfigType["value"]): Size {
-    return new Size({ value, unit: SizeUnitEnum.GB });
-  }
-
-  toBytes(): SizeBytesType {
-    return this.bytes;
-  }
-
-  tokB(): number {
-    return Size.CONVERT_ROUND.round(this.bytes / Size.KB_MULTIPLIER);
-  }
-
-  toMB(): number {
-    return Size.CONVERT_ROUND.round(this.bytes / Size.MB_MULTIPLIER);
-  }
-
-  toGB(): number {
-    return Size.CONVERT_ROUND.round(this.bytes / Size.GB_MULTIPLIER);
-  }
-
-  equals(another: Size): boolean {
-    return this.bytes === another.toBytes();
-  }
-
-  isSmallerThan(another: Size): boolean {
-    return this.bytes < another.toBytes();
-  }
-
-  isGreaterThan(another: Size): boolean {
-    return this.bytes > another.toBytes();
-  }
-
-  format(unit: SizeUnitEnum): string {
-    switch (unit) {
-      case SizeUnitEnum.kB:
-        return `${Size.FORMAT_ROUND.round(this.bytes / Size.KB_MULTIPLIER)} ${SizeUnitEnum.kB}`;
-      case SizeUnitEnum.MB:
-        return `${Size.FORMAT_ROUND.round(this.bytes / Size.MB_MULTIPLIER)} ${SizeUnitEnum.MB}`;
-      case SizeUnitEnum.GB:
-        return `${Size.FORMAT_ROUND.round(this.bytes / Size.GB_MULTIPLIER)} ${SizeUnitEnum.GB}`;
-      default:
-        return `${this.bytes} ${SizeUnitEnum.b}`;
-    }
-  }
-
-  static toBytes(config: SizeConfigType): SizeBytesType {
-    return new Size(config).toBytes();
-  }
-
-  static unit = SizeUnitEnum;
-
-  private calculateBytes(value: SizeConfigType["value"], unit: SizeUnitEnum): SizeBytesType {
-    switch (unit) {
-      case SizeUnitEnum.kB:
-        return SizeBytes.parse(value * Size.KB_MULTIPLIER);
-      case SizeUnitEnum.MB:
-        return SizeBytes.parse(value * Size.MB_MULTIPLIER);
-      case SizeUnitEnum.GB:
-        return SizeBytes.parse(value * Size.GB_MULTIPLIER);
-      default:
-        return SizeBytes.parse(value);
-    }
-  }
-
-  toString(): string {
-    return this.format(this.unit);
-  }
-
-  toJSON(): { bytes: number } {
-    return { bytes: this.bytes };
-  }
-}

package/src/slug.service.ts

@@ -1,18 +0,0 @@
-export class Slug {
-  // Any letter or any number
-  private static WHITELIST = /[\p{L}\p{N}]/u;
-
-  static generate(input: string, separator = "-"): string {
-    return (
-      input
-        .split("")
-        .map((character) => (Slug.WHITELIST.test(character) ? character : separator))
-        .join("")
-        // Collapse multiple consecutive separators
-        .replace(new RegExp(`\\${separator}+`, "g"), separator)
-        // Trim leading and trailing separators
-        .replace(new RegExp(`^\\${separator}|\\${separator}$`, "g"), "")
-        .toLocaleLowerCase()
-    );
-  }
-}