@pushwoosh/websdk-common 0.0.0 → 6.17.0

package/web-popups/timer.d.ts

@@ -0,0 +1,16 @@
+import { type WebPopupTimerRemaining } from './types';
+/** Can this engine compute offsets in the zone? Empty = the contract's UTC, so supported. */
+export declare function webPopupTimeZoneSupported(timezone: string): boolean;
+/** The instant (epoch ms) a wall clock names in a zone, or null when this engine can't place it. */
+export declare function webPopupWallClockMs(endTime: string, timezone: string): number | null;
+/** What's left at `nowMs`, by unit; a passed OR uncomputable deadline reads as all zeros. */
+export declare function webPopupTimerRemaining(endTime: string, timezone: string, nowMs: number): WebPopupTimerRemaining;
+/** The four unit labels a timer draws under its digits. */
+export type WebPopupTimerLabels = {
+    days: string;
+    hours: string;
+    minutes: string;
+    seconds: string;
+};
+/** The unit labels for a language code; empty/unknown = English. */
+export declare function webPopupTimerLabels(language: string): WebPopupTimerLabels;

package/web-popups/timer.js

@@ -0,0 +1,194 @@
+// Countdown math: `endTime` is a LOCAL WALL CLOCK in `timezone` (empty = UTC),
+// never an instant. Pure, `now` passed in — the renderer ticks, this computes.
+const WALL_CLOCK = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?$/;
+// One formatter per zone: the reader asks for the remainder once a second per
+// timer slot, and constructing an Intl.DateTimeFormat is the expensive part.
+const zoneFormatters = new Map();
+function zoneFormatter(timeZone) {
+  const cached = zoneFormatters.get(timeZone);
+  if (cached) return cached;
+  try {
+    const formatter = new Intl.DateTimeFormat('en-US', {
+      timeZone,
+      hour12: false,
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit'
+    });
+    zoneFormatters.set(timeZone, formatter);
+    return formatter;
+  } catch {
+    // An unknown/unsupported IANA name — the engine can't place a wall clock in it.
+    return null;
+  }
+}
+/** Can this engine compute offsets in the zone? Empty = the contract's UTC, so supported. */
+export function webPopupTimeZoneSupported(timezone) {
+  return !timezone || zoneFormatter(timezone) !== null;
+}
+// The zone's offset from UTC at an instant, in ms: render local parts, read
+// them back as if they were UTC, take the difference.
+function zoneOffsetMs(instantMs, formatter) {
+  const parts = formatter.formatToParts(new Date(instantMs));
+  const read = type => Number(parts.find(part => part.type === type)?.value ?? '0');
+  // hour12: false still renders midnight as '24' in some engines.
+  const asUtc = Date.UTC(read('year'), read('month') - 1, read('day'), read('hour') % 24, read('minute'), read('second'));
+  return asUtc - instantMs;
+}
+const DAY_MS = 86400000;
+// Every offset that can apply to a wall clock this close to a DST switch: the
+// day before, the naive instant, the day after.
+function candidateOffsets(wallAsUtc, formatter) {
+  const offsets = [];
+  for (const probe of [wallAsUtc - DAY_MS, wallAsUtc, wallAsUtc + DAY_MS]) {
+    const offset = zoneOffsetMs(probe, formatter);
+    if (!offsets.includes(offset)) offsets.push(offset);
+  }
+  return offsets;
+}
+// The reader asks for the remainder once a second per slot, and the deadline
+// never moves; a handful of entries, cleared wholesale if a document is absurd.
+const deadlines = new Map();
+/** The instant (epoch ms) a wall clock names in a zone, or null when this engine can't place it. */
+export function webPopupWallClockMs(endTime, timezone) {
+  const cacheKey = `${endTime}|${timezone}`;
+  const cached = deadlines.get(cacheKey);
+  if (cached !== undefined) return cached;
+  const resolved = resolveWallClockMs(endTime, timezone);
+  if (deadlines.size > 100) deadlines.clear();
+  deadlines.set(cacheKey, resolved);
+  return resolved;
+}
+function resolveWallClockMs(endTime, timezone) {
+  const match = WALL_CLOCK.exec((endTime || '').trim());
+  if (!match) return null;
+  const [, year, month, day, hour, minute, rawSecond] = match.map(Number);
+  // The seconds group is optional — an absent one reads as NaN, not 0.
+  const second = Number.isNaN(rawSecond) ? 0 : rawSecond;
+  if (month < 1 || month > 12 || day < 1 || day > 31) return null;
+  if (hour > 23 || minute > 59 || second > 59) return null;
+  const wallAsUtc = Date.UTC(year, month - 1, day, hour, minute, second);
+  // Date.UTC rolls impossible days over (Feb 30 → Mar 2); reject instead.
+  const rolled = new Date(wallAsUtc);
+  if (rolled.getUTCMonth() !== month - 1 || rolled.getUTCDate() !== day) return null;
+  if (!timezone) return wallAsUtc;
+  const formatter = zoneFormatter(timezone);
+  if (!formatter) return null;
+  // One rule for every zone, whatever the sign of its offset: an offset counts
+  // when the instant it produces reads back as the wall clock asked for.
+  const offsets = candidateOffsets(wallAsUtc, formatter);
+  const instants = offsets.filter(offset => zoneOffsetMs(wallAsUtc - offset, formatter) === offset).map(offset => wallAsUtc - offset);
+  // An ambiguous wall clock (fall back) takes the FIRST of its two instants.
+  if (instants.length > 0) return Math.min(...instants);
+  // None reads back: the wall clock is inside a spring-forward gap. The pre-gap
+  // offset is the smaller one, so this rolls forward to just past the gap.
+  return wallAsUtc - Math.min(...offsets);
+}
+/** What's left at `nowMs`, by unit; a passed OR uncomputable deadline reads as all zeros. */
+export function webPopupTimerRemaining(endTime, timezone, nowMs) {
+  const deadline = webPopupWallClockMs(endTime, timezone);
+  const total = deadline === null ? 0 : Math.max(0, deadline - nowMs);
+  const seconds = Math.floor(total / 1000);
+  return {
+    total,
+    days: Math.floor(seconds / 86400),
+    hours: Math.floor(seconds / 3600) % 24,
+    minutes: Math.floor(seconds / 60) % 60,
+    seconds: seconds % 60
+  };
+}
+// Unit labels by ISO 639-1 code, the editor's 14 languages; anything else = English.
+// NOTE: not written by native speakers — worth a review before customers see them.
+const TIMER_LABELS = {
+  en: {
+    days: 'Days',
+    hours: 'Hours',
+    minutes: 'Minutes',
+    seconds: 'Seconds'
+  },
+  ru: {
+    days: 'Дни',
+    hours: 'Часы',
+    minutes: 'Минуты',
+    seconds: 'Секунды'
+  },
+  de: {
+    days: 'Tage',
+    hours: 'Stunden',
+    minutes: 'Minuten',
+    seconds: 'Sekunden'
+  },
+  es: {
+    days: 'Días',
+    hours: 'Horas',
+    minutes: 'Minutos',
+    seconds: 'Segundos'
+  },
+  fr: {
+    days: 'Jours',
+    hours: 'Heures',
+    minutes: 'Minutes',
+    seconds: 'Secondes'
+  },
+  pt: {
+    days: 'Dias',
+    hours: 'Horas',
+    minutes: 'Minutos',
+    seconds: 'Segundos'
+  },
+  ja: {
+    days: '日',
+    hours: '時間',
+    minutes: '分',
+    seconds: '秒'
+  },
+  ko: {
+    days: '일',
+    hours: '시간',
+    minutes: '분',
+    seconds: '초'
+  },
+  zh: {
+    days: '天',
+    hours: '小时',
+    minutes: '分',
+    seconds: '秒'
+  },
+  hi: {
+    days: 'दिन',
+    hours: 'घंटे',
+    minutes: 'मिनट',
+    seconds: 'सेकंड'
+  },
+  bn: {
+    days: 'দিন',
+    hours: 'ঘণ্টা',
+    minutes: 'মিনিট',
+    seconds: 'সেকেন্ড'
+  },
+  ar: {
+    days: 'أيام',
+    hours: 'ساعات',
+    minutes: 'دقائق',
+    seconds: 'ثوان'
+  },
+  he: {
+    days: 'ימים',
+    hours: 'שעות',
+    minutes: 'דקות',
+    seconds: 'שניות'
+  },
+  th: {
+    days: 'วัน',
+    hours: 'ชั่วโมง',
+    minutes: 'นาที',
+    seconds: 'วินาที'
+  }
+};
+/** The unit labels for a language code; empty/unknown = English. */
+export function webPopupTimerLabels(language) {
+  return TIMER_LABELS[language] ?? TIMER_LABELS.en;
+}