temporal-fmt 0.9.2 → 0.9.4

package/dist/chunk-ACKKWH5Z.js

@@ -0,0 +1,578 @@
+import {
+  MAX_FORMAT_LENGTH
+} from "./chunk-YEUASGDK.js";
+import {
+  FormatSyntaxError,
+  InvalidDurationError,
+  InvalidLocaleError,
+  canonicalCacheKey,
+  normalizeLocaleTag
+} from "./chunk-EGUUO6LE.js";
+import {
+  asDateFieldView
+} from "./chunk-HXY2GUUM.js";
+
+// src/rounding.ts
+var MS_PER_UNIT = {
+  day: 864e5,
+  hour: 36e5,
+  minute: 6e4,
+  second: 1e3,
+  millisecond: 1
+};
+function applyMode(ms, mode, increment) {
+  const sign = ms < 0 ? -1 : 1;
+  const abs = Math.abs(ms);
+  const stepped = abs / increment;
+  let rounded;
+  switch (mode) {
+    case "nearest":
+      rounded = Math.round(stepped);
+      break;
+    case "floor":
+      rounded = Math.floor(stepped);
+      break;
+    case "ceil":
+      rounded = Math.ceil(stepped);
+      break;
+    case "trunc":
+      rounded = Math.trunc(stepped);
+      break;
+  }
+  return sign * rounded * increment;
+}
+function toMs(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;
+  const days = era * 146097 + doe - 719468;
+  return days * MS_PER_UNIT.day + (v.hour ?? 0) * MS_PER_UNIT.hour + (v.minute ?? 0) * MS_PER_UNIT.minute + (v.second ?? 0) * MS_PER_UNIT.second + (v.millisecond ?? 0);
+}
+function fromMs(ms, base) {
+  const MS_PER_DAY = MS_PER_UNIT.day;
+  const totalDays = Math.floor(ms / MS_PER_DAY);
+  let withinDay = ms - totalDays * MS_PER_DAY;
+  if (withinDay < 0) withinDay += MS_PER_DAY;
+  const hour = Math.floor(withinDay / MS_PER_UNIT.hour);
+  const minute = Math.floor(withinDay % MS_PER_UNIT.hour / MS_PER_UNIT.minute);
+  const second = Math.floor(withinDay % MS_PER_UNIT.minute / MS_PER_UNIT.second);
+  const millisecond = withinDay % MS_PER_UNIT.second;
+  const z = totalDays + 719468;
+  const era = Math.floor((z >= 0 ? z : z - 146096) / 146097);
+  const doe = z - era * 146097;
+  const yoe = Math.floor((doe - Math.floor(doe / 1460) + Math.floor(doe / 36524) - Math.floor(doe / 146096)) / 365);
+  const y2 = yoe + era * 400;
+  const doy = doe - (365 * yoe + Math.floor(yoe / 4) - Math.floor(yoe / 100));
+  const mp = Math.floor((5 * doy + 2) / 153);
+  const d = doy - Math.floor((153 * mp + 2) / 5) + 1;
+  const m = mp < 10 ? mp + 3 : mp - 9;
+  const year = m <= 2 ? y2 + 1 : y2;
+  return { ...base, year, month: m, day: d, hour, minute, second, millisecond };
+}
+function round(value, options) {
+  const base = asDateFieldView(value);
+  const mode = options.mode ?? "nearest";
+  const increment = (options.roundingIncrement ?? 1) * MS_PER_UNIT[options.unit];
+  if (increment <= 0) {
+    throw new Error(`temporal-fmt: round() requires a positive roundingIncrement (got ${options.roundingIncrement}).`);
+  }
+  const ms = toMs(base);
+  const rounded = applyMode(ms, mode, increment);
+  return fromMs(rounded, base);
+}
+function floor(value, unit, roundingIncrement = 1) {
+  return round(value, { unit, mode: "floor", roundingIncrement });
+}
+function ceil(value, unit, roundingIncrement = 1) {
+  return round(value, { unit, mode: "ceil", roundingIncrement });
+}
+function truncate(value, unit, roundingIncrement = 1) {
+  return round(value, { unit, mode: "trunc", roundingIncrement });
+}
+function fieldToNs(v, nsPer, field) {
+  if (Number.isInteger(v)) return BigInt(v) * nsPer;
+  const scaled = v * Number(nsPer);
+  if (Number.isSafeInteger(scaled)) return BigInt(scaled);
+  throw new InvalidDurationError({
+    reason: `field "${field}" (${v}) cannot be converted to nanoseconds exactly \u2014 the value is too large for a fractional unit; use smaller units`
+  });
+}
+var DURATION_UNIT_TO_NS = {
+  years: 0n,
+  // calendar-bound, can't convert without relativeTo
+  months: 0n,
+  // same
+  weeks: 0n,
+  // same
+  days: 86400n * 1000000000n,
+  hours: 3600n * 1000000000n,
+  minutes: 60n * 1000000000n,
+  seconds: 1000000000n,
+  milliseconds: 1000000n,
+  microseconds: 1000n,
+  nanoseconds: 1n
+};
+function isCalendarBound(unit) {
+  return unit === "years" || unit === "months" || unit === "weeks";
+}
+function roundDuration(duration, options) {
+  const mode = options.mode ?? "nearest";
+  const increment = BigInt(options.roundingIncrement ?? 1);
+  if (increment <= 0n) {
+    throw new Error(`temporal-fmt: roundDuration() requires a positive roundingIncrement (got ${options.roundingIncrement}).`);
+  }
+  if (isCalendarBound(options.unit)) {
+    throw new Error(
+      `temporal-fmt: roundDuration() to "${options.unit}" requires a Temporal.Duration with a relativeTo \u2014 this helper operates on plain field bags without calendar context. Use Temporal.Duration.prototype.round() directly.`
+    );
+  }
+  let totalNs = 0n;
+  for (const u of ["days", "hours", "minutes", "seconds", "milliseconds", "microseconds", "nanoseconds"]) {
+    const v = duration[u] ?? 0;
+    totalNs += fieldToNs(v, DURATION_UNIT_TO_NS[u], u);
+  }
+  const stepNs = increment * DURATION_UNIT_TO_NS[options.unit];
+  const sign = totalNs < 0n ? -1n : 1n;
+  const abs = totalNs < 0n ? -totalNs : totalNs;
+  const stepped = abs / stepNs;
+  const remainder = abs % stepNs;
+  let rounded;
+  switch (mode) {
+    case "nearest":
+      rounded = remainder * 2n >= stepNs ? stepped + 1n : stepped;
+      break;
+    case "floor":
+      rounded = stepped;
+      break;
+    case "ceil":
+      rounded = remainder > 0n ? stepped + 1n : stepped;
+      break;
+    case "trunc":
+      rounded = stepped;
+      break;
+  }
+  const newTotalNs = sign * rounded * stepNs;
+  const result = { ...duration };
+  let remaining = newTotalNs;
+  const unitsInOrder = ["days", "hours", "minutes", "seconds", "milliseconds", "microseconds", "nanoseconds"];
+  const startIdx = unitsInOrder.indexOf(options.unit);
+  for (let i = startIdx + 1; i < unitsInOrder.length; i++) {
+    result[unitsInOrder[i]] = 0;
+  }
+  for (let i = 0; i <= startIdx; i++) {
+    const u = unitsInOrder[i];
+    const unitNs = DURATION_UNIT_TO_NS[u];
+    if (unitNs === 0n) continue;
+    const count = remaining / unitNs;
+    remaining -= count * unitNs;
+    result[u] = Number(count);
+  }
+  return result;
+}
+
+// src/formatDuration.ts
+var DURATION_UNITS = {
+  y: { longSingular: "year", longPlural: "years", shortSingular: "yr", shortPlural: "yrs", field: "years", intlUnit: "year" },
+  o: { longSingular: "month", longPlural: "months", shortSingular: "mo", shortPlural: "mos", field: "months", intlUnit: "month" },
+  w: { longSingular: "week", longPlural: "weeks", shortSingular: "wk", shortPlural: "wks", field: "weeks", intlUnit: "week" },
+  d: { longSingular: "day", longPlural: "days", shortSingular: "d", shortPlural: "d", field: "days", intlUnit: "day" },
+  h: { longSingular: "hour", longPlural: "hours", shortSingular: "h", shortPlural: "h", field: "hours", intlUnit: "hour" },
+  m: { longSingular: "minute", longPlural: "minutes", shortSingular: "m", shortPlural: "m", field: "minutes", intlUnit: "minute" },
+  s: { longSingular: "second", longPlural: "seconds", shortSingular: "s", shortPlural: "s", field: "seconds", intlUnit: "second" },
+  S: { longSingular: "millisecond", longPlural: "milliseconds", shortSingular: "ms", shortPlural: "ms", field: "milliseconds", intlUnit: "millisecond" }
+};
+var DURATION_TOKEN_STRINGS = Object.keys(DURATION_UNITS).flatMap((single) => [single + single + single, single + single, single]).sort((a, b) => b.length - a.length);
+function tokenizeDuration(format) {
+  const pieces = [];
+  let i = 0;
+  while (i < format.length) {
+    const ch = format[i];
+    if (ch === "'") {
+      if (format[i + 1] === "'") {
+        appendLiteral(pieces, "'");
+        i += 2;
+        continue;
+      }
+      let j = i + 1;
+      let literal = "";
+      let closed = false;
+      while (j < format.length) {
+        if (format[j] === "'") {
+          if (format[j + 1] === "'") {
+            literal += "'";
+            j += 2;
+            continue;
+          }
+          closed = true;
+          j += 1;
+          break;
+        }
+        literal += format[j];
+        j += 1;
+      }
+      if (!closed) {
+        throw new Error(`temporal-fmt: unterminated quote in duration format string "${format}"`);
+      }
+      appendLiteral(pieces, literal);
+      i = j;
+      continue;
+    }
+    const match = DURATION_TOKEN_STRINGS.find((tok) => format.startsWith(tok, i));
+    if (match) {
+      const unit = match[0];
+      const form = match.length === 1 ? "numeric" : match.length === 2 ? "short" : "long";
+      pieces.push({ kind: "token", value: match, unit, form });
+      i += match.length;
+      continue;
+    }
+    appendLiteral(pieces, ch);
+    i += 1;
+  }
+  return pieces;
+}
+function appendLiteral(pieces, value) {
+  const last = pieces[pieces.length - 1];
+  if (last && last.kind === "literal") {
+    last.value += value;
+  } else {
+    pieces.push({ kind: "literal", value });
+  }
+}
+function readUnit(duration, field) {
+  const value = duration[field];
+  if (value === void 0 || value === null) return 0;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  const coerced = Number(value);
+  if (!Number.isFinite(coerced)) {
+    throw new Error(
+      `temporal-fmt: duration field "${field}" is not a finite number (got ${String(value)}).`
+    );
+  }
+  return coerced;
+}
+var unitFormatterCache = /* @__PURE__ */ new Map();
+var MAX_UNIT_FORMATTER_CACHE_SIZE = 200;
+function getUnitFormatter(locale, intlUnit, unitDisplay) {
+  const key = `${canonicalCacheKey(locale)}|${intlUnit}|${unitDisplay}`;
+  const cached = unitFormatterCache.get(key);
+  if (cached) return cached;
+  if (unitFormatterCache.size >= MAX_UNIT_FORMATTER_CACHE_SIZE) {
+    const oldestKey = unitFormatterCache.keys().next().value;
+    if (oldestKey !== void 0) unitFormatterCache.delete(oldestKey);
+  }
+  let formatter;
+  try {
+    formatter = new Intl.NumberFormat(normalizeLocaleTag(locale), {
+      style: "unit",
+      unit: intlUnit,
+      unitDisplay
+    });
+  } catch (err) {
+    throw new InvalidLocaleError({ actual: locale, reason: err.message });
+  }
+  unitFormatterCache.set(key, formatter);
+  return formatter;
+}
+function formatDuration(duration, formatStr, options = {}) {
+  return renderDurationPieces(duration, formatStr, options).map((p) => p.value).join("");
+}
+function renderDurationPieces(duration, formatStr, options = {}) {
+  if (formatStr.length > MAX_FORMAT_LENGTH) {
+    throw new Error(
+      `temporal-fmt: duration format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.length}).`
+    );
+  }
+  const showZeroes = options.showZeroValues === true;
+  const locale = options.locale;
+  const useIntl = locale !== void 0;
+  const pieces = tokenizeDuration(formatStr);
+  const out = [];
+  for (const piece of pieces) {
+    if (piece.kind === "literal") {
+      out.push({ kind: "literal", value: piece.value });
+      continue;
+    }
+    const unit = DURATION_UNITS[piece.unit];
+    if (!unit) {
+      throw new Error(`temporal-fmt: unknown duration token "${piece.value}"`);
+    }
+    const value = readUnit(duration, unit.field);
+    if (value === 0 && !showZeroes) {
+      out.push({ kind: "token", value: "", token: piece.value });
+      continue;
+    }
+    if (piece.form === "numeric") {
+      out.push({ kind: "token", value: String(value), token: piece.value });
+      continue;
+    }
+    if (useIntl) {
+      const unitDisplay = piece.form === "short" ? "short" : "long";
+      const formatter = getUnitFormatter(locale, unit.intlUnit, unitDisplay);
+      out.push({ kind: "token", value: formatter.format(value), token: piece.value });
+      continue;
+    }
+    if (piece.form === "short") {
+      out.push({ kind: "token", value: value + (value === 1 || value === -1 ? unit.shortSingular : unit.shortPlural), token: piece.value });
+    } else {
+      out.push({ kind: "token", value: value + " " + (value === 1 || value === -1 ? unit.longSingular : unit.longPlural), token: piece.value });
+    }
+  }
+  return out;
+}
+
+// src/duration.ts
+function formatDurationToParts(duration, formatStr, options = {}) {
+  return renderDurationPieces(duration, formatStr, options).map(
+    (p) => p.kind === "token" ? { type: "token", value: p.value, token: p.token } : { type: "literal", value: p.value }
+  );
+}
+function parseISODuration(input) {
+  const re = /^P(?:(?:(\d+(?:\.\d+)?)Y)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)W)?(?:(\d+(?:\.\d+)?)D)?)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
+  const m = re.exec(input);
+  if (!m) {
+    throw new InvalidDurationError({ input, reason: "does not match ISO 8601 duration grammar (P[n]Y[n]M[n]W[n]DT[n]H[n]M[n]S)" });
+  }
+  if (m.slice(1).every((g) => g === void 0)) {
+    throw new InvalidDurationError({ input, reason: 'duration has no fields (use "P0D" for zero duration)' });
+  }
+  const toNum = (s) => s === void 0 ? 0 : Number(s);
+  return {
+    years: toNum(m[1]),
+    months: toNum(m[2]),
+    weeks: toNum(m[3]),
+    days: toNum(m[4]),
+    hours: toNum(m[5]),
+    minutes: toNum(m[6]),
+    seconds: toNum(m[7])
+  };
+}
+function formatISODuration(duration) {
+  const parts = ["P"];
+  const years = duration.years ?? 0;
+  const months = duration.months ?? 0;
+  const weeks = duration.weeks ?? 0;
+  const days = duration.days ?? 0;
+  const hours = duration.hours ?? 0;
+  const minutes = duration.minutes ?? 0;
+  const seconds = duration.seconds ?? 0;
+  if (years) parts.push(`${years}Y`);
+  if (months) parts.push(`${months}M`);
+  if (weeks) parts.push(`${weeks}W`);
+  if (days) parts.push(`${days}D`);
+  if (hours || minutes || seconds) {
+    parts.push("T");
+    if (hours) parts.push(`${hours}H`);
+    if (minutes) parts.push(`${minutes}M`);
+    if (seconds) parts.push(`${seconds}S`);
+  }
+  if (parts.length === 1) parts.push("0D");
+  return parts.join("");
+}
+function tokenizeDurationFormat(formatStr) {
+  const DURATION_TOKEN_STRINGS2 = ["y", "o", "w", "d", "h", "m", "s", "S"].flatMap((single) => [single + single + single, single + single, single]).sort((a, b) => b.length - a.length);
+  const pieces = [];
+  let i = 0;
+  while (i < formatStr.length) {
+    const ch = formatStr[i];
+    if (ch === "'") {
+      if (formatStr[i + 1] === "'") {
+        appendLiteral2(pieces, "'");
+        i += 2;
+        continue;
+      }
+      let j = i + 1;
+      let literal = "";
+      let closed = false;
+      while (j < formatStr.length) {
+        if (formatStr[j] === "'") {
+          if (formatStr[j + 1] === "'") {
+            literal += "'";
+            j += 2;
+            continue;
+          }
+          closed = true;
+          j += 1;
+          break;
+        }
+        literal += formatStr[j];
+        j += 1;
+      }
+      if (!closed) throw new FormatSyntaxError({ format: formatStr, reason: "unterminated quote" });
+      appendLiteral2(pieces, literal);
+      i = j;
+      continue;
+    }
+    const match = DURATION_TOKEN_STRINGS2.find((tok) => formatStr.startsWith(tok, i));
+    if (match) {
+      pieces.push({ kind: "token", value: match, unit: match[0] });
+      i += match.length;
+      continue;
+    }
+    appendLiteral2(pieces, ch);
+    i += 1;
+  }
+  return pieces;
+}
+function appendLiteral2(pieces, value) {
+  const last = pieces[pieces.length - 1];
+  if (last && last.kind === "literal") {
+    last.value += value;
+  } else {
+    pieces.push({ kind: "literal", value });
+  }
+}
+function parseDuration(input, formatStr, options = {}) {
+  const tokens = tokenizeDurationFormat(formatStr);
+  const fields = {};
+  const groupSpecs = [];
+  let regex = "";
+  for (const tok of tokens) {
+    if (tok.kind === "literal") {
+      regex += tok.value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    } else {
+      const unit = tok.unit;
+      const form = tok.value.length === 1 ? "numeric" : tok.value.length === 2 ? "short" : "long";
+      /* c8 ignore start @preserve -- the final `: null` branch, and the
+         `if (key === null)` throw it feeds, are both unreachable: tok.unit
+         is always one of the 8 letters in DURATION_TOKEN_STRINGS (the same
+         source set this ternary checks against), so `null` can't be
+         produced by any token the tokenizer emits. Kept as a guard against
+         a future letter being added to one set without the other. */
+      const key = unit === "y" ? "years" : unit === "o" ? "months" : unit === "w" ? "weeks" : unit === "d" ? "days" : unit === "h" ? "hours" : unit === "m" ? "minutes" : unit === "s" ? "seconds" : unit === "S" ? "milliseconds" : null;
+      if (key === null) {
+        throw new FormatSyntaxError({ format: formatStr, token: tok.value, reason: "unknown duration token" });
+      }
+      /* c8 ignore stop @preserve */
+      if (form === "numeric") {
+        regex += "(-?\\d+)";
+      } else {
+        regex += "(\\d+)\\s*\\w*";
+      }
+      groupSpecs.push({ unit: key, form });
+    }
+  }
+  const re = new RegExp(`^${regex}$`, "u");
+  const m = re.exec(input);
+  if (!m) {
+    throw new FormatSyntaxError({ input, format: formatStr, reason: "does not match duration format" });
+  }
+  groupSpecs.forEach((spec, i) => {
+    const raw = m[i + 1];
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+      throw new InvalidDurationError({ input, reason: `token for ${spec.unit} matched "${raw}" but isn't a finite number` });
+    }
+    fields[spec.unit] = value;
+  });
+  return fields;
+}
+function balanceDuration(duration) {
+  const NS_PER = [
+    ["days", 86400n * 1000000000n],
+    ["hours", 3600n * 1000000000n],
+    ["minutes", 60n * 1000000000n],
+    ["seconds", 1000000000n],
+    ["milliseconds", 1000000n],
+    ["microseconds", 1000n],
+    ["nanoseconds", 1n]
+  ];
+  let totalNs = 0n;
+  for (const [k, nsPer] of NS_PER) {
+    const v = duration[k];
+    if (typeof v === "number") totalNs += fieldToNs(v, nsPer, k);
+  }
+  const result = { ...duration };
+  let remaining = totalNs;
+  for (const [k, nsPer] of NS_PER) {
+    const count = remaining / nsPer;
+    remaining -= count * nsPer;
+    result[k] = Number(count);
+  }
+  return result;
+}
+function totalDuration(duration, unit) {
+  const NS_PER = {
+    days: 86400n * 1000000000n,
+    hours: 3600n * 1000000000n,
+    minutes: 60n * 1000000000n,
+    seconds: 1000000000n,
+    milliseconds: 1000000n,
+    microseconds: 1000n,
+    nanoseconds: 1n
+  };
+  let totalNs = 0n;
+  for (const k of Object.keys(NS_PER)) {
+    const v = duration[k];
+    if (typeof v === "number") totalNs += fieldToNs(v, NS_PER[k], k);
+  }
+  const divisor = NS_PER[unit];
+  if (!divisor) {
+    throw new InvalidDurationError({ reason: `totalDuration() does not support unit "${unit}" (calendar-bound units need a relativeTo)` });
+  }
+  return Number(totalNs) / Number(divisor);
+}
+function compareDuration(a, b) {
+  const aNs = totalDurationNs(a);
+  const bNs = totalDurationNs(b);
+  if (aNs < bNs) return -1;
+  if (aNs > bNs) return 1;
+  return 0;
+}
+function totalDurationNs(d) {
+  const NS_PER = {
+    days: 86400n * 1000000000n,
+    hours: 3600n * 1000000000n,
+    minutes: 60n * 1000000000n,
+    seconds: 1000000000n,
+    milliseconds: 1000000n,
+    microseconds: 1000n,
+    nanoseconds: 1n
+  };
+  let total = 0n;
+  for (const k of Object.keys(NS_PER)) {
+    const v = d[k];
+    if (typeof v === "number") total += fieldToNs(v, NS_PER[k], k);
+  }
+  return total;
+}
+function addDuration(a, b) {
+  const keys = ["years", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds", "microseconds", "nanoseconds"];
+  const result = {};
+  for (const k of keys) {
+    result[k] = (a[k] ?? 0) + (b[k] ?? 0);
+  }
+  return result;
+}
+function subtractDuration(a, b) {
+  return addDuration(a, negateDuration(b));
+}
+function negateDuration(d) {
+  const result = {};
+  for (const k of Object.keys(d)) {
+    result[k] = -(d[k] ?? 0);
+  }
+  return result;
+}
+
+export {
+  round,
+  floor,
+  ceil,
+  truncate,
+  roundDuration,
+  formatDuration,
+  formatDurationToParts,
+  parseISODuration,
+  formatISODuration,
+  parseDuration,
+  balanceDuration,
+  totalDuration,
+  compareDuration,
+  addDuration,
+  subtractDuration
+};
+//# sourceMappingURL=chunk-ACKKWH5Z.js.map