@bgord/tools 1.4.5 → 1.4.7

package/dist/month-iso-id.vo.js

@@ -1,14 +0,0 @@
-import * as v from "valibot";
-export const MonthIsoIdError = {
-    Type: "month.iso.id.type",
-    BadChars: "month.iso.id.bad.chars",
-    Invalid: "month.iso.id.invalid",
-};
-// Four digits, hyphen, two digits
-const MONTH_ISO_ID_CHARS_WHITELIST = /^\d{4}-\d{2}$/;
-export const MonthIsoId = v.pipe(v.string(MonthIsoIdError.Type), v.regex(MONTH_ISO_ID_CHARS_WHITELIST, MonthIsoIdError.BadChars), v.check((value) => {
-    const month = value.split("-").map(Number)[1];
-    return month >= 1 && month <= 12;
-}, MonthIsoIdError.Invalid), 
-// Stryker disable next-line StringLiteral
-v.brand("MonthIsoId"));

package/dist/month.vo.d.ts

@@ -1,16 +0,0 @@
-import { DateRange } from "./date-range.vo";
-import type { IntegerType } from "./integer.vo";
-import { type MonthIsoIdType } from "./month-iso-id.vo";
-import { Timestamp } from "./timestamp.vo";
-import type { TimestampValueType } from "./timestamp-value.vo";
-export declare class Month extends DateRange {
-    static fromTimestamp(timestamp: Timestamp): Month;
-    static fromTimestampValue(timestamp: TimestampValueType): Month;
-    static fromNow(now: Timestamp): Month;
-    static fromIsoId(iso: MonthIsoIdType): Month;
-    toIsoId(): MonthIsoIdType;
-    previous(): Month;
-    next(): Month;
-    shift(count: IntegerType): Month;
-    toString(): string;
-}

package/dist/month.vo.js

@@ -1,40 +0,0 @@
-import { endOfMonth, format, startOfMonth } from "date-fns";
-import * as v from "valibot";
-import { DateRange } from "./date-range.vo";
-import { Int } from "./int.vo";
-import { MonthIsoId } from "./month-iso-id.vo";
-import { Timestamp } from "./timestamp.vo";
-export class Month extends DateRange {
-    static fromTimestamp(timestamp) {
-        const start = Timestamp.fromNumber(startOfMonth(timestamp.ms).getTime());
-        const end = Timestamp.fromNumber(endOfMonth(timestamp.ms).getTime());
-        return new Month(start, end);
-    }
-    static fromTimestampValue(timestamp) {
-        return Month.fromTimestamp(Timestamp.fromValue(timestamp));
-    }
-    static fromNow(now) {
-        return Month.fromTimestamp(now);
-    }
-    static fromIsoId(iso) {
-        const [year, month] = v.parse(MonthIsoId, iso).split("-").map(Number);
-        const reference = Timestamp.fromNumber(Date.UTC(year, month - 1, 1));
-        return Month.fromTimestamp(reference);
-    }
-    toIsoId() {
-        return v.parse(MonthIsoId, format(this.getStart().ms, "yyyy-MM"));
-    }
-    previous() {
-        return this.shift(Int.of(-1));
-    }
-    next() {
-        return this.shift(Int.of(1));
-    }
-    shift(count) {
-        const start = new Date(this.getStart().ms);
-        return Month.fromTimestamp(Timestamp.fromNumber(Date.UTC(start.getUTCFullYear(), start.getUTCMonth() + count, 1)));
-    }
-    toString() {
-        return this.toIsoId();
-    }
-}

package/dist/multiplication-factor.vo.d.ts

@@ -1,7 +0,0 @@
-import * as v from "valibot";
-export declare const MultiplicationFactorError: {
-    Type: string;
-    Invalid: string;
-};
-export declare const MultiplicationFactor: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.MinValueAction<number, 0, string>, v.BrandAction<number, "MultiplicationFactor">]>;
-export type MultiplicationFactorType = v.InferOutput<typeof MultiplicationFactor>;

package/dist/multiplication-factor.vo.js

@@ -1,8 +0,0 @@
-import * as v from "valibot";
-export const MultiplicationFactorError = {
-    Type: "multiplication.factor.type",
-    Invalid: "multiplication.factor.invalid",
-};
-export const MultiplicationFactor = v.pipe(v.number(MultiplicationFactorError.Type), v.minValue(0, MultiplicationFactorError.Invalid), 
-// Stryker disable next-line StringLiteral
-v.brand("MultiplicationFactor"));

package/dist/noop.service.d.ts

@@ -1,2 +0,0 @@
-export declare function noop(): void;
-export declare function anoop(): Promise<void>;

package/dist/noop.service.js

@@ -1,2 +0,0 @@
-export function noop() { }
-export async function anoop() { }

package/dist/object-key.vo.d.ts

@@ -1,11 +0,0 @@
-import * as v from "valibot";
-export declare const ObjectKeyError: {
-    Type: string;
-    LeadingSlash: string;
-    Empty: string;
-    TooLong: string;
-    BadChars: string;
-    DotSegments: string;
-};
-export declare const ObjectKey: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>, v.MaxLengthAction<string, 256, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.BrandAction<string, "ObjectKey">]>;
-export type ObjectKeyType = v.InferOutput<typeof ObjectKey>;

package/dist/object-key.vo.js

@@ -1,19 +0,0 @@
-import * as v from "valibot";
-export const ObjectKeyError = {
-    Type: "object.key.type",
-    LeadingSlash: "object.key.leading.slash",
-    Empty: "object.key.empty",
-    TooLong: "object.key.too.long",
-    BadChars: "object.key.bad.chars",
-    DotSegments: "object.key.dot.segments",
-};
-// Lowercase letters, digits, dots, underscores, and hyphens
-const OBJECT_KEY_SEGMENT_CHARS_WHITELIST = /^[a-z0-9._-]+$/;
-const DOT_SEGMENTS = [".", ".."];
-export const ObjectKey = v.pipe(v.string(ObjectKeyError.Type), v.minLength(1, ObjectKeyError.Empty), v.maxLength(256, ObjectKeyError.TooLong), v.check((value) => !value.startsWith("/"), ObjectKeyError.LeadingSlash), 
-// Allow only known characters for users/avatars/1234567890/avatar.png segments
-v.check((value) => value.split("/").every((segment) => OBJECT_KEY_SEGMENT_CHARS_WHITELIST.test(segment)), ObjectKeyError.BadChars), 
-// Reject object keys like users/./avatar.png or users/../avatar.png
-v.check((value) => value.split("/").every((segment) => !DOT_SEGMENTS.includes(segment)), ObjectKeyError.DotSegments), 
-// Stryker disable next-line StringLiteral
-v.brand("ObjectKey"));

package/dist/outlier-detector.service.d.ts

@@ -1,9 +0,0 @@
-export declare const OutlierDetectorError: {
-    NotEnoughValues: string;
-};
-export declare class OutlierDetector {
-    private readonly zScore;
-    private readonly threshold;
-    constructor(values: ReadonlyArray<number>, threshold: number);
-    isInlier(value: number): boolean;
-}

package/dist/outlier-detector.service.js

@@ -1,16 +0,0 @@
-import { ZScore } from "./z-score.service";
-export const OutlierDetectorError = { NotEnoughValues: "outlier.detector.not.enough.values" };
-export class OutlierDetector {
-    zScore;
-    threshold;
-    constructor(values, threshold) {
-        if (values.length < 2)
-            throw new Error(OutlierDetectorError.NotEnoughValues);
-        this.zScore = new ZScore(values);
-        this.threshold = Math.abs(threshold);
-    }
-    isInlier(value) {
-        const score = this.zScore.calculate(value);
-        return Math.abs(score) <= this.threshold;
-    }
-}

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

@@ -1,8 +0,0 @@
-import * as v from "valibot";
-export declare const PackageVersionSchemaError: {
-    Type: string;
-    BadChars: string;
-};
-export declare const PACKAGE_VERSIONS_CHARS_WHITELIST: RegExp;
-export declare const PackageVersionSchema: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>, v.BrandAction<string, "PackageVersionSchema">]>;
-export type PackageVersionSchemaType = v.InferOutput<typeof PackageVersionSchema>;

package/dist/package-version-schema.vo.js

@@ -1,10 +0,0 @@
-import * as v from "valibot";
-export const PackageVersionSchemaError = {
-    Type: "package.version.schema.error",
-    BadChars: "package.version.schema.bad.chars",
-};
-// v, 1-4 digits, dot, 1-4 digits, dot, 1-4 digits - () for capturing groups
-export const PACKAGE_VERSIONS_CHARS_WHITELIST = /^v([0-9]{1,4})\.([0-9]{1,4})\.([0-9]{1,4})$/;
-export const PackageVersionSchema = v.pipe(v.string(PackageVersionSchemaError.Type), v.regex(PACKAGE_VERSIONS_CHARS_WHITELIST, PackageVersionSchemaError.BadChars), 
-// Stryker disable next-line StringLiteral
-v.brand("PackageVersionSchema"));

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

@@ -1,22 +0,0 @@
-import { type PackageVersionSchemaType } from "./package-version-schema.vo";
-export declare class PackageVersion {
-    private readonly major;
-    private readonly minor;
-    private readonly patch;
-    private constructor();
-    static fromVersionString(candidate: string): PackageVersion;
-    static fromVersionStringSafe(candidate: PackageVersionSchemaType): PackageVersion;
-    static fromString(candidate: string): PackageVersion;
-    private compareTo;
-    equals(another: PackageVersion): boolean;
-    isGreaterThan(another: PackageVersion): boolean;
-    isGreaterThanOrEqual(another: PackageVersion): boolean;
-    isSmallerThan(another: PackageVersion): boolean;
-    isSmallerThanOrEqual(another: PackageVersion): boolean;
-    toString(): string;
-    toJSON(): {
-        major: number;
-        minor: number;
-        patch: number;
-    };
-}

package/dist/package-version.vo.js

@@ -1,58 +0,0 @@
-import * as v from "valibot";
-import { PACKAGE_VERSIONS_CHARS_WHITELIST, PackageVersionSchema, } from "./package-version-schema.vo";
-export class PackageVersion {
-    major;
-    minor;
-    patch;
-    constructor(major, minor, patch) {
-        this.major = major;
-        this.minor = minor;
-        this.patch = patch;
-    }
-    static fromVersionString(candidate) {
-        return PackageVersion.fromVersionStringSafe(v.parse(PackageVersionSchema, candidate));
-    }
-    static fromVersionStringSafe(candidate) {
-        const [, major, minor, patch] = PACKAGE_VERSIONS_CHARS_WHITELIST.exec(candidate).map(Number);
-        return new PackageVersion(major, minor, patch);
-    }
-    static fromString(candidate) {
-        return PackageVersion.fromVersionStringSafe(v.parse(PackageVersionSchema, `v${candidate}`));
-    }
-    compareTo(another) {
-        if (this.major > another.major)
-            return 1;
-        if (this.major < another.major)
-            return -1;
-        if (this.minor > another.minor)
-            return 1;
-        if (this.minor < another.minor)
-            return -1;
-        if (this.patch > another.patch)
-            return 1;
-        if (this.patch < another.patch)
-            return -1;
-        return 0;
-    }
-    equals(another) {
-        return this.compareTo(another) === 0;
-    }
-    isGreaterThan(another) {
-        return this.compareTo(another) === 1;
-    }
-    isGreaterThanOrEqual(another) {
-        return this.compareTo(another) !== -1;
-    }
-    isSmallerThan(another) {
-        return this.compareTo(another) === -1;
-    }
-    isSmallerThanOrEqual(another) {
-        return this.compareTo(another) !== 1;
-    }
-    toString() {
-        return `${this.major}.${this.minor}.${this.patch}`;
-    }
-    toJSON() {
-        return { major: this.major, minor: this.minor, patch: this.patch };
-    }
-}

package/dist/pagination-page.vo.d.ts

@@ -1,6 +0,0 @@
-import * as v from "valibot";
-export declare const PaginationPageError: {
-    Type: string;
-};
-export declare const Page: v.SchemaWithPipe<readonly [v.UnknownSchema, v.TransformAction<unknown, number>, v.NumberSchema<string>, v.IntegerAction<number, string>, v.TransformAction<number, number>]>;
-export type PageType = v.InferOutput<typeof Page>;

package/dist/pagination-page.vo.js

@@ -1,3 +0,0 @@
-import * as v from "valibot";
-export const PaginationPageError = { Type: "pagination.page.type" };
-export const Page = v.pipe(v.unknown(), v.transform((value) => (value === undefined ? 1 : Number(value))), v.number(PaginationPageError.Type), v.integer(PaginationPageError.Type), v.transform((value) => (value <= 0 ? 1 : value)));

package/dist/pagination-skip.vo.d.ts

@@ -1,7 +0,0 @@
-import * as v from "valibot";
-export declare const PaginationSkipError: {
-    Type: string;
-    Invalid: string;
-};
-export declare const Skip: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>]>;
-export type SkipType = v.InferOutput<typeof Skip>;

package/dist/pagination-skip.vo.js

@@ -1,3 +0,0 @@
-import * as v from "valibot";
-export const PaginationSkipError = { Type: "pagination.skip.type", Invalid: "pagination.skip.invalid" };
-export const Skip = v.pipe(v.number(PaginationSkipError.Type), v.integer(PaginationSkipError.Type), v.minValue(0, PaginationSkipError.Invalid));

package/dist/pagination-take.vo.d.ts

@@ -1,7 +0,0 @@
-import * as v from "valibot";
-export declare const PaginationTakeError: {
-    Type: string;
-    Invalid: string;
-};
-export declare const Take: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 1, string>]>;
-export type TakeType = v.InferOutput<typeof Take>;

package/dist/pagination-take.vo.js

@@ -1,3 +0,0 @@
-import * as v from "valibot";
-export const PaginationTakeError = { Type: "pagination.take.type", Invalid: "pagination.take.invalid" };
-export const Take = v.pipe(v.number(PaginationTakeError.Type), v.integer(PaginationTakeError.Type), v.minValue(1, PaginationTakeError.Invalid));

package/dist/pagination.service.d.ts

@@ -1,53 +0,0 @@
-import { type PageType } from "./pagination-page.vo";
-import { type SkipType } from "./pagination-skip.vo";
-import { type TakeType } from "./pagination-take.vo";
-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: ReadonlyArray<T>;
-};
-export declare class Pagination {
-    static parse(values: PaginationValuesType, _take: TakeType): PaginationType;
-    static prepare<T>(config: PaginationPrepareConfigType<T>): Paged<T>;
-    static isExhausted(config: PaginationExhaustedConfig): ExhaustedType;
-    private static getLastPage;
-    static empty: {
-        result: never[];
-        meta: {
-            exhausted: boolean;
-            currentPage: number;
-            previousPage: undefined;
-            nextPage: undefined;
-            lastPage: number;
-            total: number;
-        };
-    };
-    static getFirstPage(input: {
-        take: TakeType;
-    }): PaginationType;
-}
-export type Paged<T> = {
-    result: ReadonlyArray<T>;
-    meta: {
-        exhausted: ExhaustedType;
-        currentPage: PageType;
-        previousPage: PageType | undefined;
-        nextPage: PageType | undefined;
-        lastPage: PageType;
-        total: TotalType;
-    };
-};

package/dist/pagination.service.js

@@ -1,44 +0,0 @@
-import * as v from "valibot";
-import { Page } from "./pagination-page.vo";
-import { Skip } from "./pagination-skip.vo";
-import { Take } from "./pagination-take.vo";
-import { RoundingUpStrategy } from "./rounding-up.strategy";
-export class Pagination {
-    static parse(values, _take) {
-        const page = v.parse(Page, values.page);
-        const take = v.parse(Take, _take);
-        const skip = v.parse(Skip, (page - 1) * take);
-        return { values: { take, skip }, page };
-    }
-    static prepare(config) {
-        const exhausted = Pagination.isExhausted(config);
-        const currentPage = config.pagination.page;
-        const lastPage = Pagination.getLastPage(config);
-        const previousPage = currentPage > 1 ? v.parse(Page, currentPage - 1) : undefined;
-        const nextPage = currentPage < lastPage ? v.parse(Page, currentPage + 1) : undefined;
-        return {
-            result: config.result,
-            meta: { exhausted, currentPage, previousPage, nextPage, lastPage, total: config.total },
-        };
-    }
-    static isExhausted(config) {
-        return Pagination.getLastPage(config) <= config.pagination.page;
-    }
-    static getLastPage(config) {
-        return v.parse(Page, 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) {
-        return { values: { take: v.parse(Take, input.take), skip: v.parse(Skip, 0) }, page: v.parse(Page, 1) };
-    }
-}

package/dist/percentage.service.d.ts

@@ -1,7 +0,0 @@
-import type { RoundingStrategy } from "./rounding.strategy";
-export declare const PercentageError: {
-    InvalidDenominator: string;
-};
-export declare class Percentage {
-    static of(numerator: number, denominator: number, rounding?: RoundingStrategy): number;
-}

package/dist/percentage.service.js

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

package/dist/population-standard-deviation.service.d.ts

@@ -1,7 +0,0 @@
-import type { RoundingStrategy } from "./rounding.strategy";
-export declare const PopulationStandardDeviationError: {
-    NotEnoughValues: string;
-};
-export declare class PopulationStandardDeviation {
-    static calculate(values: ReadonlyArray<number>, rounding?: RoundingStrategy): number;
-}

package/dist/population-standard-deviation.service.js

@@ -1,17 +0,0 @@
-import { Mean } from "./mean.service";
-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, rounding = new RoundingDecimalStrategy(2)) {
-        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/dist/quarter-iso-id.vo.d.ts

@@ -1,8 +0,0 @@
-import * as v from "valibot";
-export declare const QuarterIsoIdError: {
-    Type: string;
-    BadChars: string;
-};
-export declare const QUARTER_ISO_ID_CHARS_WHITELIST: RegExp;
-export declare const QuarterIsoId: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>, v.BrandAction<string, "QuarterIsoId">]>;
-export type QuarterIsoIdType = v.InferOutput<typeof QuarterIsoId>;

package/dist/quarter-iso-id.vo.js

@@ -1,7 +0,0 @@
-import * as v from "valibot";
-export const QuarterIsoIdError = { Type: "quarter.iso.id.type", BadChars: "quarter.iso.id.bad.chars" };
-// 4 digits, hyphen, Q, digits from 1 to 4
-export const QUARTER_ISO_ID_CHARS_WHITELIST = /^\d{4}-Q[1-4]$/;
-export const QuarterIsoId = v.pipe(v.string(QuarterIsoIdError.Type), v.regex(QUARTER_ISO_ID_CHARS_WHITELIST, QuarterIsoIdError.BadChars), 
-// Stryker disable next-line StringLiteral
-v.brand("QuarterIsoId"));

package/dist/quarter.vo.d.ts

@@ -1,12 +0,0 @@
-import { DateRange } from "./date-range.vo";
-import { type QuarterIsoIdType } from "./quarter-iso-id.vo";
-import { Timestamp } from "./timestamp.vo";
-import type { TimestampValueType } from "./timestamp-value.vo";
-export declare class Quarter extends DateRange {
-    static fromTimestamp(timestamp: Timestamp): Quarter;
-    static fromTimestampValue(timestamp: TimestampValueType): Quarter;
-    static fromNow(now: Timestamp): Quarter;
-    static fromIsoId(isoId: QuarterIsoIdType): Quarter;
-    toIsoId(): QuarterIsoIdType;
-    toString(): string;
-}

package/dist/quarter.vo.js

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

package/dist/random.service.d.ts

@@ -1,13 +0,0 @@
-type RandomGenerateConfigType = {
-    min: number;
-    max: number;
-};
-export declare const RandomError: {
-    MinMax: string;
-};
-export declare class Random {
-    private static readonly DEFAULT_MIN;
-    private static readonly DEFAULT_MAX;
-    static generate(config?: RandomGenerateConfigType): number;
-}
-export {};

package/dist/random.service.js

@@ -1,13 +0,0 @@
-import { RoundingDownStrategy } from "./rounding-down.strategy";
-export const RandomError = { MinMax: "random.min.max" };
-export class Random {
-    static DEFAULT_MIN = 0;
-    static DEFAULT_MAX = 1;
-    static generate(config) {
-        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/dist/rate-limiter.service.d.ts

@@ -1,17 +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 declare class RateLimiter {
-    private readonly duration;
-    private lastInvocation;
-    constructor(duration: Duration);
-    verify(now: Timestamp): RateLimiterResultType;
-}
-export {};

package/dist/rate-limiter.service.js

@@ -1,19 +0,0 @@
-export class RateLimiter {
-    duration;
-    lastInvocation = null;
-    constructor(duration) {
-        this.duration = duration;
-    }
-    verify(now) {
-        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/dist/relative-date.vo.d.ts

@@ -1,13 +0,0 @@
-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 declare class RelativeDate {
-    static truthy(timestamp: Timestamp): RelativeDateType;
-    static falsy(timestamp: Falsy<Timestamp>): RelativeDateType | null;
-    private static _format;
-}
-export {};

package/dist/relative-date.vo.js

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

package/dist/reordering-item-position-value.vo.d.ts

@@ -1,6 +0,0 @@
-import * as v from "valibot";
-export declare const ReorderingItemPositionValueError: {
-    Invalid: string;
-};
-export declare const ReorderingItemPositionValue: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>]>;
-export type ReorderingItemPositionValueType = v.InferOutput<typeof ReorderingItemPositionValue>;

package/dist/reordering-item-position-value.vo.js

@@ -1,3 +0,0 @@
-import * as v from "valibot";
-export const ReorderingItemPositionValueError = { Invalid: "reordering.position.type" };
-export const ReorderingItemPositionValue = v.pipe(v.number(ReorderingItemPositionValueError.Invalid), v.integer(ReorderingItemPositionValueError.Invalid), v.minValue(0, ReorderingItemPositionValueError.Invalid));