@bgord/tools 0.17.0 → 0.17.2

package/dist/month.vo.js

@@ -1,4 +1,3 @@
-// src/month.vo.ts
 import { DateRange } from "./date-range.vo";
 import { MonthIsoId } from "./month-iso-id.vo";
 import { Timestamp } from "./timestamp.vo";

package/dist/rate-limiter.service.d.ts

@@ -1,19 +1,17 @@
-import { type TimestampType } from "./timestamp.vo";
-type RateLimiterOptionsType = {
-    ms: TimestampType;
-};
+import { Duration } from "./duration.service";
+import type { TimestampType } from "./timestamp.vo";
 type RateLimiterResultSuccessType = {
     allowed: true;
 };
 type RateLimiterResultErrorType = {
     allowed: false;
-    remainingMs: TimestampType;
+    remaining: Duration;
 };
 type RateLimiterResultType = RateLimiterResultSuccessType | RateLimiterResultErrorType;
 export declare class RateLimiter {
-    private readonly options;
+    private readonly duration;
     private lastInvocationTimestampMs;
-    constructor(options: RateLimiterOptionsType);
+    constructor(duration: Duration);
     verify(currentTimestampMs: TimestampType): RateLimiterResultType;
 }
 export {};

package/dist/rate-limiter.service.js

@@ -1,22 +1,21 @@
-import { Timestamp } from "./timestamp.vo";
+import { Duration } from "./duration.service";
 export class RateLimiter {
-    options;
+    duration;
     lastInvocationTimestampMs = null;
-    constructor(options) {
-        this.options = options;
+    constructor(duration) {
+        this.duration = duration;
     }
     verify(currentTimestampMs) {
         if (this.lastInvocationTimestampMs == null) {
             this.lastInvocationTimestampMs = currentTimestampMs;
             return { allowed: true };
         }
-        const nextAllowedTimestampMs = this.lastInvocationTimestampMs + this.options.ms;
+        const nextAllowedTimestampMs = this.lastInvocationTimestampMs + this.duration.ms;
         if (nextAllowedTimestampMs <= currentTimestampMs) {
             this.lastInvocationTimestampMs = currentTimestampMs;
             return { allowed: true };
         }
         const remainingDelta = nextAllowedTimestampMs - currentTimestampMs;
-        const remainingMs = Timestamp.parse(remainingDelta);
-        return { allowed: false, remainingMs };
+        return { allowed: false, remaining: Duration.Ms(remainingDelta) };
     }
 }

package/dist/relative-date.vo.d.ts

@@ -5,8 +5,8 @@ type RelativeDateType = {
     relative: string;
 };
 export declare class RelativeDate {
-    static truthy(timestampMs: TimestampType): RelativeDateType;
-    static falsy(timestampMs: Falsy<TimestampType>): RelativeDateType | null;
+    static truthy(timestamp: TimestampType): RelativeDateType;
+    static falsy(timestamp: Falsy<TimestampType>): RelativeDateType | null;
     private static _format;
 }
 export {};

package/dist/relative-date.vo.js

@@ -1,12 +1,12 @@
 import { DateFormatters } from "./date-formatter.service";
 export class RelativeDate {
-    static truthy(timestampMs) {
-        return RelativeDate._format(timestampMs);
+    static truthy(timestamp) {
+        return RelativeDate._format(timestamp);
     }
-    static falsy(timestampMs) {
-        if (!timestampMs)
+    static falsy(timestamp) {
+        if (!timestamp)
             return null;
-        return RelativeDate._format(timestampMs);
+        return RelativeDate._format(timestamp);
     }
     static _format(timestampMs) {
         return { raw: timestampMs, relative: DateFormatters.relative(timestampMs) };

package/dist/stopwatch.service.d.ts

@@ -1,8 +1,7 @@
+import { Duration } from "./duration.service";
 import { type TimestampType } from "./timestamp.vo";
 export declare const StopwatchStateError: "stopwatch.already.stopped";
-export type StopwatchResultType = {
-    durationMs: TimestampType;
-};
+export type StopwatchResultType = Duration;
 export declare class Stopwatch {
     private readonly startMs;
     private state;

package/dist/stopwatch.service.js

@@ -1,3 +1,4 @@
+import { Duration } from "./duration.service";
 import { Timestamp } from "./timestamp.vo";
 var StopwatchState;
 (function (StopwatchState) {
@@ -15,6 +16,6 @@ export class Stopwatch {
         if (this.state === StopwatchState.stopped)
             throw new Error(StopwatchStateError);
         this.state = StopwatchState.stopped;
-        return { durationMs: Timestamp.parse(Date.now() - this.startMs) };
+        return Duration.Ms(Timestamp.parse(Date.now() - this.startMs));
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/tools",
-  "version": "0.17.0",
+  "version": "0.17.2",
   "type": "module",
   "license": "MIT",
   "author": "Bartosz Gordon",
@@ -27,19 +27,19 @@
     "@types/bun": "1.2.23",
     "@types/mime-types": "3.0.1",
     "cspell": "9.2.1",
-    "knip": "5.64.1",
+    "knip": "5.64.2",
     "lefthook": "1.13.6",
     "only-allow": "1.2.1",
     "shellcheck": "4.1.0",
     "typescript": "5.9.3",
-    "zod": "4.1.11"
+    "zod": "4.1.12"
   },
   "dependencies": {
     "date-fns": "4.1.0",
     "mime-types": "3.0.1"
   },
   "peerDependencies": {
-    "zod": "4.1.11"
+    "zod": "4.1.12"
   },
   "sideEffects": false
 }

package/src/month.vo.ts

@@ -1,4 +1,3 @@
-// src/month.vo.ts
 import { DateRange } from "./date-range.vo";
 import { MonthIsoId, type MonthIsoIdType } from "./month-iso-id.vo";
 import { Timestamp, type TimestampType } from "./timestamp.vo";

package/src/rate-limiter.service.ts

@@ -1,14 +1,14 @@
-import { Timestamp, type TimestampType } from "./timestamp.vo";
+import { Duration } from "./duration.service";
+import type { TimestampType } from "./timestamp.vo";
 
-type RateLimiterOptionsType = { ms: TimestampType };
 type RateLimiterResultSuccessType = { allowed: true };
-type RateLimiterResultErrorType = { allowed: false; remainingMs: TimestampType };
+type RateLimiterResultErrorType = { allowed: false; remaining: Duration };
 type RateLimiterResultType = RateLimiterResultSuccessType | RateLimiterResultErrorType;
 
 export class RateLimiter {
   private lastInvocationTimestampMs: TimestampType | null = null;
 
-  constructor(private readonly options: RateLimiterOptionsType) {}
+  constructor(private readonly duration: Duration) {}
 
   verify(currentTimestampMs: TimestampType): RateLimiterResultType {
     if (this.lastInvocationTimestampMs == null) {
@@ -17,7 +17,7 @@ export class RateLimiter {
       return { allowed: true };
     }
 
-    const nextAllowedTimestampMs = this.lastInvocationTimestampMs + this.options.ms;
+    const nextAllowedTimestampMs = this.lastInvocationTimestampMs + this.duration.ms;
 
     if (nextAllowedTimestampMs <= currentTimestampMs) {
       this.lastInvocationTimestampMs = currentTimestampMs;
@@ -25,8 +25,7 @@ export class RateLimiter {
     }
 
     const remainingDelta = nextAllowedTimestampMs - currentTimestampMs;
-    const remainingMs = Timestamp.parse(remainingDelta);
 
-    return { allowed: false, remainingMs };
+    return { allowed: false, remaining: Duration.Ms(remainingDelta) };
   }
 }

package/src/relative-date.vo.ts

@@ -5,13 +5,13 @@ import type { Falsy } from "./ts-utils";
 type RelativeDateType = { raw: TimestampType; relative: string };
 
 export class RelativeDate {
-  static truthy(timestampMs: TimestampType): RelativeDateType {
-    return RelativeDate._format(timestampMs);
+  static truthy(timestamp: TimestampType): RelativeDateType {
+    return RelativeDate._format(timestamp);
   }
 
-  static falsy(timestampMs: Falsy<TimestampType>): RelativeDateType | null {
-    if (!timestampMs) return null;
-    return RelativeDate._format(timestampMs);
+  static falsy(timestamp: Falsy<TimestampType>): RelativeDateType | null {
+    if (!timestamp) return null;
+    return RelativeDate._format(timestamp);
   }
 
   private static _format(timestampMs: TimestampType): RelativeDateType {

package/src/stopwatch.service.ts

@@ -1,3 +1,4 @@
+import { Duration } from "./duration.service";
 import { Timestamp, type TimestampType } from "./timestamp.vo";
 
 enum StopwatchState {
@@ -7,7 +8,7 @@ enum StopwatchState {
 
 export const StopwatchStateError = "stopwatch.already.stopped" as const;
 
-export type StopwatchResultType = { durationMs: TimestampType };
+export type StopwatchResultType = Duration;
 
 export class Stopwatch {
   private state: StopwatchState = StopwatchState.started;
@@ -19,6 +20,6 @@ export class Stopwatch {
 
     this.state = StopwatchState.stopped;
 
-    return { durationMs: Timestamp.parse(Date.now() - this.startMs) };
+    return Duration.Ms(Timestamp.parse(Date.now() - this.startMs));
   }
 }