@explorins/pers-sdk-react-native 2.3.3 → 2.3.5

package/dist/index.js

@@ -3445,10 +3445,6 @@ const getOperatorText = (op) => operatorText[op];
  * Does not check cross-field comparisons (use validateFieldComparisons for that).
  */
 const validateFieldValue = (value, rules, fieldType) => {
-    // No rules = valid
-    if (!rules) {
-        return null;
-    }
     const stringValue = value !== null && value !== undefined ? String(value) : '';
     const isEmpty = value === null || value === undefined || value === '';
     // Skip validation if empty - required-ness is determined by requiredUserFields
@@ -3456,16 +3452,17 @@ const validateFieldValue = (value, rules, fieldType) => {
     if (isEmpty) {
         return null;
     }
-    // Type-specific validation
+    // Type-specific validation (happens regardless of rules)
+    // Rules object only controls additional constraints (min/max, length, etc.)
     switch (fieldType) {
         case 'text':
-            if (rules.minLength && stringValue.length < rules.minLength) {
+            if (rules?.minLength && stringValue.length < rules.minLength) {
                 return { field: '', message: `Minimum ${rules.minLength} characters required`, code: 'minLength' };
             }
-            if (rules.maxLength && stringValue.length > rules.maxLength) {
+            if (rules?.maxLength && stringValue.length > rules.maxLength) {
                 return { field: '', message: `Maximum ${rules.maxLength} characters allowed`, code: 'maxLength' };
             }
-            if (rules.pattern && !new RegExp(rules.pattern).test(stringValue)) {
+            if (rules?.pattern && !new RegExp(rules.pattern).test(stringValue)) {
                 return { field: '', message: rules.patternMessage || 'Invalid format', code: 'pattern' };
             }
             break;
@@ -3473,7 +3470,7 @@ const validateFieldValue = (value, rules, fieldType) => {
             if (stringValue.length > EMAIL_MAX_LENGTH || !EMAIL_REGEX.test(stringValue)) {
                 return { field: '', message: 'Invalid email format', code: 'email' };
             }
-            if (rules.maxLength && stringValue.length > rules.maxLength) {
+            if (rules?.maxLength && stringValue.length > rules.maxLength) {
                 return { field: '', message: `Maximum ${rules.maxLength} characters allowed`, code: 'maxLength' };
             }
             break;
@@ -3481,19 +3478,20 @@ const validateFieldValue = (value, rules, fieldType) => {
             if (!URL_REGEX.test(stringValue)) {
                 return { field: '', message: 'Invalid URL format', code: 'url' };
             }
-            if (rules.maxLength && stringValue.length > rules.maxLength) {
+            if (rules?.maxLength && stringValue.length > rules.maxLength) {
                 return { field: '', message: `Maximum ${rules.maxLength} characters allowed`, code: 'maxLength' };
             }
             break;
         case 'number':
             const numValue = typeof value === 'number' ? value : parseFloat(stringValue);
-            if (isNaN(numValue)) {
+            // Check if string contains non-numeric garbage
+            if (isNaN(numValue) || (typeof value === 'string' && !/^-?\d*\.?\d+$/.test(stringValue.trim()))) {
                 return { field: '', message: 'Must be a valid number', code: 'type' };
             }
-            if (rules.min !== undefined && numValue < rules.min) {
+            if (rules?.min !== undefined && numValue < rules.min) {
                 return { field: '', message: `Minimum value is ${rules.min}`, code: 'min' };
             }
-            if (rules.max !== undefined && numValue > rules.max) {
+            if (rules?.max !== undefined && numValue > rules.max) {
                 return { field: '', message: `Maximum value is ${rules.max}`, code: 'max' };
             }
             break;
@@ -3508,7 +3506,7 @@ const validateFieldValue = (value, rules, fieldType) => {
                 return { field: '', message: 'Must be a valid date', code: 'type' };
             }
             const now = new Date();
-            if (rules.minDate) {
+            if (rules?.minDate) {
                 const minDate = rules.minDate === 'now' ? now : new Date(rules.minDate);
                 if (dateValue < minDate) {
                     return {
@@ -3518,7 +3516,7 @@ const validateFieldValue = (value, rules, fieldType) => {
                     };
                 }
             }
-            if (rules.maxDate) {
+            if (rules?.maxDate) {
                 const maxDate = rules.maxDate === 'now' ? now : new Date(rules.maxDate);
                 if (dateValue > maxDate) {
                     return {
@@ -3535,10 +3533,10 @@ const validateFieldValue = (value, rules, fieldType) => {
             if (!phoneRegex.test(stringValue)) {
                 return { field: '', message: 'Invalid phone number format', code: 'phone' };
             }
-            if (rules.minLength && stringValue.replace(/\D/g, '').length < rules.minLength) {
+            if (rules?.minLength && stringValue.replace(/\D/g, '').length < rules.minLength) {
                 return { field: '', message: `Phone number too short`, code: 'minLength' };
             }
-            if (rules.maxLength && stringValue.length > rules.maxLength) {
+            if (rules?.maxLength && stringValue.length > rules.maxLength) {
                 return { field: '', message: `Maximum ${rules.maxLength} characters allowed`, code: 'maxLength' };
             }
             break;
@@ -3552,10 +3550,10 @@ const validateFieldValue = (value, rules, fieldType) => {
             if (!Array.isArray(value)) {
                 return { field: '', message: 'Must be an array', code: 'type' };
             }
-            if (rules.minItems !== undefined && value.length < rules.minItems) {
+            if (rules?.minItems !== undefined && value.length < rules.minItems) {
                 return { field: '', message: `Select at least ${rules.minItems} options`, code: 'minItems' };
             }
-            if (rules.maxItems !== undefined && value.length > rules.maxItems) {
+            if (rules?.maxItems !== undefined && value.length > rules.maxItems) {
                 return { field: '', message: `Select at most ${rules.maxItems} options`, code: 'maxItems' };
             }
             // Validate each item is a string
@@ -4249,6 +4247,54 @@ function isBookingStatusValid(status, requirement) {
             return false;
     }
 }
+/**
+ * Compute booking status based on check-in and check-out dates.
+ *
+ * Logic:
+ * - 'past': Check-out date is before today (booking ended yesterday or earlier)
+ * - 'active': Check-in date is today or earlier, AND check-out is today or later (guest is staying)
+ * - 'future': Check-in date is after today (upcoming booking)
+ *
+ * Note: Checkout day itself counts as 'active' since guest is there until end of day.
+ *
+ * @param checkInDate - Booking start date
+ * @param checkOutDate - Booking end date
+ * @param referenceDate - Date to compare against (defaults to current date)
+ * @returns Computed booking status
+ * @throws Error if checkOutDate is not after checkInDate
+ *
+ * @example
+ * // Today is June 5
+ * computeBookingStatus('2026-06-01', '2026-06-04') // 'past' (checked out yesterday)
+ * computeBookingStatus('2026-06-01', '2026-06-05') // 'active' (checking out today)
+ * computeBookingStatus('2026-06-03', '2026-06-08') // 'active' (currently staying)
+ * computeBookingStatus('2026-06-10', '2026-06-15') // 'future' (upcoming)
+ */
+function computeBookingStatus(checkInDate, checkOutDate, referenceDate = new Date()) {
+    // Normalize all dates to start of day (00:00:00)
+    const now = new Date(referenceDate);
+    const checkIn = new Date(checkInDate);
+    const checkOut = new Date(checkOutDate);
+    now.setHours(0, 0, 0, 0);
+    checkIn.setHours(0, 0, 0, 0);
+    checkOut.setHours(0, 0, 0, 0);
+    // Defensive validation: checkOut must be after checkIn
+    // This catches invalid data from frontend or data integrity issues
+    if (checkOut <= checkIn) {
+        throw new Error(`Invalid booking dates: checkOut (${checkOut.toISOString()}) must be after checkIn (${checkIn.toISOString()})`);
+    }
+    // Checkout day itself counts as still active (guest there until end of day)
+    if (checkOut < now) {
+        return 'past';
+    }
+    else if (checkIn <= now) {
+        // Note: checkOut >= now is implicit here (already ruled out checkOut < now above)
+        return 'active';
+    }
+    else {
+        return 'future';
+    }
+}
 
 /**
  * Unified data source tracking for analytics across all entities.
@@ -12075,7 +12121,7 @@ class DefaultAuthProvider {
 /** SDK package name */
 const SDK_NAME = "@explorins/pers-sdk";
 /** SDK version - injected from package.json at build time */
-const SDK_VERSION = "2.3.3";
+const SDK_VERSION = "2.3.10";
 /** Full SDK identifier for headers */
 const SDK_USER_AGENT = `${SDK_NAME}/${SDK_VERSION}`;
 
@@ -50637,6 +50683,7 @@ exports.buildWalletEventsWsUrl = buildWalletEventsWsUrl;
 exports.builtInUserFieldMetadata = builtInUserFieldMetadata;
 exports.builtInUserFields = builtInUserFields;
 exports.compareValues = compareValues;
+exports.computeBookingStatus = computeBookingStatus;
 exports.createPersEventsClient = createPersEventsClient;
 exports.createPersSDK = createPersSDK;
 exports.createReactNativeAuthProvider = createReactNativeAuthProvider;