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

package/dist/utils/calendarIntegration.d.ts

@@ -0,0 +1,36 @@
+export interface CalendarEvent {
+    title: string;
+    description?: string;
+    location?: string;
+    startDate: Date;
+    endDate: Date;
+    allDay?: boolean;
+    url?: string;
+    notes?: string;
+}
+export interface CalendarPermissionStatus {
+    granted: boolean;
+    canRequest: boolean;
+}
+export interface CalendarResult {
+    success: boolean;
+    eventId?: string;
+    error?: string;
+}
+/**
+ * Request calendar permissions
+ * Note: Requires react-native-calendar-events package
+ */
+export declare function requestCalendarPermission(): Promise<CalendarPermissionStatus>;
+/**
+ * Check current calendar permission status
+ */
+export declare function checkCalendarPermission(): Promise<CalendarPermissionStatus>;
+/**
+ * Add event to calendar
+ */
+export declare function addCalendarEvent(event: CalendarEvent): Promise<CalendarResult>;
+/**
+ * Check if calendar is supported
+ */
+export declare function isCalendarSupported(): boolean;

package/dist/utils/calendarIntegration.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestCalendarPermission = requestCalendarPermission;
+exports.checkCalendarPermission = checkCalendarPermission;
+exports.addCalendarEvent = addCalendarEvent;
+exports.isCalendarSupported = isCalendarSupported;
+const react_native_1 = require("react-native");
+/**
+ * Request calendar permissions
+ * Note: Requires react-native-calendar-events package
+ */
+async function requestCalendarPermission() {
+    try {
+        // Dynamic import to avoid errors if package not installed
+        const RNCalendarEvents = require('react-native-calendar-events');
+        if (react_native_1.Platform.OS === 'android' && react_native_1.Platform.Version >= 23) {
+            const granted = await react_native_1.PermissionsAndroid.request(react_native_1.PermissionsAndroid.PERMISSIONS.WRITE_CALENDAR);
+            return {
+                granted: granted === react_native_1.PermissionsAndroid.RESULTS.GRANTED,
+                canRequest: granted !== react_native_1.PermissionsAndroid.RESULTS.NEVER_ASK_AGAIN,
+            };
+        }
+        const status = await RNCalendarEvents.requestPermissions();
+        return {
+            granted: status === 'authorized',
+            canRequest: status === 'undetermined',
+        };
+    }
+    catch (error) {
+        console.warn('react-native-calendar-events not installed');
+        return { granted: false, canRequest: false };
+    }
+}
+/**
+ * Check current calendar permission status
+ */
+async function checkCalendarPermission() {
+    try {
+        const RNCalendarEvents = require('react-native-calendar-events');
+        const status = await RNCalendarEvents.checkPermissions();
+        return {
+            granted: status === 'authorized',
+            canRequest: status === 'undetermined',
+        };
+    }
+    catch (error) {
+        return { granted: false, canRequest: false };
+    }
+}
+/**
+ * Add event to calendar
+ */
+async function addCalendarEvent(event) {
+    try {
+        const RNCalendarEvents = require('react-native-calendar-events');
+        const permission = await checkCalendarPermission();
+        if (!permission.granted) {
+            return { success: false, error: 'Calendar permission not granted' };
+        }
+        const eventId = await RNCalendarEvents.saveEvent(event.title, {
+            startDate: event.startDate.toISOString(),
+            endDate: event.endDate.toISOString(),
+            description: event.description,
+            location: event.location,
+            allDay: event.allDay,
+            notes: event.notes,
+            url: event.url,
+        });
+        return { success: true, eventId };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to add event',
+        };
+    }
+}
+/**
+ * Check if calendar is supported
+ */
+function isCalendarSupported() {
+    try {
+        require('react-native-calendar-events');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/configurationResolver.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Configuration resolver for React Native
+ * Implements fallback logic for multi-device configurations
+ */
+import { PaywallConfiguration } from '../types';
+import { DeviceCategory } from './deviceDetection';
+export interface MultiPaywallConfig {
+    phone_portrait?: PaywallConfiguration;
+    phone_landscape?: PaywallConfiguration;
+    xl_phone_portrait?: PaywallConfiguration;
+    xl_phone_landscape?: PaywallConfiguration;
+    tablet_portrait?: PaywallConfiguration;
+    tablet_landscape?: PaywallConfiguration;
+    desktop_web?: PaywallConfiguration;
+}
+/**
+ * Find the nearest existing configuration for fallback
+ */
+export declare function findNearestConfig(multiConfig: MultiPaywallConfig, targetCategory: DeviceCategory): DeviceCategory | null;
+/**
+ * Resolve the appropriate configuration with fallback logic
+ */
+export declare function resolveConfiguration(multiConfig: MultiPaywallConfig, targetCategory: DeviceCategory): PaywallConfiguration | null;

package/dist/utils/configurationResolver.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Configuration resolver for React Native
+ * Implements fallback logic for multi-device configurations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNearestConfig = findNearestConfig;
+exports.resolveConfiguration = resolveConfiguration;
+const DEVICE_GROUPS = {
+    phone_portrait: { group: 'phone', orientation: 'portrait' },
+    phone_landscape: { group: 'phone', orientation: 'landscape' },
+    xl_phone_portrait: { group: 'xl_phone', orientation: 'portrait' },
+    xl_phone_landscape: { group: 'xl_phone', orientation: 'landscape' },
+    tablet_portrait: { group: 'tablet', orientation: 'portrait' },
+    tablet_landscape: { group: 'tablet', orientation: 'landscape' },
+    desktop_web: { group: 'desktop', orientation: 'landscape' },
+};
+/**
+ * Find the nearest existing configuration for fallback
+ */
+function findNearestConfig(multiConfig, targetCategory) {
+    const targetInfo = DEVICE_GROUPS[targetCategory];
+    // Priority 1: Same device group, same orientation
+    const sameGroupSameOrientation = Object.keys(DEVICE_GROUPS)
+        .find(cat => cat !== targetCategory &&
+        DEVICE_GROUPS[cat].group === targetInfo.group &&
+        DEVICE_GROUPS[cat].orientation === targetInfo.orientation &&
+        multiConfig[cat]);
+    if (sameGroupSameOrientation)
+        return sameGroupSameOrientation;
+    // Priority 2: Same device group, different orientation
+    const sameGroupDiffOrientation = Object.keys(DEVICE_GROUPS)
+        .find(cat => cat !== targetCategory &&
+        DEVICE_GROUPS[cat].group === targetInfo.group &&
+        multiConfig[cat]);
+    if (sameGroupDiffOrientation)
+        return sameGroupDiffOrientation;
+    // Priority 3: Fallback to smaller device in same orientation
+    if (targetInfo.group === 'xl_phone') {
+        const phoneEquivalent = targetInfo.orientation === 'portrait'
+            ? 'phone_portrait'
+            : 'phone_landscape';
+        if (multiConfig[phoneEquivalent])
+            return phoneEquivalent;
+    }
+    if (targetInfo.group === 'tablet') {
+        const xlPhoneEquivalent = targetInfo.orientation === 'portrait'
+            ? 'xl_phone_portrait'
+            : 'xl_phone_landscape';
+        if (multiConfig[xlPhoneEquivalent])
+            return xlPhoneEquivalent;
+        const phoneEquivalent = targetInfo.orientation === 'portrait'
+            ? 'phone_portrait'
+            : 'phone_landscape';
+        if (multiConfig[phoneEquivalent])
+            return phoneEquivalent;
+    }
+    // Priority 4: Phone portrait (base config - ALWAYS exists)
+    if (multiConfig.phone_portrait && targetCategory !== 'phone_portrait') {
+        return 'phone_portrait';
+    }
+    return null;
+}
+/**
+ * Resolve the appropriate configuration with fallback logic
+ */
+function resolveConfiguration(multiConfig, targetCategory) {
+    // Try to get specific configuration
+    let config = multiConfig[targetCategory];
+    // If not found, use fallback logic
+    if (!config) {
+        const nearestCategory = findNearestConfig(multiConfig, targetCategory);
+        if (nearestCategory) {
+            config = multiConfig[nearestCategory];
+        }
+    }
+    return config || null;
+}

package/dist/utils/deviceDetection.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Device detection utilities for React Native
+ */
+export type DeviceCategory = 'phone_portrait' | 'phone_landscape' | 'xl_phone_portrait' | 'xl_phone_landscape' | 'tablet_portrait' | 'tablet_landscape' | 'desktop_web';
+export interface DeviceCategoryInfo {
+    category: DeviceCategory;
+    label: string;
+    dimensions: {
+        width: number;
+        height: number;
+    };
+    orientation: 'portrait' | 'landscape';
+    group: 'phone' | 'xl_phone' | 'tablet' | 'desktop';
+    osName: string;
+    osVersion: string;
+}
+/**
+ * Detect device category based on current dimensions
+ */
+export declare function detectDeviceCategory(): DeviceCategory;
+/**
+ * Get device info including OS details
+ */
+export declare function getDeviceInfo(): {
+    width: number;
+    height: number;
+    category: DeviceCategory;
+    platform: "ios" | "android" | "windows" | "macos" | "web";
+    osName: string;
+    osVersion: string;
+    isTablet: boolean;
+    isPhone: boolean;
+    orientation: string;
+};
+/**
+ * Check if device is a tablet
+ */
+export declare function isTablet(): boolean;

package/dist/utils/deviceDetection.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Device detection utilities for React Native
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectDeviceCategory = detectDeviceCategory;
+exports.getDeviceInfo = getDeviceInfo;
+exports.isTablet = isTablet;
+const react_native_1 = require("react-native");
+/**
+ * Detect device category based on current dimensions
+ */
+function detectDeviceCategory() {
+    const { width, height } = react_native_1.Dimensions.get('window');
+    const isLandscape = width > height;
+    // Desktop web (viewport >= 1200px)
+    if (width >= 1200)
+        return 'desktop_web';
+    // Tablet range (700-1200px)
+    if (width >= 700 && width < 1200) {
+        return isLandscape ? 'tablet_landscape' : 'tablet_portrait';
+    }
+    // XL Phone range (430-700px width)
+    if (width >= 430 && width < 700) {
+        return isLandscape ? 'xl_phone_landscape' : 'xl_phone_portrait';
+    }
+    // Standard phone (<430px)
+    return isLandscape ? 'phone_landscape' : 'phone_portrait';
+}
+/**
+ * Get device info including OS details
+ */
+function getDeviceInfo() {
+    const { width, height } = react_native_1.Dimensions.get('window');
+    const category = detectDeviceCategory();
+    // Get OS name (capitalize first letter)
+    const osName = react_native_1.Platform.OS === 'ios' ? 'iOS' : react_native_1.Platform.OS === 'android' ? 'Android' : 'Web';
+    // Get OS version
+    const osVersion = String(react_native_1.Platform.Version || 'Unknown');
+    return {
+        width,
+        height,
+        category,
+        platform: react_native_1.Platform.OS,
+        osName,
+        osVersion,
+        isTablet: category.includes('tablet'),
+        isPhone: category.includes('phone'),
+        orientation: width > height ? 'landscape' : 'portrait',
+    };
+}
+/**
+ * Check if device is a tablet
+ */
+function isTablet() {
+    const { width, height } = react_native_1.Dimensions.get('window');
+    const minDimension = Math.min(width, height);
+    return minDimension >= 700;
+}

package/dist/utils/hapticFeedback.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Haptic feedback utilities for React Native
+ */
+export type HapticType = 'light' | 'medium' | 'heavy' | 'success' | 'warning' | 'error';
+/**
+ * Trigger haptic feedback
+ * Phase 4.5: Integrated with paywall action execution
+ */
+export declare function triggerHaptic(type: HapticType, intensity?: number): void;
+/**
+ * Trigger haptic from WebView action (Phase 4.5)
+ */
+export declare function triggerHapticFromAction(hapticType?: string): void;
+/**
+ * Check if haptic feedback is available
+ */
+export declare function isHapticAvailable(): boolean;

package/dist/utils/hapticFeedback.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Haptic feedback utilities for React Native
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.triggerHaptic = triggerHaptic;
+exports.triggerHapticFromAction = triggerHapticFromAction;
+exports.isHapticAvailable = isHapticAvailable;
+const react_native_1 = require("react-native");
+/**
+ * Trigger haptic feedback
+ * Phase 4.5: Integrated with paywall action execution
+ */
+function triggerHaptic(type, intensity = 1.0) {
+    if (react_native_1.Platform.OS === 'ios') {
+        // iOS uses native haptic feedback (requires expo-haptics or react-native-haptic-feedback)
+        // For now, use basic vibration
+        const duration = getHapticDuration(type, intensity);
+        react_native_1.Vibration.vibrate(duration);
+    }
+    else if (react_native_1.Platform.OS === 'android') {
+        // Android vibration
+        const duration = getHapticDuration(type, intensity);
+        react_native_1.Vibration.vibrate(duration);
+    }
+}
+/**
+ * Trigger haptic from WebView action (Phase 4.5)
+ */
+function triggerHapticFromAction(hapticType) {
+    const type = (hapticType || 'medium');
+    triggerHaptic(type);
+}
+/**
+ * Get vibration duration for haptic type
+ */
+function getHapticDuration(type, intensity) {
+    const baseDurations = {
+        light: 10,
+        medium: 20,
+        heavy: 40,
+        success: 15,
+        warning: 25,
+        error: 30,
+    };
+    return Math.round(baseDurations[type] * intensity);
+}
+/**
+ * Check if haptic feedback is available
+ */
+function isHapticAvailable() {
+    return react_native_1.Platform.OS === 'ios' || react_native_1.Platform.OS === 'android';
+}

package/dist/utils/iconMapper.d.ts

@@ -0,0 +1,26 @@
+/**
+ * React Native uses Lucide directly - no mapping needed
+ * This file exists for consistency with other platforms
+ * and to provide a unified API
+ */
+export interface IconMapperResult {
+    component: React.ComponentType<any> | null;
+    fallback: string | null;
+}
+/**
+ * Get Lucide icon component by name
+ * React Native renders Lucide icons directly (best cross-platform solution for RN)
+ */
+export declare function getLucideIcon(iconName: string): IconMapperResult;
+/**
+ * Check if icon exists in Lucide library
+ */
+export declare function hasLucideIcon(iconName: string): boolean;
+/**
+ * Get all available Lucide icon names
+ */
+export declare function getAvailableIcons(): string[];
+/**
+ * Recommended cross-platform icons (guaranteed to look good everywhere)
+ */
+export declare const RECOMMENDED_ICONS: string[];

package/dist/utils/iconMapper.js

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECOMMENDED_ICONS = void 0;
+exports.getLucideIcon = getLucideIcon;
+exports.hasLucideIcon = hasLucideIcon;
+exports.getAvailableIcons = getAvailableIcons;
+const LucideIcons = __importStar(require("lucide-react-native"));
+/**
+ * Get Lucide icon component by name
+ * React Native renders Lucide icons directly (best cross-platform solution for RN)
+ */
+function getLucideIcon(iconName) {
+    const icons = LucideIcons;
+    const IconComponent = icons[iconName];
+    if (IconComponent && typeof IconComponent === 'function') {
+        return {
+            component: IconComponent,
+            fallback: null,
+        };
+    }
+    // Return fallback
+    return {
+        component: null,
+        fallback: iconName,
+    };
+}
+/**
+ * Check if icon exists in Lucide library
+ */
+function hasLucideIcon(iconName) {
+    const icons = LucideIcons;
+    return iconName in icons && typeof icons[iconName] === 'function';
+}
+/**
+ * Get all available Lucide icon names
+ */
+function getAvailableIcons() {
+    const icons = LucideIcons;
+    return Object.keys(icons).filter(key => typeof icons[key] === 'function');
+}
+/**
+ * Recommended cross-platform icons (guaranteed to look good everywhere)
+ */
+exports.RECOMMENDED_ICONS = [
+    // Core Navigation & Actions
+    'Star', 'Heart', 'Home', 'Settings', 'User', 'Search', 'Menu', 'X', 'Check',
+    'ChevronRight', 'ChevronLeft', 'ChevronDown', 'ChevronUp', 'Plus', 'Minus',
+    'Edit', 'Trash', 'Calendar', 'Clock', 'Mail', 'Phone', 'Camera', 'Image',
+    'Video', 'Music', 'Download', 'Upload', 'Share', 'Info', 'AlertTriangle',
+    'Lock', 'Eye', 'Bell', 'ShoppingCart', 'Gift', 'Globe', 'ArrowRight', 'ArrowLeft',
+    // Forms & Controls (expanded)
+    'CheckSquare', 'Square', 'ToggleRight', 'Bold', 'Italic', 'AlignLeft',
+    'AlignCenter', 'AlignRight', 'List', 'Palette', 'Crop', 'RotateCw',
+    // Arrows & Navigation (expanded)
+    'ArrowUp', 'ArrowDown', 'ArrowUpRight', 'ChevronsRight', 'Repeat', 'Undo',
+    'Redo', 'Navigation', 'Compass', 'Expand', 'Minimize',
+    // E-commerce (expanded)
+    'Store', 'ShoppingBag', 'Wallet', 'CreditCard', 'Package', 'Truck',
+    'Receipt', 'Barcode', 'QrCode', 'Tag', 'Percent',
+    // Communication (expanded)
+    'MessageCircle', 'MessageSquare', 'MailOpen', 'Inbox', 'Send', 'Reply',
+    'Phone', 'Mic', 'Users', 'UserPlus', 'Contact', 'Award',
+    // Files & Documents (expanded)
+    'File', 'FileText', 'Folder', 'FolderOpen', 'Save', 'Copy', 'Clipboard',
+    'Paperclip', 'Link', 'Database',
+    // Media (expanded)
+    'Play', 'Pause', 'SkipForward', 'Volume2', 'Film', 'Radio', 'Tv',
+    // Charts & Data (expanded)
+    'BarChart', 'LineChart', 'PieChart', 'Activity', 'TrendingUp', 'TrendingDown',
+    'Zap', 'Signal', 'Network',
+    // Transportation
+    'Car', 'Bus', 'Train', 'Plane', 'Bike', 'MapPin', 'Map',
+    // Health & Lifestyle
+    'Heart', 'Pill', 'Coffee', 'Pizza', 'Leaf', 'Accessibility',
+    // Weather
+    'Sun', 'Moon', 'Cloud', 'CloudRain', 'CloudSnow', 'Droplet', 'Wind',
+    // System & Miscellaneous
+    'Grid', 'Layers', 'Filter', 'RefreshCw', 'Code', 'Power', 'Battery',
+    'Sparkles', 'Crown', 'Shield', 'Timer', 'Flag', 'Target',
+];

package/dist/utils/notificationPermissions.d.ts

@@ -0,0 +1,13 @@
+export type NotificationPermissionStatus = 'granted' | 'denied' | 'default';
+/**
+ * Request push notification permissions
+ */
+export declare function requestNotificationPermission(): Promise<NotificationPermissionStatus>;
+/**
+ * Check current notification permission status
+ */
+export declare function checkNotificationPermission(): Promise<NotificationPermissionStatus>;
+/**
+ * Check if notifications are supported
+ */
+export declare function isNotificationSupported(): boolean;

package/dist/utils/notificationPermissions.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestNotificationPermission = requestNotificationPermission;
+exports.checkNotificationPermission = checkNotificationPermission;
+exports.isNotificationSupported = isNotificationSupported;
+const react_native_1 = require("react-native");
+const react_native_push_notification_1 = __importDefault(require("react-native-push-notification"));
+/**
+ * Request push notification permissions
+ */
+async function requestNotificationPermission() {
+    if (react_native_1.Platform.OS === 'ios') {
+        return new Promise((resolve) => {
+            react_native_push_notification_1.default.requestPermissions((permissions) => {
+                resolve(permissions.alert ? 'granted' : 'denied');
+            });
+        });
+    }
+    else if (react_native_1.Platform.OS === 'android') {
+        if (react_native_1.Platform.Version >= 33) {
+            const granted = await react_native_1.PermissionsAndroid.request(react_native_1.PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS);
+            return granted === react_native_1.PermissionsAndroid.RESULTS.GRANTED ? 'granted' : 'denied';
+        }
+        return 'granted'; // Granted by default on older Android versions
+    }
+    return 'denied';
+}
+/**
+ * Check current notification permission status
+ */
+async function checkNotificationPermission() {
+    return new Promise((resolve) => {
+        react_native_push_notification_1.default.checkPermissions((permissions) => {
+            if (permissions.alert === true || permissions.alert === 1) {
+                resolve('granted');
+            }
+            else {
+                resolve('denied');
+            }
+        });
+    });
+}
+/**
+ * Check if notifications are supported
+ */
+function isNotificationSupported() {
+    return true;
+}

package/dist/utils/priceFormatting.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Utilities for formatting prices and subscription periods
+ */
+/**
+ * Format a price with currency
+ */
+export declare function formatPrice(price: number, currency?: string, locale?: string): string;
+/**
+ * Format a subscription period
+ */
+export declare function formatSubscriptionPeriod(duration: number, period: string, locale?: string): string;
+/**
+ * Format intro pricing info
+ */
+export declare function formatIntroPricing(introPrice: number | null | undefined, introDuration: number | null | undefined, introPeriod: string | null | undefined, introCycles: number | null | undefined, currency?: string, locale?: string): string | null;
+/**
+ * Helper to get package type display name
+ */
+export declare function getPackageTypeDisplayName(packageType: string): string;