@purple-brock/time 0.0.0-stage → 1.0.0

package/dist/Badger.d.ts

@@ -0,0 +1,154 @@
+import { type LocaleInput } from "./localeInfo";
+type UnitOfTime = "year" | "quarter" | "month" | "week" | "day" | "hour" | "minute" | "second" | "millisecond";
+type DurationObject = {
+    years?: number;
+    year?: number;
+    months?: number;
+    month?: number;
+    weeks?: number;
+    week?: number;
+    days?: number;
+    day?: number;
+    hours?: number;
+    hour?: number;
+    minutes?: number;
+    minute?: number;
+    seconds?: number;
+    second?: number;
+    milliseconds?: number;
+    millisecond?: number;
+};
+
+export declare class Badger {
+    private currentDate;
+    
+    constructor(dateTime?: string | Date);
+    
+    static min(...dates: Badger[]): Badger;
+    
+    static max(...dates: Badger[]): Badger;
+    
+    static fromLocal(date: string, time: string): Badger;
+    
+    static range(start: string | Date | Badger, end: string | Date | Badger, unit: "day" | "week" | "month"): Badger[];
+    
+    isValid(): boolean;
+    
+    toDate(): Date;
+    
+    toISOString(): string;
+    
+    toLocalISODate(): string;
+    
+    toUnixTimestamp(): number;
+    
+    toMillisecondTimestamp(): number;
+    
+    toObject(): {
+        year: number;
+        month: number;
+        day: number;
+        hour: number;
+        minute: number;
+        second: number;
+        millisecond: number;
+    };
+    
+    clone(): Badger;
+    
+    get year(): number;
+    
+    get month(): number;
+    
+    get day(): number;
+    
+    get hour(): number;
+    
+    get minute(): number;
+    
+    get second(): number;
+    
+    get millisecond(): number;
+    
+    get quarter(): number;
+    
+    get weekYear(): number;
+    
+    get dayOfYear(): number;
+    
+    get dayOfWeek(): number;
+    
+    getDaysInMonth(): number;
+    
+    getWeekNumber(): number;
+    
+    daysInYear(): number;
+    
+    isLeapYear(): boolean;
+    
+    startOf(unit: UnitOfTime): Badger;
+    
+    endOf(unit: UnitOfTime): Badger;
+    
+    add(amount: number | Partial<DurationObject>, unit?: UnitOfTime): Badger;
+    private _addUnit;
+    
+    set(unit: Exclude<UnitOfTime, "week" | "quarter">, value: number): Badger;
+    
+    subtract(amount: number | Partial<DurationObject>, unit?: UnitOfTime): Badger;
+    
+    isBefore(other: Badger | Date): boolean;
+    
+    isAfter(other: Badger | Date): boolean;
+    
+    isSame(other: Badger | Date, unit?: UnitOfTime): boolean;
+    
+    isSameOrBefore(other: Badger | Date, unit?: UnitOfTime): boolean;
+    
+    isSameOrAfter(other: Badger | Date, unit?: UnitOfTime): boolean;
+    
+    clamp(min: Badger | Date, max: Badger | Date): Badger;
+    
+    isBetween(start: Badger | Date, end: Badger | Date, options?: {
+        includeStart?: boolean;
+        includeEnd?: boolean;
+    }): boolean;
+    
+    isPast(): boolean;
+    
+    isFuture(): boolean;
+    
+    isToday(): boolean;
+    
+    isYesterday(): boolean;
+    
+    isTomorrow(): boolean;
+    
+    isWeekend(): boolean;
+    
+    isWeekday(): boolean;
+    
+    countdown(relativeTo?: Date): {
+        days: number;
+        hours: number;
+        minutes: number;
+        seconds: number;
+    } | null;
+    
+    private getWeekend;
+    
+    private static buildHolidaySet;
+    
+    private static assertISODate;
+    
+    private localDateKey;
+    
+    isBusinessDay(locale?: LocaleInput, holidays?: Iterable<string>): boolean;
+    
+    addBusinessDays(n: number, locale?: LocaleInput, holidays?: Iterable<string>): Badger;
+    
+    subtractBusinessDays(n: number, locale?: LocaleInput, holidays?: Iterable<string>): Badger;
+    
+    diff(other: Badger | Date, unit: UnitOfTime, float?: boolean): number;
+}
+export {};

package/dist/BadgerSett.d.ts

@@ -0,0 +1,45 @@
+import { type LocaleInput } from "./localeInfo";
+type Month = "numeric" | "2-digit" | "long" | "short" | "narrow" | undefined;
+type Weekday = "long" | "short" | "narrow" | undefined;
+
+export declare class BadgerSett extends Intl.DateTimeFormat {
+    readonly currentDate: Date;
+    
+    constructor(date?: Date | string, locale?: LocaleInput, options?: Intl.DateTimeFormatOptions);
+    
+    private assertDateValid;
+    
+    formatForBackend(): string;
+    
+    formatForBackendToStartOfDay(): string;
+    
+    formatForBackendToEndOfDay(): string;
+    
+    private zonedDateKey;
+    
+    private firstInstantOfLocalDate;
+    
+    formatDate(): string;
+    
+    formatDateOnly(): string;
+    
+    formatTimeOnly(): string;
+    
+    getDayName(format?: Weekday): string;
+    
+    getMonthName(format?: Month): string;
+    
+    getDaysOfTheWeek(format?: Weekday): string[];
+    
+    getMonthsOfTheYear(format?: Month): string[];
+    
+    isWeekend(): boolean;
+    
+    startOfWeek(): Date;
+    
+    formatCountdown(target: Date): string | null;
+    formatDuration(duration: Record<string, number>): string;
+    
+    formatRelative(relativeTo?: Date): string;
+}
+export {};

package/dist/BadgerSettings.d.ts

@@ -0,0 +1,14 @@
+type LocaleSubscriber = (locale: Intl.Locale) => void;
+
+export declare class BadgerSettings {
+    static defaultLocale: Intl.Locale | undefined;
+    static defaultTimeZone: string | undefined;
+    private static subscribers;
+    
+    static setLocale(locale: Intl.Locale): void;
+    
+    static subscribe(fn: LocaleSubscriber): () => void;
+    
+    static reset(): void;
+}
+export {};

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { Badger as BadgerClass } from "./Badger";
+import { BadgerSett as BadgerSettClass } from "./BadgerSett";
+import type { LocaleInput } from "./localeInfo";
+export { BadgerSettings } from "./BadgerSettings";
+export type { Badger as BadgerInstance } from "./Badger";
+export type { BadgerSett as BadgerSettInstance } from "./BadgerSett";
+export type { LocaleInput } from "./localeInfo";
+
+export declare const Badger: ((date?: string | Date) => BadgerClass) & {
+    fromLocal: typeof BadgerClass.fromLocal;
+    range: typeof BadgerClass.range;
+    min: typeof BadgerClass.min;
+    max: typeof BadgerClass.max;
+};
+
+export type Badger = BadgerClass;
+
+export declare const Sett: (date?: Date | string, locale?: LocaleInput, options?: Intl.DateTimeFormatOptions) => BadgerSettClass;
+
+export type Sett = BadgerSettClass;