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

package/dist/dynamicValues.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * Dynamic Values System for React Native SDK
+ * Supports nested condition groups with AND/OR logic
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDynamicValue = isDynamicValue;
+exports.evaluateDynamicValue = evaluateDynamicValue;
+exports.evaluateConditionGroup = evaluateConditionGroup;
+exports.processComponentProperties = processComponentProperties;
+exports.processFullComponent = processFullComponent;
+exports.createConditionGroup = createConditionGroup;
+exports.createDynamicValue = createDynamicValue;
+exports.createCondition = createCondition;
+exports.createSimpleValueEntry = createSimpleValueEntry;
+const valueUtils_1 = require("./valueUtils");
+function isDynamicValue(value) {
+    return typeof value === 'object' && value !== null && value._isDynamic === true;
+}
+function evaluateDynamicValue(dynamicValue, variables) {
+    if (!isDynamicValue(dynamicValue))
+        return dynamicValue;
+    try {
+        const entries = dynamicValue.values || [];
+        for (const entry of entries) {
+            if (evaluateConditionGroup(entry.rootGroup, variables)) {
+                return entry.value;
+            }
+        }
+        return dynamicValue.default;
+    }
+    catch (error) {
+        console.warn('[DynamicValue] Evaluation failed, using default:', error);
+        return dynamicValue.default;
+    }
+}
+function evaluateConditionGroup(group, variables) {
+    var _a, _b;
+    // `?? []` — a group commonly omits `conditions` or `groups` when empty (the conformance corpus and
+    // DB-stored dynamic values both do). `.map` on the missing array throws, the throw is swallowed by
+    // evaluateDynamicValue's try/catch, and the value silently collapses to its default. The web copy had
+    // this guard; it was never propagated here.
+    const conditionResults = ((_a = group.conditions) !== null && _a !== void 0 ? _a : []).map(c => evaluateSingleCondition(c, variables));
+    const groupResults = ((_b = group.groups) !== null && _b !== void 0 ? _b : []).map(g => evaluateConditionGroup(g, variables));
+    const allResults = [...conditionResults, ...groupResults];
+    // Empty group evaluates to true
+    if (allResults.length === 0)
+        return true;
+    return group.logic === 'AND'
+        ? allResults.every(Boolean)
+        : allResults.some(Boolean);
+}
+function evaluateSingleCondition(condition, variables) {
+    if (!condition.variableName)
+        return false;
+    const varValue = (0, valueUtils_1.getNestedValue)(variables, condition.variableName);
+    switch (condition.operator) {
+        case 'equals': return (0, valueUtils_1.isEqual)(varValue, condition.value);
+        case 'not_equals': return !(0, valueUtils_1.isEqual)(varValue, condition.value);
+        // toNumber (not Number()): non-numeric → 0, matching native `toDouble`. `Number()` yields NaN, which
+        // makes every ordering comparison silently false and disagrees with the device.
+        case 'greater_than': return (0, valueUtils_1.toNumber)(varValue) > (0, valueUtils_1.toNumber)(condition.value);
+        case 'less_than': return (0, valueUtils_1.toNumber)(varValue) < (0, valueUtils_1.toNumber)(condition.value);
+        case 'greater_than_or_equal': return (0, valueUtils_1.toNumber)(varValue) >= (0, valueUtils_1.toNumber)(condition.value);
+        case 'less_than_or_equal': return (0, valueUtils_1.toNumber)(varValue) <= (0, valueUtils_1.toNumber)(condition.value);
+        case 'contains':
+            if (varValue == null)
+                return false;
+            return (0, valueUtils_1.stringify)(varValue).toLowerCase().includes((0, valueUtils_1.stringify)(condition.value).toLowerCase());
+        case 'exists': return varValue != null && (0, valueUtils_1.stringify)(varValue) !== '';
+        default: return false;
+    }
+}
+function processComponentProperties(properties, variables) {
+    const safeProps = (properties && typeof properties === 'object') ? properties : {};
+    const processed = {};
+    for (const [key, value] of Object.entries(safeProps)) {
+        if (isDynamicValue(value)) {
+            processed[key] = evaluateDynamicValue(value, variables);
+        }
+        else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            processed[key] = processComponentProperties(value, variables);
+        }
+        else {
+            processed[key] = value;
+        }
+    }
+    return processed;
+}
+function processFullComponent(component, variables) {
+    const result = { ...component };
+    const nestedKeys = ['properties', 'appearance', 'size', 'containerLayout', 'layout', 'border', 'shadow', 'selectedAppearance', 'selectedProperties', 'selectedLayout', 'selectedSize', 'activeAppearance', 'completedAppearance', 'tapBehavior'];
+    for (const key of nestedKeys) {
+        if (component[key] && typeof component[key] === 'object') {
+            result[key] = processComponentProperties(component[key], variables);
+        }
+    }
+    if (isDynamicValue(component.visible)) {
+        result.visible = evaluateDynamicValue(component.visible, variables);
+    }
+    // Recursive children processing
+    if (Array.isArray(component.children)) {
+        result.children = component.children.map((child) => processFullComponent(child, variables));
+    }
+    return result;
+}
+// Factory functions
+function createConditionGroup(logic = 'AND') {
+    return {
+        id: generateId(),
+        logic,
+        conditions: [],
+        groups: [],
+    };
+}
+function createDynamicValue(defaultValue, values = []) {
+    return { _isDynamic: true, default: defaultValue, values };
+}
+function createCondition(variableName, operator, value) {
+    return {
+        id: generateId(),
+        type: 'variable',
+        variableName,
+        operator,
+        value,
+    };
+}
+function createSimpleValueEntry(variableName, operator, value, returnValue) {
+    const condition = createCondition(variableName, operator, value);
+    const group = {
+        ...createConditionGroup('AND'),
+        conditions: [condition],
+    };
+    return {
+        id: generateId(),
+        rootGroup: group,
+        value: returnValue,
+    };
+}
+function generateId() {
+    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+}

package/dist/filters/dateFilters.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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.
+ */
+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;
+}
+export declare function parseDate(value: string | number | Date): Date;
+export declare function formatDate(date: Date | string | number, format: string, locale?: string): string;
+export declare function parseMsString(value: string): {
+    amount: number;
+    unit: 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years';
+} | null;
+export declare function dateAdd(date: Date | string | number, amount: number | string, unit?: 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years'): Date;
+export declare function dateSubtract(date: Date | string | number, amount: number | string, unit?: 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years'): Date;
+export declare function calculateTimeRemaining(endDate: Date | string | number, startDate?: Date | string | number): TimeRemaining;
+export declare function formatCountdown(timeRemaining: TimeRemaining, format?: CountdownFormat, maxUnit?: MaxUnit): string;
+export declare function toOrdinal(num: number): string;
+export declare function toMonthName(month: number, format?: 'short' | 'long', locale?: string): string;
+export declare function toDayName(day: number, format?: 'short' | 'long', locale?: string): string;
+export declare function relativeTime(date: Date | string | number, locale?: string): string;
+export declare function countdownDaysTotal(startDate: Date | string | number, endDate: Date | string | number): number;
+export declare function countdownHoursTotal(startDate: Date | string | number, endDate: Date | string | number): number;
+export declare function countdownMinutesTotal(startDate: Date | string | number, endDate: Date | string | number): number;
+export declare function countdownSecondsTotal(startDate: Date | string | number, endDate: Date | string | number): number;
+export declare function countdownFrom(endDate: Date | string | number, startDate?: Date | string | number, format?: CountdownFormat, maxUnit?: MaxUnit): string;
+export declare const DATE_FILTERS: {
+    date: typeof formatDate;
+    date_add: typeof dateAdd;
+    date_subtract: typeof dateSubtract;
+    countdown_from: typeof countdownFrom;
+    countdown_days_total: typeof countdownDaysTotal;
+    countdown_hours_total: typeof countdownHoursTotal;
+    countdown_minutes_total: typeof countdownMinutesTotal;
+    countdown_seconds_total: typeof countdownSecondsTotal;
+    to_ordinal: typeof toOrdinal;
+    to_month_name: typeof toMonthName;
+    to_day_name: typeof toDayName;
+    relative_time: typeof relativeTime;
+};

package/dist/filters/dateFilters.js

@@ -0,0 +1,390 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATE_FILTERS = void 0;
+exports.parseDate = parseDate;
+exports.formatDate = formatDate;
+exports.parseMsString = parseMsString;
+exports.dateAdd = dateAdd;
+exports.dateSubtract = dateSubtract;
+exports.calculateTimeRemaining = calculateTimeRemaining;
+exports.formatCountdown = formatCountdown;
+exports.toOrdinal = toOrdinal;
+exports.toMonthName = toMonthName;
+exports.toDayName = toDayName;
+exports.relativeTime = relativeTime;
+exports.countdownDaysTotal = countdownDaysTotal;
+exports.countdownHoursTotal = countdownHoursTotal;
+exports.countdownMinutesTotal = countdownMinutesTotal;
+exports.countdownSecondsTotal = countdownSecondsTotal;
+exports.countdownFrom = countdownFrom;
+// ============= Date Format Tokens (strftime-like) =============
+const FORMAT_TOKENS = {
+    '%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')}`,
+    '%%': () => '%',
+};
+// ============= Core Date Parsing =============
+function parseDate(value) {
+    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) {
+    const units = {
+        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 =============
+function formatDate(date, format, locale) {
+    const d = parseDate(date);
+    const presetFormats = {
+        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 = {
+    s: 'seconds',
+    m: 'minutes',
+    h: 'hours',
+    d: 'days',
+    w: 'weeks',
+    M: 'months',
+    y: 'years',
+};
+function parseMsString(value) {
+    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 =============
+function dateAdd(date, amount, unit) {
+    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;
+}
+function dateSubtract(date, amount, unit) {
+    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 =============
+function calculateTimeRemaining(endDate, startDate = new Date()) {
+    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, maxUnit) {
+    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) {
+    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;
+    }
+}
+function formatCountdown(timeRemaining, format = 'digital', maxUnit) {
+    const resolved = resolveFormatAlias(format);
+    const capped = maxUnit ? applyMaxUnit(timeRemaining, maxUnit) : timeRemaining;
+    const { days, hours, minutes, seconds, totalSeconds } = capped;
+    if (resolved === 'column') {
+        const colParts = [];
+        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 = [];
+            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 = [];
+            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 =============
+function toOrdinal(num) {
+    const suffixes = ['th', 'st', 'nd', 'rd'];
+    const v = num % 100;
+    return num + (suffixes[(v - 20) % 10] || suffixes[v] || suffixes[0]);
+}
+function toMonthName(month, format = 'long', locale = 'en-US') {
+    const date = new Date(2000, month - 1, 1);
+    return date.toLocaleDateString(locale, { month: format });
+}
+function toDayName(day, format = 'long', locale = 'en-US') {
+    const date = new Date(2000, 0, 2 + day);
+    return date.toLocaleDateString(locale, { weekday: format });
+}
+function relativeTime(date, locale = 'en-US') {
+    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;
+    let unit;
+    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 =============
+function countdownDaysTotal(startDate, endDate) {
+    return Math.floor(calculateTimeRemaining(endDate, startDate).totalSeconds / 86400);
+}
+function countdownHoursTotal(startDate, endDate) {
+    return Math.floor(calculateTimeRemaining(endDate, startDate).totalSeconds / 3600);
+}
+function countdownMinutesTotal(startDate, endDate) {
+    return Math.floor(calculateTimeRemaining(endDate, startDate).totalSeconds / 60);
+}
+function countdownSecondsTotal(startDate, endDate) {
+    return calculateTimeRemaining(endDate, startDate).totalSeconds;
+}
+function countdownFrom(endDate, startDate = new Date(), format = 'digital', maxUnit) {
+    return formatCountdown(calculateTimeRemaining(endDate, startDate), format, maxUnit);
+}
+// ============= Export All Filters =============
+exports.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/dist/filters/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ */
+export declare const ALL_FILTERS: Record<string, (...args: any[]) => any>;
+export declare function applyFilterChain(value: any, filterChain: string): any;
+/**
+ * Replace {{ variable }} and {{ variable | filter: arg }} occurrences in text.
+ * Mirror of the web replaceVariablesWithFilters — unresolved variables are
+ * left untouched.
+ */
+export declare function replaceVariablesWithFilters(text: string, variables: Record<string, any>): string;
+export { DATE_FILTERS } from './dateFilters';
+export type { CountdownFormat, TimeRemaining, MaxUnit } from './dateFilters';