test/tz-utils.test.js (1)

11-14: Add DST-transition assertions to harden zone parsing and UTC arithmetic

Consider adding cases around DST edges (e.g., 2024-03-31 Europe/Berlin 02:00 missing hour; and 2024-10-27 repeated hour) to verify parseDateTimeInZone, parseWithOffset, and utcAdd behave as expected across transitions.

Also applies to: 16-20, 22-26

test/examples-snapshot.test.js (3)

32-34: Include stderr in failure message for easier debugging

Propagate stderr to the thrown error to make failures actionable.

-  if (result.status !== 0) {
-    throw new Error(`Script ${script} exited with code ${result.status}`);
-  }
+  if (result.status !== 0) {
+    throw new Error(`Script ${script} exited with code ${result.status}\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`);
+  }

---

17-18: Ensure snapshot directory exists before creating missing snapshots

Avoids EEXIST errors in fresh environments.

 const snapshotDir = path.join(__dirname, 'snapshots');
 
+// Ensure snapshot directory exists
+if (!fs.existsSync(snapshotDir)) {
+  fs.mkdirSync(snapshotDir, {recursive: true});
+}
@@
       } else {
         // If no snapshot exists, create it
         fs.writeFileSync(snapshotFile, output, 'utf8');
         this.skip();
       }

Also applies to: 55-58

---

39-43: Normalize lone CR as well

Some environments may emit stray '\r'. Consider handling both CRLF and CR.

 function normalizeNewlines(text) {
-  return text.replaceAll('\r\n', '\n');
+  return text.replaceAll('\r\n', '\n').replaceAll('\r', '\n');
 }

test/advanced.test.js (2)

253-266: Robust local-day span check; minor tweak to prefer toLocaleDateString

Current approach is fine. For clarity and to avoid slicing, prefer toLocaleDateString('sv-SE', {timeZone: zone}).

-const startLocalYMD = event.start.toLocaleString('sv-SE', {timeZone: zone}).slice(0, 10);
-const endLocalYMD = event.end.toLocaleString('sv-SE', {timeZone: zone}).slice(0, 10);
+const startLocalYMD = event.start.toLocaleDateString('sv-SE', {timeZone: zone});
+const endLocalYMD = event.end.toLocaleDateString('sv-SE', {timeZone: zone});

---

334-343: Apply same local-day span computation for recurrences

Same optional tweak as above; keeps formats consistent across tests.

-const startLocalYMD = rec.start.toLocaleString('sv-SE', {timeZone: zone2}).slice(0, 10);
-const endLocalYMD = rec.end.toLocaleString('sv-SE', {timeZone: zone2}).slice(0, 10);
+const startLocalYMD = rec.start.toLocaleDateString('sv-SE', {timeZone: zone2});
+const endLocalYMD = rec.end.toLocaleDateString('sv-SE', {timeZone: zone2});

examples/example-rrule-luxon.js (1)

101-107: Optional: make zone handling explicit for formatting

If you want stable outputs irrespective of process TZ, consider using the event’s tz metadata (if present) or a fixed zone when formatting:

• Use DateTime.fromJSDate(event.start, {zone: event.start.tz || 'Europe/Berlin'})
• Or pass zone: 'Europe/Berlin' into toLocaleString options

ical.js (1)

224-251: Scan all parameters for TZID, not only parameters[0]

Some events may place TZID after other params. Consider searching the entire parameters array for TZID=... before parsing.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

tz-utils.js (5)

102-126: Validate offset bounds (minutes < 60, ±14:00 max) in offsetLabelToMinutes.

Prevents accepting impossible offsets like +12:90 or +23:59 while aligning with IANA/ICS limits.

Apply:

   const [, sign, hoursPart, minutesPart] = match;
   const hours = Number(hoursPart);
   const minutes = minutesPart ? Number(minutesPart) : 0;
   if (Number.isNaN(hours) || Number.isNaN(minutes)) {
     return undefined;
   }
+  // Minutes must be < 60; IANA/ICS max absolute offset is 14:00
+  if (minutes >= 60) {
+    return undefined;
+  }
+  if (hours > 14 || (hours === 14 && minutes !== 0)) {
+    return undefined;
+  }
 
   const total = (hours * 60) + minutes;
   return sign === '-' ? -total : total;

---

297-307: Cache Intl.DateTimeFormat instances to avoid repeated construction in hot paths.

RRULE expansion and parsing can call this many times per zone; caching cuts CPU and allocations.

Apply:

-    const formatter = new Intl.DateTimeFormat('en-CA', {
-      timeZone: tzInfo.iana,
-      hour12: false,
-      year: 'numeric',
-      month: '2-digit',
-      day: '2-digit',
-      hour: '2-digit',
-      minute: '2-digit',
-      second: '2-digit',
-    });
+    const formatter = getFormatter(tzInfo.iana);

Add once (outside this range, e.g., near the top-level helpers):

// Simple per-zone formatter cache to reduce Intl constructor churn
const dtfCache = new Map();
function getFormatter(tz) {
  let f = dtfCache.get(tz);
  if (!f) {
    f = new Intl.DateTimeFormat('en-CA', {
      timeZone: tz,
      hour12: false,
      year: 'numeric',
      month: '2-digit',
      day: '2-digit',
      hour: '2-digit',
      minute: '2-digit',
      second: '2-digit',
    });
    dtfCache.set(tz, f);
  }
  return f;
}

Also applies to: 309-327

---

456-471: Defensive: return undefined for invalid zones and reuse cached formatter.

Avoids throwing if a bad zone leaks in, and reduces formatter churn in getLocalParts.

Apply:

-  const tz = resolveZone(zone);
+  const tz = resolveZone(zone);
+  if (!isValidIana(tz)) {
+    return undefined;
+  }
   // Initial guess: interpret local fields as if they were UTC
   const t = Date.UTC(fields.year, fields.month - 1, fields.day, fields.hour, fields.minute, fields.second);
 
   const getLocalParts = date => {
-    const df = new Intl.DateTimeFormat('en-CA', {
-      timeZone: tz,
-      hour12: false,
-      year: 'numeric',
-      month: '2-digit',
-      day: '2-digit',
-      hour: '2-digit',
-      minute: '2-digit',
-      second: '2-digit',
-    });
+    const df = getFormatter(tz);

Helper (if not already added in another change):

// See formatter cache helper in formatDateForRrule comment

---

408-418: Memoize isValidIana results to avoid repeated Intl throws.

This can be hit frequently via resolveTZID and guards; caching avoids costly exceptions.

Apply:

+const validIanaCache = new Map();
+
 function isValidIana(zone) {
   if (!zone) {
     return false;
   }
 
   try {
     // Rely on Intl throwing for invalid timeZone identifiers
     // This is more portable across Node builds than Temporal alone
-    const tz = resolveZone(zone);
-
-    new Intl.DateTimeFormat('en-US', {timeZone: tz}).format(new Date(0));
-    return true;
+    const tz = resolveZone(zone);
+    if (validIanaCache.has(tz)) {
+      return validIanaCache.get(tz);
+    }
+    new Intl.DateTimeFormat('en-US', { timeZone: tz }).format(new Date(0));
+    validIanaCache.set(tz, true);
+    return true;
   } catch {
-    return false;
+    validIanaCache.set(resolveZone(zone), false);
+    return false;
   }
 }

---

536-538: Preserve offset metadata on returned Date from parseWithOffset.

Attaching tz as a normalized offset string aligns with parseDateTimeInZone behavior and lets downstream code recover the source offset without serializing it.

Apply:

-  const utcMs = Date.UTC(year, month - 1, day, hour, minute, second) - (totalMinutes * 60_000);
-  return new Date(utcMs);
+  const utcMs = Date.UTC(year, month - 1, day, hour, minute, second) - (totalMinutes * 60_000);
+  return attachTz(new Date(utcMs), minutesToOffset(totalMinutes));

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

tz-utils.js (3)

96-101: Cap the DateTimeFormat cache to avoid unbounded growth.

In long‑lived processes parsing many zones, dtfCache can grow without bound. A tiny cap with simple eviction is enough.

Apply:

-// Simple per-zone formatter cache to reduce Intl constructor churn
-const dtfCache = new Map();
+// Simple per-zone formatter cache to reduce Intl constructor churn
+const dtfCache = new Map();
+const DTF_CACHE_MAX = 256;
@@
   if (!formatter) {
     formatter = new Intl.DateTimeFormat('en-CA', {
@@
     });
     dtfCache.set(tz, formatter);
+    if (dtfCache.size > DTF_CACHE_MAX) {
+      // Simple eviction: clear when exceeding cap. Good enough given limited zone count.
+      dtfCache.clear();
+    }
   }

Also applies to: 109-126

---

134-167: Accept zero-offset shorthands and Unicode minus in offset parsing.

Real-world feeds sometimes use “Z”, “UTC” alone, or the Unicode minus (−). Treat these as valid zero/negative offsets.

Apply:

 function offsetLabelToMinutes(offset) {
   if (!offset) {
     return undefined;
   }
 
-  const trimmed = String(offset)
+  const trimmed = String(offset)
     .trim()
     .replace(/^\(?(?:utc|gmt)\)?\s*/i, '')
     .replace(/\)$/, '')
     .trim();
-  const match = trimmed.match(/^([+-])(\d{1,2})(?::?(\d{2}))?$/);
+  // Accept bare "Z" or empty after UTC/GMT removal as zero offset
+  if (trimmed === '' || /^z$/i.test(trimmed)) {
+    return 0;
+  }
+  // Normalize Unicode minus (U+2212) to ASCII "-".
+  const normalized = trimmed.replace(/\u2212/g, '-');
+  const match = normalized.match(/^([+-])(\d{1,2})(?::?(\d{2}))?$/);
   if (!match) {
     return undefined;
   }
 
-  const [, sign, hoursPart, minutesPart] = match;
+  const [, sign, hoursPart, minutesPart] = match;

---

581-599: Validate amount in utcAdd.

Guard against non-finite amounts to avoid NaN propagation.

Apply:

   const factor = msPer[unit];
   if (!factor) {
     throw new Error('Unsupported unit: ' + unit);
   }
 
-  return new Date(date.getTime() + (amount * factor));
+  if (!Number.isFinite(amount)) {
+    throw new TypeError('Amount must be a finite number');
+  }
+  return new Date(date.getTime() + (amount * factor));

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

tz-utils.js (6)

314-321: Trim TZID early to avoid stray whitespace mismatches

Minor hardening: trim before quote‑stripping/mapping to avoid subtle exact‑key misses when labels include leading/trailing spaces.

-  tz = tz.replace(/^"(.*)"$/, '$1');
+  tz = String(tz).trim();
+  tz = tz.replace(/^"(.*)"$/, '$1');
   const original = tz;

---

442-448: Follow alias chains and guard against cycles in resolveZone

Current implementation handles only a single hop. Chained aliases (A→B→C) won’t resolve fully. Resolve until fixed point with a small cycle guard.

-function resolveZone(zone) {
-  if (!zone) {
-    return zone;
-  }
-
-  return aliasMap.get(zone) || zone;
-}
+function resolveZone(zone) {
+  if (!zone) return zone;
+  let z = String(zone);
+  const seen = new Set();
+  while (aliasMap.has(z) && !seen.has(z)) {
+    seen.add(z);
+    z = aliasMap.get(z);
+  }
+  return z;
+}

---

501-536: Accept input wall time “24:00:00” by normalizing to next-day 00:00:00

You already normalize Intl’s 24:00 output; do the same for input strings so DTSTART/RECURRENCE parsing tolerates valid RFC 5545 edge cases.

   if (!fields) {
     return undefined;
   }
 
+  // Normalize input 24:00:00 → next day 00:00:00 (RFC 5545 allowance)
+  if (fields.hour === 24 && fields.minute === 0 && fields.second === 0) {
+    const next = new Date(Date.UTC(fields.year, fields.month - 1, fields.day) + 24 * 60 * 60 * 1000);
+    fields.year = next.getUTCFullYear();
+    fields.month = next.getUTCMonth() + 1;
+    fields.day = next.getUTCDate();
+    fields.hour = 0;
+    // minute/second already 0
+  }

---

243-254: Optionally validate Y/M/D ranges to avoid silent rollovers

Date.UTC will normalize invalid dates (e.g., 2025‑02‑30 → 2025‑03‑02). If you want strictness similar to malformed offset handling, consider an opt‑in validation.

 function ymdhmsToUtcMs(parts = {}) {
   const {
     year,
     month,
     day,
     hour = 0,
     minute = 0,
     second = 0,
   } = parts;
 
-  return Date.UTC(year, month - 1, day, hour, minute, second);
+  const ms = Date.UTC(year, month - 1, day, hour, minute, second);
+  // Strict round‑trip check (kept cheap and local)
+  const d = new Date(ms);
+  if (d.getUTCFullYear() !== year || d.getUTCMonth() + 1 !== month || d.getUTCDate() !== day ||
+      d.getUTCHours() !== hour || d.getUTCMinutes() !== minute || d.getUTCSeconds() !== second) {
+    return NaN; // caller decides how to handle invalid parts
+  }
+  return ms;
 }

---

590-617: Preserving -00:00 vs +00:00 (if semantics matter)

Current normalization emits “+00:00” for both ±0. If the distinction (-00:00 = unknown offset) is important for consumers, preserve the original sign when totalMinutes === 0. Otherwise, ignore.

-  const normalizedOffset = minutesToOffset(totalMinutes);
+  const normalizedOffset =
+    totalMinutes === 0
+      ? (String(offset).includes('-') ? '-00:00' : '+00:00')
+      : minutesToOffset(totalMinutes);

---

653-671: Expose a lightweight cache reset for tests/long‑running processes

Useful for deterministic tests and bounded memory in daemons; keep it under test to avoid expanding public API.

 module.exports = {
   guessLocalZone,
   getZoneNames,
   findExactZoneMatch,
   isValidIana,
   parseDateTimeInZone,
   parseWithOffset,
   utcAdd,
   linkAlias,
   resolveTZID,
   formatDateForRrule,
   attachTz,
 };
 
 // Expose some internals for testing
 module.exports.__test__ = {
   normalizeMidnightParts,
+  _resetCaches() {
+    dtfCache.clear();
+    validIanaCache.clear();
+    aliasMap.clear();
+  },
 };

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro