@bereasoftware/time-guard 1.0.3 → 2.0.3

package/dist/types/src/locales/english.locale.d.ts

@@ -0,0 +1,6 @@
+import { ILocale } from '../types';
+export declare const EN_LOCALE_DATA: ILocale;
+export declare const EN_AU_LOCALE_DATA: ILocale;
+export declare const EN_GB_LOCALE_DATA: ILocale;
+export declare const EN_CA_LOCALE_DATA: ILocale;
+export declare const ENGLISH_LOCALES: Record<string, ILocale>;

package/dist/types/src/locales/european.locale.d.ts

@@ -0,0 +1,9 @@
+import { ILocale } from '../types';
+export declare const DE_LOCALE_DATA: ILocale;
+export declare const NL_LOCALE_DATA: ILocale;
+export declare const EL_LOCALE_DATA: ILocale;
+export declare const HU_LOCALE_DATA: ILocale;
+export declare const EU_LOCALE_DATA: ILocale;
+export declare const CA_LOCALE_DATA: ILocale;
+export declare const TR_LOCALE_DATA: ILocale;
+export declare const EUROPEAN_LOCALES: Record<string, ILocale>;

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

@@ -0,0 +1,17 @@
+import { ILocale } from '../types';
+/**
+ * Aggregated locale data from all modules
+ */
+export declare const ALL_LOCALES: Record<string, ILocale>;
+/**
+ * Register all locales into a locale map
+ */
+export declare function registerAllLocales(localeMap: Map<string, ILocale> | Record<string, ILocale>): void;
+/**
+ * Get all available locales
+ */
+export declare function getAvailableLocales(): string[];
+/**
+ * Total locales count (minimum 40 required)
+ */
+export declare const LOCALES_COUNT = 40;

package/dist/types/src/locales/locale.manager.d.ts

@@ -0,0 +1,42 @@
+import { ILocale, ILocaleManager } from '../types';
+/**
+ * English locale data
+ */
+export declare const EN_LOCALE: ILocale;
+/**
+ * Spanish locale data (sample for i18n support)
+ */
+export declare const ES_LOCALE: ILocale;
+/**
+ * Locale Manager - implements ILocaleManager
+ */
+export declare class LocaleManager implements ILocaleManager {
+    private static instance;
+    private locales;
+    private currentLocale;
+    /**
+     * Singleton pattern
+     */
+    static getInstance(): LocaleManager;
+    private constructor();
+    /**
+     * Set or register a locale
+     */
+    setLocale(locale: string, data?: ILocale): void;
+    /**
+     * Get locale information
+     */
+    getLocale(locale?: string): ILocale;
+    /**
+     * List all registered locales
+     */
+    listLocales(): string[];
+    /**
+     * Get current locale
+     */
+    getCurrentLocale(): string;
+    /**
+     * Load multiple locales
+     */
+    loadLocales(locales: Record<string, ILocale>): void;
+}

package/dist/types/src/locales/locales-data.d.ts

@@ -0,0 +1,17 @@
+import { ILocale } from '../types';
+/**
+ * Locale data record for all supported languages
+ */
+export declare const LOCALES_DATA: Record<string, ILocale>;
+/**
+ * Dynamically register all locales
+ */
+export declare function registerAllLocales(localeMap: Map<string, ILocale> | Record<string, ILocale>): void;
+/**
+ * Get all available locales
+ */
+export declare function getAvailableLocales(): string[];
+/**
+ * Total locales count
+ */
+export declare const LOCALES_COUNT: number;

package/dist/types/src/locales/middle-eastern.locale.d.ts

@@ -0,0 +1,5 @@
+import { ILocale } from '../types';
+export declare const AR_LOCALE_DATA: ILocale;
+export declare const HE_LOCALE_DATA: ILocale;
+export declare const HI_LOCALE_DATA: ILocale;
+export declare const MIDDLE_EASTERN_LOCALES: Record<string, ILocale>;

package/dist/types/src/locales/nordic.locale.d.ts

@@ -0,0 +1,6 @@
+import { ILocale } from '../types';
+export declare const SV_LOCALE_DATA: ILocale;
+export declare const NB_LOCALE_DATA: ILocale;
+export declare const DA_LOCALE_DATA: ILocale;
+export declare const FI_LOCALE_DATA: ILocale;
+export declare const NORDIC_LOCALES: Record<string, ILocale>;

package/dist/types/src/locales/romance.locale.d.ts

@@ -0,0 +1,7 @@
+import { ILocale } from '../types';
+export declare const FR_LOCALE_DATA: ILocale;
+export declare const IT_LOCALE_DATA: ILocale;
+export declare const PT_LOCALE_DATA: ILocale;
+export declare const PT_BR_LOCALE_DATA: ILocale;
+export declare const RO_LOCALE_DATA: ILocale;
+export declare const ROMANCE_LOCALES: Record<string, ILocale>;

package/dist/types/src/locales/slavic.locale.d.ts

@@ -0,0 +1,6 @@
+import { ILocale } from '../types';
+export declare const RU_LOCALE_DATA: ILocale;
+export declare const PL_LOCALE_DATA: ILocale;
+export declare const CS_LOCALE_DATA: ILocale;
+export declare const SK_LOCALE_DATA: ILocale;
+export declare const SLAVIC_LOCALES: Record<string, ILocale>;

package/dist/types/src/locales/spanish.locale.d.ts

@@ -0,0 +1,5 @@
+import { ILocale } from '../types';
+export declare const ES_LOCALE_DATA: ILocale;
+export declare const ES_MX_LOCALE_DATA: ILocale;
+export declare const ES_US_LOCALE_DATA: ILocale;
+export declare const SPANISH_LOCALES: Record<string, ILocale>;

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

@@ -0,0 +1,47 @@
+import { ITimeGuardPlugin } from '../../types';
+import { TimeGuard } from '../../time-guard';
+export declare class AdvancedFormatPlugin implements ITimeGuardPlugin {
+    name: string;
+    version: string;
+    /**
+     * Install plugin into TimeGuard
+     */
+    install(TimeGuardClass: typeof TimeGuard): void;
+    /**
+     * Get ordinal suffix (1st, 2nd, 3rd, etc.)
+     */
+    private getOrdinal;
+    /**
+     * Pad number with leading zeros
+     */
+    private padNumber;
+    /**
+     * Get ISO week number
+     */
+    private getISOWeek;
+    /**
+     * Get week of year (locale-based)
+     */
+    private getWeekOfYear;
+    /**
+     * Get ISO week year
+     */
+    private getISOWeekYear;
+    /**
+     * Get week year
+     */
+    private getWeekYear;
+    /**
+     * Get timezone offset short form
+     */
+    private getTimezoneOffset;
+    /**
+     * Get timezone offset long form
+     */
+    private getTimezoneOffsetLong;
+}
+/**
+ * Create and export default instance
+ */
+declare const _default: AdvancedFormatPlugin;
+export default _default;

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

@@ -0,0 +1,107 @@
+import { ITimeGuardPlugin } from '../../types';
+import { TimeGuard } from '../../time-guard';
+import { DurationInput, DurationObject, DurationUnit, IDuration } from './types';
+/**
+ * Duration class - represents time span following ISO 8601 standard
+ */
+export declare class Duration implements IDuration {
+    private years;
+    private months;
+    private weeks;
+    private days;
+    private hours;
+    private minutes;
+    private seconds;
+    private milliseconds;
+    constructor(input: DurationInput);
+    /**
+     * Create Duration from ISO 8601 string
+     * @example Duration.fromISO("P3Y6M4DT12H30M5S")
+     */
+    static fromISO(iso: string): Duration;
+    /**
+     * Create a Duration between this date and another
+     */
+    static between(from: TimeGuard, to: TimeGuard): Duration;
+    /**
+     * Create Duration from milliseconds
+     */
+    static fromMilliseconds(ms: number): Duration;
+    /**
+     * Get duration in specific unit
+     */
+    as(unit: DurationUnit): number;
+    /**
+     * Get duration as milliseconds
+     */
+    asMilliseconds(): number;
+    /**
+     * Get duration as seconds
+     */
+    asSeconds(): number;
+    /**
+     * Get duration as minutes
+     */
+    asMinutes(): number;
+    /**
+     * Get duration as hours
+     */
+    asHours(): number;
+    /**
+     * Get duration as days
+     */
+    asDays(): number;
+    /**
+     * Get duration as weeks
+     */
+    asWeeks(): number;
+    /**
+     * Get duration as months
+     */
+    asMonths(): number;
+    /**
+     * Get duration as years
+     */
+    asYears(): number;
+    /**
+     * Get all components
+     */
+    toObject(): DurationObject;
+    /**
+     * Get ISO 8601 string representation
+     * @example "P3Y6M4DT12H30M5S"
+     */
+    toISO(): string;
+    /**
+     * Get human-readable string
+     */
+    humanize(): string;
+    /**
+     * Check if duration is negative
+     */
+    isNegative(): boolean;
+    /**
+     * Get absolute duration
+     */
+    abs(): Duration;
+    /**
+     * String representation
+     */
+    toString(): string;
+}
+/**
+ * Duration Plugin
+ */
+export declare class DurationPlugin implements ITimeGuardPlugin {
+    name: string;
+    version: string;
+    /**
+     * Install plugin into TimeGuard
+     */
+    install(TimeGuardClass: typeof TimeGuard): void;
+}
+/**
+ * Create and export default instance
+ */
+export declare const durationPlugin: DurationPlugin;
+export default durationPlugin;

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

@@ -0,0 +1,85 @@
+/**
+ * Duration Plugin Types
+ */
+export type DurationUnit = 'years' | 'months' | 'weeks' | 'days' | 'hours' | 'minutes' | 'seconds' | 'milliseconds';
+export interface DurationInput {
+    years?: number;
+    months?: number;
+    weeks?: number;
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+    milliseconds?: number;
+}
+export interface DurationObject {
+    years: number;
+    months: number;
+    weeks: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+}
+/**
+ * Duration class for ISO 8601 durations
+ */
+export interface IDuration {
+    /**
+     * Get duration in specific unit
+     */
+    as(unit: DurationUnit): number;
+    /**
+     * Get duration as milliseconds
+     */
+    asMilliseconds(): number;
+    /**
+     * Get duration as seconds
+     */
+    asSeconds(): number;
+    /**
+     * Get duration as minutes
+     */
+    asMinutes(): number;
+    /**
+     * Get duration as hours
+     */
+    asHours(): number;
+    /**
+     * Get duration as days
+     */
+    asDays(): number;
+    /**
+     * Get duration as weeks
+     */
+    asWeeks(): number;
+    /**
+     * Get duration as months
+     */
+    asMonths(): number;
+    /**
+     * Get duration as years
+     */
+    asYears(): number;
+    /**
+     * Get all components
+     */
+    toObject(): DurationObject;
+    /**
+     * Get ISO 8601 string representation
+     */
+    toISO(): string;
+    /**
+     * Get human-readable string
+     */
+    humanize(): string;
+    /**
+     * Check if duration is negative
+     */
+    isNegative(): boolean;
+    /**
+     * Get absolute duration
+     */
+    abs(): IDuration;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * TimeGuard Plugins
+ * Central export point for all plugins
+ */
+export { PluginManager } from './manager';
+export { RelativeTimePlugin, default as relativeTimePlugin } from './relative-time';
+export { DurationPlugin, Duration, default as durationPlugin } from './duration';
+export { AdvancedFormatPlugin, default as advancedFormatPlugin } from './advanced-format';
+export type { RelativeTimeConfig, RelativeTimeFormats, RelativeTimeThreshold } from './relative-time/types';
+export type { IDuration, DurationInput, DurationObject, DurationUnit } from './duration/types';

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

@@ -0,0 +1,58 @@
+import { ITimeGuardPlugin } from '../types';
+import { TimeGuard } from '../time-guard';
+/**
+ * Plugin Manager - handles plugin registration and initialization
+ * Uses Singleton pattern to ensure single instance across application
+ */
+export declare class PluginManager {
+    private static instance;
+    private plugins;
+    /**
+     * Get singleton instance
+     */
+    static getInstance(): PluginManager;
+    /**
+     * Register a plugin
+     * @param plugin - The plugin to register
+     * @param timeGuardClass - Reference to TimeGuard class
+     * @param config - Optional plugin configuration
+     */
+    static use(plugin: ITimeGuardPlugin, timeGuardClass: typeof TimeGuard, config?: unknown): void;
+    /**
+     * Register multiple plugins at once
+     * @param plugins - Array of plugins to register
+     * @param timeGuardClass - Reference to TimeGuard class
+     * @param config - Optional plugin configuration
+     */
+    static useMultiple(plugins: ITimeGuardPlugin[], timeGuardClass: typeof TimeGuard, config?: unknown): void;
+    /**
+     * Get registered plugin by name
+     * @param name - Plugin name
+     * @returns Plugin instance or undefined
+     */
+    static getPlugin(name: string): ITimeGuardPlugin | undefined;
+    /**
+     * Check if plugin is registered
+     * @param name - Plugin name
+     * @returns True if plugin is registered
+     */
+    static hasPlugin(name: string): boolean;
+    /**
+     * Get all registered plugins
+     * @returns Array of registered plugin names
+     */
+    static listPlugins(): string[];
+    /**
+     * Unregister a plugin
+     * @param name - Plugin name
+     */
+    static unuse(name: string): boolean;
+    /**
+     * Clear all plugins
+     */
+    static clear(): void;
+    /**
+     * Internal register method
+     */
+    private register;
+}

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

@@ -0,0 +1,39 @@
+import { ITimeGuardPlugin } from '../../types';
+import { TimeGuard } from '../../time-guard';
+import { RelativeTimeConfig, RelativeTimeFormats } from './types';
+export declare class RelativeTimePlugin implements ITimeGuardPlugin {
+    name: string;
+    version: string;
+    private config;
+    private formats;
+    constructor(config?: RelativeTimeConfig);
+    /**
+     * Install plugin into TimeGuard
+     */
+    install(TimeGuardClass: typeof TimeGuard): void;
+    /**
+     * Format relative time
+     */
+    private formatRelativeTime;
+    /**
+     * Get relative time string based on milliseconds
+     */
+    private getRelativeTimeString;
+    /**
+     * Get milliseconds per unit
+     */
+    private getUnitMilliseconds;
+    /**
+     * Set format strings
+     */
+    setFormats(formats: Partial<RelativeTimeFormats>): void;
+    /**
+     * Get current formats
+     */
+    getFormats(): RelativeTimeFormats;
+}
+/**
+ * Create and export default instance
+ */
+declare const _default: RelativeTimePlugin;
+export default _default;

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

@@ -0,0 +1,27 @@
+/**
+ * RelativeTime Plugin Types
+ */
+export interface RelativeTimeConfig {
+    thresholds?: RelativeTimeThreshold[];
+    rounding?: (value: number) => number;
+}
+export interface RelativeTimeThreshold {
+    l: string;
+    r?: number;
+    d?: string;
+}
+export interface RelativeTimeFormats {
+    future: string;
+    past: string;
+    s: string;
+    m: string;
+    mm: string;
+    h: string;
+    hh: string;
+    d: string;
+    dd: string;
+    M: string;
+    MM: string;
+    y: string;
+    yy: string;
+}

package/dist/types/src/polyfill-loader.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Polyfill Loader - Verifies Temporal API availability
+ * The actual polyfill is loaded via `import '@js-temporal/polyfill'` in index.ts
+ */
+export {};

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

@@ -0,0 +1,154 @@
+import { ITimeGuard, ITimeGuardConfig, Unit, FormatPreset, IRoundOptions } from './types';
+/**
+ * TimeGuard implementation - Main facade class
+ */
+export declare class TimeGuard implements ITimeGuard {
+    private temporal;
+    private config;
+    private formatterInstance;
+    constructor(input?: unknown, config?: ITimeGuardConfig);
+    /**
+     * Static factory methods
+     */
+    static now(config?: ITimeGuardConfig): TimeGuard;
+    static from(input: unknown, config?: ITimeGuardConfig): TimeGuard;
+    static fromTemporal(temporal: any, // Temporal.PlainDateTime | Temporal.ZonedDateTime
+    config?: ITimeGuardConfig): TimeGuard;
+    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, unit?: Unit): number;
+    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
+     */
+    until(other: TimeGuard): {
+        years: number;
+        months: number;
+        days: number;
+        hours: number;
+        minutes: number;
+        seconds: number;
+        milliseconds: number;
+    };
+    /**
+     * 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
+     */
+    since(other: TimeGuard): {
+        years: number;
+        months: number;
+        days: number;
+        hours: number;
+        minutes: number;
+        seconds: number;
+        milliseconds: number;
+    };
+    /**
+     * 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;
+}