temporal-fmt 0.9.80 → 0.9.82

package/dist/format.js

@@ -4,13 +4,13 @@ import {
   compileFormat,
   format,
   formatToParts
-} from "./chunk-HGRT37LT.js";
-import "./chunk-DMJWJTFY.js";
-import "./chunk-Z245NHDT.js";
-import "./chunk-DFWTCRS3.js";
+} from "./chunk-KWOTFJNY.js";
+import "./chunk-AF3LHBDQ.js";
+import "./chunk-4JMHI6E2.js";
+import "./chunk-JCJW2VOV.js";
 import "./chunk-SOPTTXUI.js";
-import "./chunk-QRLQ7RR7.js";
 import "./chunk-BLZDBPSV.js";
+import "./chunk-QRLQ7RR7.js";
 export {
   _getPieces,
   _handlerFor,

package/dist/index.cjs

@@ -167,8 +167,18 @@ __export(index_exports, {
   isWeekend: () => isWeekend,
   isYesterday: () => isYesterday,
   isZonedDateTime: () => isZonedDateTime,
+  legacyCompileFormat: () => compileFormat2,
+  legacyCompileParser: () => compileParser2,
+  legacyFormat: () => format2,
+  legacyFormatToParts: () => formatToParts2,
+  legacyMatchesFormat: () => matchesFormat,
+  legacyParse: () => parse2,
+  legacyParseToParts: () => parseToParts2,
+  legacySafeParse: () => safeParse2,
+  legacyTryParse: () => tryParse2,
   listRegisteredGrammars: () => listRegisteredGrammars,
   listTokens: () => listTokens,
+  matchesFormat: () => matchesFormat,
   max: () => max,
   mergeIntervals: () => mergeIntervals,
   mergeWithConfig: () => mergeWithConfig,
@@ -236,17 +246,20 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/temporalProvider.ts
-var injectedTemporal;
-var onTemporalChanged = [];
+var TEMPORAL_PROVIDER_STATE = /* @__PURE__ */ Symbol.for("temporal-fmt.temporal-provider");
+var globalState = globalThis;
+var providerState = globalState[TEMPORAL_PROVIDER_STATE] ??= {
+  onTemporalChanged: []
+};
 function subscribeToTemporalChanges(listener) {
-  onTemporalChanged.push(listener);
+  providerState.onTemporalChanged.push(listener);
 }
 function setTemporal(temporal) {
-  injectedTemporal = temporal;
-  for (const listener of onTemporalChanged) listener();
+  providerState.injectedTemporal = temporal;
+  for (const listener of providerState.onTemporalChanged) listener();
 }
 function resolveTemporal() {
-  return injectedTemporal ?? globalThis.Temporal;
+  return providerState.injectedTemporal ?? globalThis.Temporal;
 }
 function getTemporal() {
   const temporal = resolveTemporal();
@@ -1075,13 +1088,13 @@ var TOKENS = [
 
 // src/tokenize.ts
 var SORTED_TOKEN_STRINGS = TOKENS.map(([tok]) => tok).sort((a, b) => b.length - a.length);
-function tokenizeWithSpans(format2) {
+function tokenizeWithSpans(format3) {
   const pieces = [];
   let i = 0;
-  while (i < format2.length) {
-    const ch = format2[i];
+  while (i < format3.length) {
+    const ch = format3[i];
     if (ch === "'") {
-      if (format2[i + 1] === "'") {
+      if (format3[i + 1] === "'") {
         appendLiteral(pieces, "'", i, i + 2);
         i += 2;
         continue;
@@ -1089,9 +1102,9 @@ function tokenizeWithSpans(format2) {
       let j = i + 1;
       let literal = "";
       let closed = false;
-      while (j < format2.length) {
-        if (format2[j] === "'") {
-          if (format2[j + 1] === "'") {
+      while (j < format3.length) {
+        if (format3[j] === "'") {
+          if (format3[j + 1] === "'") {
             literal += "'";
             j += 2;
             continue;
@@ -1100,29 +1113,29 @@ function tokenizeWithSpans(format2) {
           j += 1;
           break;
         }
-        literal += format2[j];
+        literal += format3[j];
         j += 1;
       }
       if (!closed) {
         throw new FormatSyntaxError({
-          format: format2,
-          message: `temporal-fmt: unterminated quote in format string "${format2}"`
+          format: format3,
+          message: `temporal-fmt: unterminated quote in format string "${format3}"`
         });
       }
       appendLiteral(pieces, literal, i, j);
       i = j;
       continue;
     }
-    const match = SORTED_TOKEN_STRINGS.find((tok) => format2.startsWith(tok, i));
+    const match = SORTED_TOKEN_STRINGS.find((tok) => format3.startsWith(tok, i));
     if (match) {
       const runChar = match[match.length - 1];
-      if (format2[i + match.length] === runChar) {
+      if (format3[i + match.length] === runChar) {
         let end = i + match.length;
-        while (format2[end] === runChar) end += 1;
+        while (format3[end] === runChar) end += 1;
         throw new UnknownTokenError({
-          format: format2,
-          token: format2.slice(i, end),
-          message: `temporal-fmt: "${format2.slice(i, end)}" in format string "${format2}" isn't a recognized token \u2014 did you mean "${match}"?`
+          format: format3,
+          token: format3.slice(i, end),
+          message: `temporal-fmt: "${format3.slice(i, end)}" in format string "${format3}" isn't a recognized token \u2014 did you mean "${match}"?`
         });
       }
       pieces.push({ kind: "token", value: match, start: i, end: i + match.length });
@@ -1134,8 +1147,8 @@ function tokenizeWithSpans(format2) {
   }
   return pieces;
 }
-function tokenize(format2) {
-  return tokenizeWithSpans(format2).map(({ kind, value }) => ({ kind, value }));
+function tokenize(format3) {
+  return tokenizeWithSpans(format3).map(({ kind, value }) => ({ kind, value }));
 }
 function appendLiteral(pieces, value, start, end) {
   const last = pieces[pieces.length - 1];
@@ -2366,6 +2379,96 @@ function compileParser(formatStr, options = {}) {
   };
 }
 
+// src/legacy/matchesFormat.ts
+var patternCache2 = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE3 = 500;
+function getPattern2(formatStr, locale) {
+  const key = locale + "\0" + formatStr;
+  const cached = patternCache2.get(key);
+  if (cached) return cached;
+  if (patternCache2.size >= MAX_CACHE_SIZE3) {
+    const oldestKey = patternCache2.keys().next().value;
+    if (oldestKey !== void 0) patternCache2.delete(oldestKey);
+  }
+  const pattern = buildCapturingPattern(tokenize(formatStr), locale);
+  patternCache2.set(key, pattern);
+  return pattern;
+}
+function matchesFormat(formatStr, input, options = {}) {
+  try {
+    if (formatStr.length > MAX_FORMAT_LENGTH) {
+      throw new Error(
+        `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.length}).`
+      );
+    }
+    const locale = options.locale ?? DEFAULT_LOCALE;
+    const pattern = getPattern2(formatStr, locale);
+    const match = pattern.regex.exec(input);
+    if (!match) return false;
+    for (const run of pattern.ambiguousRuns) {
+      const range = match.indices?.groups?.[run.groupName];
+      if (!range || enumerateValidSplits(input.slice(range[0], range[1]), run.tokens).length === 0) {
+        return false;
+      }
+    }
+    return true;
+  } catch (error) {
+    if (error instanceof TemporalFmtError) throw new Error(error.message);
+    throw error;
+  }
+}
+
+// src/legacy/index.ts
+function withLegacyErrors(operation) {
+  try {
+    return operation();
+  } catch (error) {
+    if (error instanceof TemporalFmtError) {
+      throw new Error(error.message);
+    }
+    throw error;
+  }
+}
+function toLegacySafeParseResult(result) {
+  return result.ok ? result : { ok: false, error: new Error(result.error.message) };
+}
+function format2(temporal, formatStr, options = {}) {
+  return withLegacyErrors(() => format(temporal, formatStr, options));
+}
+function formatToParts2(temporal, formatStr, options = {}) {
+  return withLegacyErrors(() => formatToParts(temporal, formatStr, options));
+}
+function compileFormat2(formatStr) {
+  const compiled = withLegacyErrors(() => compileFormat(formatStr));
+  return {
+    ...compiled,
+    format: (temporal, options) => withLegacyErrors(() => compiled.format(temporal, options)),
+    formatToParts: (temporal, options) => withLegacyErrors(() => compiled.formatToParts(temporal, options))
+  };
+}
+function parse2(formatStr, input, options = {}) {
+  return withLegacyErrors(() => parse(formatStr, input, options));
+}
+function safeParse2(formatStr, input, options = {}) {
+  return toLegacySafeParseResult(safeParse(formatStr, input, options));
+}
+function tryParse2(formatStr, input, options = {}) {
+  return tryParse(formatStr, input, options);
+}
+function parseToParts2(formatStr, input, options = {}) {
+  return withLegacyErrors(() => parseToParts(formatStr, input, options));
+}
+function compileParser2(formatStr, options = {}) {
+  const compiled = withLegacyErrors(() => compileParser(formatStr, options));
+  return {
+    ...compiled,
+    parse: (input, callOptions) => withLegacyErrors(() => compiled.parse(input, callOptions)),
+    safeParse: (input, callOptions) => toLegacySafeParseResult(compiled.safeParse(input, callOptions)),
+    tryParse: (input, callOptions) => compiled.tryParse(input, callOptions),
+    parseToParts: (input, callOptions) => withLegacyErrors(() => compiled.parseToParts(input, callOptions))
+  };
+}
+
 // src/formatDuration.ts
 var DURATION_UNITS = {
   y: { longSingular: "year", longPlural: "years", shortSingular: "yr", shortPlural: "yrs", field: "years", intlUnit: "year" },
@@ -2378,13 +2481,13 @@ var DURATION_UNITS = {
   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(format2) {
+function tokenizeDuration(format3) {
   const pieces = [];
   let i = 0;
-  while (i < format2.length) {
-    const ch = format2[i];
+  while (i < format3.length) {
+    const ch = format3[i];
     if (ch === "'") {
-      if (format2[i + 1] === "'") {
+      if (format3[i + 1] === "'") {
         appendLiteral2(pieces, "'");
         i += 2;
         continue;
@@ -2392,9 +2495,9 @@ function tokenizeDuration(format2) {
       let j = i + 1;
       let literal = "";
       let closed = false;
-      while (j < format2.length) {
-        if (format2[j] === "'") {
-          if (format2[j + 1] === "'") {
+      while (j < format3.length) {
+        if (format3[j] === "'") {
+          if (format3[j + 1] === "'") {
             literal += "'";
             j += 2;
             continue;
@@ -2403,17 +2506,17 @@ function tokenizeDuration(format2) {
           j += 1;
           break;
         }
-        literal += format2[j];
+        literal += format3[j];
         j += 1;
       }
       if (!closed) {
-        throw new Error(`temporal-fmt: unterminated quote in duration format string "${format2}"`);
+        throw new Error(`temporal-fmt: unterminated quote in duration format string "${format3}"`);
       }
       appendLiteral2(pieces, literal);
       i = j;
       continue;
     }
-    const match = DURATION_TOKEN_STRINGS.find((tok) => format2.startsWith(tok, i));
+    const match = DURATION_TOKEN_STRINGS.find((tok) => format3.startsWith(tok, i));
     if (match) {
       const unit = match[0];
       const form = match.length === 1 ? "numeric" : match.length === 2 ? "short" : "long";
@@ -7222,8 +7325,18 @@ function translateDateFnsFormatString(formatStr) {
   isWeekend,
   isYesterday,
   isZonedDateTime,
+  legacyCompileFormat,
+  legacyCompileParser,
+  legacyFormat,
+  legacyFormatToParts,
+  legacyMatchesFormat,
+  legacyParse,
+  legacyParseToParts,
+  legacySafeParse,
+  legacyTryParse,
   listRegisteredGrammars,
   listTokens,
+  matchesFormat,
   max,
   mergeIntervals,
   mergeWithConfig,