@bereasoftware/time-guard 2.6.1 → 2.7.0

package/dist/core.d.ts

@@ -0,0 +1,224 @@
+import { ITimeGuard, ITimeGuardConfig, Unit, FormatPreset, IRoundOptions, IDurationOptions, DurationParts, IDiffResult, IDiffOptions, IDurationExplanation, IFormattableDuration, TemporalPlainDateTime, TemporalZonedDateTime } from './types';
+import { LocaleManager, EN_LOCALE, ES_LOCALE } from './locales/locale.manager';
+/**
+ * Diff result object that allows chaining with .as()
+ *
+ * Supports two modes:
+ * - 'exact': Returns precise time differences
+ * - 'calendar': Returns calendar-aware breakdown
+ */
+declare class DiffResult implements IDiffResult, IFormattableDuration {
+    private _value;
+    private _tg1;
+    private _tg2;
+    private _mode;
+    private _breakdownData;
+    private _locale;
+    constructor(value: number, tg1: TimeGuard, tg2: TimeGuard, mode?: 'calendar' | 'exact', breakdownData?: DurationParts, locale?: string);
+    as(unit: Unit): number;
+    breakdown(): DurationParts | null;
+    format(locale?: string): string;
+    getMode(): 'calendar' | 'exact';
+    valueOf(): number;
+    toString(): string;
+    toJSON(): number;
+}
+/**
+ * DurationResult class - Represents a duration breakdown with humanize support
+ * Returned by until(), since(), and between() methods
+ */
+export declare class DurationResult implements DurationParts, IFormattableDuration {
+    years: number;
+    months: number;
+    weeks: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+    private _locale;
+    private _startDate?;
+    private _endDate?;
+    private _steps;
+    private _mode;
+    private _leapYearFlags;
+    private _calculationTimeMs;
+    constructor(parts: DurationParts, locale?: string, metadata?: {
+        startDate?: string;
+        endDate?: string;
+        steps?: string[];
+        mode?: 'exact' | 'estimated';
+        leapYearFlags?: Array<{
+            year: number;
+            isLeap: boolean;
+            daysInFebruary: number;
+        }>;
+        calculationTimeMs?: number;
+    });
+    humanize(options?: {
+        locale?: string;
+        fullBreakdown?: boolean;
+        numeric?: 'always' | 'auto';
+    }): string;
+    total(unit: Unit): number;
+    toString(): string;
+    toJSON(): Record<string, number>;
+    explain(): IDurationExplanation;
+    private generateExplanationSteps;
+    private pluralizeUnit;
+}
+/**
+ * TimeRange - Fluent API for date range operations
+ *
+ * @example
+ * TimeGuard.range('2024-01-15', '2024-03-20')
+ *   .toDuration().humanize()        // "2 months and 5 days"
+ *   .inMonths()                     // 2.1355 (precise decimal)
+ */
+export declare class TimeRange {
+    private _start;
+    private _end;
+    constructor(start: TimeGuard, end: TimeGuard);
+    get start(): TimeGuard;
+    get end(): TimeGuard;
+    private getOrdered;
+    toDuration(): DurationResult;
+    inMonths(): number;
+    humanize(options?: {
+        locale?: string;
+        fullBreakdown?: boolean;
+        numeric?: 'always' | 'auto';
+    }): string;
+    in(unit: Unit): number;
+    contains(date: unknown): boolean;
+    overlaps(other: TimeRange): boolean;
+    intersect(other: TimeRange): TimeRange | null;
+    union(other: TimeRange): TimeRange;
+}
+/**
+ * TimeGuard implementation - Main facade class
+ */
+export declare class TimeGuard implements ITimeGuard {
+    private temporal;
+    private config;
+    private formatterInstance;
+    private static holidays;
+    static registerHolidays(dates: string[]): void;
+    static clearHolidays(): void;
+    static getRegisteredHolidays(): string[];
+    private static readonly ZERO_DURATION;
+    private static isLeapYearValue;
+    private static toDurationParts;
+    constructor(input?: unknown, config?: ITimeGuardConfig);
+    static now(config?: ITimeGuardConfig): TimeGuard;
+    static from(input: unknown, config?: ITimeGuardConfig): TimeGuard;
+    static fromTemporal(temporal: TemporalPlainDateTime | TemporalZonedDateTime, config?: ITimeGuardConfig): TimeGuard;
+    /**
+     * Calculate duration between two dates - always returns positive duration
+     *
+     * @example
+     * TimeGuard.between(start, end).humanize() // "2 months and 5 days"
+     * TimeGuard.between(end, start).humanize() // "2 months and 5 days" (still positive)
+     */
+    static between(date1: TimeGuard, date2: TimeGuard): DurationResult;
+    /**
+     * Create a TimeRange for fluent duration calculations
+     *
+     * @example
+     * TimeGuard.range("2024-01-15", "2024-03-20").humanize() // "2 months and 5 days"
+     */
+    static range(start: unknown, end: unknown): TimeRange;
+    toTemporal(): TemporalPlainDateTime | TemporalZonedDateTime;
+    toDate(): Date;
+    toISOString(): string;
+    valueOf(): number;
+    unix(): number;
+    toJSON(): string;
+    [Symbol.toPrimitive](hint: 'default' | 'string' | 'number'): string | number;
+    toString(): string;
+    locale(): string;
+    locale(locale: string): TimeGuard;
+    timezone(): string | null;
+    timezone(timezone: string): TimeGuard;
+    format(pattern: string | FormatPreset): string;
+    get(component: Unit): number;
+    /** Map from singular Unit to plural Temporal polyfill key */
+    private static readonly UNIT_TO_PLURAL;
+    add(units: Partial<Record<Unit, number>>): TimeGuard;
+    subtract(units: Partial<Record<Unit, number>>): TimeGuard;
+    diff(other: TimeGuard): DiffResult;
+    diff(other: TimeGuard, unit: Unit): number;
+    diff(other: TimeGuard, options: IDiffOptions): DiffResult;
+    isBefore(other: TimeGuard): boolean;
+    isAfter(other: TimeGuard): boolean;
+    isSame(other: TimeGuard, unit?: Unit): boolean;
+    isBetween(start: TimeGuard, end: TimeGuard, unit?: Unit, inclusivity?: '[)' | '()' | '[]' | '(]'): boolean;
+    clone(): TimeGuard;
+    startOf(unit: Unit): TimeGuard;
+    endOf(unit: Unit): TimeGuard;
+    set(values: Partial<Record<Unit, number>>): TimeGuard;
+    year(): number;
+    month(): number;
+    day(): number;
+    hour(): number;
+    minute(): number;
+    second(): number;
+    millisecond(): number;
+    dayOfWeek(): number;
+    dayOfYear(): number;
+    weekOfYear(): number;
+    daysInMonth(): number;
+    daysInYear(): number;
+    inLeapYear(): boolean;
+    until(other: TimeGuard, options?: IDurationOptions): DurationResult;
+    private generateUntilSteps;
+    round(options?: IRoundOptions): TimeGuard;
+    toPlainDate(): {
+        year: number;
+        month: number;
+        day: number;
+        dayOfWeek: number;
+    };
+    toPlainTime(): {
+        hour: number;
+        minute: number;
+        second: number;
+        millisecond: number;
+    };
+    withDate(year: number, month: number, day: number): TimeGuard;
+    withTime(hour: number, minute?: number, second?: number, millisecond?: number): TimeGuard;
+    getOffset(): string;
+    getOffsetNanoseconds(): number;
+    getTimeZoneId(): string | null;
+    startOfDay(): TimeGuard;
+    endOfDay(): TimeGuard;
+    since(other: TimeGuard, options?: IDurationOptions): DurationResult;
+    toDurationString(other?: TimeGuard): string;
+    isPast(): boolean;
+    isFuture(): boolean;
+    isToday(): boolean;
+    isTomorrow(): boolean;
+    isYesterday(): boolean;
+    isWeekend(): boolean;
+    isHoliday(): boolean;
+    isBusinessDay(): boolean;
+    addBusinessDays(days: number): TimeGuard;
+    subtractBusinessDays(days: number): TimeGuard;
+}
+export type { ITimeGuard, ITimeGuardConfig, ITimeGuardFactory, ITimeGuardPlugin, IDateParser, IDateFormatter, ILocaleManager, IDateArithmetic, IDateQuery, IDateManipulation, ITimezoneAdapter, ICalendarSystem, ICalendarManager, IRoundOptions, IDurationOptions, IDurationResult, IDurationExplanation, IHumanizeOptions, IDiffResult, IDiffOptions, DurationParts, Unit, FormatPreset, ILocale, } from './types';
+export { TemporalAdapter } from './adapters/temporal.adapter';
+export { LocaleManager, EN_LOCALE, ES_LOCALE };
+export { getAvailableLocales, LOCALES_COUNT, ALL_LOCALES, registerAllLocales, } from './locales/index';
+export { DateFormatter } from './formatters/date.formatter';
+export { CalendarManager, GregorianCalendar, calendarManager, } from './calendars/calendar.manager';
+export { IslamicCalendar, HebrewCalendar, ChineseCalendar, JapaneseCalendar, BuddhistCalendar, } from './calendars/index';
+export * from './plugins/index';
+export { PluginManager } from './plugins/manager';
+export { RelativeTimePlugin, default as relativeTimePlugin, } from './plugins/relative-time';
+export type { RelativeTimeConfig, RelativeTimeFormats, RelativeTimeThreshold, } from './plugins/relative-time/types';
+export { DurationPlugin, Duration, default as durationPlugin, } from './plugins/duration';
+export type { IDuration, DurationInput, DurationObject, DurationUnit, } from './plugins/duration/types';
+export { AdvancedFormatPlugin, default as advancedFormatPlugin, } from './plugins/advanced-format';
+export declare function timeGuard(input?: unknown, config?: ITimeGuardConfig): TimeGuard;
+/** The current version of TimeGuard */
+export declare const version: string;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * TimeGuard - Modern date/time library using Temporal API
+ * Full bundle (backward compatible)
+ * Includes: core + all locales + all plugins + all calendars + polyfill (auto-loaded)
+ *
+ * @author Berea-Soft
+ * @license MIT
+ */
+export * from './core';

package/dist/locales/african.locale.d.ts

@@ -0,0 +1,7 @@
+import { ILocale } from '../types';
+export declare const SW_LOCALE_DATA: ILocale;
+export declare const AF_LOCALE_DATA: ILocale;
+export declare const ZU_LOCALE_DATA: ILocale;
+export declare const AM_LOCALE_DATA: ILocale;
+export declare const YO_LOCALE_DATA: ILocale;
+export declare const AFRICAN_LOCALES: Record<string, ILocale>;

package/dist/locales/index.cjs

@@ -1 +1,7 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../locales-ybx7jS8G.cjs`);exports.ALL_LOCALES=e.t,exports.LOCALES_COUNT=e.n,exports.getAvailableLocales=e.r,exports.registerAllLocales=e.i;
+/*! time-guard v2.7.0 | (c) 2026 Berea-Soft | MIT License | https://github.com/Berea-Soft/time-guard */
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_locales = require("../locales-C2-lOmC8.cjs");
+exports.ALL_LOCALES = require_locales.ALL_LOCALES;
+exports.LOCALES_COUNT = require_locales.LOCALES_COUNT;
+exports.getAvailableLocales = require_locales.getAvailableLocales;
+exports.registerAllLocales = require_locales.registerAllLocales;

package/dist/{types/locales → locales}/index.d.ts

@@ -12,6 +12,6 @@ export declare function registerAllLocales(localeMap: Map<string, ILocale> | Rec
  */
 export declare function getAvailableLocales(): string[];
 /**
- * Total locales count (minimum 40 required)
+ * Total locales count
  */
-export declare const LOCALES_COUNT = 40;
+export declare const LOCALES_COUNT: number;

package/dist/locales/index.es.js

@@ -1,3 +1,3 @@
-/*! time-guard v2.6.1 | (c) 2026 Berea-Soft | MIT License | https://github.com/Berea-Soft/time-guard */
-import { i as e, n as t, r as n, t as r } from "../locales-DSBvgSaw.js";
-export { r as ALL_LOCALES, t as LOCALES_COUNT, n as getAvailableLocales, e as registerAllLocales };
+/*! time-guard v2.7.0 | (c) 2026 Berea-Soft | MIT License | https://github.com/Berea-Soft/time-guard */
+import { i as registerAllLocales, n as LOCALES_COUNT, r as getAvailableLocales, t as ALL_LOCALES } from "../locales-CcuSu4P1.js";
+export { ALL_LOCALES, LOCALES_COUNT, getAvailableLocales, registerAllLocales };

package/dist/locales/south-american.locale.d.ts

@@ -0,0 +1,7 @@
+import { ILocale } from '../types';
+export declare const ES_419_LOCALE_DATA: ILocale;
+export declare const QU_LOCALE_DATA: ILocale;
+export declare const GN_LOCALE_DATA: ILocale;
+export declare const AY_LOCALE_DATA: ILocale;
+export declare const ARN_LOCALE_DATA: ILocale;
+export declare const SOUTH_AMERICAN_LOCALES: Record<string, ILocale>;