@arkv/temporal 0.2.0

package/dist/cjs/dayjs.js

@@ -0,0 +1,319 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TDayjs = exports.DEFAULT_TZ = void 0;
+const constants_js_1 = require("./constants.js");
+const diff_js_1 = require("./diff.js");
+const format_js_1 = require("./format.js");
+const locale_js_1 = require("./locale.js");
+const parse_js_1 = require("./parse.js");
+const start_end_js_1 = require("./start-end.js");
+const units_js_1 = require("./units.js");
+function addToZdt(zdt, n, key) {
+    switch (key) {
+        case 'years':
+            return zdt.add({ years: n });
+        case 'months':
+            return zdt.add({ months: n });
+        case 'weeks':
+            return zdt.add({ weeks: n });
+        case 'days':
+            return zdt.add({ days: n });
+        case 'hours':
+            return zdt.add({ hours: n });
+        case 'minutes':
+            return zdt.add({ minutes: n });
+        case 'seconds':
+            return zdt.add({ seconds: n });
+        case 'milliseconds':
+            return zdt.add({ milliseconds: n });
+    }
+}
+exports.DEFAULT_TZ = Temporal.Now.timeZoneId();
+class TDayjs {
+    $zdt;
+    $L;
+    $tz;
+    constructor(cfg) {
+        this.$L = cfg.locale ?? (0, locale_js_1.getGlobalLocale)();
+        this.$tz = cfg.tz ?? exports.DEFAULT_TZ;
+        this.$zdt =
+            cfg.zdt !== undefined
+                ? cfg.zdt
+                : (0, parse_js_1.parseInput)(cfg.date, this.$tz);
+    }
+    _clone(zdt) {
+        return new TDayjs({
+            zdt,
+            locale: this.$L,
+            tz: this.$tz,
+        });
+    }
+    isValid() {
+        return this.$zdt !== null;
+    }
+    clone() {
+        return this._clone(this.$zdt);
+    }
+    year(value) {
+        if (value === undefined) {
+            return this.$zdt?.year ?? NaN;
+        }
+        if (!this.$zdt)
+            return this._clone(null);
+        return this.add(value - this.$zdt.year, 'year');
+    }
+    month(value) {
+        if (value === undefined) {
+            return (this.$zdt?.month ?? 1) - 1;
+        }
+        if (!this.$zdt)
+            return this._clone(null);
+        // value is 0-indexed; $zdt.month is 1-indexed
+        return this.add(value - (this.$zdt.month - 1), 'month');
+    }
+    date(value) {
+        if (value === undefined) {
+            return this.$zdt?.day ?? NaN;
+        }
+        if (!this.$zdt)
+            return this._clone(null);
+        return this.add(value - this.$zdt.day, 'day');
+    }
+    day(value) {
+        if (value === undefined) {
+            return (this.$zdt?.dayOfWeek ?? 0) % 7;
+        }
+        if (!this.$zdt)
+            return this._clone(null);
+        const current = this.$zdt.dayOfWeek % 7;
+        return this._clone(this.$zdt.add({ days: value - current }));
+    }
+    hour(value) {
+        if (value === undefined) {
+            return this.$zdt?.hour ?? NaN;
+        }
+        if (!this.$zdt)
+            return this._clone(null);
+        return this.add(value - this.$zdt.hour, 'hour');
+    }
+    minute(value) {
+        if (value === undefined) {
+            return this.$zdt?.minute ?? NaN;
+        }
+        if (!this.$zdt)
+            return this._clone(null);
+        return this.add(value - this.$zdt.minute, 'minute');
+    }
+    second(value) {
+        if (value === undefined) {
+            return this.$zdt?.second ?? NaN;
+        }
+        if (!this.$zdt)
+            return this._clone(null);
+        return this.add(value - this.$zdt.second, 'second');
+    }
+    millisecond(value) {
+        if (value === undefined) {
+            return this.$zdt?.millisecond ?? NaN;
+        }
+        if (!this.$zdt)
+            return this._clone(null);
+        return this.add(value - this.$zdt.millisecond, 'millisecond');
+    }
+    get(unit) {
+        const u = (0, units_js_1.normalizeUnit)(unit);
+        return this._getByUnit(u);
+    }
+    _getByUnit(u) {
+        switch (u) {
+            case 'year':
+                return this.year();
+            case 'month':
+                return this.month();
+            case 'date':
+                return this.date();
+            case 'day':
+                return this.day();
+            case 'hour':
+                return this.hour();
+            case 'minute':
+                return this.minute();
+            case 'second':
+                return this.second();
+            case 'millisecond':
+                return this.millisecond();
+            case 'week':
+                return this.day();
+            case 'quarter':
+                return Math.ceil((this.month() + 1) / 3);
+        }
+    }
+    set(unit, value) {
+        const u = (0, units_js_1.normalizeUnit)(unit);
+        return this._setByUnit(u, value);
+    }
+    _setByUnit(u, value) {
+        switch (u) {
+            case 'year':
+                return this.year(value);
+            case 'month':
+                return this.month(value);
+            case 'date':
+                return this.date(value);
+            case 'day':
+                return this.day(value);
+            case 'hour':
+                return this.hour(value);
+            case 'minute':
+                return this.minute(value);
+            case 'second':
+                return this.second(value);
+            case 'millisecond':
+                return this.millisecond(value);
+            default:
+                return this.clone();
+        }
+    }
+    // --- Manipulation ---
+    add(value, unit) {
+        if (!this.$zdt)
+            return this._clone(null);
+        const n = Number(value);
+        const u = (0, units_js_1.normalizeUnit)(unit ?? 'millisecond');
+        if (u === 'quarter') {
+            return this.add(n * 3, 'month');
+        }
+        const key = units_js_1.DURATION_KEY[u];
+        if (!key)
+            return this._clone(this.$zdt);
+        return this._clone(addToZdt(this.$zdt, n, key));
+    }
+    subtract(value, unit) {
+        return this.add(-Number(value), unit);
+    }
+    startOf(unit) {
+        if (!this.$zdt)
+            return this._clone(null);
+        const u = (0, units_js_1.normalizeUnit)(unit);
+        return this._clone((0, start_end_js_1.startOfHelper)(this.$zdt, u, (0, locale_js_1.getLocaleObj)(this.$L)));
+    }
+    endOf(unit) {
+        if (!this.$zdt)
+            return this._clone(null);
+        const u = (0, units_js_1.normalizeUnit)(unit);
+        return this._clone((0, start_end_js_1.endOfHelper)(this.$zdt, u, (0, locale_js_1.getLocaleObj)(this.$L)));
+    }
+    // --- Comparison ---
+    _toZdt(d) {
+        if (d instanceof TDayjs)
+            return d;
+        return new TDayjs({ date: d, tz: this.$tz });
+    }
+    isBefore(date, unit) {
+        if (!this.$zdt)
+            return false;
+        const other = this._toZdt(date);
+        if (!other.isValid())
+            return false;
+        if (!unit) {
+            return (Temporal.ZonedDateTime.compare(this.$zdt, other.$zdt) < 0);
+        }
+        return this.endOf(unit).valueOf() < other.valueOf();
+    }
+    isAfter(date, unit) {
+        if (!this.$zdt)
+            return false;
+        const other = this._toZdt(date);
+        if (!other.isValid())
+            return false;
+        if (!unit) {
+            return (Temporal.ZonedDateTime.compare(this.$zdt, other.$zdt) > 0);
+        }
+        return other.valueOf() < this.startOf(unit).valueOf();
+    }
+    isSame(date, unit) {
+        if (!this.$zdt)
+            return false;
+        const other = this._toZdt(date);
+        if (!other.isValid())
+            return false;
+        if (!unit) {
+            return (Temporal.ZonedDateTime.compare(this.$zdt, other.$zdt) === 0);
+        }
+        const start = this.startOf(unit).valueOf();
+        const end = this.endOf(unit).valueOf();
+        const v = other.valueOf();
+        return start <= v && v <= end;
+    }
+    // --- Display ---
+    format(template) {
+        if (!this.$zdt)
+            return constants_js_1.INVALID_DATE;
+        const loc = (0, locale_js_1.getLocaleObj)(this.$L);
+        return (0, format_js_1.formatDate)(this.$zdt, template ?? constants_js_1.FORMAT_DEFAULT, loc);
+    }
+    diff(date, unit, float = false) {
+        if (!this.$zdt)
+            return NaN;
+        const other = this._toZdt(date ?? undefined);
+        if (!other.$zdt)
+            return NaN;
+        const u = (0, units_js_1.normalizeUnit)(unit ?? 'millisecond');
+        // dayjs: this.diff(other) = this - other
+        // diffHelper(from, to) = from.until(to) = to - from
+        // so pass (other, this) to get this - other
+        return (0, diff_js_1.diffHelper)(other.$zdt, this.$zdt, u, float);
+    }
+    valueOf() {
+        return this.$zdt?.epochMilliseconds ?? NaN;
+    }
+    unix() {
+        return Math.floor(this.valueOf() / 1_000);
+    }
+    daysInMonth() {
+        return this.$zdt?.daysInMonth ?? NaN;
+    }
+    utcOffset() {
+        if (!this.$zdt)
+            return 0;
+        return this.$zdt.offsetNanoseconds / 60_000_000_000;
+    }
+    // --- Conversion ---
+    toDate() {
+        return new Date(this.valueOf());
+    }
+    toISOString() {
+        if (!this.$zdt)
+            return constants_js_1.INVALID_DATE;
+        return this.$zdt.toInstant().toString();
+    }
+    toJSON() {
+        return this.isValid() ? this.toISOString() : null;
+    }
+    toString() {
+        return this.isValid()
+            ? this.toDate().toUTCString()
+            : constants_js_1.INVALID_DATE;
+    }
+    locale(preset, object) {
+        if (preset === undefined)
+            return this.$L;
+        let name;
+        if (typeof preset === 'string') {
+            name = preset.toLowerCase();
+            if (object) {
+                (0, locale_js_1.registerLocale)({ ...object, name });
+            }
+        }
+        else {
+            (0, locale_js_1.registerLocale)(preset);
+            name = preset.name;
+        }
+        return new TDayjs({
+            zdt: this.$zdt,
+            locale: name,
+            tz: this.$tz,
+        });
+    }
+}
+exports.TDayjs = TDayjs;

package/dist/cjs/diff.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffHelper = diffHelper;
+function monthDiff(from, to, float) {
+    const dur = from.until(to, {
+        largestUnit: 'months',
+    });
+    const whole = dur.months;
+    if (!float)
+        return whole;
+    const anchor = from.add({ months: whole });
+    const remaining = to.epochMilliseconds - anchor.epochMilliseconds;
+    const nextMs = anchor.add({ months: 1 }).epochMilliseconds -
+        anchor.epochMilliseconds;
+    return whole + remaining / nextMs;
+}
+function dayDiff(from, to, float) {
+    const dur = from.until(to, { largestUnit: 'days' });
+    const total = dur.days +
+        dur.hours / 24 +
+        dur.minutes / 1440 +
+        dur.seconds / 86_400 +
+        dur.milliseconds / 86_400_000;
+    return float ? total : Math.trunc(total);
+}
+function msDiff(from, to, unit, float) {
+    const ms = to.epochMilliseconds - from.epochMilliseconds;
+    const divisors = {
+        hour: 3_600_000,
+        minute: 60_000,
+        second: 1_000,
+        millisecond: 1,
+    };
+    const result = ms / (divisors[unit] ?? 1);
+    return float ? result : Math.trunc(result);
+}
+function diffHelper(from, to, unit, float) {
+    switch (unit) {
+        case 'year': {
+            const months = monthDiff(from, to, float);
+            return float ? months / 12 : Math.trunc(months / 12);
+        }
+        case 'quarter': {
+            const months = monthDiff(from, to, float);
+            return float ? months / 3 : Math.trunc(months / 3);
+        }
+        case 'month':
+            return monthDiff(from, to, float);
+        case 'week': {
+            const days = dayDiff(from, to, true);
+            const result = days / 7;
+            return float ? result : Math.trunc(result);
+        }
+        case 'day':
+        case 'date':
+            return dayDiff(from, to, float);
+        default:
+            return msDiff(from, to, unit, float);
+    }
+}

package/dist/cjs/format.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDate = formatDate;
+const constants_js_1 = require("./constants.js");
+function pad(n, len = 2) {
+    return String(n).padStart(len, '0');
+}
+function offsetStr(ns, sep) {
+    const totalMin = Math.round(ns / 60_000_000_000);
+    const sign = totalMin >= 0 ? '+' : '-';
+    const absMin = Math.abs(totalMin);
+    const h = pad(Math.floor(absMin / 60));
+    const m = pad(absMin % 60);
+    return sep ? `${sign}${h}:${m}` : `${sign}${h}${m}`;
+}
+// Temporal: 1=Mon...7=Sun → dayjs: 0=Sun...6=Sat
+function toDayjsDay(dow) {
+    return dow % 7;
+}
+function matchToken(zdt, locale, token) {
+    const { year, month, day, hour, minute, second, millisecond, dayOfWeek, offsetNanoseconds, } = zdt;
+    const djDay = toDayjsDay(dayOfWeek);
+    switch (token) {
+        case 'YYYY':
+            return pad(year, 4);
+        case 'YY':
+            return String(year).slice(-2);
+        case 'M':
+            return String(month);
+        case 'MM':
+            return pad(month);
+        case 'MMM':
+            return locale.monthsShort[month - 1];
+        case 'MMMM':
+            return locale.months[month - 1];
+        case 'D':
+            return String(day);
+        case 'DD':
+            return pad(day);
+        case 'd':
+            return String(djDay);
+        case 'dd':
+            return locale.weekdaysMin[djDay];
+        case 'ddd':
+            return locale.weekdaysShort[djDay];
+        case 'dddd':
+            return locale.weekdays[djDay];
+        case 'H':
+            return String(hour);
+        case 'HH':
+            return pad(hour);
+        case 'h':
+            return String(hour % 12 || 12);
+        case 'hh':
+            return pad(hour % 12 || 12);
+        case 'a':
+            return hour < 12 ? 'am' : 'pm';
+        case 'A':
+            return hour < 12 ? 'AM' : 'PM';
+        case 'm':
+            return String(minute);
+        case 'mm':
+            return pad(minute);
+        case 's':
+            return String(second);
+        case 'ss':
+            return pad(second);
+        case 'SSS':
+            return pad(millisecond, 3);
+        case 'Z':
+            return offsetStr(offsetNanoseconds, ':');
+        case 'ZZ':
+            return offsetStr(offsetNanoseconds, '');
+        default:
+            return null;
+    }
+}
+function formatDate(zdt, template, locale) {
+    return template.replace(constants_js_1.REGEX_FORMAT, (match, escaped) => {
+        if (escaped != null)
+            return escaped;
+        return matchToken(zdt, locale, match) ?? match;
+    });
+}

package/dist/cjs/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TDayjs = void 0;
+require("temporal-polyfill/global");
+const dayjs_js_1 = require("./dayjs.js");
+const locale_js_1 = require("./locale.js");
+var dayjs_js_2 = require("./dayjs.js");
+Object.defineProperty(exports, "TDayjs", { enumerable: true, get: function () { return dayjs_js_2.TDayjs; } });
+const installed = new Set();
+function tdayjs(date) {
+    if (date instanceof dayjs_js_1.TDayjs)
+        return date.clone();
+    return new dayjs_js_1.TDayjs({ date });
+}
+tdayjs.extend = (plugin, option) => {
+    if (!installed.has(plugin)) {
+        plugin(option, dayjs_js_1.TDayjs, tdayjs);
+        installed.add(plugin);
+    }
+    return tdayjs;
+};
+tdayjs.isDayjs = (d) => {
+    return d instanceof dayjs_js_1.TDayjs;
+};
+tdayjs.unix = (t) => {
+    return new dayjs_js_1.TDayjs({
+        date: t * 1_000,
+        tz: dayjs_js_1.DEFAULT_TZ,
+    });
+};
+tdayjs.locale = (preset, object) => {
+    if (preset === undefined)
+        return (0, locale_js_1.getGlobalLocale)();
+    let name;
+    if (typeof preset === 'string') {
+        name = preset.toLowerCase();
+        if (object) {
+            (0, locale_js_1.registerLocale)({ ...object, name });
+        }
+        (0, locale_js_1.setGlobalLocale)(name);
+    }
+    else {
+        (0, locale_js_1.registerLocale)(preset);
+        name = preset.name;
+        (0, locale_js_1.setGlobalLocale)(name);
+    }
+    return name;
+};
+exports.default = tdayjs;

package/dist/cjs/locale.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ls = void 0;
+exports.getLocaleObj = getLocaleObj;
+exports.getGlobalLocale = getGlobalLocale;
+exports.setGlobalLocale = setGlobalLocale;
+exports.registerLocale = registerLocale;
+const en = {
+    name: 'en',
+    months: [
+        'January',
+        'February',
+        'March',
+        'April',
+        'May',
+        'June',
+        'July',
+        'August',
+        'September',
+        'October',
+        'November',
+        'December',
+    ],
+    monthsShort: [
+        'Jan',
+        'Feb',
+        'Mar',
+        'Apr',
+        'May',
+        'Jun',
+        'Jul',
+        'Aug',
+        'Sep',
+        'Oct',
+        'Nov',
+        'Dec',
+    ],
+    weekdays: [
+        'Sunday',
+        'Monday',
+        'Tuesday',
+        'Wednesday',
+        'Thursday',
+        'Friday',
+        'Saturday',
+    ],
+    weekdaysShort: [
+        'Sun',
+        'Mon',
+        'Tue',
+        'Wed',
+        'Thu',
+        'Fri',
+        'Sat',
+    ],
+    weekdaysMin: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
+    weekStart: 0,
+};
+const Ls = { en };
+exports.Ls = Ls;
+let globalLocale = 'en';
+function getLocaleObj(name) {
+    return Ls[name] ?? en;
+}
+function getGlobalLocale() {
+    return globalLocale;
+}
+function setGlobalLocale(name) {
+    globalLocale = name;
+}
+function registerLocale(locale) {
+    Ls[locale.name] = locale;
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/parse.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInput = parseInput;
+const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+const HAS_OFFSET = /Z|[+-]\d{2}:\d{2}/;
+const HAS_ANNOTATION = /\[/;
+function parseString(s, tz) {
+    try {
+        if (HAS_ANNOTATION.test(s)) {
+            return Temporal.ZonedDateTime.from(s);
+        }
+        if (HAS_OFFSET.test(s)) {
+            return Temporal.Instant.from(s).toZonedDateTimeISO(tz);
+        }
+        if (DATE_ONLY.test(s)) {
+            return Temporal.PlainDate.from(s).toZonedDateTime(tz);
+        }
+        return Temporal.PlainDateTime.from(s).toZonedDateTime(tz);
+    }
+    catch {
+        return null;
+    }
+}
+function isTDayjsLike(d) {
+    return d !== null && typeof d === 'object' && '$zdt' in d;
+}
+function parseInput(date, tz) {
+    if (date === null)
+        return null;
+    if (date === undefined) {
+        return Temporal.Now.zonedDateTimeISO(tz);
+    }
+    if (isTDayjsLike(date)) {
+        return date.$zdt;
+    }
+    if (typeof date === 'number') {
+        return Temporal.Instant.fromEpochMilliseconds(date).toZonedDateTimeISO(tz);
+    }
+    if (date instanceof Date) {
+        return Temporal.Instant.fromEpochMilliseconds(date.getTime()).toZonedDateTimeISO(tz);
+    }
+    if (typeof date === 'string') {
+        return parseString(date, tz);
+    }
+    return null;
+}