@bereasoftware/time-guard 2.5.2 → 2.5.4

package/dist/types/index.d.ts

@@ -1,7 +1,192 @@
-import { TimeGuard } from './time-guard';
-import { ITimeGuardConfig } from './types';
+import { ITimeGuard, ITimeGuardConfig, Unit, FormatPreset, IRoundOptions, IDurationOptions, IDiffResult, IDiffOptions, DurationParts, IDurationExplanation, IFormattableDuration } from './types';
 import { LocaleManager, EN_LOCALE, ES_LOCALE } from './locales/locale.manager';
-export * from './time-guard';
+/**
+ * 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);
+    toDuration(): DurationResult;
+    inMonths(): number;
+    humanize(options?: {
+        locale?: string;
+        fullBreakdown?: boolean;
+        numeric?: 'always' | 'auto';
+    }): string;
+    in(unit: Unit): number;
+}
+/**
+ * TimeGuard implementation - Main facade class
+ */
+export declare class TimeGuard implements ITimeGuard {
+    private temporal;
+    private config;
+    private formatterInstance;
+    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: any, // Temporal.PlainDateTime | Temporal.ZonedDateTime
+    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(): any;
+    toDate(): Date;
+    toISOString(): string;
+    valueOf(): number;
+    unix(): number;
+    toJSON(): string;
+    toString(): string;
+    locale(): string;
+    locale(locale: string): TimeGuard;
+    timezone(): string | null;
+    timezone(timezone: string): TimeGuard;
+    format(pattern: string | FormatPreset): string;
+    get(component: Unit): number;
+    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;
+}
 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 };

package/dist/types/plugins/advanced-format/index.d.ts

@@ -1,5 +1,5 @@
 import { ITimeGuardPlugin } from '../../types';
-import { TimeGuard } from '../../time-guard';
+import { TimeGuard } from '../../index';
 export declare class AdvancedFormatPlugin implements ITimeGuardPlugin {
     name: string;
     version: string;

package/dist/types/plugins/advanced-format.d.ts

@@ -0,0 +1,6 @@
+export * from './advanced-format/index'
+export {}
+import BereasoftTimeGuard from './advanced-format/index'
+export default BereasoftTimeGuard
+export * from './advanced-format/index'
+export {}

package/dist/types/plugins/duration/index.d.ts

@@ -1,5 +1,5 @@
 import { ITimeGuardPlugin } from '../../types';
-import { TimeGuard } from '../../time-guard';
+import { TimeGuard } from '../../index';
 import { DurationInput, DurationObject, DurationUnit, IDuration } from './types';
 /**
  * Duration class - represents time span following ISO 8601 standard

package/dist/types/plugins/duration.d.ts

@@ -0,0 +1,6 @@
+export * from './duration/index'
+export {}
+import BereasoftTimeGuard from './duration/index'
+export default BereasoftTimeGuard
+export * from './duration/index'
+export {}

package/dist/types/plugins/manager.d.ts

@@ -1,5 +1,5 @@
 import { ITimeGuardPlugin } from '../types';
-import { TimeGuard } from '../time-guard';
+import { TimeGuard } from '../index';
 /**
  * Plugin Manager - handles plugin registration and initialization
  * Uses Singleton pattern to ensure single instance across application

package/dist/types/plugins/relative-time/index.d.ts

@@ -1,5 +1,5 @@
 import { ITimeGuardPlugin } from '../../types';
-import { TimeGuard } from '../../time-guard';
+import { TimeGuard } from '../../index';
 import { RelativeTimeConfig, RelativeTimeFormats } from './types';
 export declare class RelativeTimePlugin implements ITimeGuardPlugin {
     name: string;

package/dist/types/plugins/relative-time.d.ts

@@ -0,0 +1,6 @@
+export * from './relative-time/index'
+export {}
+import BereasoftTimeGuard from './relative-time/index'
+export default BereasoftTimeGuard
+export * from './relative-time/index'
+export {}

package/dist/types/types/index.d.ts

@@ -528,14 +528,14 @@ export interface ITimeGuardFactory {
 }
 /**
  * Forward declaration for TimeGuard class
- * Implementation is in ./time-guard.ts, exported via ./index.ts
+ * Implementation is in ./index.ts, exported via ./index.ts
  */
 export declare class TimeGuard {
     constructor(input?: unknown, config?: ITimeGuardConfig);
 }
 /**
  * Forward declaration for DurationResult class
- * Implementation is in ./time-guard.ts, exported via ./index.ts
+ * Implementation is in ./index.ts, exported via ./index.ts
  */
 export declare class DurationResult implements IDurationResult {
     constructor(parts: DurationParts, locale?: string, metadata?: {
@@ -571,7 +571,7 @@ export declare class DurationResult implements IDurationResult {
 /**
  * Forward declaration for TimeRange class
  * Fluent API for date range operations with semantic naming
- * Implementation is in ./time-guard.ts, exported via ./index.ts
+ * Implementation is in ./index.ts, exported via ./index.ts
  */
 export declare class TimeRange {
     constructor(start: TimeGuard, end: TimeGuard);

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@bereasoftware/time-guard",
   "private": false,
-  "version": "2.5.2",
+  "version": "2.5.4",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/time-guard.cjs",
   "module": "./dist/time-guard.es.js",
-  "types": "./dist/types/time-guard.d.ts",
+  "types": "./dist/types/index.d.ts",
   "unpkg": "./dist/time-guard.umd.js",
   "browser": {
     "./dist/time-guard.umd.js": "./dist/time-guard.umd.js",
@@ -14,7 +14,7 @@
   },
   "exports": {
     ".": {
-      "types": "./dist/types/time-guard.d.ts",
+      "types": "./dist/types/index.d.ts",
       "import": "./dist/time-guard.es.js",
       "require": "./dist/time-guard.cjs",
       "default": "./dist/time-guard.es.js"
@@ -32,19 +32,19 @@
       "default": "./dist/calendars/index.es.js"
     },
     "./plugins/relative-time": {
-      "types": "./dist/types/plugins/relative-time/index.d.ts",
+      "types": "./dist/types/plugins/relative-time.d.ts",
       "import": "./dist/plugins/relative-time.es.js",
       "require": "./dist/plugins/relative-time.cjs",
       "default": "./dist/plugins/relative-time.es.js"
     },
     "./plugins/duration": {
-      "types": "./dist/types/plugins/duration/index.d.ts",
+      "types": "./dist/types/plugins/duration.d.ts",
       "import": "./dist/plugins/duration.es.js",
       "require": "./dist/plugins/duration.cjs",
       "default": "./dist/plugins/duration.es.js"
     },
     "./plugins/advanced-format": {
-      "types": "./dist/types/plugins/advanced-format/index.d.ts",
+      "types": "./dist/types/plugins/advanced-format.d.ts",
       "import": "./dist/plugins/advanced-format.es.js",
       "require": "./dist/plugins/advanced-format.cjs",
       "default": "./dist/plugins/advanced-format.es.js"

package/dist/types/time-guard.d.ts

@@ -1,270 +0,0 @@
-import { ITimeGuard, ITimeGuardConfig, Unit, FormatPreset, IRoundOptions, IDurationOptions, IDiffResult, IDiffOptions, DurationParts, IDurationExplanation, IFormattableDuration } from './types';
-/**
- * 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;
-}
-/**
- * TimeGuard implementation - Main facade class
- */
-/**
- * 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);
-    toDuration(): DurationResult;
-    inMonths(): number;
-    humanize(options?: {
-        locale?: string;
-        fullBreakdown?: boolean;
-        numeric?: 'always' | 'auto';
-    }): string;
-    in(unit: Unit): number;
-}
-export declare class TimeGuard implements ITimeGuard {
-    private temporal;
-    private config;
-    private formatterInstance;
-    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: any, // Temporal.PlainDateTime | Temporal.ZonedDateTime
-    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(): any;
-    toDate(): Date;
-    toISOString(): string;
-    valueOf(): number;
-    unix(): number;
-    toJSON(): string;
-    toString(): string;
-    locale(): string;
-    locale(locale: string): TimeGuard;
-    timezone(): string | null;
-    timezone(timezone: string): TimeGuard;
-    format(pattern: string | FormatPreset): string;
-    get(component: Unit): number;
-    add(units: Partial<Record<Unit, number>>): TimeGuard;
-    subtract(units: Partial<Record<Unit, number>>): TimeGuard;
-    /**
-     * Calculate difference between two TimeGuard instances
-     *
-     * Supports multiple modes:
-     * 1. diff(other) - Returns DiffResult with fluent API (default: exact mode)
-     * 2. diff(other, unit) - Returns number (backward compatible)
-     * 3. diff(other, options) - Returns DiffResult with calendar or exact mode
-     *
-     * @example
-     * // Exact mode (default)
-     * tg1.diff(tg2).as('day') // 65
-     * // Calendar mode
-     * tg1.diff(tg2, { mode: 'calendar' }).format('en') // "2 months and 5 days"
-     */
-    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;
-    /**
-     * Calculate duration until another TimeGuard
-     * @returns Duration object with .humanize() and other methods
-     * @example
-     * start.until(end).humanize() // "2 months and 5 days"
-     * start.until(end).humanize({ fullBreakdown: true, locale: 'es' }) // "2 meses y 5 días"
-     */
-    until(other: TimeGuard, options?: IDurationOptions): DurationResult;
-    /**
-     * Generate explanation steps for until() calculation
-     */
-    private generateUntilSteps;
-    /**
-     * Round to a specific unit with optional rounding mode
-     */
-    round(options?: IRoundOptions): TimeGuard;
-    /**
-     * Convert to PlainDate (removes time information)
-     */
-    toPlainDate(): {
-        year: number;
-        month: number;
-        day: number;
-        dayOfWeek: number;
-    };
-    /**
-     * Convert to PlainTime (removes date information)
-     */
-    toPlainTime(): {
-        hour: number;
-        minute: number;
-        second: number;
-        millisecond: number;
-    };
-    /**
-     * Create new TimeGuard with only date, keeping time from parameter
-     */
-    withDate(year: number, month: number, day: number): TimeGuard;
-    /**
-     * Create new TimeGuard with only time, keeping date
-     */
-    withTime(hour: number, minute?: number, second?: number, millisecond?: number): TimeGuard;
-    /**
-     * Get timezone offset in format ±HH:mm
-     */
-    getOffset(): string;
-    /**
-     * Get timezone offset in nanoseconds
-     */
-    getOffsetNanoseconds(): number;
-    /**
-     * Get timezone ID
-     */
-    getTimeZoneId(): string | null;
-    /**
-     * Start of the day in current timezone
-     */
-    startOfDay(): TimeGuard;
-    /**
-     * End of the day in current timezone
-     */
-    endOfDay(): TimeGuard;
-    /**
-     * Calculate duration from another TimeGuard (inverse of until)
-     * Returns negative values if other is before this
-     * @returns Duration object with .humanize() and other methods
-     * @example
-     * end.since(start).humanize() // "2 months and 5 days"
-     * end.since(start).humanize({ locale: 'es' }) // "2 meses y 5 días"
-     */
-    since(other: TimeGuard, options?: IDurationOptions): DurationResult;
-    /**
-     * Get ISO 8601 duration string
-     * Example: P1Y2M3DT4H5M6S
-     */
-    toDurationString(other?: TimeGuard): string;
-    /**
-     * Check if this date is in the past
-     */
-    isPast(): boolean;
-    /**
-     * Check if this date is in the future
-     */
-    isFuture(): boolean;
-    /**
-     * Check if this date is today
-     */
-    isToday(): boolean;
-    /**
-     * Check if this date is tomorrow
-     */
-    isTomorrow(): boolean;
-    /**
-     * Check if this date is yesterday
-     */
-    isYesterday(): boolean;
-}
-export { PluginManager } from './plugins/manager';