@arkv/temporal 0.2.0

package/dist/cjs/start-end.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startOfHelper = startOfHelper;
+exports.endOfHelper = endOfHelper;
+const ZERO_TIME = {
+    hour: 0,
+    minute: 0,
+    second: 0,
+    millisecond: 0,
+    microsecond: 0,
+    nanosecond: 0,
+};
+const MAX_TIME = {
+    hour: 23,
+    minute: 59,
+    second: 59,
+    millisecond: 999,
+    microsecond: 999,
+    nanosecond: 999,
+};
+function startWeek(zdt, weekStart) {
+    // dayOfWeek: 1=Mon...7=Sun → convert to 0=Sun..6=Sat
+    const dow = zdt.dayOfWeek % 7;
+    const diff = (dow - weekStart + 7) % 7;
+    return zdt.subtract({ days: diff }).with(ZERO_TIME);
+}
+function endWeek(zdt, weekStart) {
+    const dow = zdt.dayOfWeek % 7;
+    const diff = (dow - weekStart + 7) % 7;
+    return zdt
+        .subtract({ days: diff })
+        .add({ days: 6 })
+        .with(MAX_TIME);
+}
+function startOfHelper(zdt, unit, locale) {
+    const weekStart = locale.weekStart ?? 0;
+    switch (unit) {
+        case 'year':
+            return zdt.with({ month: 1, day: 1, ...ZERO_TIME });
+        case 'month':
+            return zdt.with({ day: 1, ...ZERO_TIME });
+        case 'week':
+            return startWeek(zdt, weekStart);
+        case 'day':
+        case 'date':
+            return zdt.with(ZERO_TIME);
+        case 'hour':
+            return zdt.with({
+                minute: 0,
+                second: 0,
+                millisecond: 0,
+                microsecond: 0,
+                nanosecond: 0,
+            });
+        case 'minute':
+            return zdt.with({
+                second: 0,
+                millisecond: 0,
+                microsecond: 0,
+                nanosecond: 0,
+            });
+        case 'second':
+            return zdt.with({
+                millisecond: 0,
+                microsecond: 0,
+                nanosecond: 0,
+            });
+        default:
+            return zdt;
+    }
+}
+function endOfHelper(zdt, unit, locale) {
+    const weekStart = locale.weekStart ?? 0;
+    switch (unit) {
+        case 'year':
+            return zdt.with({ month: 12, day: 31, ...MAX_TIME });
+        case 'month':
+            return zdt.with({
+                day: zdt.daysInMonth,
+                ...MAX_TIME,
+            });
+        case 'week':
+            return endWeek(zdt, weekStart);
+        case 'day':
+        case 'date':
+            return zdt.with(MAX_TIME);
+        case 'hour':
+            return zdt.with({
+                minute: 59,
+                second: 59,
+                millisecond: 999,
+                microsecond: 999,
+                nanosecond: 999,
+            });
+        case 'minute':
+            return zdt.with({
+                second: 59,
+                millisecond: 999,
+                microsecond: 999,
+                nanosecond: 999,
+            });
+        case 'second':
+            return zdt.with({
+                millisecond: 999,
+                microsecond: 999,
+                nanosecond: 999,
+            });
+        default:
+            return zdt;
+    }
+}

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/units.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DURATION_KEY = void 0;
+exports.normalizeUnit = normalizeUnit;
+const UNIT_MAP = {
+    y: 'year',
+    yr: 'year',
+    year: 'year',
+    years: 'year',
+    M: 'month',
+    month: 'month',
+    months: 'month',
+    Q: 'quarter',
+    quarter: 'quarter',
+    quarters: 'quarter',
+    w: 'week',
+    week: 'week',
+    weeks: 'week',
+    d: 'day',
+    day: 'day',
+    days: 'day',
+    D: 'date',
+    date: 'date',
+    dates: 'date',
+    h: 'hour',
+    hour: 'hour',
+    hours: 'hour',
+    m: 'minute',
+    min: 'minute',
+    minute: 'minute',
+    minutes: 'minute',
+    s: 'second',
+    sec: 'second',
+    second: 'second',
+    seconds: 'second',
+    ms: 'millisecond',
+    millisecond: 'millisecond',
+    milliseconds: 'millisecond',
+};
+function normalizeUnit(u) {
+    return (UNIT_MAP[u] ??
+        UNIT_MAP[u.toLowerCase()] ??
+        'millisecond');
+}
+exports.DURATION_KEY = {
+    year: 'years',
+    month: 'months',
+    quarter: null,
+    week: 'weeks',
+    day: 'days',
+    date: 'days',
+    hour: 'hours',
+    minute: 'minutes',
+    second: 'seconds',
+    millisecond: 'milliseconds',
+};

package/dist/esm/constants.js

@@ -0,0 +1,4 @@
+export const FORMAT_DEFAULT = 'YYYY-MM-DDTHH:mm:ssZ';
+export const INVALID_DATE = 'Invalid Date';
+// Matches format tokens and [escaped] text
+export const REGEX_FORMAT = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g;

package/dist/esm/dayjs.js

@@ -0,0 +1,315 @@
+import { FORMAT_DEFAULT, INVALID_DATE, } from './constants.js';
+import { diffHelper } from './diff.js';
+import { formatDate } from './format.js';
+import { getGlobalLocale, getLocaleObj, registerLocale, } from './locale.js';
+import { parseInput } from './parse.js';
+import { endOfHelper, startOfHelper } from './start-end.js';
+import { DURATION_KEY, normalizeUnit, } from './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 });
+    }
+}
+export const DEFAULT_TZ = Temporal.Now.timeZoneId();
+export class TDayjs {
+    $zdt;
+    $L;
+    $tz;
+    constructor(cfg) {
+        this.$L = cfg.locale ?? getGlobalLocale();
+        this.$tz = cfg.tz ?? DEFAULT_TZ;
+        this.$zdt =
+            cfg.zdt !== undefined
+                ? cfg.zdt
+                : 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 = 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 = 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 = normalizeUnit(unit ?? 'millisecond');
+        if (u === 'quarter') {
+            return this.add(n * 3, 'month');
+        }
+        const key = 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 = normalizeUnit(unit);
+        return this._clone(startOfHelper(this.$zdt, u, getLocaleObj(this.$L)));
+    }
+    endOf(unit) {
+        if (!this.$zdt)
+            return this._clone(null);
+        const u = normalizeUnit(unit);
+        return this._clone(endOfHelper(this.$zdt, u, 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 INVALID_DATE;
+        const loc = getLocaleObj(this.$L);
+        return formatDate(this.$zdt, template ?? 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 = 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 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 INVALID_DATE;
+        return this.$zdt.toInstant().toString();
+    }
+    toJSON() {
+        return this.isValid() ? this.toISOString() : null;
+    }
+    toString() {
+        return this.isValid()
+            ? this.toDate().toUTCString()
+            : INVALID_DATE;
+    }
+    locale(preset, object) {
+        if (preset === undefined)
+            return this.$L;
+        let name;
+        if (typeof preset === 'string') {
+            name = preset.toLowerCase();
+            if (object) {
+                registerLocale({ ...object, name });
+            }
+        }
+        else {
+            registerLocale(preset);
+            name = preset.name;
+        }
+        return new TDayjs({
+            zdt: this.$zdt,
+            locale: name,
+            tz: this.$tz,
+        });
+    }
+}

package/dist/esm/diff.js

@@ -0,0 +1,57 @@
+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);
+}
+export 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/esm/format.js

@@ -0,0 +1,81 @@
+import { REGEX_FORMAT } from './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;
+    }
+}
+export function formatDate(zdt, template, locale) {
+    return template.replace(REGEX_FORMAT, (match, escaped) => {
+        if (escaped != null)
+            return escaped;
+        return matchToken(zdt, locale, match) ?? match;
+    });
+}

package/dist/esm/index.js

@@ -0,0 +1,45 @@
+import 'temporal-polyfill/global';
+import { DEFAULT_TZ, TDayjs } from './dayjs.js';
+import { getGlobalLocale, registerLocale, setGlobalLocale, } from './locale.js';
+export { TDayjs } from './dayjs.js';
+const installed = new Set();
+function tdayjs(date) {
+    if (date instanceof TDayjs)
+        return date.clone();
+    return new TDayjs({ date });
+}
+tdayjs.extend = (plugin, option) => {
+    if (!installed.has(plugin)) {
+        plugin(option, TDayjs, tdayjs);
+        installed.add(plugin);
+    }
+    return tdayjs;
+};
+tdayjs.isDayjs = (d) => {
+    return d instanceof TDayjs;
+};
+tdayjs.unix = (t) => {
+    return new TDayjs({
+        date: t * 1_000,
+        tz: DEFAULT_TZ,
+    });
+};
+tdayjs.locale = (preset, object) => {
+    if (preset === undefined)
+        return getGlobalLocale();
+    let name;
+    if (typeof preset === 'string') {
+        name = preset.toLowerCase();
+        if (object) {
+            registerLocale({ ...object, name });
+        }
+        setGlobalLocale(name);
+    }
+    else {
+        registerLocale(preset);
+        name = preset.name;
+        setGlobalLocale(name);
+    }
+    return name;
+};
+export default tdayjs;