@billdog.io/react-native 1.0.0-beta.2

package/src/filters/dateFilters.ts

@@ -0,0 +1,411 @@
+/**
+ * xFlow Date/Time Filters — React Native SDK.
+ *
+ * Verbatim mirror of src/lib/filters/dateFilters.ts (pure TypeScript, only
+ * Date + Intl — no web dependencies). Kept in lockstep with the web file;
+ * the shared conformance corpus (tests/parity/xflow-corpus/) enforces parity.
+ */
+
+// ============= Date Format Tokens (strftime-like) =============
+
+const FORMAT_TOKENS: Record<string, (date: Date, locale?: string) => string> = {
+  '%Y': (d) => d.getFullYear().toString(),
+  '%y': (d) => d.getFullYear().toString().slice(-2),
+  '%m': (d) => String(d.getMonth() + 1).padStart(2, '0'),
+  '%B': (d, locale = 'en-US') => d.toLocaleDateString(locale, { month: 'long' }),
+  '%b': (d, locale = 'en-US') => d.toLocaleDateString(locale, { month: 'short' }),
+  '%d': (d) => String(d.getDate()).padStart(2, '0'),
+  '%e': (d) => String(d.getDate()),
+  '%j': (d) => {
+    const start = new Date(d.getFullYear(), 0, 0);
+    const diff = d.getTime() - start.getTime();
+    return String(Math.floor(diff / (1000 * 60 * 60 * 24))).padStart(3, '0');
+  },
+  '%A': (d, locale = 'en-US') => d.toLocaleDateString(locale, { weekday: 'long' }),
+  '%a': (d, locale = 'en-US') => d.toLocaleDateString(locale, { weekday: 'short' }),
+  '%w': (d) => d.getDay().toString(),
+  '%u': (d) => (d.getDay() || 7).toString(),
+  '%H': (d) => String(d.getHours()).padStart(2, '0'),
+  '%I': (d) => String(d.getHours() % 12 || 12).padStart(2, '0'),
+  '%k': (d) => String(d.getHours()),
+  '%l': (d) => String(d.getHours() % 12 || 12),
+  '%M': (d) => String(d.getMinutes()).padStart(2, '0'),
+  '%S': (d) => String(d.getSeconds()).padStart(2, '0'),
+  '%p': (d) => (d.getHours() >= 12 ? 'PM' : 'AM'),
+  '%P': (d) => (d.getHours() >= 12 ? 'pm' : 'am'),
+  '%z': (d) => {
+    const offset = d.getTimezoneOffset();
+    const sign = offset <= 0 ? '+' : '-';
+    const hours = String(Math.floor(Math.abs(offset) / 60)).padStart(2, '0');
+    const mins = String(Math.abs(offset) % 60).padStart(2, '0');
+    return `${sign}${hours}${mins}`;
+  },
+  '%Z': () => Intl.DateTimeFormat().resolvedOptions().timeZone,
+  '%F': (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`,
+  '%T': (d) => `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}:${String(d.getSeconds()).padStart(2, '0')}`,
+  '%R': (d) => `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`,
+  '%%': () => '%',
+};
+
+// ============= Countdown Format Types =============
+
+export type MaxUnit = 'days' | 'hours' | 'minutes' | 'seconds';
+
+export type CountdownFormat =
+  | 'digital'
+  | 'digital_full'
+  | 'long'
+  | 'long_most_significant'
+  | 'short'
+  | 'short_most_significant'
+  | 'narrow'
+  | 'narrow_most_significant'
+  | 'wide'
+  | 'wide_most_significant'
+  | 'column'
+  | 'days_only'
+  | 'hours_only'
+  | 'minutes_only'
+  | 'seconds_only'
+  | 'compact';
+
+export interface TimeRemaining {
+  days: number;
+  hours: number;
+  minutes: number;
+  seconds: number;
+  totalSeconds: number;
+  isExpired: boolean;
+}
+
+// ============= Core Date Parsing =============
+
+export function parseDate(value: string | number | Date): Date {
+  if (value instanceof Date) return value;
+  if (typeof value === 'number') return new Date(value);
+
+  const trimmed = String(value).trim();
+
+  const relativeMatch = trimmed.match(/^([+-])(\d+)([smhdwMy])$/);
+  if (relativeMatch) {
+    const [, sign, amount, unit] = relativeMatch;
+    const multiplier = sign === '+' ? 1 : -1;
+    const unitMs = getUnitMilliseconds(unit);
+    return new Date(Date.now() + multiplier * parseInt(amount) * unitMs);
+  }
+
+  const parsed = new Date(trimmed);
+  if (!isNaN(parsed.getTime())) return parsed;
+
+  console.warn('[parseDate] Could not parse date value:', value, '- defaulting to 5 minutes');
+  return new Date(Date.now() + 5 * 60 * 1000);
+}
+
+function getUnitMilliseconds(unit: string): number {
+  const units: Record<string, number> = {
+    s: 1000,
+    m: 60 * 1000,
+    h: 60 * 60 * 1000,
+    d: 24 * 60 * 60 * 1000,
+    w: 7 * 24 * 60 * 60 * 1000,
+    M: 30 * 24 * 60 * 60 * 1000,
+    y: 365 * 24 * 60 * 60 * 1000,
+  };
+  return units[unit] || units.d;
+}
+
+// ============= Date Formatting =============
+
+export function formatDate(date: Date | string | number, format: string, locale?: string): string {
+  const d = parseDate(date);
+
+  const presetFormats: Record<string, string> = {
+    iso: '%Y-%m-%dT%H:%M:%S',
+    date: '%Y-%m-%d',
+    time: '%H:%M:%S',
+    datetime: '%Y-%m-%d %H:%M:%S',
+    short: '%m/%d/%Y',
+    long: '%B %e, %Y',
+    full: '%A, %B %e, %Y',
+    time12: '%I:%M %p',
+    time24: '%H:%M',
+  };
+
+  const formatString = presetFormats[format] || format;
+
+  return formatString.replace(/%[A-Za-z%]/g, (token) => {
+    const formatter = FORMAT_TOKENS[token];
+    return formatter ? formatter(d, locale) : token;
+  });
+}
+
+// ============= ms-string Parser =============
+
+const MS_STRING_UNITS: Record<string, 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years'> = {
+  s: 'seconds',
+  m: 'minutes',
+  h: 'hours',
+  d: 'days',
+  w: 'weeks',
+  M: 'months',
+  y: 'years',
+};
+
+export function parseMsString(
+  value: string,
+): { amount: number; unit: 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years' } | null {
+  const match = String(value).match(/^(-?\d+(?:\.\d+)?)\s*([smhdwMy])$/);
+  if (!match) return null;
+  const unit = MS_STRING_UNITS[match[2]];
+  if (!unit) return null;
+  return { amount: parseFloat(match[1]), unit };
+}
+
+// ============= Date Arithmetic =============
+
+export function dateAdd(
+  date: Date | string | number,
+  amount: number | string,
+  unit?: 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years',
+): Date {
+  if (typeof amount === 'string') {
+    const parsed = parseMsString(amount);
+    if (parsed) {
+      amount = parsed.amount;
+      unit = parsed.unit;
+    } else {
+      amount = parseFloat(amount) || 0;
+    }
+  }
+  if (!unit) unit = 'days';
+  const d = parseDate(date);
+  const result = new Date(d);
+
+  switch (unit) {
+    case 'seconds': result.setSeconds(result.getSeconds() + amount); break;
+    case 'minutes': result.setMinutes(result.getMinutes() + amount); break;
+    case 'hours': result.setHours(result.getHours() + amount); break;
+    case 'days': result.setDate(result.getDate() + amount); break;
+    case 'weeks': result.setDate(result.getDate() + amount * 7); break;
+    case 'months': result.setMonth(result.getMonth() + amount); break;
+    case 'years': result.setFullYear(result.getFullYear() + amount); break;
+  }
+  return result;
+}
+
+export function dateSubtract(
+  date: Date | string | number,
+  amount: number | string,
+  unit?: 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years',
+): Date {
+  if (typeof amount === 'string') {
+    const parsed = parseMsString(amount);
+    if (parsed) return dateAdd(date, -parsed.amount, parsed.unit);
+  }
+  return dateAdd(date, -(typeof amount === 'number' ? amount : parseFloat(amount) || 0), unit);
+}
+
+// ============= Countdown Calculations =============
+
+export function calculateTimeRemaining(
+  endDate: Date | string | number,
+  startDate: Date | string | number = new Date(),
+): TimeRemaining {
+  const end = parseDate(endDate);
+  const start = parseDate(startDate);
+
+  const totalSeconds = Math.max(0, Math.floor((end.getTime() - start.getTime()) / 1000));
+
+  const days = Math.floor(totalSeconds / 86400);
+  const hours = Math.floor((totalSeconds % 86400) / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+
+  return { days, hours, minutes, seconds, totalSeconds, isExpired: totalSeconds <= 0 };
+}
+
+function applyMaxUnit(time: TimeRemaining, maxUnit: MaxUnit): TimeRemaining {
+  const { totalSeconds, isExpired } = time;
+  switch (maxUnit) {
+    case 'hours':
+      return { days: 0, hours: Math.floor(totalSeconds / 3600), minutes: Math.floor((totalSeconds % 3600) / 60), seconds: totalSeconds % 60, totalSeconds, isExpired };
+    case 'minutes':
+      return { days: 0, hours: 0, minutes: Math.floor(totalSeconds / 60), seconds: totalSeconds % 60, totalSeconds, isExpired };
+    case 'seconds':
+      return { days: 0, hours: 0, minutes: 0, seconds: totalSeconds, totalSeconds, isExpired };
+    case 'days':
+    default:
+      return time;
+  }
+}
+
+function resolveFormatAlias(format: CountdownFormat): CountdownFormat {
+  switch (format) {
+    case 'narrow': return 'short';
+    case 'narrow_most_significant': return 'short_most_significant';
+    case 'wide': return 'long';
+    case 'wide_most_significant': return 'long_most_significant';
+    default: return format;
+  }
+}
+
+export function formatCountdown(
+  timeRemaining: TimeRemaining,
+  format: CountdownFormat = 'digital',
+  maxUnit?: MaxUnit,
+): string {
+  const resolved = resolveFormatAlias(format);
+  const capped = maxUnit ? applyMaxUnit(timeRemaining, maxUnit) : timeRemaining;
+  const { days, hours, minutes, seconds, totalSeconds } = capped;
+
+  if (resolved === 'column') {
+    const colParts: string[] = [];
+    if (days > 0) colParts.push(`${days}d`);
+    if (hours > 0 || days > 0) colParts.push(`${hours}h`);
+    if (minutes > 0 || hours > 0 || days > 0) colParts.push(`${minutes}m`);
+    colParts.push(`${seconds}s`);
+    return colParts.join('\n');
+  }
+
+  switch (resolved) {
+    case 'digital':
+      return [
+        String(hours + days * 24).padStart(2, '0'),
+        String(minutes).padStart(2, '0'),
+        String(seconds).padStart(2, '0'),
+      ].join(':');
+    case 'digital_full':
+      return [
+        String(days).padStart(2, '0'),
+        String(hours).padStart(2, '0'),
+        String(minutes).padStart(2, '0'),
+        String(seconds).padStart(2, '0'),
+      ].join(':');
+    case 'long': {
+      const parts: string[] = [];
+      if (days > 0) parts.push(`${days} day${days !== 1 ? 's' : ''}`);
+      if (hours > 0) parts.push(`${hours} hour${hours !== 1 ? 's' : ''}`);
+      if (minutes > 0) parts.push(`${minutes} minute${minutes !== 1 ? 's' : ''}`);
+      if (seconds > 0 || parts.length === 0) parts.push(`${seconds} second${seconds !== 1 ? 's' : ''}`);
+      return parts.join(', ');
+    }
+    case 'long_most_significant':
+      if (days > 0) return `${days} day${days !== 1 ? 's' : ''}`;
+      if (hours > 0) return `${hours} hour${hours !== 1 ? 's' : ''}`;
+      if (minutes > 0) return `${minutes} minute${minutes !== 1 ? 's' : ''}`;
+      return `${seconds} second${seconds !== 1 ? 's' : ''}`;
+    case 'short': {
+      const shortParts: string[] = [];
+      if (days > 0) shortParts.push(`${days}d`);
+      if (hours > 0) shortParts.push(`${hours}h`);
+      if (minutes > 0) shortParts.push(`${minutes}m`);
+      if (seconds > 0 || shortParts.length === 0) shortParts.push(`${seconds}s`);
+      return shortParts.join(' ');
+    }
+    case 'short_most_significant':
+      if (days > 0) return `${days}d`;
+      if (hours > 0) return `${hours}h`;
+      if (minutes > 0) return `${minutes}m`;
+      return `${seconds}s`;
+    case 'days_only':
+      return `${days} day${days !== 1 ? 's' : ''}`;
+    case 'hours_only': {
+      const totalHours = days * 24 + hours;
+      return `${totalHours} hour${totalHours !== 1 ? 's' : ''}`;
+    }
+    case 'minutes_only': {
+      const totalMinutes = Math.floor(totalSeconds / 60);
+      return `${totalMinutes} minute${totalMinutes !== 1 ? 's' : ''}`;
+    }
+    case 'seconds_only':
+      return `${totalSeconds} second${totalSeconds !== 1 ? 's' : ''}`;
+    case 'compact':
+      return `${days}:${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+    default:
+      return formatCountdown(timeRemaining, 'digital', maxUnit);
+  }
+}
+
+// ============= Helper Filters =============
+
+export function toOrdinal(num: number): string {
+  const suffixes = ['th', 'st', 'nd', 'rd'];
+  const v = num % 100;
+  return num + (suffixes[(v - 20) % 10] || suffixes[v] || suffixes[0]);
+}
+
+export function toMonthName(month: number, format: 'short' | 'long' = 'long', locale = 'en-US'): string {
+  const date = new Date(2000, month - 1, 1);
+  return date.toLocaleDateString(locale, { month: format });
+}
+
+export function toDayName(day: number, format: 'short' | 'long' = 'long', locale = 'en-US'): string {
+  const date = new Date(2000, 0, 2 + day);
+  return date.toLocaleDateString(locale, { weekday: format });
+}
+
+export function relativeTime(date: Date | string | number, locale = 'en-US'): string {
+  const d = parseDate(date);
+  const now = new Date();
+  const diffMs = d.getTime() - now.getTime();
+  const diffSeconds = Math.abs(Math.floor(diffMs / 1000));
+  const isPast = diffMs < 0;
+
+  let value: number;
+  let unit: Intl.RelativeTimeFormatUnit;
+
+  if (diffSeconds < 60) { value = diffSeconds; unit = 'second'; }
+  else if (diffSeconds < 3600) { value = Math.floor(diffSeconds / 60); unit = 'minute'; }
+  else if (diffSeconds < 86400) { value = Math.floor(diffSeconds / 3600); unit = 'hour'; }
+  else if (diffSeconds < 604800) { value = Math.floor(diffSeconds / 86400); unit = 'day'; }
+  else if (diffSeconds < 2592000) { value = Math.floor(diffSeconds / 604800); unit = 'week'; }
+  else if (diffSeconds < 31536000) { value = Math.floor(diffSeconds / 2592000); unit = 'month'; }
+  else { value = Math.floor(diffSeconds / 31536000); unit = 'year'; }
+
+  const rtf = new Intl.RelativeTimeFormat(locale, { numeric: 'auto' });
+  return rtf.format(isPast ? -value : value, unit);
+}
+
+// ============= Countdown Specific Filters =============
+
+export function countdownDaysTotal(startDate: Date | string | number, endDate: Date | string | number): number {
+  return Math.floor(calculateTimeRemaining(endDate, startDate).totalSeconds / 86400);
+}
+
+export function countdownHoursTotal(startDate: Date | string | number, endDate: Date | string | number): number {
+  return Math.floor(calculateTimeRemaining(endDate, startDate).totalSeconds / 3600);
+}
+
+export function countdownMinutesTotal(startDate: Date | string | number, endDate: Date | string | number): number {
+  return Math.floor(calculateTimeRemaining(endDate, startDate).totalSeconds / 60);
+}
+
+export function countdownSecondsTotal(startDate: Date | string | number, endDate: Date | string | number): number {
+  return calculateTimeRemaining(endDate, startDate).totalSeconds;
+}
+
+export function countdownFrom(
+  endDate: Date | string | number,
+  startDate: Date | string | number = new Date(),
+  format: CountdownFormat = 'digital',
+  maxUnit?: MaxUnit,
+): string {
+  return formatCountdown(calculateTimeRemaining(endDate, startDate), format, maxUnit);
+}
+
+// ============= Export All Filters =============
+
+export const DATE_FILTERS = {
+  date: formatDate,
+  date_add: dateAdd,
+  date_subtract: dateSubtract,
+  countdown_from: countdownFrom,
+  countdown_days_total: countdownDaysTotal,
+  countdown_hours_total: countdownHoursTotal,
+  countdown_minutes_total: countdownMinutesTotal,
+  countdown_seconds_total: countdownSecondsTotal,
+  to_ordinal: toOrdinal,
+  to_month_name: toMonthName,
+  to_day_name: toDayName,
+  relative_time: relativeTime,
+};

package/src/filters/index.ts

@@ -0,0 +1,281 @@
+/**
+ * Filter Registry and Chain Processor — React Native SDK.
+ *
+ * Verbatim mirror of src/lib/filters/index.ts (pure TypeScript, no web
+ * dependencies). Handles xFlow filter syntax: {{ variable | filter: arg }}
+ * and {% assign x = value | filter %}. Kept in lockstep with the web file;
+ * the shared conformance corpus enforces parity.
+ */
+
+import {
+  formatDate,
+  dateAdd,
+  dateSubtract,
+  countdownFrom,
+  countdownDaysTotal,
+  countdownHoursTotal,
+  countdownMinutesTotal,
+  countdownSecondsTotal,
+  toOrdinal,
+  toMonthName,
+  toDayName,
+  relativeTime,
+  CountdownFormat,
+} from './dateFilters';
+
+// ============= String Filters =============
+
+const STRING_FILTERS = {
+  upcase: (value: string) => String(value).toUpperCase(),
+  downcase: (value: string) => String(value).toLowerCase(),
+  capitalize: (value: string) => {
+    const str = String(value);
+    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+  },
+  titlecase: (value: string) =>
+    String(value).replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.slice(1).toLowerCase()),
+  strip: (value: string) => String(value).trim(),
+  lstrip: (value: string) => String(value).trimStart(),
+  rstrip: (value: string) => String(value).trimEnd(),
+  truncate: (value: string, length: number = 50, ellipsis: string = '...') => {
+    const str = String(value);
+    if (str.length <= length) return str;
+    return str.slice(0, length - ellipsis.length) + ellipsis;
+  },
+  truncatewords: (value: string, words: number = 15, ellipsis: string = '...') => {
+    const wordArray = String(value).split(/\s+/);
+    if (wordArray.length <= words) return value;
+    return wordArray.slice(0, words).join(' ') + ellipsis;
+  },
+  append: (value: string, suffix: string) => String(value) + suffix,
+  prepend: (value: string, prefix: string) => prefix + String(value),
+  replace: (value: string, search: string, replacement: string = '') =>
+    String(value).replace(new RegExp(search, 'g'), replacement),
+  replace_first: (value: string, search: string, replacement: string = '') =>
+    String(value).replace(search, replacement),
+  remove: (value: string, toRemove: string) => String(value).replace(new RegExp(toRemove, 'g'), ''),
+  remove_first: (value: string, toRemove: string) => String(value).replace(toRemove, ''),
+  size: (value: string | any[]) => (Array.isArray(value) ? value.length : String(value).length),
+  escape: (value: string) =>
+    String(value)
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&#39;'),
+  url_encode: (value: string) => encodeURIComponent(String(value)),
+  url_decode: (value: string) => decodeURIComponent(String(value)),
+};
+
+// ============= Number Filters =============
+
+const NUMBER_FILTERS = {
+  plus: (value: number, addend: number) => Number(value) + Number(addend),
+  minus: (value: number, subtrahend: number) => Number(value) - Number(subtrahend),
+  times: (value: number, multiplier: number) => Number(value) * Number(multiplier),
+  divided_by: (value: number, divisor: number) => Number(value) / Number(divisor),
+  modulo: (value: number, divisor: number) => Number(value) % Number(divisor),
+  round: (value: number, decimals: number = 0) => {
+    const factor = Math.pow(10, decimals);
+    return Math.round(Number(value) * factor) / factor;
+  },
+  floor: (value: number) => Math.floor(Number(value)),
+  ceil: (value: number) => Math.ceil(Number(value)),
+  abs: (value: number) => Math.abs(Number(value)),
+  number_with_delimiter: (value: number, delimiter: string = ',') =>
+    Number(value).toLocaleString('en-US').replace(/,/g, delimiter),
+  currency: (value: number, symbol: string = '$', decimals: number = 2) =>
+    `${symbol}${Number(value).toFixed(decimals)}`,
+  percentage: (value: number, decimals: number = 0) => `${(Number(value) * 100).toFixed(decimals)}%`,
+  at_least: (value: number, min: number) => Math.max(Number(value), Number(min)),
+  at_most: (value: number, max: number) => Math.min(Number(value), Number(max)),
+};
+
+// ============= Array Filters =============
+
+const ARRAY_FILTERS = {
+  first: (value: any[]) => (Array.isArray(value) ? value[0] : value),
+  last: (value: any[]) => (Array.isArray(value) ? value[value.length - 1] : value),
+  join: (value: any[], separator: string = ', ') =>
+    Array.isArray(value) ? value.join(separator) : String(value),
+  reverse: (value: any[]) => (Array.isArray(value) ? [...value].reverse() : value),
+  sort: (value: any[]) => (Array.isArray(value) ? [...value].sort() : value),
+  uniq: (value: any[]) => (Array.isArray(value) ? [...new Set(value)] : value),
+  compact: (value: any[]) => (Array.isArray(value) ? value.filter((v) => v != null) : value),
+};
+
+// ============= Default/Fallback Filters =============
+
+const UTILITY_FILTERS = {
+  default: (value: any, defaultValue: any) =>
+    value == null || value === '' || value === false ? defaultValue : value,
+  default_if_none: (value: any, defaultValue: any) => (value == null ? defaultValue : value),
+};
+
+// ============= All Filters Combined =============
+
+export const ALL_FILTERS: Record<string, (...args: any[]) => any> = {
+  ...STRING_FILTERS,
+  ...NUMBER_FILTERS,
+  ...ARRAY_FILTERS,
+  ...UTILITY_FILTERS,
+  date: (value: any, format: string, locale?: string) => formatDate(value, format, locale),
+  date_add: (value: any, amount: number | string, unit?: any) => dateAdd(value, amount, unit),
+  date_subtract: (value: any, amount: number | string, unit?: any) => dateSubtract(value, amount, unit),
+  countdown_from: (endDate: any, startDate?: any, format?: CountdownFormat, maxUnit?: string) =>
+    countdownFrom(endDate, startDate, format, maxUnit as any),
+  countdown_days_total: (start: any, end: any) => countdownDaysTotal(start, end),
+  countdown_hours_total: (start: any, end: any) => countdownHoursTotal(start, end),
+  countdown_minutes_total: (start: any, end: any) => countdownMinutesTotal(start, end),
+  countdown_seconds_total: (start: any, end: any) => countdownSecondsTotal(start, end),
+  to_ordinal: (value: number) => toOrdinal(value),
+  to_month_name: (value: number, format?: 'short' | 'long', locale?: string) =>
+    toMonthName(value, format, locale),
+  to_day_name: (value: number, format?: 'short' | 'long', locale?: string) =>
+    toDayName(value, format, locale),
+  relative_time: (value: any, locale?: string) => relativeTime(value, locale),
+};
+
+// ============= Filter Argument Parser =============
+
+function parseFilterArgs(argsString: string): any[] {
+  if (!argsString?.trim()) return [];
+
+  const args: any[] = [];
+  let current = '';
+  let inQuote = false;
+  let quoteChar = '';
+  let depth = 0;
+
+  for (let i = 0; i < argsString.length; i++) {
+    const char = argsString[i];
+    if ((char === '"' || char === "'") && argsString[i - 1] !== '\\') {
+      if (!inQuote) { inQuote = true; quoteChar = char; }
+      else if (char === quoteChar) { inQuote = false; }
+      current += char;
+    } else if (char === '[' || char === '{') {
+      depth++;
+      current += char;
+    } else if (char === ']' || char === '}') {
+      depth--;
+      current += char;
+    } else if (char === ',' && !inQuote && depth === 0) {
+      args.push(parseArgValue(current.trim()));
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+
+  if (current.trim()) args.push(parseArgValue(current.trim()));
+  return args;
+}
+
+function parseArgValue(value: string): any {
+  if ((value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1);
+  }
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  if (value === 'null' || value === 'nil') return null;
+  const num = Number(value);
+  if (!isNaN(num) && value !== '') return num;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+// ============= Filter Chain Processor =============
+
+interface ParsedFilter {
+  name: string;
+  args: any[];
+}
+
+function parseFilterChain(filterChain: string): ParsedFilter[] {
+  const filters: ParsedFilter[] = [];
+  const parts: string[] = [];
+  let current = '';
+  let inQuote = false;
+  let quoteChar = '';
+
+  for (let i = 0; i < filterChain.length; i++) {
+    const char = filterChain[i];
+    if ((char === '"' || char === "'") && filterChain[i - 1] !== '\\') {
+      if (!inQuote) { inQuote = true; quoteChar = char; }
+      else if (char === quoteChar) { inQuote = false; }
+      current += char;
+    } else if (char === '|' && !inQuote) {
+      if (current.trim()) parts.push(current.trim());
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) parts.push(current.trim());
+
+  for (const part of parts) {
+    const colonIndex = part.indexOf(':');
+    if (colonIndex === -1) {
+      filters.push({ name: part.trim(), args: [] });
+    } else {
+      const name = part.slice(0, colonIndex).trim();
+      const argsString = part.slice(colonIndex + 1).trim();
+      filters.push({ name, args: parseFilterArgs(argsString) });
+    }
+  }
+  return filters;
+}
+
+export function applyFilterChain(value: any, filterChain: string): any {
+  const filters = parseFilterChain(filterChain);
+  let result = value;
+  for (const filter of filters) {
+    const filterFn = ALL_FILTERS[filter.name];
+    if (filterFn) {
+      try {
+        result = filterFn(result, ...filter.args);
+      } catch (error) {
+        console.warn(`Filter "${filter.name}" failed:`, error);
+      }
+    } else {
+      console.warn(`Unknown filter: "${filter.name}"`);
+    }
+  }
+  return result;
+}
+
+/**
+ * Replace {{ variable }} and {{ variable | filter: arg }} occurrences in text.
+ * Mirror of the web replaceVariablesWithFilters — unresolved variables are
+ * left untouched.
+ */
+export function replaceVariablesWithFilters(
+  text: string,
+  variables: Record<string, any>,
+): string {
+  if (!text) return text;
+
+  return text.replace(
+    /\{\{\s*([\w.]+)(?:\s*\|\s*(.+?))?\s*\}\}/g,
+    (match, varPath, filterChain) => {
+      let value = varPath
+        .split('.')
+        .reduce((obj: any, key: string) => obj?.[key], variables);
+
+      if (value === undefined) return match;
+
+      if (filterChain) {
+        value = applyFilterChain(value, filterChain);
+      }
+
+      return value !== undefined ? String(value) : match;
+    },
+  );
+}
+
+export { DATE_FILTERS } from './dateFilters';
+export type { CountdownFormat, TimeRemaining, MaxUnit } from './dateFilters';