@bgord/tools 0.6.0 → 0.8.0

package/src/reordering.service.ts

@@ -0,0 +1,169 @@
+import { z } from "zod/v4";
+
+import { DoublyLinkedList, Node } from "./dll.service";
+
+export const ReorderingItemPositionValue = z.number().int().min(0);
+
+export type ReorderingItemPositionValueType = z.infer<typeof ReorderingItemPositionValue>;
+
+export const ReorderingCorrelationId = z.string().min(1);
+
+export type ReorderingCorrelationIdType = z.infer<typeof ReorderingCorrelationId>;
+
+export const ReorderingItemId = z.uuid();
+
+export type ReorderingItemIdType = z.infer<typeof ReorderingItemId>;
+
+export const Reordering = z.object({
+  correlationId: ReorderingCorrelationId,
+  id: ReorderingItemId,
+  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) {
+    if (!ReorderingItemPositionValue.safeParse(value).success) {
+      throw new Error("Position is not a positive integer");
+    }
+
+    this.value = 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;
+  }) {
+    this.id = config.id;
+    this.to = new ReorderingPosition(config.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 position = new ReorderingPosition(this.dll.getSize());
+    const item = new ReorderingItem(id, position);
+    this.dll.append(new Node(item));
+    return item;
+  }
+
+  delete(id: ReorderingItem["id"]) {
+    const item = this.dll.find((x) => x.data.eq(id));
+    if (!item) {
+      throw new Error("Cannot find Item");
+    }
+    this.dll.remove(item);
+    this.recalculate();
+  }
+
+  transfer(transfer: ReorderingTransfer): ReturnType<ReorderingCalculator["read"]> {
+    const current = this.dll.find((node) => node.data.eq(transfer.id));
+    const target = this.dll.find((node) => node.data.position.eq(transfer.to));
+
+    if (!current) {
+      throw new Error("Cannot find current Item");
+    }
+    if (!target) {
+      throw new Error("Cannot find target Item");
+    }
+
+    const direction = transfer.getDirection(current.data.position);
+
+    if (direction === ReorderingTransferDirection.noop) return this.read();
+    if (direction === ReorderingTransferDirection.upwards) {
+      this.dll.remove(current);
+      this.dll.insertBefore(current, target);
+      this.recalculate();
+    }
+    if (direction === ReorderingTransferDirection.downwards) {
+      this.dll.remove(current);
+      this.dll.insertAfter(current, target);
+      this.recalculate();
+    }
+    return this.read();
+  }
+
+  read() {
+    const ids = Array.from(this.dll).map((item) => item.data.id);
+    const items = Array.from(this.dll).map((item) => item.data);
+    return { ids, items };
+  }
+
+  private recalculate() {
+    this.dll = ReorderingCalculator.fromArray(this.read().ids).dll;
+  }
+}
+
+export class ReorderingIntegrator {
+  static appendPosition(reordering: ReorderingType[]) {
+    return function <T extends { id: ReorderingItemIdType }>(item: T): WithReorderingPositionValue<T> {
+      return {
+        ...item,
+        position: reordering.find((x) => x.id === item.id)?.position ?? 0,
+      };
+    };
+  }
+
+  static sortByPosition() {
+    return (a: WithReorderingPositionValue<unknown>, b: WithReorderingPositionValue<unknown>) =>
+      a.position - b.position;
+  }
+}

package/src/revision.vo.ts

@@ -0,0 +1,61 @@
+import { z } from "zod/v4";
+
+import { ETag, WeakETag } from "./etags.vo";
+
+export const RevisionValue = z.number().int().min(0);
+
+export type RevisionValueType = z.infer<typeof RevisionValue>;
+
+export class Revision {
+  readonly value: RevisionValueType;
+
+  static initial: RevisionValueType = 0;
+
+  constructor(value: unknown) {
+    const result = RevisionValue.safeParse(value);
+
+    if (!result.success) throw new InvalidRevisionError();
+
+    this.value = result.data;
+  }
+
+  matches(another: RevisionValueType): boolean {
+    return this.value === another;
+  }
+
+  validate(another: RevisionValueType): void {
+    if (!this.matches(another)) throw new RevisionMismatchError();
+  }
+
+  next(): Revision {
+    return new Revision(this.value + 1);
+  }
+
+  static fromETag(etag: ETag | null): Revision {
+    if (!etag) {
+      throw new InvalidRevisionError();
+    }
+    return new Revision(etag.revision);
+  }
+
+  static fromWeakETag(weakEtag: WeakETag | null): Revision {
+    if (!weakEtag) {
+      throw new InvalidRevisionError();
+    }
+    return new Revision(weakEtag.revision);
+  }
+}
+
+export class RevisionMismatchError extends Error {
+  constructor() {
+    super();
+    Object.setPrototypeOf(this, RevisionMismatchError.prototype);
+  }
+}
+
+export class InvalidRevisionError extends Error {
+  constructor() {
+    super();
+    Object.setPrototypeOf(this, InvalidRevisionError.prototype);
+  }
+}

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

@@ -0,0 +1,74 @@
+import { RoundToNearest, RoundingStrategy } from "./rounding.service";
+import { Sum } from "./sum.service";
+
+export type SLRPairType = { x: number; y: number };
+
+export type SLRParamsType = { a: number; b: number };
+
+export type SLRPredictionType = number;
+
+export class SimpleLinearRegression {
+  private readonly rounding: RoundingStrategy = new RoundToNearest();
+
+  constructor(
+    private readonly params: SLRParamsType,
+    rounding?: RoundingStrategy,
+  ) {
+    this.rounding = rounding ?? this.rounding;
+  }
+
+  static fromPairs(pairs: SLRPairType[], rounding?: RoundingStrategy) {
+    const n = pairs.length;
+
+    if (n < 2) {
+      throw new Error("At least two pairs needed");
+    }
+
+    const x = pairs.map((pair) => pair.x);
+    const y = pairs.map((pair) => pair.y);
+    const xx = x.map((x) => x ** 2);
+    const xy = pairs.map((pair) => pair.x * pair.y);
+
+    const sX = Sum.of(x);
+    if (sX >= Number.MAX_SAFE_INTEGER) {
+      throw new Error("Sum of x values is too big");
+    }
+
+    const sY = Sum.of(y);
+    if (sY >= Number.MAX_SAFE_INTEGER) {
+      throw new Error("Sum of y values is too big");
+    }
+
+    const sSX = Sum.of(xx);
+    if (sSX >= Number.MAX_SAFE_INTEGER) {
+      throw new Error("Sum of x squared values is too big");
+    }
+
+    const sXY = Sum.of(xy);
+    if (sXY >= Number.MAX_SAFE_INTEGER) {
+      throw new Error("Sum of x times y values is too big");
+    }
+
+    const bDenominator = sSX - sX ** 2 / n;
+
+    if (bDenominator === 0) {
+      throw new Error("Unable to create the model");
+    }
+
+    const b = (sXY - (sX * sY) / n) / bDenominator;
+    const a = (sY - b * sX) / n;
+
+    return new SimpleLinearRegression({ a, b }, rounding);
+  }
+
+  predict(x: SLRPairType["x"], strategy?: RoundingStrategy): SLRPredictionType {
+    const rounding = strategy ?? this.rounding;
+    const prediction = this.params.b * x + this.params.a;
+
+    return rounding.round(prediction);
+  }
+
+  inspect(): SimpleLinearRegression["params"] {
+    return this.params;
+  }
+}

package/src/stepper.service.ts

@@ -0,0 +1,50 @@
+type StepType = number;
+
+type StepperConfigType = { total: StepType };
+
+export class Stepper {
+  static readonly DEFAULT_CURRENT = 1;
+
+  private current: StepType = Stepper.DEFAULT_CURRENT;
+
+  private readonly total: StepType;
+
+  constructor(config: StepperConfigType) {
+    if (!Number.isInteger(config.total)) {
+      throw new Error("Total value is not an integer");
+    }
+
+    if (config.total <= Stepper.DEFAULT_CURRENT) {
+      throw new Error("Total value should be greater than one");
+    }
+
+    this.total = config.total;
+  }
+
+  continue(): Stepper {
+    this.current = Math.min(this.current + 1, this.total);
+
+    return this;
+  }
+
+  read() {
+    return {
+      finished: this.isFinished(),
+      raw: { current: this.current, total: this.total },
+      formatted: `${this.current}/${this.total}`,
+    };
+  }
+
+  reset(): Stepper {
+    this.current = Stepper.DEFAULT_CURRENT;
+    return this;
+  }
+
+  format(): string {
+    return this.read().formatted;
+  }
+
+  isFinished(): boolean {
+    return this.current === this.total;
+  }
+}

package/src/streak-calculator.service.ts

@@ -0,0 +1,42 @@
+import { format, isAfter, isEqual, subDays } from "date-fns";
+
+type DateType = string;
+
+export type StreakType = {
+  cutoff: DateType;
+  dates: DateType[];
+  streak: number;
+};
+
+export class StreakCalculator {
+  private readonly cutoff: DateType;
+
+  constructor() {
+    const today = new Date();
+    this.cutoff = StreakCalculator.format(today);
+  }
+
+  calculate(_dates: DateType[]): StreakType {
+    const dates = Array.from(new Set(_dates));
+
+    let streak = 0;
+    let streakTail = this.cutoff;
+
+    for (let i = 0; i < dates.length; i++) {
+      const date = dates[i] as string;
+
+      if (isAfter(date, streakTail)) continue;
+
+      if (isEqual(streakTail, date) || isAfter(date, streakTail)) {
+        streakTail = StreakCalculator.format(subDays(date, 1));
+        streak++;
+      } else break;
+    }
+
+    return { cutoff: this.cutoff, dates, streak };
+  }
+
+  static format(date: Parameters<typeof format>[0]): DateType {
+    return format(date, "yyyy-MM-dd");
+  }
+}

package/src/sum.service.ts

@@ -0,0 +1,5 @@
+export class Sum {
+  static of(values: number[]): number {
+    return values.reduce((sum, x) => sum + x, 0);
+  }
+}

package/src/thousands-separator.service.ts

@@ -0,0 +1,7 @@
+export class ThousandsSeparator {
+  private static DEFAULT_SEPARATOR = " ";
+
+  static format(value: number, separator = ThousandsSeparator.DEFAULT_SEPARATOR): string {
+    return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+  }
+}

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

@@ -0,0 +1,42 @@
+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/z-score.service.ts

@@ -0,0 +1,24 @@
+import { Mean } from "./mean.service";
+import { PopulationStandardDeviation } from "./population-standard-deviation.service";
+import { RoundToDecimal, RoundingStrategy } from "./rounding.service";
+
+export class ZScore {
+  private readonly mean: number;
+  private readonly standardDeviation: number;
+
+  constructor(
+    values: number[],
+    private readonly rounding: RoundingStrategy = new RoundToDecimal(2),
+  ) {
+    if (values.length < 2) {
+      throw new Error("At least two values are needed");
+    }
+
+    this.mean = Mean.calculate(values);
+    this.standardDeviation = PopulationStandardDeviation.calculate(values);
+  }
+
+  calculate(value: number): number {
+    return this.rounding.round((value - this.mean) / this.standardDeviation);
+  }
+}