temporal-fmt 0.9.2 → 0.9.4

package/dist/relativeTime.cjs

@@ -1,25 +1,272 @@
-"use strict";var l=Object.defineProperty;var x=Object.getOwnPropertyDescriptor;var _=Object.getOwnPropertyNames;var O=Object.prototype.hasOwnProperty;var I=(n,e)=>{for(var t in e)l(n,t,{get:e[t],enumerable:!0})},L=(n,e,t,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of _(e))!O.call(n,r)&&r!==t&&l(n,r,{get:()=>e[r],enumerable:!(o=x(e,r))||o.enumerable});return n};var V=n=>L(l({},"__esModule",{value:!0}),n);var U={};I(U,{formatRelative:()=>M,formatRelativeToNow:()=>C});module.exports=V(U);function g(n){if(typeof n!="object"||n===null)throw new Error(`temporal-fmt: expected a date-carrying Temporal value, got ${String(n)}.`);let e=n,t={};if(typeof e.year=="number"&&(t.year=e.year),typeof e.month=="number"&&(t.month=e.month),typeof e.day=="number"&&(t.day=e.day),typeof e.hour=="number"&&(t.hour=e.hour),typeof e.minute=="number"&&(t.minute=e.minute),typeof e.second=="number"&&(t.second=e.second),typeof e.millisecond=="number"&&(t.millisecond=e.millisecond),typeof e.dayOfWeek=="number"&&(t.dayOfWeek=e.dayOfWeek),typeof e.calendarId=="string"&&(t.calendarId=e.calendarId),t.year===void 0||t.month===void 0||t.day===void 0)throw new Error("temporal-fmt: value is missing year/month/day fields \u2014 pass a Temporal.PlainDate / PlainDateTime / ZonedDateTime.");return t}function w(n){return g(n)}function $(n,e,t){let o=w(n),r=w(e);if(t==="years")return r.year-o.year;if(t==="months")return r.year*12+r.month-1-(o.year*12+o.month-1);if(t==="weeks"||t==="days"){let F=f(o),h=f(r)-F;return t==="weeks"?Math.trunc(h/7):h}let s=36e5,a=6e4,i=1e3,d=k(o),c=k(r)-d;switch(t){case"hours":return Math.trunc(c/s);case"minutes":return Math.trunc(c/a);case"seconds":return Math.trunc(c/i);case"milliseconds":return c}}function f(n){let e=n.year,t=n.month,o=n.day,r=t<=2?e-1:e,s=Math.floor((r>=0?r:r-399)/400),a=r-s*400,i=t>2?t-3:t+9,d=Math.floor((153*i+2)/5)+o-1,y=a*365+Math.floor(a/4)-Math.floor(a/100)+d;return s*146097+y-719468}function k(n){return f(n)*864e5+(n.hour??0)*36e5+(n.minute??0)*6e4+(n.second??0)*1e3+(n.millisecond??0)}var T=(n,e)=>$(n,e,"days");var A=[];function b(n){A.push(n)}var p=class extends Error{code;input;format;token;position;expected;actual;reason;constructor(e,t){super(e),this.name="TemporalFmtError",this.code=t.code,this.input=t.input,this.format=t.format,this.token=t.token,this.position=t.position,this.expected=t.expected,this.actual=t.actual,this.reason=t.reason;let o=Error.captureStackTrace;typeof o=="function"&&o(this,this.constructor)}toJSON(){return{name:this.name,message:this.message,code:this.code,input:this.input,format:this.format,token:this.token,position:this.position,expected:this.expected,actual:this.actual,reason:this.reason}}};/* c8 ignore start @preserve -- InvalidTimeError is part of the public
-   error-class surface (exported from index.ts, code 'INVALID_TIME')
-   but nothing in this package constructs one. Investigated wiring it
-   in the same way InvalidTimeZoneError was just wired (see parse.ts's
-   zzz-validation loop): checked whether hour/minute/second have a
-   post-match semantic range check the way zone ids do. They don't —
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/relativeTime.ts
+var relativeTime_exports = {};
+__export(relativeTime_exports, {
+  formatRelative: () => formatRelative,
+  formatRelativeToNow: () => formatRelativeToNow
+});
+module.exports = __toCommonJS(relativeTime_exports);
+
+// src/calendarUtils.ts
+function asDateFieldView(value) {
+  if (typeof value !== "object" || value === null) {
+    throw new Error(`temporal-fmt: expected a date-carrying Temporal value, got ${String(value)}.`);
+  }
+  const v = value;
+  const out = {};
+  if (typeof v.year === "number") out.year = v.year;
+  if (typeof v.month === "number") out.month = v.month;
+  if (typeof v.day === "number") out.day = v.day;
+  if (typeof v.hour === "number") out.hour = v.hour;
+  if (typeof v.minute === "number") out.minute = v.minute;
+  if (typeof v.second === "number") out.second = v.second;
+  if (typeof v.millisecond === "number") out.millisecond = v.millisecond;
+  if (typeof v.dayOfWeek === "number") out.dayOfWeek = v.dayOfWeek;
+  if (typeof v.calendarId === "string") out.calendarId = v.calendarId;
+  if (out.year === void 0 || out.month === void 0 || out.day === void 0) {
+    throw new Error(
+      `temporal-fmt: value is missing year/month/day fields \u2014 pass a Temporal.PlainDate / PlainDateTime / ZonedDateTime.`
+    );
+  }
+  return out;
+}
+
+// src/arithmetic.ts
+function asDateTime(value) {
+  return asDateFieldView(value);
+}
+function difference(a, b, unit) {
+  const av = asDateTime(a);
+  const bv = asDateTime(b);
+  if (unit === "years") {
+    return bv.year - av.year;
+  }
+  if (unit === "months") {
+    return bv.year * 12 + bv.month - 1 - (av.year * 12 + av.month - 1);
+  }
+  if (unit === "weeks" || unit === "days") {
+    const aDays = toDayCount(av);
+    const bDays = toDayCount(bv);
+    const days = bDays - aDays;
+    return unit === "weeks" ? Math.trunc(days / 7) : days;
+  }
+  const MS_PER_HOUR = 36e5;
+  const MS_PER_MINUTE = 6e4;
+  const MS_PER_SECOND = 1e3;
+  const aMs = toTotalMs(av);
+  const bMs = toTotalMs(bv);
+  const diffMs = bMs - aMs;
+  switch (unit) {
+    case "hours":
+      return Math.trunc(diffMs / MS_PER_HOUR);
+    case "minutes":
+      return Math.trunc(diffMs / MS_PER_MINUTE);
+    case "seconds":
+      return Math.trunc(diffMs / MS_PER_SECOND);
+    case "milliseconds":
+      return diffMs;
+  }
+}
+function toDayCount(v) {
+  const y = v.year, m = v.month, d = v.day;
+  const y2 = m <= 2 ? y - 1 : y;
+  const era = Math.floor((y2 >= 0 ? y2 : y2 - 399) / 400);
+  const yoe = y2 - era * 400;
+  const m2 = m > 2 ? m - 3 : m + 9;
+  const doy = Math.floor((153 * m2 + 2) / 5) + d - 1;
+  const doe = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + doy;
+  return era * 146097 + doe - 719468;
+}
+function toTotalMs(v) {
+  const MS_PER_DAY = 864e5;
+  const MS_PER_HOUR = 36e5;
+  const MS_PER_MINUTE = 6e4;
+  const MS_PER_SECOND = 1e3;
+  return toDayCount(v) * MS_PER_DAY + (v.hour ?? 0) * MS_PER_HOUR + (v.minute ?? 0) * MS_PER_MINUTE + (v.second ?? 0) * MS_PER_SECOND + (v.millisecond ?? 0);
+}
+var differenceInDays = (a, b) => difference(a, b, "days");
+
+// src/temporalProvider.ts
+var onTemporalChanged = [];
+function subscribeToTemporalChanges(listener) {
+  onTemporalChanged.push(listener);
+}
+
+// src/errors.ts
+var TemporalFmtError = class extends Error {
+  code;
+  input;
+  format;
+  token;
+  position;
+  expected;
+  actual;
+  reason;
+  constructor(message, fields) {
+    super(message);
+    this.name = "TemporalFmtError";
+    this.code = fields.code;
+    this.input = fields.input;
+    this.format = fields.format;
+    this.token = fields.token;
+    this.position = fields.position;
+    this.expected = fields.expected;
+    this.actual = fields.actual;
+    this.reason = fields.reason;
+    const capture = Error.captureStackTrace;
+    if (typeof capture === "function") {
+      capture(this, this.constructor);
+    }
+  }
+  // lets callers just call err.toJSON() for logging. plain Error doesn't
+  // serialize its non-enumerable fields on its own, so this picks them
+  // up explicitly
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      input: this.input,
+      format: this.format,
+      token: this.token,
+      position: this.position,
+      expected: this.expected,
+      actual: this.actual,
+      reason: this.reason
+    };
+  }
+};
+/* c8 ignore start @preserve -- InvalidTimeError is part of the public
+   error-class surface (exported from index.ts, code 'INVALID_TIME') but
+   nothing in this package actually constructs one. went and checked
+   whether it could get wired in the same way InvalidTimeZoneError just
+   was (see parse.ts's zzz-validation loop) — does hour/minute/second have
+   a post-match semantic range check the way zone ids do? nope.
    pattern.ts's regex fragments for HH/H/hh/h/mm/m/ss/s already enforce
-   their valid ranges at the regex level (e.g. HH is '(?:[01]\d|2[0-3])',
-   which can't match "99" in the first place), so an out-of-range time
-   is rejected as a plain shape mismatch before any semantic check
-   could run. There's no live gap to hook this into without inventing a
-   redundant check purely to give this class a body. Left unconstructed
-   until the library actually has a real invalid-time case to report. *//* c8 ignore stop @preserve *//* c8 ignore start @preserve -- InvalidCalendarError is part of the
+   their valid ranges right at the regex level (e.g. HH is
+   '(?:[01]\d|2[0-3])', which literally can't match "99"), so an
+   out-of-range time just gets rejected as a plain shape mismatch before
+   any semantic check would even run. no live gap to hook this into
+   without inventing a redundant check purely to give this class a body.
+   leaving it unconstructed until the library actually hits a real
+   invalid-time case worth reporting */
+/* c8 ignore stop @preserve */
+/* c8 ignore start @preserve -- InvalidCalendarError is part of the
    public error-class surface (exported from index.ts, code
-   'INVALID_CALENDAR') but nothing in this package constructs one.
-   Checked for a wiring opportunity the same way InvalidTimeZoneError
-   got one: there's no user-supplied calendar identifier anywhere in
-   the library to validate against a supported list. resolveCalendar()
+   'INVALID_CALENDAR') but same story as InvalidTimeError above — nothing
+   in this package constructs one. checked for a wiring opportunity the
+   same way: there's no user-supplied calendar identifier anywhere in the
+   library that we'd validate against a supported list. resolveCalendar()
    in parse.ts derives the calendar entirely from Intl's own resolution
-   of the locale string — it's never handed an arbitrary "calendar"
-   value a caller could get wrong. There's no live input to reject.
-   Left unconstructed until the library actually accepts a calendar
-   parameter that could be invalid. *//* c8 ignore stop @preserve */var u=class extends p{constructor(e){let{message:t,...o}=e;super(t??`locale "${e.actual??""}" is not a valid BCP-47 tag${e.reason?`: ${e.reason}`:""}.`,{code:"INVALID_LOCALE",...o}),this.name="InvalidLocaleError"}};/* c8 ignore start @preserve -- unreachable from the current test suite,
-   see rationale above *//* c8 ignore stop @preserve */function D(n){return n.replace(/_/g,"-")}function E(n,e){let t=n<0,o=String(Math.abs(n)).padStart(e,"0");return t?"-"+o:o}E.fraction=function(e,t){let o=e.millisecond*1e6+(e.microsecond??0)*1e3+(e.nanosecond??0);return E(o,9).slice(0,t)};var S="en-US";var P;b(()=>{P=void 0});var m=new Map,N=100;function R(n,e){let t=`${n}|${e}`,o=m.get(t);if(o)return o;if(m.size>=N){let r=m.keys().next().value;r!==void 0&&m.delete(r)}try{o=new Intl.RelativeTimeFormat(D(n),{numeric:e})}catch(r){throw new u({actual:n,reason:r.message})}return m.set(t,o),o}function M(n,e,t={}){let o=t.locale??S,r=t.numeric??"auto",s=R(o,r),a=-T(n,e),i=Math.abs(a);return i===0?s.format(0,"day"):i<7?s.format(a,"day"):i<30?s.format(-Math.trunc(-a/7),"week"):i<365?s.format(-Math.trunc(-a/30),"month"):s.format(-Math.trunc(-a/365),"year")}function C(n,e={}){let t=new Date,o={year:t.getFullYear(),month:t.getMonth()+1,day:t.getDate()};return M(n,o,e)}0&&(module.exports={formatRelative,formatRelativeToNow});
+   of the locale string — it's never handed an arbitrary "calendar" value
+   a caller could actually get wrong. no live input to reject here.
+   leaving it unconstructed until the library accepts an actual calendar
+   parameter that could be invalid */
+/* c8 ignore stop @preserve */
+var InvalidLocaleError = class extends TemporalFmtError {
+  constructor(fields) {
+    const { message, ...rest } = fields;
+    super(
+      message ?? `locale "${fields.actual ?? ""}" is not a valid BCP-47 tag${fields.reason ? `: ${fields.reason}` : ""}.`,
+      { code: "INVALID_LOCALE", ...rest }
+    );
+    this.name = "InvalidLocaleError";
+  }
+};
+/* c8 ignore start @preserve -- unreachable from the current test suite,
+   see rationale above */
+/* c8 ignore stop @preserve */
+
+// src/localeVocab.ts
+function normalizeLocaleTag(locale) {
+  return locale.replace(/_/g, "-");
+}
+
+// src/tokens.ts
+function pad(n, len) {
+  const negative = n < 0;
+  const digits = String(Math.abs(n)).padStart(len, "0");
+  return negative ? "-" + digits : digits;
+}
+pad.fraction = function formatFraction(t, width) {
+  const nanoOfSecond = t.millisecond * 1e6 + (t.microsecond ?? 0) * 1e3 + (t.nanosecond ?? 0);
+  return pad(nanoOfSecond, 9).slice(0, width);
+};
+var DEFAULT_LOCALE = "en-US";
+var nativeSupport;
+subscribeToTemporalChanges(() => {
+  nativeSupport = void 0;
+});
+
+// src/relativeTime.ts
+var rtfCache = /* @__PURE__ */ new Map();
+var MAX_RTF_CACHE_SIZE = 100;
+function getRtf(locale, numeric) {
+  const key = `${locale}|${numeric}`;
+  let rtf = rtfCache.get(key);
+  if (rtf) return rtf;
+  if (rtfCache.size >= MAX_RTF_CACHE_SIZE) {
+    const oldestKey = rtfCache.keys().next().value;
+    if (oldestKey !== void 0) rtfCache.delete(oldestKey);
+  }
+  try {
+    rtf = new Intl.RelativeTimeFormat(normalizeLocaleTag(locale), { numeric });
+  } catch (err) {
+    throw new InvalidLocaleError({ actual: locale, reason: err.message });
+  }
+  rtfCache.set(key, rtf);
+  return rtf;
+}
+function formatRelative(date1, date2, options = {}) {
+  const locale = options.locale ?? DEFAULT_LOCALE;
+  const numeric = options.numeric ?? "auto";
+  const rtf = getRtf(locale, numeric);
+  const dayDiff = -differenceInDays(date1, date2);
+  const absDays = Math.abs(dayDiff);
+  if (absDays === 0) {
+    return rtf.format(0, "day");
+  }
+  if (absDays < 7) {
+    return rtf.format(dayDiff, "day");
+  }
+  if (absDays < 30) {
+    return rtf.format(-Math.trunc(-dayDiff / 7), "week");
+  }
+  if (absDays < 365) {
+    return rtf.format(-Math.trunc(-dayDiff / 30), "month");
+  }
+  return rtf.format(-Math.trunc(-dayDiff / 365), "year");
+}
+function formatRelativeToNow(date, options = {}) {
+  const now = /* @__PURE__ */ new Date();
+  const nowFields = {
+    year: now.getFullYear(),
+    month: now.getMonth() + 1,
+    day: now.getDate()
+  };
+  return formatRelative(date, nowFields, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatRelative,
+  formatRelativeToNow
+});
 //# sourceMappingURL=relativeTime.cjs.map