@webority-technologies/mobile-core 0.0.4 → 0.0.6

package/lib/commonjs/formatters/dateMath.js

@@ -0,0 +1,310 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startOfDay = exports.isSameDay = exports.isDateBefore = exports.isDateAfter = exports.formatTimeInZone = exports.formatTimeInWindowsZone = exports.formatTime12h = exports.formatDatePattern = exports.formatDateISO = exports.formatDateDDMMMYYYY = exports.diffMs = exports.addDays = void 0;
+var _windowsIana = require("windows-iana");
+const toDate = value => {
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? null : value;
+  }
+  const d = new Date(value);
+  return Number.isNaN(d.getTime()) ? null : d;
+};
+const PAD = n => n < 10 ? `0${n}` : `${n}`;
+
+/**
+ * Whether two values fall on the same calendar day in the device's local
+ * timezone. Invalid input on either side returns false rather than throwing.
+ */
+const isSameDay = (a, b) => {
+  const da = toDate(a);
+  const db = toDate(b);
+  if (!da || !db) {
+    return false;
+  }
+  return da.getFullYear() === db.getFullYear() && da.getMonth() === db.getMonth() && da.getDate() === db.getDate();
+};
+
+/** `a` is strictly before `b`. Invalid input on either side returns false. */
+exports.isSameDay = isSameDay;
+const isDateBefore = (a, b) => {
+  const da = toDate(a);
+  const db = toDate(b);
+  return da !== null && db !== null && da.getTime() < db.getTime();
+};
+
+/** `a` is strictly after `b`. Invalid input on either side returns false. */
+exports.isDateBefore = isDateBefore;
+const isDateAfter = (a, b) => {
+  const da = toDate(a);
+  const db = toDate(b);
+  return da !== null && db !== null && da.getTime() > db.getTime();
+};
+
+/**
+ * `a - b` in milliseconds, matching dayjs's `a.diff(b)` sign convention
+ * (positive when `a` is later than `b`). Returns `NaN` if either side fails
+ * to parse, the same way subtracting two invalid dayjs objects would.
+ */
+exports.isDateAfter = isDateAfter;
+const diffMs = (a, b) => {
+  const da = toDate(a);
+  const db = toDate(b);
+  if (!da || !db) {
+    return Number.NaN;
+  }
+  return da.getTime() - db.getTime();
+};
+
+/**
+ * Midnight of the given date, in the device's local timezone. Returns null
+ * for unparseable input.
+ */
+exports.diffMs = diffMs;
+const startOfDay = value => {
+  const d = toDate(value);
+  if (!d) {
+    return null;
+  }
+  const start = new Date(d);
+  start.setHours(0, 0, 0, 0);
+  return start;
+};
+
+/**
+ * Adds (or, with a negative count, subtracts) whole calendar days in the
+ * device's local timezone. Returns null for unparseable input.
+ */
+exports.startOfDay = startOfDay;
+const addDays = (value, count) => {
+  const d = toDate(value);
+  if (!d) {
+    return null;
+  }
+  const next = new Date(d);
+  next.setDate(next.getDate() + count);
+  return next;
+};
+exports.addDays = addDays;
+const WEEKDAY_SHORT = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const WEEKDAY_LONG = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+const MONTH_LONG = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+
+// Longest-first so 'YYYY' is tried before 'YY', 'DD' before 'D', etc. — a
+// greedy single pass over the pattern, not a regex, so a literal character
+// (a comma, a colon, a digit) can never accidentally match a token.
+const TOKENS = ['YYYY', 'YY', 'MMMM', 'MMM', 'MM', 'M', 'DD', 'D', 'dddd', 'ddd', 'HH', 'H', 'hh', 'h', 'mm', 'm', 'ss', 's', 'A', 'a'];
+const tokenizePattern = pattern => {
+  const result = [];
+  let i = 0;
+  outer: while (i < pattern.length) {
+    for (const token of TOKENS) {
+      if (pattern.startsWith(token, i)) {
+        result.push(token);
+        i += token.length;
+        continue outer;
+      }
+    }
+    result.push(pattern[i]);
+    i += 1;
+  }
+  return result;
+};
+
+/**
+ * Small dayjs/moment-style token formatter — YYYY/YY, MMMM/MMM/MM/M,
+ * DD/D, dddd/ddd, HH/H (24h), hh/h (12h), mm/m, ss/s, A/a (upper/lower AM/PM).
+ * Everything else in the pattern (spaces, commas, colons) passes through
+ * literally. Hand-rolled rather than a dependency because this fleet's date
+ * formatting needs are a small, closed token set, not general i18n — for
+ * genuinely locale-aware output, `formatDate`/`formatTime` (Intl-backed, in
+ * `./date`) are the ones to reach for; this is for matching an exact
+ * existing pattern (a legacy display string, an API's expected shape).
+ *
+ * `utc: true` reads every field from the UTC calendar/clock instead of the
+ * device's local one — see `formatDateDDMMMYYYY`'s note on why this isn't
+ * cosmetic.
+ */
+const formatDatePattern = (value, pattern, options) => {
+  const d = toDate(value);
+  if (!d) {
+    return '';
+  }
+  const utc = options?.utc ?? false;
+  const year = utc ? d.getUTCFullYear() : d.getFullYear();
+  const month = utc ? d.getUTCMonth() : d.getMonth();
+  const day = utc ? d.getUTCDate() : d.getDate();
+  const weekday = utc ? d.getUTCDay() : d.getDay();
+  const hours24 = utc ? d.getUTCHours() : d.getHours();
+  const minutes = utc ? d.getUTCMinutes() : d.getMinutes();
+  const seconds = utc ? d.getUTCSeconds() : d.getSeconds();
+  const {
+    hour12,
+    period
+  } = to12Hour(hours24);
+  return tokenizePattern(pattern).map(t => {
+    switch (t) {
+      case 'YYYY':
+        return String(year);
+      case 'YY':
+        return String(year).slice(-2);
+      case 'MMMM':
+        return MONTH_LONG[month];
+      case 'MMM':
+        return MONTH_SHORT[month];
+      case 'MM':
+        return PAD(month + 1);
+      case 'M':
+        return String(month + 1);
+      case 'DD':
+        return PAD(day);
+      case 'D':
+        return String(day);
+      case 'dddd':
+        return WEEKDAY_LONG[weekday];
+      case 'ddd':
+        return WEEKDAY_SHORT[weekday];
+      case 'HH':
+        return PAD(hours24);
+      case 'H':
+        return String(hours24);
+      case 'hh':
+        return PAD(hour12);
+      case 'h':
+        return String(hour12);
+      case 'mm':
+        return PAD(minutes);
+      case 'm':
+        return String(minutes);
+      case 'ss':
+        return PAD(seconds);
+      case 's':
+        return String(seconds);
+      case 'A':
+        return period;
+      case 'a':
+        return period.toLowerCase();
+      default:
+        return t;
+    }
+  }).join('');
+};
+exports.formatDatePattern = formatDatePattern;
+const MONTH_SHORT = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+/**
+ * `DD MMM, YYYY` — zero-padded day, short month, comma, year (e.g.
+ * `05 Sep, 2025`). A specific legacy pattern some apps already display,
+ * not the fleet's own product convention: `formatDate` (the Intl `style`-based
+ * formatter in `./date`) is the one to reach for in new code. This exists so
+ * an app already showing this exact pattern can move off a date library
+ * without a visible change.
+ *
+ * `utc: true` reads the calendar day from the UTC fields instead of the
+ * device's local ones — matching `dayjs.utc(x).format(...)`, not
+ * `dayjs(x).format(...)`. The two disagree whenever local time has crossed a
+ * day boundary UTC hasn't yet (or vice versa), so this is not a cosmetic
+ * option; pass it only to match a call site that was genuinely UTC-explicit.
+ */
+const formatDateDDMMMYYYY = (value, options) => {
+  const d = toDate(value);
+  if (!d) {
+    return '';
+  }
+  if (options?.utc) {
+    return `${PAD(d.getUTCDate())} ${MONTH_SHORT[d.getUTCMonth()]}, ${d.getUTCFullYear()}`;
+  }
+  return `${PAD(d.getDate())} ${MONTH_SHORT[d.getMonth()]}, ${d.getFullYear()}`;
+};
+
+/** `YYYY-MM-DD`, in the device's local timezone. */
+exports.formatDateDDMMMYYYY = formatDateDDMMMYYYY;
+const formatDateISO = value => {
+  const d = toDate(value);
+  if (!d) {
+    return '';
+  }
+  return `${d.getFullYear()}-${PAD(d.getMonth() + 1)}-${PAD(d.getDate())}`;
+};
+exports.formatDateISO = formatDateISO;
+const to12Hour = hours => {
+  const period = hours >= 12 ? 'PM' : 'AM';
+  const hour12 = hours % 12 || 12;
+  return {
+    hour12,
+    period
+  };
+};
+
+/**
+ * `hh:mm A` in the device's local timezone — zero-padded 12-hour clock,
+ * uppercase AM/PM (e.g. `09:30 PM`).
+ */
+const formatTime12h = value => {
+  const d = toDate(value);
+  if (!d) {
+    return '';
+  }
+  const {
+    hour12,
+    period
+  } = to12Hour(d.getHours());
+  return `${PAD(hour12)}:${PAD(d.getMinutes())} ${period}`;
+};
+exports.formatTime12h = formatTime12h;
+const hasIntl = () => typeof Intl !== 'undefined' && typeof Intl.DateTimeFormat === 'function';
+
+/**
+ * `hh:mm a` (zero-padded 12-hour, lowercase am/pm) of the given instant as
+ * seen in `ianaTimeZone` (e.g. `Asia/Kolkata`) — not the device's own
+ * timezone. Reads the hour/minute/period through `Intl.DateTimeFormat`'s
+ * `formatToParts` rather than its assembled string, because the assembled
+ * string's spacing before AM/PM varies by JS engine (some insert a narrow
+ * no-break space, U+202F, instead of a plain space) and isn't reliably
+ * zero-padded either. Throws if `ianaTimeZone` isn't a timezone Intl
+ * recognises — the same failure mode as handing dayjs.tz() a bad zone name.
+ */
+const formatTimeInZone = (value, ianaTimeZone) => {
+  const d = toDate(value);
+  if (!d) {
+    return '';
+  }
+  if (!hasIntl()) {
+    // No Intl.DateTimeFormat means no reliable IANA timezone database to
+    // convert against; the device-local fallback below is the least-wrong
+    // answer available, not a genuine timezone conversion.
+    return formatTime12h(d);
+  }
+  const parts = new Intl.DateTimeFormat('en-US', {
+    timeZone: ianaTimeZone,
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: true
+  }).formatToParts(d);
+  const get = type => parts.find(p => p.type === type)?.value ?? '';
+  const hour = Number.parseInt(get('hour'), 10);
+  const minute = get('minute');
+  const period = get('dayPeriod').toLowerCase();
+  return `${PAD(hour)}:${minute} ${period}`;
+};
+
+/**
+ * Same as {@link formatTimeInZone}, but for a .NET-style Windows timezone ID
+ * (e.g. `"India Standard Time"`) rather than an IANA one. .NET's own
+ * `TimeZoneInfo` API only knows Windows IDs, so a backend built on it hands
+ * these to clients directly — `Intl`, by contrast, only recognises IANA
+ * names, so the ID has to be translated before it can be used here. Throws
+ * if `windowsTimeZoneId` has no known IANA mapping.
+ */
+exports.formatTimeInZone = formatTimeInZone;
+const formatTimeInWindowsZone = (value, windowsTimeZoneId) => {
+  const ianaTimeZones = (0, _windowsIana.findIana)(windowsTimeZoneId);
+  if (!ianaTimeZones || ianaTimeZones.length === 0) {
+    throw new Error(`Mapping for Windows time zone '${windowsTimeZoneId}' not found.`);
+  }
+  return formatTimeInZone(value, ianaTimeZones[0]);
+};
+exports.formatTimeInWindowsZone = formatTimeInWindowsZone;
+//# sourceMappingURL=dateMath.js.map

package/lib/commonjs/formatters/index.js

@@ -3,12 +3,24 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "addDays", {
+  enumerable: true,
+  get: function () {
+    return _dateMath.addDays;
+  }
+});
 Object.defineProperty(exports, "detectPhoneCountry", {
   enumerable: true,
   get: function () {
     return _phone.detectPhoneCountry;
   }
 });
+Object.defineProperty(exports, "diffMs", {
+  enumerable: true,
+  get: function () {
+    return _dateMath.diffMs;
+  }
+});
 Object.defineProperty(exports, "formatCompactNumber", {
   enumerable: true,
   get: function () {
@@ -27,6 +39,24 @@ Object.defineProperty(exports, "formatDate", {
     return _date.formatDate;
   }
 });
+Object.defineProperty(exports, "formatDateDDMMMYYYY", {
+  enumerable: true,
+  get: function () {
+    return _dateMath.formatDateDDMMMYYYY;
+  }
+});
+Object.defineProperty(exports, "formatDateISO", {
+  enumerable: true,
+  get: function () {
+    return _dateMath.formatDateISO;
+  }
+});
+Object.defineProperty(exports, "formatDatePattern", {
+  enumerable: true,
+  get: function () {
+    return _dateMath.formatDatePattern;
+  }
+});
 Object.defineProperty(exports, "formatDateTime", {
   enumerable: true,
   get: function () {
@@ -63,12 +93,48 @@ Object.defineProperty(exports, "formatTime", {
     return _date.formatTime;
   }
 });
+Object.defineProperty(exports, "formatTime12h", {
+  enumerable: true,
+  get: function () {
+    return _dateMath.formatTime12h;
+  }
+});
+Object.defineProperty(exports, "formatTimeInWindowsZone", {
+  enumerable: true,
+  get: function () {
+    return _dateMath.formatTimeInWindowsZone;
+  }
+});
+Object.defineProperty(exports, "formatTimeInZone", {
+  enumerable: true,
+  get: function () {
+    return _dateMath.formatTimeInZone;
+  }
+});
 Object.defineProperty(exports, "getInitials", {
   enumerable: true,
   get: function () {
     return _initials.getInitials;
   }
 });
+Object.defineProperty(exports, "isDateAfter", {
+  enumerable: true,
+  get: function () {
+    return _dateMath.isDateAfter;
+  }
+});
+Object.defineProperty(exports, "isDateBefore", {
+  enumerable: true,
+  get: function () {
+    return _dateMath.isDateBefore;
+  }
+});
+Object.defineProperty(exports, "isSameDay", {
+  enumerable: true,
+  get: function () {
+    return _dateMath.isSameDay;
+  }
+});
 Object.defineProperty(exports, "isValidPhoneNumber", {
   enumerable: true,
   get: function () {
@@ -93,8 +159,15 @@ Object.defineProperty(exports, "parsePhoneNumberFromString", {
     return _phone.parsePhoneNumberFromString;
   }
 });
+Object.defineProperty(exports, "startOfDay", {
+  enumerable: true,
+  get: function () {
+    return _dateMath.startOfDay;
+  }
+});
 var _currency = require("./currency.js");
 var _date = require("./date.js");
+var _dateMath = require("./dateMath.js");
 var _initials = require("./initials.js");
 var _number = require("./number.js");
 var _phone = require("./phone.js");

package/lib/commonjs/index.js

@@ -51,6 +51,12 @@ Object.defineProperty(exports, "VersionCheck", {
     return _index8.VersionCheck;
   }
 });
+Object.defineProperty(exports, "addDays", {
+  enumerable: true,
+  get: function () {
+    return _index3.addDays;
+  }
+});
 Object.defineProperty(exports, "addNetworkStatusListener", {
   enumerable: true,
   get: function () {
@@ -87,6 +93,12 @@ Object.defineProperty(exports, "detectPhoneCountry", {
     return _index3.detectPhoneCountry;
   }
 });
+Object.defineProperty(exports, "diffMs", {
+  enumerable: true,
+  get: function () {
+    return _index3.diffMs;
+  }
+});
 Object.defineProperty(exports, "formatCompactNumber", {
   enumerable: true,
   get: function () {
@@ -105,6 +117,24 @@ Object.defineProperty(exports, "formatDate", {
     return _index3.formatDate;
   }
 });
+Object.defineProperty(exports, "formatDateDDMMMYYYY", {
+  enumerable: true,
+  get: function () {
+    return _index3.formatDateDDMMMYYYY;
+  }
+});
+Object.defineProperty(exports, "formatDateISO", {
+  enumerable: true,
+  get: function () {
+    return _index3.formatDateISO;
+  }
+});
+Object.defineProperty(exports, "formatDatePattern", {
+  enumerable: true,
+  get: function () {
+    return _index3.formatDatePattern;
+  }
+});
 Object.defineProperty(exports, "formatDateTime", {
   enumerable: true,
   get: function () {
@@ -141,6 +171,24 @@ Object.defineProperty(exports, "formatTime", {
     return _index3.formatTime;
   }
 });
+Object.defineProperty(exports, "formatTime12h", {
+  enumerable: true,
+  get: function () {
+    return _index3.formatTime12h;
+  }
+});
+Object.defineProperty(exports, "formatTimeInWindowsZone", {
+  enumerable: true,
+  get: function () {
+    return _index3.formatTimeInWindowsZone;
+  }
+});
+Object.defineProperty(exports, "formatTimeInZone", {
+  enumerable: true,
+  get: function () {
+    return _index3.formatTimeInZone;
+  }
+});
 Object.defineProperty(exports, "getConfig", {
   enumerable: true,
   get: function () {
@@ -225,6 +273,18 @@ Object.defineProperty(exports, "isBetween", {
     return _index7.isBetween;
   }
 });
+Object.defineProperty(exports, "isDateAfter", {
+  enumerable: true,
+  get: function () {
+    return _index3.isDateAfter;
+  }
+});
+Object.defineProperty(exports, "isDateBefore", {
+  enumerable: true,
+  get: function () {
+    return _index3.isDateBefore;
+  }
+});
 Object.defineProperty(exports, "isEmail", {
   enumerable: true,
   get: function () {
@@ -303,6 +363,12 @@ Object.defineProperty(exports, "isRetryableStatus", {
     return _retry.isRetryableStatus;
   }
 });
+Object.defineProperty(exports, "isSameDay", {
+  enumerable: true,
+  get: function () {
+    return _index3.isSameDay;
+  }
+});
 Object.defineProperty(exports, "isStorageAvailable", {
   enumerable: true,
   get: function () {
@@ -435,6 +501,12 @@ Object.defineProperty(exports, "setStorageImplementation", {
     return _index6.setStorageImplementation;
   }
 });
+Object.defineProperty(exports, "startOfDay", {
+  enumerable: true,
+  get: function () {
+    return _index3.startOfDay;
+  }
+});
 Object.defineProperty(exports, "storeToken", {
   enumerable: true,
   get: function () {

package/lib/module/formatters/dateMath.js

@@ -0,0 +1,294 @@
+"use strict";
+
+import { findIana } from 'windows-iana';
+const toDate = value => {
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? null : value;
+  }
+  const d = new Date(value);
+  return Number.isNaN(d.getTime()) ? null : d;
+};
+const PAD = n => n < 10 ? `0${n}` : `${n}`;
+
+/**
+ * Whether two values fall on the same calendar day in the device's local
+ * timezone. Invalid input on either side returns false rather than throwing.
+ */
+export const isSameDay = (a, b) => {
+  const da = toDate(a);
+  const db = toDate(b);
+  if (!da || !db) {
+    return false;
+  }
+  return da.getFullYear() === db.getFullYear() && da.getMonth() === db.getMonth() && da.getDate() === db.getDate();
+};
+
+/** `a` is strictly before `b`. Invalid input on either side returns false. */
+export const isDateBefore = (a, b) => {
+  const da = toDate(a);
+  const db = toDate(b);
+  return da !== null && db !== null && da.getTime() < db.getTime();
+};
+
+/** `a` is strictly after `b`. Invalid input on either side returns false. */
+export const isDateAfter = (a, b) => {
+  const da = toDate(a);
+  const db = toDate(b);
+  return da !== null && db !== null && da.getTime() > db.getTime();
+};
+
+/**
+ * `a - b` in milliseconds, matching dayjs's `a.diff(b)` sign convention
+ * (positive when `a` is later than `b`). Returns `NaN` if either side fails
+ * to parse, the same way subtracting two invalid dayjs objects would.
+ */
+export const diffMs = (a, b) => {
+  const da = toDate(a);
+  const db = toDate(b);
+  if (!da || !db) {
+    return Number.NaN;
+  }
+  return da.getTime() - db.getTime();
+};
+
+/**
+ * Midnight of the given date, in the device's local timezone. Returns null
+ * for unparseable input.
+ */
+export const startOfDay = value => {
+  const d = toDate(value);
+  if (!d) {
+    return null;
+  }
+  const start = new Date(d);
+  start.setHours(0, 0, 0, 0);
+  return start;
+};
+
+/**
+ * Adds (or, with a negative count, subtracts) whole calendar days in the
+ * device's local timezone. Returns null for unparseable input.
+ */
+export const addDays = (value, count) => {
+  const d = toDate(value);
+  if (!d) {
+    return null;
+  }
+  const next = new Date(d);
+  next.setDate(next.getDate() + count);
+  return next;
+};
+const WEEKDAY_SHORT = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const WEEKDAY_LONG = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+const MONTH_LONG = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+
+// Longest-first so 'YYYY' is tried before 'YY', 'DD' before 'D', etc. — a
+// greedy single pass over the pattern, not a regex, so a literal character
+// (a comma, a colon, a digit) can never accidentally match a token.
+const TOKENS = ['YYYY', 'YY', 'MMMM', 'MMM', 'MM', 'M', 'DD', 'D', 'dddd', 'ddd', 'HH', 'H', 'hh', 'h', 'mm', 'm', 'ss', 's', 'A', 'a'];
+const tokenizePattern = pattern => {
+  const result = [];
+  let i = 0;
+  outer: while (i < pattern.length) {
+    for (const token of TOKENS) {
+      if (pattern.startsWith(token, i)) {
+        result.push(token);
+        i += token.length;
+        continue outer;
+      }
+    }
+    result.push(pattern[i]);
+    i += 1;
+  }
+  return result;
+};
+
+/**
+ * Small dayjs/moment-style token formatter — YYYY/YY, MMMM/MMM/MM/M,
+ * DD/D, dddd/ddd, HH/H (24h), hh/h (12h), mm/m, ss/s, A/a (upper/lower AM/PM).
+ * Everything else in the pattern (spaces, commas, colons) passes through
+ * literally. Hand-rolled rather than a dependency because this fleet's date
+ * formatting needs are a small, closed token set, not general i18n — for
+ * genuinely locale-aware output, `formatDate`/`formatTime` (Intl-backed, in
+ * `./date`) are the ones to reach for; this is for matching an exact
+ * existing pattern (a legacy display string, an API's expected shape).
+ *
+ * `utc: true` reads every field from the UTC calendar/clock instead of the
+ * device's local one — see `formatDateDDMMMYYYY`'s note on why this isn't
+ * cosmetic.
+ */
+export const formatDatePattern = (value, pattern, options) => {
+  const d = toDate(value);
+  if (!d) {
+    return '';
+  }
+  const utc = options?.utc ?? false;
+  const year = utc ? d.getUTCFullYear() : d.getFullYear();
+  const month = utc ? d.getUTCMonth() : d.getMonth();
+  const day = utc ? d.getUTCDate() : d.getDate();
+  const weekday = utc ? d.getUTCDay() : d.getDay();
+  const hours24 = utc ? d.getUTCHours() : d.getHours();
+  const minutes = utc ? d.getUTCMinutes() : d.getMinutes();
+  const seconds = utc ? d.getUTCSeconds() : d.getSeconds();
+  const {
+    hour12,
+    period
+  } = to12Hour(hours24);
+  return tokenizePattern(pattern).map(t => {
+    switch (t) {
+      case 'YYYY':
+        return String(year);
+      case 'YY':
+        return String(year).slice(-2);
+      case 'MMMM':
+        return MONTH_LONG[month];
+      case 'MMM':
+        return MONTH_SHORT[month];
+      case 'MM':
+        return PAD(month + 1);
+      case 'M':
+        return String(month + 1);
+      case 'DD':
+        return PAD(day);
+      case 'D':
+        return String(day);
+      case 'dddd':
+        return WEEKDAY_LONG[weekday];
+      case 'ddd':
+        return WEEKDAY_SHORT[weekday];
+      case 'HH':
+        return PAD(hours24);
+      case 'H':
+        return String(hours24);
+      case 'hh':
+        return PAD(hour12);
+      case 'h':
+        return String(hour12);
+      case 'mm':
+        return PAD(minutes);
+      case 'm':
+        return String(minutes);
+      case 'ss':
+        return PAD(seconds);
+      case 's':
+        return String(seconds);
+      case 'A':
+        return period;
+      case 'a':
+        return period.toLowerCase();
+      default:
+        return t;
+    }
+  }).join('');
+};
+const MONTH_SHORT = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+/**
+ * `DD MMM, YYYY` — zero-padded day, short month, comma, year (e.g.
+ * `05 Sep, 2025`). A specific legacy pattern some apps already display,
+ * not the fleet's own product convention: `formatDate` (the Intl `style`-based
+ * formatter in `./date`) is the one to reach for in new code. This exists so
+ * an app already showing this exact pattern can move off a date library
+ * without a visible change.
+ *
+ * `utc: true` reads the calendar day from the UTC fields instead of the
+ * device's local ones — matching `dayjs.utc(x).format(...)`, not
+ * `dayjs(x).format(...)`. The two disagree whenever local time has crossed a
+ * day boundary UTC hasn't yet (or vice versa), so this is not a cosmetic
+ * option; pass it only to match a call site that was genuinely UTC-explicit.
+ */
+export const formatDateDDMMMYYYY = (value, options) => {
+  const d = toDate(value);
+  if (!d) {
+    return '';
+  }
+  if (options?.utc) {
+    return `${PAD(d.getUTCDate())} ${MONTH_SHORT[d.getUTCMonth()]}, ${d.getUTCFullYear()}`;
+  }
+  return `${PAD(d.getDate())} ${MONTH_SHORT[d.getMonth()]}, ${d.getFullYear()}`;
+};
+
+/** `YYYY-MM-DD`, in the device's local timezone. */
+export const formatDateISO = value => {
+  const d = toDate(value);
+  if (!d) {
+    return '';
+  }
+  return `${d.getFullYear()}-${PAD(d.getMonth() + 1)}-${PAD(d.getDate())}`;
+};
+const to12Hour = hours => {
+  const period = hours >= 12 ? 'PM' : 'AM';
+  const hour12 = hours % 12 || 12;
+  return {
+    hour12,
+    period
+  };
+};
+
+/**
+ * `hh:mm A` in the device's local timezone — zero-padded 12-hour clock,
+ * uppercase AM/PM (e.g. `09:30 PM`).
+ */
+export const formatTime12h = value => {
+  const d = toDate(value);
+  if (!d) {
+    return '';
+  }
+  const {
+    hour12,
+    period
+  } = to12Hour(d.getHours());
+  return `${PAD(hour12)}:${PAD(d.getMinutes())} ${period}`;
+};
+const hasIntl = () => typeof Intl !== 'undefined' && typeof Intl.DateTimeFormat === 'function';
+
+/**
+ * `hh:mm a` (zero-padded 12-hour, lowercase am/pm) of the given instant as
+ * seen in `ianaTimeZone` (e.g. `Asia/Kolkata`) — not the device's own
+ * timezone. Reads the hour/minute/period through `Intl.DateTimeFormat`'s
+ * `formatToParts` rather than its assembled string, because the assembled
+ * string's spacing before AM/PM varies by JS engine (some insert a narrow
+ * no-break space, U+202F, instead of a plain space) and isn't reliably
+ * zero-padded either. Throws if `ianaTimeZone` isn't a timezone Intl
+ * recognises — the same failure mode as handing dayjs.tz() a bad zone name.
+ */
+export const formatTimeInZone = (value, ianaTimeZone) => {
+  const d = toDate(value);
+  if (!d) {
+    return '';
+  }
+  if (!hasIntl()) {
+    // No Intl.DateTimeFormat means no reliable IANA timezone database to
+    // convert against; the device-local fallback below is the least-wrong
+    // answer available, not a genuine timezone conversion.
+    return formatTime12h(d);
+  }
+  const parts = new Intl.DateTimeFormat('en-US', {
+    timeZone: ianaTimeZone,
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: true
+  }).formatToParts(d);
+  const get = type => parts.find(p => p.type === type)?.value ?? '';
+  const hour = Number.parseInt(get('hour'), 10);
+  const minute = get('minute');
+  const period = get('dayPeriod').toLowerCase();
+  return `${PAD(hour)}:${minute} ${period}`;
+};
+
+/**
+ * Same as {@link formatTimeInZone}, but for a .NET-style Windows timezone ID
+ * (e.g. `"India Standard Time"`) rather than an IANA one. .NET's own
+ * `TimeZoneInfo` API only knows Windows IDs, so a backend built on it hands
+ * these to clients directly — `Intl`, by contrast, only recognises IANA
+ * names, so the ID has to be translated before it can be used here. Throws
+ * if `windowsTimeZoneId` has no known IANA mapping.
+ */
+export const formatTimeInWindowsZone = (value, windowsTimeZoneId) => {
+  const ianaTimeZones = findIana(windowsTimeZoneId);
+  if (!ianaTimeZones || ianaTimeZones.length === 0) {
+    throw new Error(`Mapping for Windows time zone '${windowsTimeZoneId}' not found.`);
+  }
+  return formatTimeInZone(value, ianaTimeZones[0]);
+};
+//# sourceMappingURL=dateMath.js.map

package/lib/module/formatters/index.js

@@ -2,6 +2,7 @@
 
 export { formatCurrency } from "./currency.js";
 export { formatDate, formatDateTime, formatRelativeTime, formatTime } from "./date.js";
+export { addDays, diffMs, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatTime12h, formatTimeInWindowsZone, formatTimeInZone, isDateAfter, isDateBefore, isSameDay, startOfDay } from "./dateMath.js";
 export { getInitials } from "./initials.js";
 export { formatCompactNumber, formatNumber, formatPercent } from "./number.js";
 export { detectPhoneCountry, formatPhone, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString } from "./phone.js";

package/lib/module/index.js

@@ -29,7 +29,7 @@ export { getConfig, getConfigValue, resetConfig, setConfig } from "./config/inde
 // Deep links
 export { DeepLink, parseDeepLink, useDeepLink } from "./deepLink/index.js";
 // Formatters
-export { detectPhoneCountry, formatCompactNumber, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, getInitials, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString } from "./formatters/index.js";
+export { addDays, detectPhoneCountry, diffMs, formatCompactNumber, formatCurrency, formatDate, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, formatTime12h, formatTimeInWindowsZone, formatTimeInZone, getInitials, isDateAfter, isDateBefore, isSameDay, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString, startOfDay } from "./formatters/index.js";
 // Initialization
 export { initWebority } from "./initSDK.js";
 export { initUserAuth } from "./initUserAuth.js";

package/lib/typescript/commonjs/formatters/dateMath.d.ts

@@ -0,0 +1,88 @@
+import type { DateInput } from './date';
+/**
+ * Whether two values fall on the same calendar day in the device's local
+ * timezone. Invalid input on either side returns false rather than throwing.
+ */
+export declare const isSameDay: (a: DateInput, b: DateInput) => boolean;
+/** `a` is strictly before `b`. Invalid input on either side returns false. */
+export declare const isDateBefore: (a: DateInput, b: DateInput) => boolean;
+/** `a` is strictly after `b`. Invalid input on either side returns false. */
+export declare const isDateAfter: (a: DateInput, b: DateInput) => boolean;
+/**
+ * `a - b` in milliseconds, matching dayjs's `a.diff(b)` sign convention
+ * (positive when `a` is later than `b`). Returns `NaN` if either side fails
+ * to parse, the same way subtracting two invalid dayjs objects would.
+ */
+export declare const diffMs: (a: DateInput, b: DateInput) => number;
+/**
+ * Midnight of the given date, in the device's local timezone. Returns null
+ * for unparseable input.
+ */
+export declare const startOfDay: (value: DateInput) => Date | null;
+/**
+ * Adds (or, with a negative count, subtracts) whole calendar days in the
+ * device's local timezone. Returns null for unparseable input.
+ */
+export declare const addDays: (value: DateInput, count: number) => Date | null;
+/**
+ * Small dayjs/moment-style token formatter — YYYY/YY, MMMM/MMM/MM/M,
+ * DD/D, dddd/ddd, HH/H (24h), hh/h (12h), mm/m, ss/s, A/a (upper/lower AM/PM).
+ * Everything else in the pattern (spaces, commas, colons) passes through
+ * literally. Hand-rolled rather than a dependency because this fleet's date
+ * formatting needs are a small, closed token set, not general i18n — for
+ * genuinely locale-aware output, `formatDate`/`formatTime` (Intl-backed, in
+ * `./date`) are the ones to reach for; this is for matching an exact
+ * existing pattern (a legacy display string, an API's expected shape).
+ *
+ * `utc: true` reads every field from the UTC calendar/clock instead of the
+ * device's local one — see `formatDateDDMMMYYYY`'s note on why this isn't
+ * cosmetic.
+ */
+export declare const formatDatePattern: (value: DateInput, pattern: string, options?: {
+    utc?: boolean;
+}) => string;
+/**
+ * `DD MMM, YYYY` — zero-padded day, short month, comma, year (e.g.
+ * `05 Sep, 2025`). A specific legacy pattern some apps already display,
+ * not the fleet's own product convention: `formatDate` (the Intl `style`-based
+ * formatter in `./date`) is the one to reach for in new code. This exists so
+ * an app already showing this exact pattern can move off a date library
+ * without a visible change.
+ *
+ * `utc: true` reads the calendar day from the UTC fields instead of the
+ * device's local ones — matching `dayjs.utc(x).format(...)`, not
+ * `dayjs(x).format(...)`. The two disagree whenever local time has crossed a
+ * day boundary UTC hasn't yet (or vice versa), so this is not a cosmetic
+ * option; pass it only to match a call site that was genuinely UTC-explicit.
+ */
+export declare const formatDateDDMMMYYYY: (value: DateInput, options?: {
+    utc?: boolean;
+}) => string;
+/** `YYYY-MM-DD`, in the device's local timezone. */
+export declare const formatDateISO: (value: DateInput) => string;
+/**
+ * `hh:mm A` in the device's local timezone — zero-padded 12-hour clock,
+ * uppercase AM/PM (e.g. `09:30 PM`).
+ */
+export declare const formatTime12h: (value: DateInput) => string;
+/**
+ * `hh:mm a` (zero-padded 12-hour, lowercase am/pm) of the given instant as
+ * seen in `ianaTimeZone` (e.g. `Asia/Kolkata`) — not the device's own
+ * timezone. Reads the hour/minute/period through `Intl.DateTimeFormat`'s
+ * `formatToParts` rather than its assembled string, because the assembled
+ * string's spacing before AM/PM varies by JS engine (some insert a narrow
+ * no-break space, U+202F, instead of a plain space) and isn't reliably
+ * zero-padded either. Throws if `ianaTimeZone` isn't a timezone Intl
+ * recognises — the same failure mode as handing dayjs.tz() a bad zone name.
+ */
+export declare const formatTimeInZone: (value: DateInput, ianaTimeZone: string) => string;
+/**
+ * Same as {@link formatTimeInZone}, but for a .NET-style Windows timezone ID
+ * (e.g. `"India Standard Time"`) rather than an IANA one. .NET's own
+ * `TimeZoneInfo` API only knows Windows IDs, so a backend built on it hands
+ * these to clients directly — `Intl`, by contrast, only recognises IANA
+ * names, so the ID has to be translated before it can be used here. Throws
+ * if `windowsTimeZoneId` has no known IANA mapping.
+ */
+export declare const formatTimeInWindowsZone: (value: DateInput, windowsTimeZoneId: string) => string;
+//# sourceMappingURL=dateMath.d.ts.map

package/lib/typescript/commonjs/formatters/index.d.ts

@@ -2,6 +2,7 @@ export type { FormatCurrencyOptions } from './currency';
 export { formatCurrency } from './currency';
 export type { DateInput, DateStyle, TimeStyle } from './date';
 export { formatDate, formatDateTime, formatRelativeTime, formatTime } from './date';
+export { addDays, diffMs, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatTime12h, formatTimeInWindowsZone, formatTimeInZone, isDateAfter, isDateBefore, isSameDay, startOfDay } from './dateMath';
 export { getInitials } from './initials';
 export { formatCompactNumber, formatNumber, formatPercent } from './number';
 export type { FormatPhoneOptions, PhoneCountry, PhoneNumber } from './phone';

package/lib/typescript/commonjs/index.d.ts

@@ -29,7 +29,7 @@ export { getConfig, getConfigValue, resetConfig, setConfig } from './config';
 export type { DeepLinkConfig, DeepLinkRoute, ParsedLink } from './deepLink';
 export { DeepLink, parseDeepLink, useDeepLink } from './deepLink';
 export type { DateInput, DateStyle, FormatCurrencyOptions, FormatPhoneOptions, PhoneCountry, PhoneNumber, TimeStyle } from './formatters';
-export { detectPhoneCountry, formatCompactNumber, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, getInitials, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString } from './formatters';
+export { addDays, detectPhoneCountry, diffMs, formatCompactNumber, formatCurrency, formatDate, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, formatTime12h, formatTimeInWindowsZone, formatTimeInZone, getInitials, isDateAfter, isDateBefore, isSameDay, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString, startOfDay } from './formatters';
 export type { InitConfig } from './initSDK';
 export { initWebority } from './initSDK';
 export type { AuthActions } from './initUserAuth';

package/lib/typescript/module/formatters/dateMath.d.ts

@@ -0,0 +1,88 @@
+import type { DateInput } from './date.js';
+/**
+ * Whether two values fall on the same calendar day in the device's local
+ * timezone. Invalid input on either side returns false rather than throwing.
+ */
+export declare const isSameDay: (a: DateInput, b: DateInput) => boolean;
+/** `a` is strictly before `b`. Invalid input on either side returns false. */
+export declare const isDateBefore: (a: DateInput, b: DateInput) => boolean;
+/** `a` is strictly after `b`. Invalid input on either side returns false. */
+export declare const isDateAfter: (a: DateInput, b: DateInput) => boolean;
+/**
+ * `a - b` in milliseconds, matching dayjs's `a.diff(b)` sign convention
+ * (positive when `a` is later than `b`). Returns `NaN` if either side fails
+ * to parse, the same way subtracting two invalid dayjs objects would.
+ */
+export declare const diffMs: (a: DateInput, b: DateInput) => number;
+/**
+ * Midnight of the given date, in the device's local timezone. Returns null
+ * for unparseable input.
+ */
+export declare const startOfDay: (value: DateInput) => Date | null;
+/**
+ * Adds (or, with a negative count, subtracts) whole calendar days in the
+ * device's local timezone. Returns null for unparseable input.
+ */
+export declare const addDays: (value: DateInput, count: number) => Date | null;
+/**
+ * Small dayjs/moment-style token formatter — YYYY/YY, MMMM/MMM/MM/M,
+ * DD/D, dddd/ddd, HH/H (24h), hh/h (12h), mm/m, ss/s, A/a (upper/lower AM/PM).
+ * Everything else in the pattern (spaces, commas, colons) passes through
+ * literally. Hand-rolled rather than a dependency because this fleet's date
+ * formatting needs are a small, closed token set, not general i18n — for
+ * genuinely locale-aware output, `formatDate`/`formatTime` (Intl-backed, in
+ * `./date`) are the ones to reach for; this is for matching an exact
+ * existing pattern (a legacy display string, an API's expected shape).
+ *
+ * `utc: true` reads every field from the UTC calendar/clock instead of the
+ * device's local one — see `formatDateDDMMMYYYY`'s note on why this isn't
+ * cosmetic.
+ */
+export declare const formatDatePattern: (value: DateInput, pattern: string, options?: {
+    utc?: boolean;
+}) => string;
+/**
+ * `DD MMM, YYYY` — zero-padded day, short month, comma, year (e.g.
+ * `05 Sep, 2025`). A specific legacy pattern some apps already display,
+ * not the fleet's own product convention: `formatDate` (the Intl `style`-based
+ * formatter in `./date`) is the one to reach for in new code. This exists so
+ * an app already showing this exact pattern can move off a date library
+ * without a visible change.
+ *
+ * `utc: true` reads the calendar day from the UTC fields instead of the
+ * device's local ones — matching `dayjs.utc(x).format(...)`, not
+ * `dayjs(x).format(...)`. The two disagree whenever local time has crossed a
+ * day boundary UTC hasn't yet (or vice versa), so this is not a cosmetic
+ * option; pass it only to match a call site that was genuinely UTC-explicit.
+ */
+export declare const formatDateDDMMMYYYY: (value: DateInput, options?: {
+    utc?: boolean;
+}) => string;
+/** `YYYY-MM-DD`, in the device's local timezone. */
+export declare const formatDateISO: (value: DateInput) => string;
+/**
+ * `hh:mm A` in the device's local timezone — zero-padded 12-hour clock,
+ * uppercase AM/PM (e.g. `09:30 PM`).
+ */
+export declare const formatTime12h: (value: DateInput) => string;
+/**
+ * `hh:mm a` (zero-padded 12-hour, lowercase am/pm) of the given instant as
+ * seen in `ianaTimeZone` (e.g. `Asia/Kolkata`) — not the device's own
+ * timezone. Reads the hour/minute/period through `Intl.DateTimeFormat`'s
+ * `formatToParts` rather than its assembled string, because the assembled
+ * string's spacing before AM/PM varies by JS engine (some insert a narrow
+ * no-break space, U+202F, instead of a plain space) and isn't reliably
+ * zero-padded either. Throws if `ianaTimeZone` isn't a timezone Intl
+ * recognises — the same failure mode as handing dayjs.tz() a bad zone name.
+ */
+export declare const formatTimeInZone: (value: DateInput, ianaTimeZone: string) => string;
+/**
+ * Same as {@link formatTimeInZone}, but for a .NET-style Windows timezone ID
+ * (e.g. `"India Standard Time"`) rather than an IANA one. .NET's own
+ * `TimeZoneInfo` API only knows Windows IDs, so a backend built on it hands
+ * these to clients directly — `Intl`, by contrast, only recognises IANA
+ * names, so the ID has to be translated before it can be used here. Throws
+ * if `windowsTimeZoneId` has no known IANA mapping.
+ */
+export declare const formatTimeInWindowsZone: (value: DateInput, windowsTimeZoneId: string) => string;
+//# sourceMappingURL=dateMath.d.ts.map

package/lib/typescript/module/formatters/index.d.ts

@@ -2,6 +2,7 @@ export type { FormatCurrencyOptions } from './currency.js';
 export { formatCurrency } from './currency.js';
 export type { DateInput, DateStyle, TimeStyle } from './date.js';
 export { formatDate, formatDateTime, formatRelativeTime, formatTime } from './date.js';
+export { addDays, diffMs, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatTime12h, formatTimeInWindowsZone, formatTimeInZone, isDateAfter, isDateBefore, isSameDay, startOfDay } from './dateMath.js';
 export { getInitials } from './initials.js';
 export { formatCompactNumber, formatNumber, formatPercent } from './number.js';
 export type { FormatPhoneOptions, PhoneCountry, PhoneNumber } from './phone.js';

package/lib/typescript/module/index.d.ts

@@ -29,7 +29,7 @@ export { getConfig, getConfigValue, resetConfig, setConfig } from './config/inde
 export type { DeepLinkConfig, DeepLinkRoute, ParsedLink } from './deepLink/index.js';
 export { DeepLink, parseDeepLink, useDeepLink } from './deepLink/index.js';
 export type { DateInput, DateStyle, FormatCurrencyOptions, FormatPhoneOptions, PhoneCountry, PhoneNumber, TimeStyle } from './formatters/index.js';
-export { detectPhoneCountry, formatCompactNumber, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, getInitials, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString } from './formatters/index.js';
+export { addDays, detectPhoneCountry, diffMs, formatCompactNumber, formatCurrency, formatDate, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, formatTime12h, formatTimeInWindowsZone, formatTimeInZone, getInitials, isDateAfter, isDateBefore, isSameDay, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString, startOfDay } from './formatters/index.js';
 export type { InitConfig } from './initSDK.js';
 export { initWebority } from './initSDK.js';
 export type { AuthActions } from './initUserAuth.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webority-technologies/mobile-core",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Platform layer for Webority React Native apps: HTTP clients, auth/token storage, config, logging, formatters, validators, network status, permissions, storage and version checks. No UI.",
   "keywords": [
     "react-native",
@@ -134,7 +134,8 @@
   },
   "dependencies": {
     "axios": "^1.19.0",
-    "libphonenumber-js": "^1.12.41"
+    "libphonenumber-js": "^1.12.41",
+    "windows-iana": "^5.1.0"
   },
   "peerDependencies": {
     "@op-engineering/op-sqlite": "*",