scdate 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Eric Vera
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# scdate
+
+Time zone free readable dates and times
+
+_This package is in active pre-release development so there may be breaking changed until v1.0 is released._

package/dist/constants.d.ts

@@ -0,0 +1,9 @@
+export declare enum Weekday {
+    Sun = 1,
+    Mon = 2,
+    Tue = 4,
+    Wed = 8,
+    Thu = 16,
+    Fri = 32,
+    Sat = 64
+}

package/dist/constants.js

@@ -0,0 +1,10 @@
+export var Weekday;
+(function (Weekday) {
+    Weekday[Weekday["Sun"] = 1] = "Sun";
+    Weekday[Weekday["Mon"] = 2] = "Mon";
+    Weekday[Weekday["Tue"] = 4] = "Tue";
+    Weekday[Weekday["Wed"] = 8] = "Wed";
+    Weekday[Weekday["Thu"] = 16] = "Thu";
+    Weekday[Weekday["Fri"] = 32] = "Fri";
+    Weekday[Weekday["Sat"] = 64] = "Sat";
+})(Weekday || (Weekday = {}));

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './sDate';
+export * from './sTime';
+export * from './sTimestamp';
+export * from './sWeekdays';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './sDate';
+export * from './sTime';
+export * from './sTimestamp';
+export * from './sWeekdays';

package/dist/internal/SDate.d.ts

@@ -0,0 +1,5 @@
+export declare class SDate {
+    readonly date: string;
+    constructor(isoValue: string);
+    toJSON(): string;
+}

package/dist/internal/SDate.js

@@ -0,0 +1,11 @@
+import { validateISODate } from './date';
+export class SDate {
+    date;
+    constructor(isoValue) {
+        validateISODate(isoValue);
+        this.date = isoValue;
+    }
+    toJSON() {
+        return this.date;
+    }
+}

package/dist/internal/STime.d.ts

@@ -0,0 +1,5 @@
+export declare class STime {
+    readonly time: string;
+    constructor(isoValue: string);
+    toJSON(): string;
+}

package/dist/internal/STime.js

@@ -0,0 +1,11 @@
+import { validateISOTime } from './time';
+export class STime {
+    time;
+    constructor(isoValue) {
+        validateISOTime(isoValue);
+        this.time = isoValue;
+    }
+    toJSON() {
+        return this.time;
+    }
+}

package/dist/internal/STimestamp.d.ts

@@ -0,0 +1,5 @@
+export declare class STimestamp {
+    readonly timestamp: string;
+    constructor(timestamp: string);
+    toJSON(): string;
+}

package/dist/internal/STimestamp.js

@@ -0,0 +1,11 @@
+import { validateISOTimestamp } from './timestamp';
+export class STimestamp {
+    timestamp;
+    constructor(timestamp) {
+        validateISOTimestamp(timestamp);
+        this.timestamp = timestamp;
+    }
+    toJSON() {
+        return this.timestamp;
+    }
+}

package/dist/internal/SWeekdays.d.ts

@@ -0,0 +1,5 @@
+export declare class SWeekdays {
+    readonly weekdays: string;
+    constructor(weekdays: string);
+    toJSON(): string;
+}

package/dist/internal/SWeekdays.js

@@ -0,0 +1,11 @@
+import { validateWeekdays } from './weekdays';
+export class SWeekdays {
+    weekdays;
+    constructor(weekdays) {
+        validateWeekdays(weekdays);
+        this.weekdays = weekdays;
+    }
+    toJSON() {
+        return this.weekdays;
+    }
+}

package/dist/internal/constants.d.ts

@@ -0,0 +1,2 @@
+import { Weekday } from '../constants';
+export declare const DayToWeekday: Weekday[];

package/dist/internal/constants.js

@@ -0,0 +1,10 @@
+import { Weekday } from '../constants';
+export const DayToWeekday = [
+    Weekday.Sun,
+    Weekday.Mon,
+    Weekday.Tue,
+    Weekday.Wed,
+    Weekday.Thu,
+    Weekday.Fri,
+    Weekday.Sat,
+];

package/dist/internal/date.d.ts

@@ -0,0 +1,8 @@
+import { UTCDateMini } from '@date-fns/utc';
+import { SDate } from './SDate';
+export declare const getISOYearFromISODate: (isoDate: string) => string;
+export declare const getISOMonthFromISODate: (isoDate: string) => string;
+export declare const getISODateFromISODate: (isoDate: string) => string;
+export declare const getISODateFromZonedDate: (date: Date) => string;
+export declare const validateISODate: (isoDate: string) => void;
+export declare const getDateAsUTCDateMini: (date: SDate) => UTCDateMini;

package/dist/internal/date.js

@@ -0,0 +1,35 @@
+import { UTCDateMini } from '@date-fns/utc';
+import { formatISO } from 'date-fns';
+export const getISOYearFromISODate = (isoDate) => {
+    const EndOfYearIndex = 4;
+    return isoDate.slice(0, EndOfYearIndex);
+};
+export const getISOMonthFromISODate = (isoDate) => {
+    const StartOfMonthIndex = 5;
+    const EndOfMonthIndex = 7;
+    return isoDate.slice(StartOfMonthIndex, EndOfMonthIndex);
+};
+export const getISODateFromISODate = (isoDate) => {
+    const StartOfDateIndex = 8;
+    return isoDate.slice(StartOfDateIndex);
+};
+export const getISODateFromZonedDate = (date) => {
+    const EndOfISODateIndex = 10;
+    return formatISO(date).slice(0, EndOfISODateIndex);
+};
+export const validateISODate = (isoDate) => {
+    const ValidISODate = /^\d{4}-\d{2}-\d{2}$/;
+    if (!ValidISODate.test(isoDate)) {
+        throw new Error(`Invalid date format. Expected format: YYYY-MM-DD. Current value: '${isoDate}'.`);
+    }
+    const year = Number(getISOYearFromISODate(isoDate));
+    const month = Number(getISOMonthFromISODate(isoDate)) - 1;
+    const date = Number(getISODateFromISODate(isoDate));
+    const nativeDate = new Date(year, month, date);
+    if (nativeDate.getFullYear() !== year ||
+        nativeDate.getMonth() !== month ||
+        nativeDate.getDate() !== date) {
+        throw new Error(`Invalid ISO date value. Current value: '${isoDate}'.`);
+    }
+};
+export const getDateAsUTCDateMini = (date) => new UTCDateMini(`${date.date}T00:00z`);

package/dist/internal/time.d.ts

@@ -0,0 +1,4 @@
+export declare const getISOHoursFromISOTime: (isoTime: string) => string;
+export declare const getISOMinutesFromISOTime: (isoTime: string) => string;
+export declare const getISOTimeFromDate: (date: Date) => string;
+export declare const validateISOTime: (isoTime: string) => void;

package/dist/internal/time.js

@@ -0,0 +1,28 @@
+import { formatISO } from 'date-fns';
+export const getISOHoursFromISOTime = (isoTime) => {
+    const EndOfHoursIndex = 2;
+    return isoTime.slice(0, EndOfHoursIndex);
+};
+export const getISOMinutesFromISOTime = (isoTime) => {
+    const StartOfMinutesIndex = 3;
+    return isoTime.slice(StartOfMinutesIndex);
+};
+export const getISOTimeFromDate = (date) => {
+    const StartOfISOTimeIndex = 11;
+    const EndOfISOTimeIndex = 16;
+    return formatISO(date).slice(StartOfISOTimeIndex, EndOfISOTimeIndex);
+};
+export const validateISOTime = (isoTime) => {
+    const ValidISOTime = /^\d{2}:\d{2}$/;
+    if (!ValidISOTime.test(isoTime)) {
+        throw new Error(`Invalid time format. Expected format: HH:MM. Current value: '${isoTime}'.`);
+    }
+    const hours = Number(getISOHoursFromISOTime(isoTime));
+    const minutes = Number(getISOMinutesFromISOTime(isoTime));
+    const nativeDate = new Date();
+    nativeDate.setHours(hours);
+    nativeDate.setMinutes(minutes);
+    if (nativeDate.getMinutes() !== minutes || nativeDate.getHours() !== hours) {
+        throw new Error(`Invalid ISO time value. Expected from 00:00 to 23:59. Current value: '${isoTime}'.`);
+    }
+};

package/dist/internal/timestamp.d.ts

@@ -0,0 +1,7 @@
+import { UTCDateMini } from '@date-fns/utc';
+import { STimestamp } from './STimestamp';
+export declare const getISODateFromISOTimestamp: (isoTimestamp: string) => string;
+export declare const getISOTimeFromISOTimestamp: (isoTimestamp: string) => string;
+export declare const getISOTimestampFromZonedDate: (date: Date) => string;
+export declare const validateISOTimestamp: (isoTimestamp: string) => void;
+export declare const getTimestampAsUTCDateMini: (timestamp: STimestamp) => UTCDateMini;

package/dist/internal/timestamp.js

@@ -0,0 +1,27 @@
+import { UTCDateMini } from '@date-fns/utc';
+import { formatISO } from 'date-fns';
+import { validateISODate } from './date';
+import { validateISOTime } from './time';
+export const getISODateFromISOTimestamp = (isoTimestamp) => {
+    const EndOfDateIndex = 10;
+    return isoTimestamp.slice(0, EndOfDateIndex);
+};
+export const getISOTimeFromISOTimestamp = (isoTimestamp) => {
+    const StartOfTimeIndex = 11;
+    return isoTimestamp.slice(StartOfTimeIndex);
+};
+export const getISOTimestampFromZonedDate = (date) => {
+    const ISOTimestampLength = 16;
+    return formatISO(date).slice(0, ISOTimestampLength);
+};
+export const validateISOTimestamp = (isoTimestamp) => {
+    const ValidISOTimestamp = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/;
+    if (!ValidISOTimestamp.test(isoTimestamp)) {
+        throw new Error(`Invalid date and time format. Expected format: YYYY-MM-DDTHH:MM. Current value: '${isoTimestamp}'.`);
+    }
+    const isoDate = getISODateFromISOTimestamp(isoTimestamp);
+    validateISODate(isoDate);
+    const isoTime = getISOTimeFromISOTimestamp(isoTimestamp);
+    validateISOTime(isoTime);
+};
+export const getTimestampAsUTCDateMini = (timestamp) => new UTCDateMini(`${timestamp.timestamp}z`);

package/dist/internal/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const hasFlag: (flags: number, checkFlag: number) => boolean;
+export declare const getAtIndex: <T extends string | unknown[]>(arrayOrString: T, index: number) => T[number];

package/dist/internal/utils.js

@@ -0,0 +1,8 @@
+export const hasFlag = (flags, checkFlag) => (flags & checkFlag) === checkFlag;
+export const getAtIndex = (arrayOrString, index) => {
+    const value = arrayOrString[index];
+    if (value === undefined) {
+        throw new Error(`Value at index ${String(index)} is undefined.`);
+    }
+    return value;
+};

package/dist/internal/weekdays.d.ts

@@ -0,0 +1,3 @@
+import { Weekday } from '../constants';
+export declare const validateWeekdays: (weekdays: string) => void;
+export declare const getIndexForWeekday: (weekday: Weekday) => number;

package/dist/internal/weekdays.js

@@ -0,0 +1,15 @@
+import { DayToWeekday } from './constants';
+export const validateWeekdays = (weekdays) => {
+    const ValidWeekdays = /^[S-][M-][T-][W-][T-][F-][S-]$/;
+    if (!ValidWeekdays.test(weekdays)) {
+        throw new Error(`Invalid weekdays format. Expected format: SMTWTFS. Any of the values can be replaced with a '-'. Current value: '${weekdays}'.`);
+    }
+    return;
+};
+export const getIndexForWeekday = (weekday) => {
+    const weekdayIndex = DayToWeekday.indexOf(weekday);
+    if (weekdayIndex < 0) {
+        throw new Error(`Invalid weekday '${String(weekday)}'. Expected a single weekday.`);
+    }
+    return weekdayIndex;
+};

package/dist/internal/zoned.d.ts

@@ -0,0 +1,5 @@
+import { SDate } from './SDate';
+import { STimestamp } from './STimestamp';
+export declare const getMillisecondsInUTCFromTimestamp: (timestamp: STimestamp, timeZone: string) => number;
+export declare const getMillisecondsInUTCFromDate: (date: SDate, timeZone: string) => number;
+export declare const getTimeZonedDate: (millisecondsInUTC: number, timeZone: string) => Date;

package/dist/internal/zoned.js

@@ -0,0 +1,30 @@
+import { getTimezoneOffset, toZonedTime } from 'date-fns-tz';
+import { getDateAsUTCDateMini } from './date';
+import { getTimestampAsUTCDateMini } from './timestamp';
+const getValidatedTimeZoneOffset = (timeZone, utcDate) => {
+    const timeZoneOffset = getTimezoneOffset(timeZone, utcDate);
+    if (isNaN(timeZoneOffset)) {
+        throw new Error(`Invalid time zone. Time zone: '${timeZone}'`);
+    }
+    return timeZoneOffset;
+};
+export const getMillisecondsInUTCFromTimestamp = (timestamp, timeZone) => {
+    const utcDate = getTimestampAsUTCDateMini(timestamp);
+    const timeZoneOffset = getValidatedTimeZoneOffset(timeZone, utcDate);
+    return utcDate.getTime() - timeZoneOffset;
+};
+export const getMillisecondsInUTCFromDate = (date, timeZone) => {
+    const utcDate = getDateAsUTCDateMini(date);
+    const timeZoneOffset = getValidatedTimeZoneOffset(timeZone, utcDate);
+    return utcDate.getTime() - timeZoneOffset;
+};
+export const getTimeZonedDate = (millisecondsInUTC, timeZone) => {
+    if (isNaN(millisecondsInUTC.valueOf())) {
+        throw new Error(`Invalid date. Date: '${String(millisecondsInUTC.valueOf())}'`);
+    }
+    const zonedDate = toZonedTime(millisecondsInUTC, timeZone);
+    if (isNaN(zonedDate.valueOf())) {
+        throw new Error(`Invalid time zone. Time zone: '${timeZone}'`);
+    }
+    return zonedDate;
+};

package/dist/sDate.d.ts

@@ -0,0 +1,33 @@
+import { Weekday } from './constants';
+import { SDate } from './internal/SDate';
+export interface SDateShortStringOptions {
+    includeWeekday: boolean;
+    onTodayText: () => string;
+}
+export declare const sDate: (date: string | SDate) => SDate;
+export declare const getDateToday: (timeZone: string) => SDate;
+export declare const getNextDateByWeekday: (date: string | SDate, weekday: Weekday) => SDate;
+export declare const getPreviousDateByWeekday: (date: string | SDate, weekday: Weekday) => SDate;
+export declare const getDateForFirstDayOfMonth: (date: string | SDate) => SDate;
+export declare const getDateForLastDayOfMonth: (date: string | SDate) => SDate;
+export declare const getYearFromDate: (date: string | SDate) => number;
+export declare const getMonthFromDate: (date: string | SDate) => number;
+export declare const getDateFromDate: (date: string | SDate) => number;
+export declare const getWeekdayFromDate: (date: string | SDate) => number;
+export declare const getTimeZonedDateFromDate: (date: string | SDate, timeZone: string) => Date;
+export declare const getDaysBetweenDates: (date1: string | SDate, date2: string | SDate) => number;
+export declare const getFullDateString: (date: string | SDate, locale: Intl.LocalesArgument) => string;
+export declare const getShortDateString: (date: string | SDate, timeZone: string, locale: Intl.LocalesArgument, options: SDateShortStringOptions) => string;
+export declare const addDaysToDate: (date: string | SDate, days: number) => SDate;
+export declare const addMonthsToDate: (date: string | SDate, months: number) => SDate;
+export declare const addYearsToDate: (date: string | SDate, years: number) => SDate;
+export declare const isSameDate: (date1: string | SDate, date2: string | SDate) => boolean;
+export declare const isBeforeDate: (date1: string | SDate, date2: string | SDate) => boolean;
+export declare const isSameDateOrBefore: (date1: string | SDate, date2: string | SDate) => boolean;
+export declare const isAfterDate: (date1: string | SDate, date2: string | SDate) => boolean;
+export declare const isSameDateOrAfter: (date1: string | SDate, date2: string | SDate) => boolean;
+export declare const isDateToday: (date: string | SDate, timeZone: string) => boolean;
+export declare const areDatesInSameMonth: (date1: string | SDate, date2: string | SDate) => boolean;
+export declare const isDateInCurrentMonth: (date: string | SDate, timeZone: string) => boolean;
+export declare const areDatesInSameYear: (date1: string | SDate, date2: string | SDate) => boolean;
+export declare const isDateInCurrentYear: (date: string | SDate, timeZone: string) => boolean;

package/dist/sDate.js

@@ -0,0 +1,166 @@
+import { differenceInDays, lastDayOfMonth } from 'date-fns';
+import { daysInWeek } from 'date-fns/constants';
+import { SDate } from './internal/SDate';
+import { DayToWeekday } from './internal/constants';
+import { getDateAsUTCDateMini, getISODateFromISODate, getISODateFromZonedDate, getISOMonthFromISODate, getISOYearFromISODate, } from './internal/date';
+import { getAtIndex } from './internal/utils';
+import { getIndexForWeekday } from './internal/weekdays';
+import { getMillisecondsInUTCFromDate, getTimeZonedDate, } from './internal/zoned';
+export const sDate = (date) => {
+    if (date instanceof SDate) {
+        return date;
+    }
+    return new SDate(date);
+};
+export const getDateToday = (timeZone) => {
+    const date = getTimeZonedDate(Date.now(), timeZone);
+    return sDate(getISODateFromZonedDate(date));
+};
+export const getNextDateByWeekday = (date, weekday) => {
+    const sDateValue = sDate(date);
+    const weekdayIndex = getIndexForWeekday(weekday);
+    const todaysWeekdayIndex = DayToWeekday.indexOf(getWeekdayFromDate(sDateValue));
+    let adjustment = weekdayIndex - todaysWeekdayIndex;
+    if (adjustment <= 0) {
+        adjustment += daysInWeek;
+    }
+    return addDaysToDate(sDateValue, adjustment);
+};
+export const getPreviousDateByWeekday = (date, weekday) => {
+    const sDateValue = sDate(date);
+    const weekdayIndex = getIndexForWeekday(weekday);
+    const todaysWeekdayIndex = DayToWeekday.indexOf(getWeekdayFromDate(sDateValue));
+    let adjustment = weekdayIndex - todaysWeekdayIndex;
+    if (adjustment >= 0) {
+        adjustment -= daysInWeek;
+    }
+    return addDaysToDate(sDateValue, adjustment);
+};
+export const getDateForFirstDayOfMonth = (date) => {
+    const sDateValue = sDate(date);
+    const nativeDate = getDateAsUTCDateMini(sDateValue);
+    nativeDate.setDate(1);
+    return sDate(getISODateFromZonedDate(nativeDate));
+};
+export const getDateForLastDayOfMonth = (date) => {
+    const sDateValue = sDate(date);
+    const nativeDate = getDateAsUTCDateMini(sDateValue);
+    const lastDay = lastDayOfMonth(nativeDate);
+    return sDate(getISODateFromZonedDate(lastDay));
+};
+export const getYearFromDate = (date) => {
+    const sDateValue = sDate(date);
+    return Number(getISOYearFromISODate(sDateValue.date));
+};
+export const getMonthFromDate = (date) => {
+    const sDateValue = sDate(date);
+    return Number(getISOMonthFromISODate(sDateValue.date)) - 1;
+};
+export const getDateFromDate = (date) => {
+    const sDateValue = sDate(date);
+    return Number(getISODateFromISODate(sDateValue.date));
+};
+export const getWeekdayFromDate = (date) => {
+    const sDateValue = sDate(date);
+    const nativeDate = getDateAsUTCDateMini(sDateValue);
+    return getAtIndex(DayToWeekday, nativeDate.getDay());
+};
+export const getTimeZonedDateFromDate = (date, timeZone) => {
+    const sDateValue = sDate(date);
+    const milliseconds = getMillisecondsInUTCFromDate(sDateValue, timeZone);
+    const zonedTime = getTimeZonedDate(milliseconds, timeZone);
+    return zonedTime;
+};
+export const getDaysBetweenDates = (date1, date2) => {
+    const sDate1 = sDate(date1);
+    const sDate2 = sDate(date2);
+    return differenceInDays(getDateAsUTCDateMini(sDate2), getDateAsUTCDateMini(sDate1));
+};
+export const getFullDateString = (date, locale) => {
+    const sDateValue = sDate(date);
+    const utcDate = getDateAsUTCDateMini(sDateValue);
+    return utcDate.toLocaleDateString(locale, {
+        timeZone: 'UTC',
+        dateStyle: 'full',
+    });
+};
+export const getShortDateString = (date, timeZone, locale, options) => {
+    const sDateValue = sDate(date);
+    if (isDateToday(sDateValue, timeZone)) {
+        return options.onTodayText();
+    }
+    const utcDate = getDateAsUTCDateMini(sDateValue);
+    return utcDate.toLocaleDateString(locale, {
+        timeZone: 'UTC',
+        month: 'short',
+        day: 'numeric',
+        weekday: options.includeWeekday ? 'short' : undefined,
+        year: isDateInCurrentYear(sDateValue, timeZone) ? undefined : '2-digit',
+    });
+};
+export const addDaysToDate = (date, days) => {
+    const sDateValue = sDate(date);
+    const nativeDate = getDateAsUTCDateMini(sDateValue);
+    nativeDate.setDate(nativeDate.getDate() + days);
+    return sDate(getISODateFromZonedDate(nativeDate));
+};
+export const addMonthsToDate = (date, months) => {
+    const sDateValue = sDate(date);
+    const nativeDate = getDateAsUTCDateMini(sDateValue);
+    nativeDate.setMonth(nativeDate.getMonth() + months);
+    return sDate(getISODateFromZonedDate(nativeDate));
+};
+export const addYearsToDate = (date, years) => {
+    const sDateValue = sDate(date);
+    const nativeDate = getDateAsUTCDateMini(sDateValue);
+    nativeDate.setFullYear(nativeDate.getFullYear() + years);
+    return sDate(getISODateFromZonedDate(nativeDate));
+};
+export const isSameDate = (date1, date2) => {
+    const sDate1 = sDate(date1);
+    const sDate2 = sDate(date2);
+    return sDate1.date === sDate2.date;
+};
+export const isBeforeDate = (date1, date2) => {
+    const sDate1 = sDate(date1);
+    const sDate2 = sDate(date2);
+    return sDate1.date < sDate2.date;
+};
+export const isSameDateOrBefore = (date1, date2) => {
+    const sDate1 = sDate(date1);
+    const sDate2 = sDate(date2);
+    return sDate1.date <= sDate2.date;
+};
+export const isAfterDate = (date1, date2) => {
+    const sDate1 = sDate(date1);
+    const sDate2 = sDate(date2);
+    return sDate1.date > sDate2.date;
+};
+export const isSameDateOrAfter = (date1, date2) => {
+    const sDate1 = sDate(date1);
+    const sDate2 = sDate(date2);
+    return sDate1.date >= sDate2.date;
+};
+export const isDateToday = (date, timeZone) => {
+    const sDateValue = sDate(date);
+    return isSameDate(sDateValue, getDateToday(timeZone));
+};
+export const areDatesInSameMonth = (date1, date2) => {
+    const sDate1 = sDate(date1);
+    const sDate2 = sDate(date2);
+    return (getISOYearFromISODate(sDate1.date) === getISOYearFromISODate(sDate2.date) &&
+        getISOMonthFromISODate(sDate1.date) === getISOMonthFromISODate(sDate2.date));
+};
+export const isDateInCurrentMonth = (date, timeZone) => {
+    const sDateValue = sDate(date);
+    return areDatesInSameMonth(sDateValue, getDateToday(timeZone));
+};
+export const areDatesInSameYear = (date1, date2) => {
+    const sDate1 = sDate(date1);
+    const sDate2 = sDate(date2);
+    return (getISOYearFromISODate(sDate1.date) === getISOYearFromISODate(sDate2.date));
+};
+export const isDateInCurrentYear = (date, timeZone) => {
+    const sDateValue = sDate(date);
+    return areDatesInSameYear(sDateValue, getDateToday(timeZone));
+};

package/dist/sTime.d.ts

@@ -0,0 +1,18 @@
+import { STime } from './internal/STime';
+export declare const sTime: (time: string | STime) => STime;
+export declare const getTimeNow: (timeZone: string) => STime;
+export declare const getTimeAtMidnight: () => STime;
+export declare const getTimeFromMinutes: (timeInMinutes: number) => STime;
+export declare const getHoursFromTime: (time: string | STime) => number;
+export declare const getHoursStringFromTime: (time: string | STime) => string;
+export declare const getMinutesFromTime: (time: string | STime) => number;
+export declare const getMinutesStringFromTime: (time: string | STime) => string;
+export declare const get12HourTimeString: (time: string | STime) => string;
+export declare const getTimeInMinutes: (time: string | STime, midnightIs24?: boolean) => number;
+export declare const addMinutesToTime: (time: string | STime, minutes: number) => STime;
+export declare const isSameTime: (time1: string | STime, time2: string | STime) => boolean;
+export declare const isAfterTime: (time1: string | STime, time2: string | STime) => boolean;
+export declare const isSameTimeOrAfter: (time1: string | STime, time2: string | STime) => boolean;
+export declare const isBeforeTime: (time1: string | STime, time2: string | STime) => boolean;
+export declare const isSameTimeOrBefore: (time1: string | STime, time2: string | STime) => boolean;
+export declare const isTimePM: (time: string | STime) => boolean;

package/dist/sTime.js

@@ -0,0 +1,90 @@
+import { minutesInDay, minutesInHour } from 'date-fns/constants';
+import { STime } from './internal/STime';
+import { getISOHoursFromISOTime, getISOMinutesFromISOTime, getISOTimeFromDate, } from './internal/time';
+import { getTimeZonedDate } from './internal/zoned';
+export const sTime = (time) => {
+    if (time instanceof STime) {
+        return time;
+    }
+    return new STime(time);
+};
+export const getTimeNow = (timeZone) => {
+    const date = getTimeZonedDate(Date.now(), timeZone);
+    return sTime(getISOTimeFromDate(date));
+};
+export const getTimeAtMidnight = () => sTime('00:00');
+export const getTimeFromMinutes = (timeInMinutes) => {
+    const midnight = getTimeAtMidnight();
+    return addMinutesToTime(midnight, timeInMinutes);
+};
+export const getHoursFromTime = (time) => {
+    const sTimeValue = sTime(time);
+    return Number(getISOHoursFromISOTime(sTimeValue.time));
+};
+export const getHoursStringFromTime = (time) => {
+    const HoursPMStart = 12;
+    const sTimeValue = sTime(time);
+    const hours = getHoursFromTime(sTimeValue) % HoursPMStart;
+    return hours === 0 ? '12' : hours.toString();
+};
+export const getMinutesFromTime = (time) => {
+    const sTimeValue = sTime(time);
+    return Number(getISOMinutesFromISOTime(sTimeValue.time));
+};
+export const getMinutesStringFromTime = (time) => {
+    const sTimeValue = sTime(time);
+    return getISOMinutesFromISOTime(sTimeValue.time);
+};
+export const get12HourTimeString = (time) => {
+    const sTimeValue = sTime(time);
+    return `${getHoursStringFromTime(sTimeValue)}:${getMinutesStringFromTime(sTimeValue)} ${isTimePM(sTimeValue) ? 'PM' : 'AM'}`;
+};
+export const getTimeInMinutes = (time, midnightIs24 = false) => {
+    const sTimeValue = sTime(time);
+    const timeInMinutesMidnight0 = getHoursFromTime(sTimeValue) * minutesInHour +
+        getMinutesFromTime(sTimeValue);
+    if (midnightIs24 && timeInMinutesMidnight0 === 0) {
+        return minutesInDay;
+    }
+    return timeInMinutesMidnight0;
+};
+export const addMinutesToTime = (time, minutes) => {
+    const sTimeValue = sTime(time);
+    let totalMinutes = (getTimeInMinutes(sTimeValue) + minutes) % minutesInDay;
+    if (totalMinutes < 0) {
+        totalMinutes += minutesInDay;
+    }
+    const newHours = Math.floor(totalMinutes / minutesInHour);
+    const newMinutes = totalMinutes % minutesInHour;
+    return sTime(`${newHours.toString().padStart(2, '0')}:${newMinutes.toString().padStart(2, '0')}`);
+};
+export const isSameTime = (time1, time2) => {
+    const sTime1 = sTime(time1);
+    const sTime2 = sTime(time2);
+    return sTime1.time === sTime2.time;
+};
+export const isAfterTime = (time1, time2) => {
+    const sTime1 = sTime(time1);
+    const sTime2 = sTime(time2);
+    return sTime1.time > sTime2.time;
+};
+export const isSameTimeOrAfter = (time1, time2) => {
+    const sTime1 = sTime(time1);
+    const sTime2 = sTime(time2);
+    return sTime1.time >= sTime2.time;
+};
+export const isBeforeTime = (time1, time2) => {
+    const sTime1 = sTime(time1);
+    const sTime2 = sTime(time2);
+    return sTime1.time < sTime2.time;
+};
+export const isSameTimeOrBefore = (time1, time2) => {
+    const sTime1 = sTime(time1);
+    const sTime2 = sTime(time2);
+    return sTime1.time <= sTime2.time;
+};
+export const isTimePM = (time) => {
+    const sTimeValue = sTime(time);
+    const NoonValue = '12:00';
+    return sTimeValue.time >= NoonValue;
+};

package/dist/sTimestamp.d.ts

@@ -0,0 +1,23 @@
+import { SDate } from './internal/SDate';
+import { STime } from './internal/STime';
+import { STimestamp } from './internal/STimestamp';
+export interface STimestampShortStringOptions {
+    includeWeekday: boolean;
+    onTodayAtText: () => string;
+}
+export declare const sTimestamp: (timestamp: string | STimestamp) => STimestamp;
+export declare const getTimestampFromUTCMilliseconds: (utcDateInMilliseconds: number, timeZone: string) => STimestamp;
+export declare const getTimestampNow: (timeZone: string) => STimestamp;
+export declare const getTimestampFromDateAndTime: (date: string | SDate, time: string | STime) => STimestamp;
+export declare const getTimeZonedDateFromTimestamp: (timestamp: string | STimestamp, timeZone: string) => Date;
+export declare const getSecondsToTimestamp: (timestamp: string | STimestamp, timeZone: string) => number;
+export declare const getDateFromTimestamp: (timestamp: string | STimestamp) => SDate;
+export declare const getTimeFromTimestamp: (timestamp: string | STimestamp) => STime;
+export declare const getShortTimestampString: (timestamp: string | STimestamp, timeZone: string, locale: Intl.LocalesArgument, options: STimestampShortStringOptions) => string;
+export declare const addDaysToTimestamp: (timestamp: string | STimestamp, days: number) => STimestamp;
+export declare const addMinutesToTimestamp: (timestamp: string | STimestamp, minutes: number, timeZone: string) => STimestamp;
+export declare const isSameTimestamp: (timestamp1: string | STimestamp, timestamp2: string | STimestamp) => boolean;
+export declare const isBeforeTimestamp: (timestamp1: string | STimestamp, timestamp2: string | STimestamp) => boolean;
+export declare const isSameTimestampOrBefore: (timestamp1: string | STimestamp, timestamp2: string | STimestamp) => boolean;
+export declare const isAfterTimestamp: (timestamp1: string | STimestamp, timestamp2: string | STimestamp) => boolean;
+export declare const isSameTimestampOrAfter: (timestamp1: string | STimestamp, timestamp2: string | STimestamp) => boolean;

package/dist/sTimestamp.js

@@ -0,0 +1,92 @@
+import { millisecondsInMinute, millisecondsInSecond } from 'date-fns/constants';
+import { STimestamp } from './internal/STimestamp';
+import { getISODateFromISOTimestamp, getISOTimeFromISOTimestamp, getISOTimestampFromZonedDate, getTimestampAsUTCDateMini, } from './internal/timestamp';
+import { getMillisecondsInUTCFromTimestamp, getTimeZonedDate, } from './internal/zoned';
+import { getShortDateString, sDate } from './sDate';
+import { get12HourTimeString, sTime } from './sTime';
+export const sTimestamp = (timestamp) => {
+    if (timestamp instanceof STimestamp) {
+        return timestamp;
+    }
+    return new STimestamp(timestamp);
+};
+export const getTimestampFromUTCMilliseconds = (utcDateInMilliseconds, timeZone) => {
+    const date = getTimeZonedDate(utcDateInMilliseconds, timeZone);
+    return sTimestamp(getISOTimestampFromZonedDate(date));
+};
+export const getTimestampNow = (timeZone) => {
+    return getTimestampFromUTCMilliseconds(Date.now(), timeZone);
+};
+export const getTimestampFromDateAndTime = (date, time) => {
+    const sDateValue = sDate(date);
+    const sDimeValue = sTime(time);
+    return sTimestamp(`${sDateValue.date}T${sDimeValue.time}`);
+};
+export const getTimeZonedDateFromTimestamp = (timestamp, timeZone) => {
+    const sTimestampValue = sTimestamp(timestamp);
+    const dateInUTCMilliseconds = getMillisecondsInUTCFromTimestamp(sTimestampValue, timeZone);
+    return getTimeZonedDate(dateInUTCMilliseconds, timeZone);
+};
+export const getSecondsToTimestamp = (timestamp, timeZone) => {
+    const sTimestampValue = sTimestamp(timestamp);
+    const millisecondsNow = Date.now();
+    const millisecondsAtTimestamp = getMillisecondsInUTCFromTimestamp(sTimestampValue, timeZone);
+    return Math.floor((millisecondsAtTimestamp - millisecondsNow) / millisecondsInSecond);
+};
+export const getDateFromTimestamp = (timestamp) => {
+    const sTimestampValue = sTimestamp(timestamp);
+    return sDate(getISODateFromISOTimestamp(sTimestampValue.timestamp));
+};
+export const getTimeFromTimestamp = (timestamp) => {
+    const sTimestampValue = sTimestamp(timestamp);
+    return sTime(getISOTimeFromISOTimestamp(sTimestampValue.timestamp));
+};
+export const getShortTimestampString = (timestamp, timeZone, locale, options) => {
+    const sTimestampValue = sTimestamp(timestamp);
+    const date = getDateFromTimestamp(sTimestampValue);
+    const time = getTimeFromTimestamp(sTimestampValue);
+    const dateText = getShortDateString(date, timeZone, locale, {
+        includeWeekday: options.includeWeekday,
+        onTodayText: options.onTodayAtText,
+    });
+    const timeText = get12HourTimeString(time);
+    return `${dateText} ${timeText}`;
+};
+export const addDaysToTimestamp = (timestamp, days) => {
+    const sTimestampValue = sTimestamp(timestamp);
+    const nativeDate = getTimestampAsUTCDateMini(sTimestampValue);
+    nativeDate.setDate(nativeDate.getDate() + days);
+    return sTimestamp(getISOTimestampFromZonedDate(nativeDate));
+};
+export const addMinutesToTimestamp = (timestamp, minutes, timeZone) => {
+    const sTimestampValue = sTimestamp(timestamp);
+    const newMillisecondsInUTC = getMillisecondsInUTCFromTimestamp(sTimestampValue, timeZone) +
+        minutes * millisecondsInMinute;
+    const newTimestamp = getTimestampFromUTCMilliseconds(newMillisecondsInUTC, timeZone);
+    return newTimestamp;
+};
+export const isSameTimestamp = (timestamp1, timestamp2) => {
+    const sTimestamp1 = sTimestamp(timestamp1);
+    const sTimestamp2 = sTimestamp(timestamp2);
+    return sTimestamp1.timestamp === sTimestamp2.timestamp;
+};
+export const isBeforeTimestamp = (timestamp1, timestamp2) => {
+    const sTimestamp1 = sTimestamp(timestamp1);
+    const sTimestamp2 = sTimestamp(timestamp2);
+    return sTimestamp1.timestamp < sTimestamp2.timestamp;
+};
+export const isSameTimestampOrBefore = (timestamp1, timestamp2) => {
+    const sTimestamp1 = sTimestamp(timestamp1);
+    const sTimestamp2 = sTimestamp(timestamp2);
+    return sTimestamp1.timestamp <= sTimestamp2.timestamp;
+};
+export const isAfterTimestamp = (timestamp1, timestamp2) => {
+    const sTimestamp1 = sTimestamp(timestamp1);
+    const sTimestamp2 = sTimestamp(timestamp2);
+    return sTimestamp1.timestamp > sTimestamp2.timestamp;
+};
+export const isSameTimestampOrAfter = (timestamp1, timestamp2) => {
+    const sTimestamp1 = sTimestamp(timestamp1);
+    const sTimestamp2 = sTimestamp(timestamp2);
+    return sTimestamp1.timestamp >= sTimestamp2.timestamp;
+};

package/dist/sWeekdays.d.ts

@@ -0,0 +1,12 @@
+import { Weekday } from './constants';
+import { SDate } from './internal/SDate';
+import { SWeekdays } from './internal/SWeekdays';
+export declare const sWeekdays: (weekdays: string | SWeekdays) => SWeekdays;
+export declare const getWeekdaysFromWeekdayFlags: (weekdays: Weekday) => SWeekdays;
+export declare const getWeekdaysWithAllIncluded: () => SWeekdays;
+export declare const getWeekdaysWithNoneIncluded: () => SWeekdays;
+export declare const shiftWeekdaysForward: (weekdays: string | SWeekdays) => SWeekdays;
+export declare const filterWeekdaysForDates: (weekdays: string | SWeekdays, fromDate: string | SDate, toDate: string | SDate) => SWeekdays;
+export declare const addWeekdayToWeekdays: (weekdays: string | SWeekdays, weekdayToAdd: Weekday) => SWeekdays;
+export declare const doesWeekdaysIncludeWeekday: (weekdays: string | SWeekdays, weekday: Weekday) => boolean;
+export declare const doesWeekdaysHaveOverlapWithWeekdays: (weekdays1: string | SWeekdays, weekdays2: string | SWeekdays) => boolean;

package/dist/sWeekdays.js

@@ -0,0 +1,89 @@
+import { daysInWeek } from 'date-fns/constants';
+import { SWeekdays } from './internal/SWeekdays';
+import { DayToWeekday } from './internal/constants';
+import { getAtIndex, hasFlag } from './internal/utils';
+import { getIndexForWeekday } from './internal/weekdays';
+import { addDaysToDate, getDaysBetweenDates, getWeekdayFromDate, isAfterDate, isSameDateOrBefore, sDate, } from './sDate';
+const AllWeekdaysIncludedMask = 'SMTWTFS';
+const NotIncludedDay = '-';
+const NoWeekdaysIncluded = NotIncludedDay.repeat(AllWeekdaysIncludedMask.length);
+const WeekdaysCount = AllWeekdaysIncludedMask.length;
+export const sWeekdays = (weekdays) => {
+    if (weekdays instanceof SWeekdays) {
+        return weekdays;
+    }
+    return new SWeekdays(weekdays);
+};
+export const getWeekdaysFromWeekdayFlags = (weekdays) => {
+    const newWeekdays = [...AllWeekdaysIncludedMask];
+    for (let i = 0; i < DayToWeekday.length; i++) {
+        const weekday = getAtIndex(DayToWeekday, i);
+        if (!hasFlag(weekdays, weekday)) {
+            newWeekdays[i] = NotIncludedDay;
+        }
+    }
+    return sWeekdays(newWeekdays.join(''));
+};
+export const getWeekdaysWithAllIncluded = () => {
+    return sWeekdays(AllWeekdaysIncludedMask);
+};
+export const getWeekdaysWithNoneIncluded = () => {
+    return sWeekdays(NoWeekdaysIncluded);
+};
+export const shiftWeekdaysForward = (weekdays) => {
+    const sWeekdaysInstance = sWeekdays(weekdays);
+    const after = [...NoWeekdaysIncluded];
+    const DayShift = 1;
+    for (let i = 0; i < WeekdaysCount; i++) {
+        const prevDayIndex = (WeekdaysCount - DayShift + i) % WeekdaysCount;
+        after[i] =
+            sWeekdaysInstance.weekdays[prevDayIndex] === NotIncludedDay
+                ? NotIncludedDay
+                : getAtIndex(AllWeekdaysIncludedMask, i);
+    }
+    return sWeekdays(after.join(''));
+};
+export const filterWeekdaysForDates = (weekdays, fromDate, toDate) => {
+    const sWeekdaysInstance = sWeekdays(weekdays);
+    const sFromDate = sDate(fromDate);
+    const sToDate = sDate(toDate);
+    if (isAfterDate(sFromDate, sToDate)) {
+        throw new Error('The from date must be before the to date.');
+    }
+    const diff = getDaysBetweenDates(sFromDate, sToDate);
+    if (diff >= daysInWeek) {
+        return sWeekdaysInstance;
+    }
+    let result = getWeekdaysWithNoneIncluded();
+    const DayAfterDelta = 1;
+    for (let date = fromDate; isSameDateOrBefore(date, toDate); date = addDaysToDate(date, DayAfterDelta)) {
+        const weekday = getWeekdayFromDate(date);
+        if (doesWeekdaysIncludeWeekday(sWeekdaysInstance, weekday)) {
+            result = addWeekdayToWeekdays(result, weekday);
+        }
+    }
+    return result;
+};
+export const addWeekdayToWeekdays = (weekdays, weekdayToAdd) => {
+    const sWeekdaysInstance = sWeekdays(weekdays);
+    const newWeekdays = [...sWeekdaysInstance.weekdays];
+    const weekdayIndex = getIndexForWeekday(weekdayToAdd);
+    newWeekdays[weekdayIndex] = getAtIndex(AllWeekdaysIncludedMask, weekdayIndex);
+    return sWeekdays(newWeekdays.join(''));
+};
+export const doesWeekdaysIncludeWeekday = (weekdays, weekday) => {
+    const sWeekdaysInstance = sWeekdays(weekdays);
+    const weekdayIndex = getIndexForWeekday(weekday);
+    return getAtIndex(sWeekdaysInstance.weekdays, weekdayIndex) !== NotIncludedDay;
+};
+export const doesWeekdaysHaveOverlapWithWeekdays = (weekdays1, weekdays2) => {
+    const sWeekdays1 = sWeekdays(weekdays1);
+    const sWeekdays2 = sWeekdays(weekdays2);
+    for (let i = 0; i < WeekdaysCount; i++) {
+        if (sWeekdays1.weekdays[i] !== NotIncludedDay &&
+            sWeekdays1.weekdays[i] === sWeekdays2.weekdays[i]) {
+            return true;
+        }
+    }
+    return false;
+};

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "scdate",
+  "version": "0.1.1",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "!/**/__test__",
+    "!*.test.*"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "build:clean": "yarn build --clean && rimraf dist && rimraf *.tgz",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:utc": "TZ=Etc/Universal vitest run",
+    "test:watch": "vitest",
+    "smoke": "yarn build && yarn lint && yarn test:utc",
+    "-- PRE-COMMIT HOOKS --": "",
+    "_postinstall": "husky install",
+    "prepublishOnly": "pinst --disable",
+    "postpublish": "pinst --enable",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@date-fns/utc": "^1.2.0",
+    "date-fns": "^3.6.0",
+    "date-fns-tz": "^3.1.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.1.1",
+    "@tsconfig/strictest": "^2.0.5",
+    "@types/node": "^20.12.7",
+    "eslint": "^9.1.1",
+    "husky": "^9.0.11",
+    "lint-staged": "^15.2.2",
+    "pinst": "^3.0.0",
+    "prettier": "^3.2.5",
+    "rimraf": "^5.0.5",
+    "typescript": "^5.4.5",
+    "typescript-eslint": "^7.7.1",
+    "vitest": "^1.5.1"
+  },
+  "prettier": {
+    "tabWidth": 2,
+    "semi": false,
+    "singleQuote": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ericvera/scdate"
+  },
+  "keywords": [
+    "date",
+    "time zones",
+    "time",
+    "datetime",
+    "immutable",
+    "schedule",
+    "timestamp"
+  ],
+  "lint-staged": {
+    "*.{ts,tsx,mjs}": "eslint --cache",
+    "*": "prettier --ignore-unknown --write"
+  },
+  "packageManager": "yarn@4.1.1"
+}