We need to talk about how we handle time in JavaScript. For over a decade, we’ve relied on Moment.js to patch the holes in the native Date object. But for some reason, the standard advice in many circles is still to pull in a 300KB library just to format a timestamp. It’s killing performance, and frankly, it’s unnecessary now that the JS Temporal API has reached Stage 4.
I’ve lost count of how many WordPress projects I’ve inherited where the bundle size was bloated by “moment-timezone” just because the original dev didn’t want to deal with the Date object’s mess. But Moment is in maintenance mode, and its mutable nature has caused more race conditions in my checkout scripts than I care to admit. The future is native, and it’s called Temporal.
What Is the JS Temporal API?
The JS Temporal API is a new, modern time and date API built directly into the ECMAScript standard. It’s designed to be a full replacement for the legacy Date object, solving its most frustrating limitations—like zero-indexed months (where January is 0) and the lack of native time zone support. Most importantly, everything in Temporal is immutable. If you add three days to a date, you get a new object; you don’t accidentally mutate the original and break your entire UI.
As of 2026, it’s already shipped in Chrome 144+ and Firefox 139+. While Safari is catching up, the official polyfill is significantly lighter than Moment.js. If you’re serious about WordPress performance, moving to a native solution should be your top priority.
Creating and Parsing: The Clean Way
In Moment, creating a UTC timestamp often looked simple until you realized you’d mutated your local object. With the JS Temporal API, you have specific types for specific needs: Instant for UTC, ZonedDateTime for localized time, and PlainDate for things like birthdays where time zones don’t matter.
// The old way (Moment)
const oldNow = moment();
const inUTC = oldNow.utc(); // Careful! oldNow is now in UTC mode too.
// The modern way (Temporal)
const now = Temporal.Now.instant();
console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// Parsing an ISO string
const eventDate = Temporal.PlainDate.from('2026-03-25');
console.log(eventDate.month); // 3 (March is 3, finally!)Date Arithmetic Without the “Gotchas”
One of the biggest war stories I have involves a subscription plugin that charged users twice because a .add(1, 'month') call mutated a shared date object in a loop. Temporal objects are immutable by design, preventing these kinds of logic errors entirely.
const start = Temporal.Now.plainDateTimeISO();
const nextWeek = start.add({ days: 7 });
// 'start' remains exactly what it was. No side effects.
console.log(start.toLocaleString());
console.log(nextWeek.toLocaleString());Calculating the difference between dates is also much more robust. Instead of getting a raw number of milliseconds and doing the math yourself, Temporal returns a Duration object.
const d1 = Temporal.PlainDate.from('2026-01-01');
const d2 = Temporal.PlainDate.from('2026-02-01');
const diff = d2.since(d1);
console.log(diff.days); // 31Formatting with Intl Integration
Moment required specific tokens like 'MM/DD/YYYY'. The JS Temporal API leverages the built-in Intl.DateTimeFormat API. This means your dates automatically respect the user’s locale without you having to ship dozens of localization files in your JavaScript bundle. This is a huge win for reducing JavaScript bloat.
const date = Temporal.Now.instant();
// Locale-aware formatting out of the box
console.log(date.toLocaleString('en-GB', { month: 'long', day: 'numeric' }));
// "19 February"Real-World Refactor: Handling Time Zones
Suppose you’re building a WooCommerce extension that displays delivery windows in different time zones. In the past, you’d need moment-timezone. Here is how you’d handle that conversion natively with the Temporal API.
function getLocalDeliveryTime(isoString, timeZone) {
const instant = Temporal.Instant.from(isoString);
const zoned = instant.toZonedDateTimeISO(timeZone);
return zoned.toLocaleString(undefined, {
timeZoneName: 'short',
hour: 'numeric',
minute: '2-digit'
});
}
// Example: Mar 5, 2026, 3:00 PM EST converted to London time
const londonTime = getLocalDeliveryTime('2026-03-05T15:00-05:00', 'Europe/London');
console.log(londonTime); // "8:00 PM GMT"Look, if this JS Temporal API stuff is eating up your dev hours, let me handle it. I’ve been wrestling with WordPress since the 4.x days.
The Takeaway: Stop Paying the “Moment Tax”
Moment.js was great for its time, but it belongs to a different era of the web—an era where the browser was weak and our bundles were small. Today, the performance cost of shipping legacy libraries is too high. The JS Temporal API gives us everything we loved about Moment (and more) without the 1MB overhead. Start using the polyfill today, and when your target browsers are ready, just delete the import. Your users’ lighthouse scores will thank you.
