@bgord/tools 0.12.26 → 0.13.1

package/src/timestamp.vo.ts

@@ -1,5 +1,4 @@
 import { z } from "zod/v4";
 
 export const Timestamp = z.number().int().gte(0).brand("Timestamp");
-
 export type TimestampType = z.infer<typeof Timestamp>;

package/src/timezone.vo.ts

@@ -6,22 +6,15 @@ export const Timezone = z
   .refine(
     (value) => {
       try {
-        // Create a dummy date and time format using the specified timezone
-        const dummyDate = new Date();
+        const date = new Date();
         const formatter = new Intl.DateTimeFormat("en-US", { timeZone: value });
-
-        // Format the dummy date
-        formatter.format(dummyDate);
-
-        // If the formatting succeeds without throwing an error, the timezone is valid
+        formatter.format(date);
         return true;
       } catch (_error) {
-        // An error occurred, indicating an invalid timezone
         return false;
       }
     },
     { message: "timezone.invalid" },
   )
   .brand("Timezone");
-
 export type TimezoneType = z.infer<typeof Timezone>;

package/src/ts-utils.ts

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

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

@@ -1,6 +1,7 @@
 import { Random } from "./random.service";
 
 export class VisuallyUnambiguousCharactersGenerator {
+  // prettier-ignore
   static chars = [
     "a",
     "b",
@@ -31,10 +32,7 @@ export class VisuallyUnambiguousCharactersGenerator {
       .map(
         () =>
           VisuallyUnambiguousCharactersGenerator.chars[
-            Random.generate({
-              min: 0,
-              max: VisuallyUnambiguousCharactersGenerator.chars.length - 1,
-            })
+            Random.generate({ min: 0, max: VisuallyUnambiguousCharactersGenerator.chars.length - 1 })
           ],
       )
       .join("");

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

@@ -20,5 +20,4 @@ export const WeekIsoId = z
     },
     { message: "week-iso-id.invalid" },
   );
-
 export type WeekIsoIdType = z.infer<typeof WeekIsoId>;

package/src/weekday.vo.ts

@@ -0,0 +1,101 @@
+import type { TimestampType } from "./timestamp.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)
+}
+
+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 {
+  private readonly value: number;
+
+  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)) throw new Error("Invalid weekday");
+    if (candidate < 0) throw new Error("Invalid weekday");
+    if (candidate > 6) throw new Error("Invalid weekday");
+
+    this.value = candidate;
+    this.formatter = (formatter as WeekdayFormatter) ?? WeekdayFormatters.FULL;
+  }
+
+  static fromUtcTimestamp(timestamp: TimestampType, formatter?: WeekdayFormatter): Weekday {
+    const day = new Date(timestamp).getUTCDay(); // 0..6
+    return new Weekday(day, formatter);
+  }
+
+  get(formatter?: WeekdayFormatter) {
+    const format = formatter ?? this.formatter;
+    return { raw: this.value, formatted: format(this.value) };
+  }
+
+  equals(another: Weekday): boolean {
+    return this.value === another.get().raw;
+  }
+
+  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): Weekday[] {
+    return Array.from({ length: 7 }).map((_, index) => new Weekday(index, formatter));
+  }
+
+  static listMondayFirst(formatter?: WeekdayFormatter): Weekday[] {
+    const days = Weekday.list(formatter);
+    return [...days.slice(1), days[0]];
+  }
+}

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

@@ -0,0 +1,13 @@
+import { z } from "zod/v4";
+
+export const YearIsoId = z
+  .string()
+  .regex(/^\d{4}$/)
+  .refine(
+    (value) => {
+      const year = Number(value);
+      return value.length === 4 && Number.isInteger(year);
+    },
+    { message: "year-iso-id.invalid" },
+  );
+export type YearIsoIdType = z.infer<typeof YearIsoId>;

package/src/year.vo.ts

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

package/src/z-score.service.ts

@@ -10,9 +10,7 @@ export class ZScore {
     values: number[],
     private readonly rounding: RoundingStrategy = new RoundToDecimal(2),
   ) {
-    if (values.length < 2) {
-      throw new Error("At least two values are needed");
-    }
+    if (values.length < 2) throw new Error("At least two values are needed");
 
     this.mean = Mean.calculate(values);
     this.standardDeviation = PopulationStandardDeviation.calculate(values);

package/dist/build-version.vo.d.ts

@@ -1,3 +0,0 @@
-import { z } from "zod/v4";
-export declare const BuildVersion: z.core.$ZodBranded<z.ZodString, "BuildVersion">;
-export type BuildVersionType = z.infer<typeof BuildVersion>;

package/dist/build-version.vo.js

@@ -1,2 +0,0 @@
-import { z } from "zod/v4";
-export const BuildVersion = z.string().min(1).max(8).brand("BuildVersion");

package/dist/filter.vo.d.ts

@@ -1,17 +0,0 @@
-import type { z } from "zod/v4";
-export type DefaultFilterSchemaType = z.ZodRawShape;
-export type FilterValuesType = Record<string, unknown>;
-export type FilterSchemaType<T extends DefaultFilterSchemaType> = z.ZodObject<T>;
-export type FilterParseConfigType<T extends DefaultFilterSchemaType> = {
-    schema: FilterSchemaType<T>;
-    values: FilterValuesType;
-};
-export declare class Filter<T extends DefaultFilterSchemaType> {
-    private readonly schema;
-    constructor(schema: FilterSchemaType<T>);
-    parse(values: FilterValuesType): z.core.$InferObjectOutput<T, {}> | undefined;
-    default(): z.core.$InferObjectOutput<T, {}> | undefined;
-    static parse<T extends DefaultFilterSchemaType>(config: FilterParseConfigType<T>): z.core.$InferObjectOutput<T, {}> | undefined;
-    static default<T extends DefaultFilterSchemaType>(config: Omit<FilterParseConfigType<T>, "values">): z.core.$InferObjectOutput<T, {}> | undefined;
-    private static _parse;
-}

package/dist/filter.vo.js

@@ -1,22 +0,0 @@
-export class Filter {
-    schema;
-    constructor(schema) {
-        this.schema = schema;
-    }
-    parse(values) {
-        return Filter._parse({ schema: this.schema, values });
-    }
-    default() {
-        return this.parse({});
-    }
-    static parse(config) {
-        return Filter._parse(config);
-    }
-    static default(config) {
-        return Filter._parse({ schema: config.schema, values: {} });
-    }
-    static _parse(config) {
-        const result = config.schema.safeParse(config.values);
-        return result.success ? result.data : undefined;
-    }
-}

package/dist/leap-year-checker.service.d.ts

@@ -1,4 +0,0 @@
-export declare class LeapYearChecker {
-    static isLeapYear(year: number): boolean;
-    static isCurrentYearLeapYear(): boolean;
-}

package/dist/leap-year-checker.service.js

@@ -1,9 +0,0 @@
-export class LeapYearChecker {
-    static isLeapYear(year) {
-        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
-    }
-    static isCurrentYearLeapYear() {
-        const year = new Date().getFullYear();
-        return LeapYearChecker.isLeapYear(year);
-    }
-}

package/src/build-version.vo.ts

@@ -1,5 +0,0 @@
-import { z } from "zod/v4";
-
-export const BuildVersion = z.string().min(1).max(8).brand("BuildVersion");
-
-export type BuildVersionType = z.infer<typeof BuildVersion>;

package/src/filter.vo.ts

@@ -1,38 +0,0 @@
-import type { z } from "zod/v4";
-
-export type DefaultFilterSchemaType = z.ZodRawShape;
-
-export type FilterValuesType = Record<string, unknown>;
-
-export type FilterSchemaType<T extends DefaultFilterSchemaType> = z.ZodObject<T>;
-
-export type FilterParseConfigType<T extends DefaultFilterSchemaType> = {
-  schema: FilterSchemaType<T>;
-  values: FilterValuesType;
-};
-
-export class Filter<T extends DefaultFilterSchemaType> {
-  constructor(private readonly schema: FilterSchemaType<T>) {}
-
-  parse(values: FilterValuesType) {
-    return Filter._parse({ schema: this.schema, values });
-  }
-
-  default() {
-    return this.parse({});
-  }
-
-  static parse<T extends DefaultFilterSchemaType>(config: FilterParseConfigType<T>) {
-    return Filter._parse(config);
-  }
-
-  static default<T extends DefaultFilterSchemaType>(config: Omit<FilterParseConfigType<T>, "values">) {
-    return Filter._parse({ schema: config.schema, values: {} });
-  }
-
-  private static _parse<T extends DefaultFilterSchemaType>(config: FilterParseConfigType<T>) {
-    const result = config.schema.safeParse(config.values);
-
-    return result.success ? result.data : undefined;
-  }
-}

package/src/leap-year-checker.service.ts

@@ -1,11 +0,0 @@
-export class LeapYearChecker {
-  static isLeapYear(year: number): boolean {
-    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
-  }
-
-  static isCurrentYearLeapYear(): boolean {
-    const year = new Date().getFullYear();
-
-    return LeapYearChecker.isLeapYear(year);
-  }
-}