@bgord/tools 1.2.19 → 1.2.21

package/dist/duration.service.d.ts

@@ -4,6 +4,7 @@ export declare class Duration {
     private static readonly rounding;
     private readonly internal;
     static readonly MIN: Duration;
+    private static readonly NS_IN_MS;
     private static readonly MS_IN_SECOND;
     private static readonly MS_IN_MINUTE;
     private static readonly MS_IN_HOUR;
@@ -16,12 +17,14 @@ export declare class Duration {
     static Minutes(value: number): Duration;
     static Seconds(value: number): Duration;
     static Ms(value: number): Duration;
+    static Ns(value: number): Duration;
     get weeks(): number;
     get days(): number;
     get hours(): number;
     get minutes(): number;
     get seconds(): number;
     get ms(): DurationMsType;
+    get ns(): number;
     isLongerThan(another: Duration): boolean;
     isShorterThan(another: Duration): boolean;
     equals(other: Duration): boolean;

package/dist/duration.service.js

@@ -5,6 +5,7 @@ export class Duration {
     static rounding = new RoundingDecimalStrategy(2);
     internal;
     static MIN = Duration.Ms(1);
+    static NS_IN_MS = 1000000;
     static MS_IN_SECOND = 1_000;
     static MS_IN_MINUTE = 60 * Duration.MS_IN_SECOND;
     static MS_IN_HOUR = 60 * Duration.MS_IN_MINUTE;
@@ -31,6 +32,9 @@ export class Duration {
     static Ms(value) {
         return new Duration(value);
     }
+    static Ns(value) {
+        return new Duration(new RoundingToNearestStrategy().round(value / Duration.NS_IN_MS));
+    }
     get weeks() {
         return Duration.rounding.round(this.internal / Duration.MS_IN_WEEK);
     }
@@ -49,6 +53,9 @@ export class Duration {
     get ms() {
         return this.internal;
     }
+    get ns() {
+        return this.internal * Duration.NS_IN_MS;
+    }
     isLongerThan(another) {
         return this.internal > another.internal;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/tools",
-  "version": "1.2.19",
+  "version": "1.2.21",
   "type": "module",
   "license": "MIT",
   "author": "Bartosz Gordon",
@@ -13,8 +13,7 @@
     }
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "scripts": {
     "build": "bash scripts/package-build.sh",

package/src/age-years.vo.ts

@@ -1,16 +0,0 @@
-import { z } from "zod/v4";
-
-export const AgeYearsError = { Type: "age.years.type", Invalid: "age.years.invalid" };
-
-export const AgeYearsConstraints = { min: 1, max: 130 };
-
-// Stryker disable all
-export const AgeYears = z
-  // Stryker restore all
-  .number(AgeYearsError.Type)
-  .int(AgeYearsError.Type)
-  .min(1, AgeYearsError.Invalid)
-  .max(130, AgeYearsError.Invalid)
-  .brand("AgeYears");
-
-export type AgeYearsType = z.infer<typeof AgeYears>;

package/src/age.vo.ts

@@ -1,60 +0,0 @@
-import { differenceInYears } from "date-fns";
-import { AgeYears, AgeYearsConstraints, type AgeYearsType } from "./age-years.vo";
-import { Timestamp } from "./timestamp.vo";
-
-export const AgeError = { FutureBirthdate: "age.future.birthdate" };
-
-export class Age {
-  static readonly MIN = AgeYearsConstraints.min;
-  static readonly MAX = AgeYearsConstraints.max;
-
-  private constructor(private readonly value: AgeYearsType) {}
-
-  static fromValue(candidate: number): Age {
-    return new Age(AgeYears.parse(candidate));
-  }
-
-  static fromValueSafe(candidate: AgeYearsType): Age {
-    return new Age(candidate);
-  }
-
-  static fromBirthdateTimestamp(params: { birthdate: Timestamp; now: Timestamp }): Age {
-    if (params.birthdate.isAfter(params.now)) throw new Error(AgeError.FutureBirthdate);
-    return Age.fromValue(differenceInYears(params.now.ms, params.birthdate.ms));
-  }
-
-  static fromBirthdate(candidate: { birthdate: string; now: Timestamp }): Age {
-    const birthdate = Timestamp.fromNumber(new Date(candidate.birthdate).getTime());
-
-    if (birthdate.isAfter(candidate.now)) throw new Error(AgeError.FutureBirthdate);
-    return Age.fromValue(differenceInYears(candidate.now.ms, birthdate.ms));
-  }
-
-  get(): number {
-    return this.value;
-  }
-
-  equals(other: Age): boolean {
-    return this.value === other.value;
-  }
-
-  isOlderThan(other: Age): boolean {
-    return this.value > other.value;
-  }
-
-  isYoungerThan(other: Age): boolean {
-    return this.value < other.value;
-  }
-
-  isAdult(minimumAge: Age): boolean {
-    return this.value >= minimumAge.value;
-  }
-
-  toString(): string {
-    return this.value.toString();
-  }
-
-  toJSON(): number {
-    return this.get();
-  }
-}

package/src/api-key.vo.ts

@@ -1,16 +0,0 @@
-import { z } from "zod/v4";
-
-export const ApiKeyError = { Type: "api.key.type", Length: "api.key.length", BadChars: "api.key.bad.chars" };
-
-// 64 letters and digits allowed
-const API_KEY_CHARS = /^[a-zA-Z0-9]{64}$/;
-
-// Stryker disable all
-export const ApiKey = z
-  // Stryker disable all
-  .string(ApiKeyError.Type)
-  .length(64, ApiKeyError.Length)
-  .regex(API_KEY_CHARS, ApiKeyError.BadChars)
-  .brand("ApiKey");
-
-export type ApiKeyType = z.infer<typeof ApiKey>;

package/src/basename.vo.ts

@@ -1,33 +0,0 @@
-import { z } from "zod/v4";
-
-export const BasenameError = {
-  Type: "basename.type",
-  Empty: "basename.empty",
-  TooLong: "basename.too.long",
-  DotSegments: "basename.dot.segments",
-  Dotfiles: "basename.dotfiles",
-  TrailingDot: "basename.trailing.dot",
-  BadChars: "basename.bad.chars",
-};
-
-// Letters, digits, dots, underscores, and hyphens allowed
-const BASENAME_CHARS = /^[a-zA-Z0-9._-]+$/;
-
-const DOT_SEGMENTS = [".", ".."];
-
-// Stryker disable all
-export const Basename = z
-  // Stryker restore all
-  .string(BasenameError.Type)
-  .min(1, BasenameError.Empty)
-  .max(128, BasenameError.TooLong)
-  // Reject "." and ".." as a filename to avoid directory traversal
-  .refine((value) => !DOT_SEGMENTS.includes(value), BasenameError.DotSegments)
-  // Reject dotfiles like ".env"
-  .refine((value) => !value.startsWith("."), BasenameError.Dotfiles)
-  // Reject trailing dot like "picture." to avoid extension collision
-  .refine((value) => !value.endsWith("."), BasenameError.TrailingDot)
-  .regex(BASENAME_CHARS, BasenameError.BadChars)
-  .brand("Basename");
-
-export type BasenameType = z.infer<typeof Basename>;

package/src/clock-format.service.ts

@@ -1,15 +0,0 @@
-import type { Hour } from "./hour.vo";
-import { HourFormatters } from "./hour-format.service";
-import type { Minute } from "./minute.vo";
-
-export type ClockFormatter = (hour: Hour, minute: Minute) => string;
-
-enum ClockFormatterEnum {
-  TWENTY_FOUR_HOURS = "TWENTY_FOUR_HOURS",
-  TWELVE_HOURS = "TWELVE_HOURS",
-}
-
-export const ClockFormatters: Record<ClockFormatterEnum, ClockFormatter> = {
-  TWENTY_FOUR_HOURS: (hour, minute) => `${hour.toString()}:${minute.toString()}`,
-  TWELVE_HOURS: (hour, minute) => `${hour.format(HourFormatters.TWELVE_HOURS)}:${minute.toString()}`,
-};

package/src/clock.vo.ts

@@ -1,55 +0,0 @@
-import { type ClockFormatter, ClockFormatters } from "./clock-format.service";
-import { Hour } from "./hour.vo";
-import type { HourSchemaType } from "./hour-schema.vo";
-import { Minute } from "./minute.vo";
-import type { MinuteSchemaType } from "./minute-schema.vo";
-import type { Timestamp } from "./timestamp.vo";
-
-export class Clock {
-  private readonly formatter: ClockFormatter;
-
-  constructor(
-    private readonly hour: Hour,
-    private readonly minute: Minute,
-    formatter?: ClockFormatter,
-  ) {
-    this.formatter = formatter ?? ClockFormatters.TWENTY_FOUR_HOURS;
-  }
-
-  static fromTimestamp(timestamp: Timestamp, formatter?: ClockFormatter): Clock {
-    const hour = Hour.fromTimestamp(timestamp);
-    const minute = Minute.fromTimestamp(timestamp);
-
-    return new Clock(hour, minute, formatter);
-  }
-
-  get(): { hour: HourSchemaType; minute: MinuteSchemaType } {
-    return { hour: this.hour.get(), minute: this.minute.get() };
-  }
-
-  format(): string {
-    return this.formatter(this.hour, this.minute);
-  }
-
-  equals(another: Clock): boolean {
-    return this.hour.equals(another.hour) && this.minute.equals(another.minute);
-  }
-
-  isAfter(another: Clock): boolean {
-    if (!this.hour.equals(another.hour)) return this.hour.isAfter(another.hour);
-    return this.minute.isAfter(another.minute);
-  }
-
-  isBefore(another: Clock): boolean {
-    if (!this.hour.equals(another.hour)) return this.hour.isBefore(another.hour);
-    return this.minute.isBefore(another.minute);
-  }
-
-  toString(): string {
-    return this.format();
-  }
-
-  toJSON(): { hour: HourSchemaType; minute: MinuteSchemaType } {
-    return this.get();
-  }
-}

package/src/date-calculator.service.ts

@@ -1,18 +0,0 @@
-import { Duration } from "./duration.service";
-import { Timestamp } from "./timestamp.vo";
-
-type GetStartOfDayTsInTzConfigType = { now: Timestamp; timeZoneOffset: Duration };
-
-export class DateCalculator {
-  static getStartOfDayTsInTz(config: GetStartOfDayTsInTzConfigType): Timestamp {
-    const dayMs = Duration.Days(1).ms;
-
-    const utcMidnightOfNow = Timestamp.fromNumber(Math.floor(config.now.ms / dayMs) * dayMs);
-
-    let startOfDayInTz = utcMidnightOfNow.add(config.timeZoneOffset);
-
-    if (startOfDayInTz.isAfter(config.now)) startOfDayInTz = startOfDayInTz.subtract(Duration.Days(1));
-
-    return startOfDayInTz;
-  }
-}

package/src/date-formatter.service.ts

@@ -1,21 +0,0 @@
-import { format, formatDistanceToNow } from "date-fns";
-
-type DateFormattersInputType = Parameters<typeof format>[0];
-
-export class DateFormatters {
-  static datetime(date: DateFormattersInputType): string {
-    return format(date, "yyyy/MM/dd HH:mm");
-  }
-
-  static date(date: DateFormattersInputType): string {
-    return format(date, "yyyy/MM/dd");
-  }
-
-  static monthDay(date: DateFormattersInputType): string {
-    return format(date, "MM/dd");
-  }
-
-  static relative(date: DateFormattersInputType): string {
-    return formatDistanceToNow(date, { addSuffix: true });
-  }
-}

package/src/date-range.vo.ts

@@ -1,36 +0,0 @@
-import type { Timestamp } from "./timestamp.vo";
-
-export const DateRangeError = { Invalid: "date.range.invalid" };
-
-export class DateRange {
-  constructor(
-    private readonly start: Timestamp,
-    private readonly end: Timestamp,
-  ) {
-    if (start.isAfter(end)) throw new Error(DateRangeError.Invalid);
-  }
-
-  getStart(): Timestamp {
-    return this.start;
-  }
-
-  getEnd(): Timestamp {
-    return this.end;
-  }
-
-  toRange(): [Timestamp, Timestamp] {
-    return [this.start, this.end];
-  }
-
-  contains(timestamp: Timestamp): boolean {
-    return timestamp.isAfterOrEqual(this.start) && timestamp.isBeforeOrEqual(this.end);
-  }
-
-  equals(other: DateRange): boolean {
-    return this.start.equals(other.start) && this.end.equals(other.end);
-  }
-
-  toJSON(): { start: number; end: number } {
-    return { start: this.getStart().ms, end: this.getEnd().ms };
-  }
-}

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

@@ -1,21 +0,0 @@
-import { isValid, parseISO } from "date-fns";
-import { z } from "zod/v4";
-
-export const DayIsoIdError = {
-  Type: "day.iso.id.type",
-  BadChars: "day.iso.id.bad.chars",
-  InvalidDate: "day.iso.id.invalid.date",
-};
-
-// Four digits, hyphen, two digits, hyphen, two digits
-export const DAY_ISO_ID_CHARS = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/;
-
-// Stryker disable all
-export const DayIsoId = z
-  // Stryker restore all
-  .string(DayIsoIdError.Type)
-  .regex(DAY_ISO_ID_CHARS, DayIsoIdError.BadChars)
-  .refine((value) => isValid(parseISO(value)), DayIsoIdError.InvalidDate)
-  .brand("DayIsoId");
-
-export type DayIsoIdType = z.infer<typeof DayIsoId>;

package/src/day.vo.ts

@@ -1,59 +0,0 @@
-import { formatISO } from "date-fns";
-import { DateRange } from "./date-range.vo";
-import { DayIsoId, type DayIsoIdType } from "./day-iso-id.vo";
-import { Duration } from "./duration.service";
-import { Integer, type IntegerType } from "./integer.vo";
-import { Timestamp } from "./timestamp.vo";
-import type { TimestampValueType } from "./timestamp-value.vo";
-
-export class Day extends DateRange {
-  static fromTimestamp(timestamp: Timestamp): Day {
-    const date = new Date(timestamp.ms);
-
-    const startUtc = Timestamp.fromNumber(
-      Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()),
-    );
-    const endUtc = startUtc.add(Duration.Days(1)).subtract(Duration.Ms(1));
-
-    return new Day(startUtc, endUtc);
-  }
-
-  static fromTimestampValue(timestamp: TimestampValueType): Day {
-    return Day.fromTimestamp(Timestamp.fromValue(timestamp));
-  }
-
-  static fromNow(now: Timestamp): Day {
-    return Day.fromTimestamp(now);
-  }
-
-  static fromIsoId(isoId: DayIsoIdType): Day {
-    const [year, month, day] = DayIsoId.parse(isoId).split("-").map(Number);
-
-    const startUtc = Timestamp.fromNumber(Date.UTC(year, month - 1, day));
-    const endUtc = startUtc.add(Duration.Days(1)).subtract(Duration.Ms(1));
-
-    return new Day(startUtc, endUtc);
-  }
-
-  toIsoId(): DayIsoIdType {
-    const midday = this.getStart().add(Duration.Hours(12));
-
-    return DayIsoId.parse(formatISO(midday.ms, { representation: "date" }));
-  }
-
-  previous(): Day {
-    return this.shift(Integer.parse(-1));
-  }
-
-  next(): Day {
-    return this.shift(Integer.parse(1));
-  }
-
-  shift(count: IntegerType): Day {
-    return Day.fromTimestamp(this.getStart().add(Duration.Days(count)));
-  }
-
-  toString(): string {
-    return this.toIsoId();
-  }
-}

package/src/directory-path-absolute.vo.ts

@@ -1,36 +0,0 @@
-import { z } from "zod/v4";
-
-export const DirectoryPathAbsoluteError = {
-  BadSegments: "directory.path.absolue.bad.segments",
-  Empty: "directory.path.absolue.empty",
-  LeadingSlash: "directory.path.absolue.leading.slash",
-  TooLong: "directory.path.absolue.too.long",
-  TrailingSlash: "directory.path.absolue.trailing.slash",
-  Type: "directory.path.absolue.type",
-};
-
-// Letters, digits, dots, underscores, and hyphens
-export const DIRECTORY_PATH_ABSOLUTE_CHARS = /^[a-zA-Z0-9._-]+$/;
-
-const DOT_SEGMENTS = [".", ".."];
-
-// Stryker disable all
-export const DirectoryPathAbsoluteSchema = z
-  // Stryker restore all
-  .string(DirectoryPathAbsoluteError.Type)
-  .min(1, DirectoryPathAbsoluteError.Empty)
-  .max(512, DirectoryPathAbsoluteError.TooLong)
-  .refine((value) => value.startsWith("/"), DirectoryPathAbsoluteError.LeadingSlash)
-  .refine((value) => (value === "/" ? true : !value.endsWith("/")), DirectoryPathAbsoluteError.TrailingSlash)
-  .refine((value) => {
-    if (value === "/") return true;
-
-    const segments = value.slice(1).split("/");
-
-    return segments.every(
-      (segment) => DIRECTORY_PATH_ABSOLUTE_CHARS.test(segment) && !DOT_SEGMENTS.includes(segment),
-    );
-  }, DirectoryPathAbsoluteError.BadSegments)
-  .brand("DirectoryPathAbsoluteSchema");
-
-export type DirectoryPathAbsoluteType = z.infer<typeof DirectoryPathAbsoluteSchema>;

package/src/directory-path-relative.vo.ts

@@ -1,34 +0,0 @@
-import { z } from "zod/v4";
-
-export const DirectoryPathRelativeError = {
-  BadSegments: "directory.path.relative.bad.segments",
-  Empty: "directory.path.relative.empty",
-  LeadingSlash: "directory.path.relative.leading.slash",
-  TooLong: "directory.path.absolue.too.long",
-  TrailingSlash: "directory.path.absolue.trailing.slash",
-  Type: "directory.path.relative.type",
-};
-
-// Letters, digits, dots, underscores, and hyphens
-export const DIRECTORY_PATH_RELATIVE_CHARS = /^[A-Za-z0-9._-]+$/;
-
-const DOT_SEGMENTS = [".", ".."];
-
-// Stryker disable all
-export const DirectoryPathRelativeSchema = z
-  // Stryker restore all
-  .string(DirectoryPathRelativeError.Type)
-  .min(1, DirectoryPathRelativeError.Empty)
-  .max(512, DirectoryPathRelativeError.TooLong)
-  .refine((value) => !value.startsWith("/"), DirectoryPathRelativeError.LeadingSlash)
-  .refine((value) => !value.endsWith("/"), DirectoryPathRelativeError.TrailingSlash)
-  .refine(
-    (value) =>
-      value
-        .split("/")
-        .every((segment) => DIRECTORY_PATH_RELATIVE_CHARS.test(segment) && !DOT_SEGMENTS.includes(segment)),
-    DirectoryPathRelativeError.BadSegments,
-  )
-  .brand("DirectoryPathRelativeSchema");
-
-export type DirectoryPathRelativeType = z.infer<typeof DirectoryPathRelativeSchema>;

package/src/distance-value.vo.ts

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

package/src/distance.vo.ts

@@ -1,76 +0,0 @@
-import { DistanceValue, type DistanceValueType } from "./distance-value.vo";
-import type { RoundingStrategy } from "./rounding.strategy";
-import { RoundingToNearestStrategy } from "./rounding-to-nearest.strategy";
-
-export const DistanceError = { SubtractResultLessThanZero: "distance.subtract.result.less.than.zero" };
-
-export class Distance {
-  private static readonly ZERO = DistanceValue.parse(0);
-
-  private constructor(private readonly value: DistanceValueType) {}
-
-  static fromMeters(candidate: number): Distance {
-    return new Distance(DistanceValue.parse(candidate));
-  }
-
-  static fromMetersSafe(candidate: DistanceValueType): Distance {
-    return new Distance(candidate);
-  }
-
-  static fromKilometers(
-    candidate: number,
-    rounding: RoundingStrategy = new RoundingToNearestStrategy(),
-  ): Distance {
-    return new Distance(DistanceValue.parse(rounding.round(candidate * 1000)));
-  }
-
-  static fromMiles(
-    candidate: number,
-    rounding: RoundingStrategy = new RoundingToNearestStrategy(),
-  ): Distance {
-    return new Distance(DistanceValue.parse(rounding.round(candidate * 1_609.344)));
-  }
-
-  get(): DistanceValueType {
-    return this.value;
-  }
-
-  add(distance: Distance): Distance {
-    return new Distance(DistanceValue.parse(this.value + distance.get()));
-  }
-
-  subtract(money: Distance): Distance {
-    const result = this.value - money.get();
-
-    if (result < Distance.ZERO) throw new Error(DistanceError.SubtractResultLessThanZero);
-    return new Distance(DistanceValue.parse(result));
-  }
-
-  equals(another: Distance): boolean {
-    return this.value === another.get();
-  }
-
-  isLongerThan(another: Distance): boolean {
-    return this.value > another.get();
-  }
-
-  isShorterThan(another: Distance): boolean {
-    return this.value < another.get();
-  }
-
-  isZero(): boolean {
-    return this.value === Distance.ZERO;
-  }
-
-  format(): string {
-    return this.value.toString();
-  }
-
-  toString(): string {
-    return this.format();
-  }
-
-  toJSON(): number {
-    return this.value;
-  }
-}

package/src/division-factor.vo.ts

@@ -1,12 +0,0 @@
-import { z } from "zod/v4";
-
-export const DivisionFactorError = { Type: "division.factor.type", Invalid: "division.factor.invalid" };
-
-// Stryker disable all
-export const DivisionFactor = z
-  // Stryker restore all
-  .number(DivisionFactorError.Type)
-  .gt(0, DivisionFactorError.Invalid)
-  .brand("DivisionFactor");
-
-export type DivisionFactorType = z.infer<typeof DivisionFactor>;