@bariskuran/base 0.0.0-stage → 0.0.2

package/src/libs/baseDate/createBaseDatePackage.js

@@ -0,0 +1,460 @@
+import { baseDate, getNow } from "../baseDate";
+import { baseStore } from "../baseStore";
+
+const getDefaults = () => {
+    const { _baseDate } = baseStore?.globalData?.get?.() || {};
+    const { defaultFormat, firstDayOfWeek, timezone } = _baseDate || {};
+    return { defaultFormat, firstDayOfWeek, timezone };
+};
+
+const weekdayIndexInTz = (timestamp, timezone) => {
+    try {
+        const name = new Intl.DateTimeFormat("en-US", {
+            timeZone: typeof timezone === "string" ? timezone : undefined,
+            weekday: "short",
+        }).format(new Date(timestamp));
+        const map = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
+        return map[name] ?? new Date(timestamp).getDay();
+    } catch {
+        return new Date(timestamp).getDay();
+    }
+};
+
+const startOfDayTs = (nowTs, timezone) => {
+    const y = Number(baseDate({ initial: nowTs, timezone, format: "|YYYY|" }));
+    const m = Number(baseDate({ initial: nowTs, timezone, format: "|MM|" }));
+    const d = Number(baseDate({ initial: nowTs, timezone, format: "|DD|" }));
+
+    return baseDate({
+        initial: { year: y, month: m, day: d, hour: 0, minute: 0, second: 0, millisecond: 0 },
+        timezone,
+        format: "timestamp",
+    });
+};
+
+const endOfDayTs = (dayStartTs, timezone) => {
+    const nextStart = baseDate({
+        initial: dayStartTs,
+        timezone,
+        calc: { day: 1 },
+        format: "timestamp",
+    });
+    return nextStart - 1;
+};
+
+const startOfMonthTs = (nowTs, timezone) => {
+    const y = Number(baseDate({ initial: nowTs, timezone, format: "|YYYY|" }));
+    const m = Number(baseDate({ initial: nowTs, timezone, format: "|MM|" }));
+    return baseDate({
+        initial: { year: y, month: m, day: 1, hour: 0, minute: 0, second: 0, millisecond: 0 },
+        timezone,
+        format: "timestamp",
+    });
+};
+
+const startOfYearTs = (nowTs, timezone) => {
+    const y = Number(baseDate({ initial: nowTs, timezone, format: "|YYYY|" }));
+    return baseDate({
+        initial: { year: y, month: 1, day: 1, hour: 0, minute: 0, second: 0, millisecond: 0 },
+        timezone,
+        format: "timestamp",
+    });
+};
+
+const makePoint = ({ timestamp, timezone, defaultFormat, longFormat }) => {
+    const ts = Number(timestamp);
+
+    return {
+        timestamp: ts,
+        defaultString: baseDate({ initial: ts, timezone, format: defaultFormat }),
+        longString: baseDate({ initial: ts, timezone, format: longFormat }),
+        calc: (delta, overrides = {}) =>
+            baseDate({
+                initial: ts,
+                timezone,
+                calc: delta && typeof delta === "object" ? delta : undefined,
+                ...overrides,
+            }),
+    };
+};
+
+const makeLastDaysRange = ({ endDayStartTs, daysBackInclusive, timezone, defaultFormat }) => {
+    const endTs = endOfDayTs(endDayStartTs, timezone);
+
+    const startTs = baseDate({
+        initial: endDayStartTs,
+        timezone,
+        calc: { day: -(daysBackInclusive - 1) },
+        format: "timestamp",
+    });
+
+    return {
+        default: [
+            baseDate({ initial: startTs, timezone, format: defaultFormat }),
+            baseDate({ initial: endTs, timezone, format: defaultFormat }),
+        ],
+        timestamps: [startTs, endTs],
+    };
+};
+
+export const createBaseDatePackage = (opts = {}) => {
+    const { defaultFormat, firstDayOfWeek, timezone: storeTz } = getDefaults();
+
+    const tz =
+        typeof opts.timezone === "number" && Number.isFinite(opts.timezone)
+            ? opts.timezone
+            : typeof opts.timezone === "string" && opts.timezone.trim()
+              ? opts.timezone.trim()
+              : storeTz;
+
+    const longFormat = "|DD|/|MM|/|YYYY| |HH|:|NN|:|SS|";
+
+    const nowTs = Date.now();
+    const getNowInTz = (opts = {}) => {
+        const { format, timezone } = opts || {};
+        return getNow({ format, timezone: timezone ?? tz });
+    };
+
+    const todayStartTs = startOfDayTs(nowTs, tz);
+    const todayEndTs = endOfDayTs(todayStartTs, tz);
+
+    const tomorrowStartTs = baseDate({
+        initial: todayStartTs,
+        timezone: tz,
+        calc: { day: 1 },
+        format: "timestamp",
+    });
+    const tomorrowEndTs = endOfDayTs(tomorrowStartTs, tz);
+
+    const yesterdayStartTs = baseDate({
+        initial: todayStartTs,
+        timezone: tz,
+        calc: { day: -1 },
+        format: "timestamp",
+    });
+    const yesterdayEndTs = endOfDayTs(yesterdayStartTs, tz);
+
+
+    const wd = weekdayIndexInTz(todayStartTs, tz);
+    const deltaThisWeekStart = (wd - firstDayOfWeek + 7) % 7;
+
+    const thisWeekStartTs = baseDate({
+        initial: todayStartTs,
+        timezone: tz,
+        calc: { day: -deltaThisWeekStart },
+        format: "timestamp",
+    });
+
+    const thisWeekEndTs = endOfDayTs(
+        baseDate({
+            initial: thisWeekStartTs,
+            timezone: tz,
+            calc: { day: 6 },
+            format: "timestamp",
+        }),
+        tz,
+    );
+
+    const nextWeekStartTs = baseDate({
+        initial: thisWeekStartTs,
+        timezone: tz,
+        calc: { day: 7 },
+        format: "timestamp",
+    });
+
+    const nextWeekEndTs = endOfDayTs(
+        baseDate({
+            initial: nextWeekStartTs,
+            timezone: tz,
+            calc: { day: 6 },
+            format: "timestamp",
+        }),
+        tz,
+    );
+
+    const lastWeekStartTs = baseDate({
+        initial: thisWeekStartTs,
+        timezone: tz,
+        calc: { day: -7 },
+        format: "timestamp",
+    });
+
+    const lastWeekEndTs = endOfDayTs(
+        baseDate({
+            initial: lastWeekStartTs,
+            timezone: tz,
+            calc: { day: 6 },
+            format: "timestamp",
+        }),
+        tz,
+    );
+
+
+    const thisMonthStartTs = startOfMonthTs(nowTs, tz);
+    const nextMonthStartTs = baseDate({
+        initial: thisMonthStartTs,
+        timezone: tz,
+        calc: { month: 1 },
+        format: "timestamp",
+    });
+    const lastMonthStartTs = baseDate({
+        initial: thisMonthStartTs,
+        timezone: tz,
+        calc: { month: -1 },
+        format: "timestamp",
+    });
+
+    const thisMonthEndTs = nextMonthStartTs - 1;
+    const nextMonthEndTs =
+        baseDate({
+            initial: nextMonthStartTs,
+            timezone: tz,
+            calc: { month: 1 },
+            format: "timestamp",
+        }) - 1;
+    const lastMonthEndTs = thisMonthStartTs - 1;
+
+
+    const thisYearStartTs = startOfYearTs(nowTs, tz);
+    const nextYearStartTs = baseDate({
+        initial: thisYearStartTs,
+        timezone: tz,
+        calc: { year: 1 },
+        format: "timestamp",
+    });
+    const lastYearStartTs = baseDate({
+        initial: thisYearStartTs,
+        timezone: tz,
+        calc: { year: -1 },
+        format: "timestamp",
+    });
+
+    const thisYearEndTs = nextYearStartTs - 1;
+    const nextYearEndTs =
+        baseDate({
+            initial: nextYearStartTs,
+            timezone: tz,
+            calc: { year: 1 },
+            format: "timestamp",
+        }) - 1;
+    const lastYearEndTs = thisYearStartTs - 1;
+
+    const day = {
+        ...makePoint({ timestamp: todayStartTs, timezone: tz, defaultFormat, longFormat }),
+        value: Number(baseDate({ initial: todayStartTs, timezone: tz, format: "|DD|" })),
+        weekdayIndex: weekdayIndexInTz(todayStartTs, tz),
+        weekdayShort: baseDate({ initial: todayStartTs, timezone: tz, format: "|aa|" }),
+        weekdayLong: baseDate({ initial: todayStartTs, timezone: tz, format: "|AA|" }),
+    };
+
+    const monthStartForNames = thisMonthStartTs;
+    const month = {
+        ...makePoint({ timestamp: monthStartForNames, timezone: tz, defaultFormat, longFormat }),
+        value: Number(baseDate({ initial: monthStartForNames, timezone: tz, format: "|MM|" })),
+        short: baseDate({ initial: monthStartForNames, timezone: tz, format: "|oo|" }),
+        long: baseDate({ initial: monthStartForNames, timezone: tz, format: "|OO|" }),
+    };
+
+    const yearStartForNums = thisYearStartTs;
+    const year = {
+        ...makePoint({ timestamp: yearStartForNums, timezone: tz, defaultFormat, longFormat }),
+        value: Number(baseDate({ initial: yearStartForNums, timezone: tz, format: "|YYYY|" })),
+        short: Number(baseDate({ initial: yearStartForNums, timezone: tz, format: "|YY|" })),
+    };
+
+
+    const tsTillEndOfDay = todayEndTs - nowTs;
+
+
+    return {
+        tsTillEndOfDay,
+        getNow: getNowInTz,
+
+        year,
+        month,
+        day,
+
+        today: makePoint({ timestamp: todayStartTs, timezone: tz, defaultFormat, longFormat }),
+        todayEnd: makePoint({ timestamp: todayEndTs, timezone: tz, defaultFormat, longFormat }),
+
+        tomorrow: makePoint({
+            timestamp: tomorrowStartTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        tomorrowEnd: makePoint({
+            timestamp: tomorrowEndTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+
+        yesterday: makePoint({
+            timestamp: yesterdayStartTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        yesterdayEnd: makePoint({
+            timestamp: yesterdayEndTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+
+        nextWeekStart: makePoint({
+            timestamp: nextWeekStartTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        nextWeekEnd: makePoint({
+            timestamp: nextWeekEndTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        thisWeekStart: makePoint({
+            timestamp: thisWeekStartTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        thisWeekEnd: makePoint({
+            timestamp: thisWeekEndTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        lastWeekStart: makePoint({
+            timestamp: lastWeekStartTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        lastWeekEnd: makePoint({
+            timestamp: lastWeekEndTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+
+        thisMonthStart: makePoint({
+            timestamp: thisMonthStartTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        thisMonthEnd: makePoint({
+            timestamp: thisMonthEndTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        nextMonthStart: makePoint({
+            timestamp: nextMonthStartTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        nextMonthEnd: makePoint({
+            timestamp: nextMonthEndTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        lastMonthStart: makePoint({
+            timestamp: lastMonthStartTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        lastMonthEnd: makePoint({
+            timestamp: lastMonthEndTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+
+        thisYearStart: makePoint({
+            timestamp: thisYearStartTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        thisYearEnd: makePoint({
+            timestamp: thisYearEndTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        nextYearStart: makePoint({
+            timestamp: nextYearStartTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        nextYearEnd: makePoint({
+            timestamp: nextYearEndTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        lastYearStart: makePoint({
+            timestamp: lastYearStartTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+        lastYearEnd: makePoint({
+            timestamp: lastYearEndTs,
+            timezone: tz,
+            defaultFormat,
+            longFormat,
+        }),
+
+        last7Days: makeLastDaysRange({
+            endDayStartTs: todayStartTs,
+            daysBackInclusive: 7,
+            timezone: tz,
+            defaultFormat,
+        }),
+        last15Days: makeLastDaysRange({
+            endDayStartTs: todayStartTs,
+            daysBackInclusive: 15,
+            timezone: tz,
+            defaultFormat,
+        }),
+        last30Days: makeLastDaysRange({
+            endDayStartTs: todayStartTs,
+            daysBackInclusive: 30,
+            timezone: tz,
+            defaultFormat,
+        }),
+        last45Days: makeLastDaysRange({
+            endDayStartTs: todayStartTs,
+            daysBackInclusive: 45,
+            timezone: tz,
+            defaultFormat,
+        }),
+        last60Days: makeLastDaysRange({
+            endDayStartTs: todayStartTs,
+            daysBackInclusive: 60,
+            timezone: tz,
+            defaultFormat,
+        }),
+        last90Days: makeLastDaysRange({
+            endDayStartTs: todayStartTs,
+            daysBackInclusive: 90,
+            timezone: tz,
+            defaultFormat,
+        }),
+        last180Days: makeLastDaysRange({
+            endDayStartTs: todayStartTs,
+            daysBackInclusive: 180,
+            timezone: tz,
+            defaultFormat,
+        }),
+    };
+};

package/src/libs/baseDate/index.js

@@ -0,0 +1,202 @@
+import { DATE_DEFAULTS } from "../../constants/DATE_DEFAULTS";
+import {
+    resolveDefaultsFromStore,
+    parseInitialString,
+    makeDateFromPartsInTz,
+    parseOffsetMinutes,
+    getPartsForOffset,
+    safeIntlParts,
+    formatWithTokens,
+} from "./tools";
+
+const calcFirstInt = (obj, keys) => {
+    if (!obj || typeof obj !== "object") return 0;
+    for (const k of keys) {
+        if (!Object.prototype.hasOwnProperty.call(obj, k)) continue;
+        const v = obj[k];
+        if (typeof v === "number" && Number.isFinite(v)) return Math.trunc(v);
+    }
+    return 0;
+};
+
+const calcSumInts = (obj, keys) => {
+    if (!obj || typeof obj !== "object") return 0;
+    let t = 0;
+    for (const k of keys) {
+        if (!Object.prototype.hasOwnProperty.call(obj, k)) continue;
+        const v = obj[k];
+        if (typeof v === "number" && Number.isFinite(v)) t += Math.trunc(v);
+    }
+    return t;
+};
+
+const isCalcObject = (v) =>
+    v != null && typeof v === "object" && !Array.isArray(v) && !(v instanceof Date);
+
+const CALC_YEAR = ["year", "years", "y"];
+const CALC_MONTH = ["month", "months", "m"];
+const CALC_DAY = ["day", "days", "d"];
+const CALC_HOUR = ["hour", "hours", "h"];
+const CALC_MINUTE = ["minute", "minutes", "min"];
+const CALC_SECONDS = ["second", "sec", "s", "seconds", "secs"];
+const CALC_MS = ["millisecond", "milliseconds", "milisecond", "ms"];
+
+export const baseDate = (opts = {}) => {
+    const { defaultFormat, timezone: storeTz } = resolveDefaultsFromStore();
+
+    const { initial, format, initialFormat, timezone, calc } = opts || {};
+
+    const tz =
+        typeof timezone === "number" && Number.isFinite(timezone)
+            ? timezone
+            : typeof timezone === "string" && timezone.trim()
+              ? timezone.trim()
+              : storeTz;
+    const initFmt =
+        typeof initialFormat === "string" && initialFormat.trim()
+            ? initialFormat.trim()
+            : defaultFormat;
+
+    let dateObj = null;
+
+    if (initial == null || initial === "") {
+        dateObj = new Date();
+    } else if (initial instanceof Date) {
+        dateObj = new Date(initial.getTime());
+    } else if (typeof initial === "number" && Number.isFinite(initial)) {
+        dateObj = new Date(initial);
+    } else if (typeof initial === "string") {
+        const parsed = parseInitialString(initial, initFmt);
+        if (parsed && typeof parsed === "object") {
+            dateObj = makeDateFromPartsInTz(parsed, tz);
+        } else {
+            const dt = new Date(initial);
+            dateObj = Number.isNaN(dt.getTime()) ? new Date() : dt;
+        }
+    } else if (typeof initial === "object") {
+        const parts = {
+            year: initial.year ?? DATE_DEFAULTS.year,
+            month: initial.month ?? DATE_DEFAULTS.month,
+            day: initial.day ?? DATE_DEFAULTS.day,
+            hour: initial.hour ?? 0,
+            minute: initial.minute ?? 0,
+            second: initial.second ?? 0,
+            millisecond: initial.millisecond ?? 0,
+        };
+        dateObj = makeDateFromPartsInTz(parts, tz);
+    } else {
+        dateObj = new Date();
+    }
+
+    if (!dateObj || Number.isNaN(dateObj.getTime())) dateObj = new Date();
+
+    const calcOpts = isCalcObject(calc) ? calc : null;
+
+    if (calcOpts) {
+
+        const addYears = calcFirstInt(calcOpts, CALC_YEAR);
+        const addMonths = calcFirstInt(calcOpts, CALC_MONTH);
+        const addDays = calcFirstInt(calcOpts, CALC_DAY);
+
+        const addHours = calcFirstInt(calcOpts, CALC_HOUR);
+        const addMinutes = calcFirstInt(calcOpts, CALC_MINUTE);
+        const addSeconds = calcSumInts(calcOpts, CALC_SECONDS);
+        const addMs = calcSumInts(calcOpts, CALC_MS);
+
+        const getTzParts = (d, tzValue) => {
+            const off = parseOffsetMinutes(tzValue);
+            if (typeof off === "number") {
+                const p = getPartsForOffset(d, off);
+                return {
+                    year: Number(p.year),
+                    month: Number(p.month),
+                    day: Number(p.day),
+                    hour: Number(p.hour),
+                    minute: Number(p.minute),
+                    second: Number(p.second),
+                    millisecond: Number(p.millisecond ?? 0),
+                };
+            }
+            const p = safeIntlParts(d, tzValue);
+            return {
+                year: p?.year ?? d.getFullYear(),
+                month: p?.month ?? d.getMonth() + 1,
+                day: p?.day ?? d.getDate(),
+                hour: p?.hour ?? d.getHours(),
+                minute: p?.minute ?? d.getMinutes(),
+                second: p?.second ?? d.getSeconds(),
+                millisecond: d.getMilliseconds(),
+            };
+        };
+
+        const daysInMonth = (y, m1to12) => {
+            const mm = Math.max(1, Math.min(12, m1to12));
+            return new Date(Date.UTC(y, mm, 0)).getUTCDate();
+        };
+
+        const normalizeYearMonth = (y, m1to12) => {
+            let year = y;
+            let month = m1to12;
+            if (!Number.isFinite(year)) year = DATE_DEFAULTS.year;
+            if (!Number.isFinite(month)) month = DATE_DEFAULTS.month;
+
+            month -= 1;
+            year += Math.floor(month / 12);
+            month = ((month % 12) + 12) % 12;
+            month += 1;
+
+            return { year, month };
+        };
+
+        const parts0 = getTzParts(dateObj, tz);
+
+        let y = parts0.year;
+        let m = parts0.month;
+        let d = parts0.day;
+
+        const hh = parts0.hour;
+        const nn = parts0.minute;
+        const ss = parts0.second;
+        const ms = parts0.millisecond;
+
+        if (addYears || addMonths) {
+            const nm = normalizeYearMonth(y + addYears, m + addMonths);
+            y = nm.year;
+            m = nm.month;
+
+            const dim = daysInMonth(y, m);
+            d = Math.min(d, dim);
+        }
+
+        if (addDays) {
+            const tmp = new Date(Date.UTC(y, (m || 1) - 1, (d || 1) + addDays, hh, nn, ss, ms));
+            y = tmp.getUTCFullYear();
+            m = tmp.getUTCMonth() + 1;
+            d = tmp.getUTCDate();
+        }
+
+        if (addYears || addMonths || addDays) {
+            dateObj = makeDateFromPartsInTz(
+                { year: y, month: m, day: d, hour: hh, minute: nn, second: ss, millisecond: ms },
+                tz,
+            );
+        }
+
+        const durationMs = addMs + addSeconds * 1000 + addMinutes * 60_000 + addHours * 3_600_000;
+
+        if (durationMs) {
+            dateObj = new Date(dateObj.getTime() + durationMs);
+        }
+    }
+
+    const fmt = typeof format === "string" && format ? format : defaultFormat;
+    if (typeof fmt === "string" && fmt.trim().toLowerCase() === "timestamp") {
+        return dateObj.getTime();
+    }
+    return formatWithTokens(dateObj, fmt, tz);
+};
+
+export const getNow = (opts = {}) => {
+    const { format, timezone } = opts || {};
+    return baseDate({ format, timezone });
+};