@usertour/helpers 0.0.43 → 0.0.45

package/dist/__tests__/get-attribute-type.test.cjs

@@ -14,46 +14,34 @@ var objToString = ObjProto.toString;
 var objHasOwn = ObjProto.hasOwnProperty;
 
 // src/attribute.ts
-var isValidYear = (date) => {
-  const year = date.getFullYear();
-  return year >= 1900 && year <= 2100;
-};
-var tryParseDate = (parser) => {
-  try {
-    const date = parser();
-    return (0, import_date_fns.isValid)(date) && isValidYear(date);
-  } catch {
+var isValidISO8601 = (value) => {
+  if (typeof value !== "string") {
     return false;
   }
-};
-function isDateString(dateStr) {
-  if (!Number.isNaN(Number(dateStr)) || dateStr.length < 10) {
+  const iso8601Pattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/;
+  if (!iso8601Pattern.test(value)) {
     return false;
   }
-  const dateFormats = [
-    "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
-    "yyyy-MM-dd'T'HH:mm:ss'Z'",
-    "yyyy-MM-dd'T'HH:mm:ss.SSS",
-    "yyyy-MM-dd'T'HH:mm:ss",
-    "yyyy-MM-dd",
-    "MM/dd/yyyy",
-    "dd/MM/yyyy",
-    "yyyy/MM/dd",
-    "MM-dd-yyyy",
-    "dd-MM-yyyy"
-  ];
-  if (tryParseDate(() => (0, import_date_fns.parseISO)(dateStr))) {
-    return true;
+  try {
+    const date = (0, import_date_fns.parseISO)(value);
+    if (!(0, import_date_fns.isValid)(date)) {
+      return false;
+    }
+    const isoString = date.toISOString();
+    const normalizedInput = value.replace(/\.\d{3}Z$/, "Z");
+    const normalizedIso = isoString.replace(/\.\d{3}Z$/, "Z");
+    return normalizedInput === normalizedIso || value === isoString;
+  } catch {
+    return false;
   }
-  return dateFormats.some((format) => tryParseDate(() => (0, import_date_fns.parse)(dateStr, format, /* @__PURE__ */ new Date())));
-}
+};
 var getAttributeType = (attribute) => {
   const t = typeof attribute;
   if (t === "number") {
     return import_types.BizAttributeTypes.Number;
   }
   if (t === "string") {
-    if (isDateString(attribute)) {
+    if (isValidISO8601(attribute)) {
       return import_types.BizAttributeTypes.DateTime;
     }
     return import_types.BizAttributeTypes.String;
@@ -100,39 +88,45 @@ describe("getAttributeType", () => {
       expect(getAttributeType("123abc")).toBe(import_types2.BizAttributeTypes.String);
     });
   });
-  describe("DateTime type", () => {
-    test("should return DateTime for ISO 8601 format with time", () => {
+  describe("DateTime type - ISO 8601 UTC only", () => {
+    test("should return DateTime for ISO 8601 format with milliseconds and Z", () => {
       expect(getAttributeType("2024-12-11T16:00:00.000Z")).toBe(import_types2.BizAttributeTypes.DateTime);
     });
-    test("should return DateTime for ISO 8601 format without milliseconds", () => {
+    test("should return DateTime for ISO 8601 format without milliseconds but with Z", () => {
       expect(getAttributeType("2024-12-11T16:00:00Z")).toBe(import_types2.BizAttributeTypes.DateTime);
     });
-    test("should return DateTime for ISO 8601 format without timezone", () => {
-      expect(getAttributeType("2024-12-11T16:00:00")).toBe(import_types2.BizAttributeTypes.DateTime);
+    test("should return DateTime for ISO 8601 format at midnight", () => {
+      expect(getAttributeType("2024-12-11T00:00:00.000Z")).toBe(import_types2.BizAttributeTypes.DateTime);
+    });
+    test("should return DateTime for ISO 8601 format at end of day", () => {
+      expect(getAttributeType("2024-12-11T23:59:59.999Z")).toBe(import_types2.BizAttributeTypes.DateTime);
+    });
+    test("should return String for ISO 8601 format without timezone (no Z)", () => {
+      expect(getAttributeType("2024-12-11T16:00:00")).toBe(import_types2.BizAttributeTypes.String);
     });
-    test("should return DateTime for ISO 8601 date only", () => {
-      expect(getAttributeType("2024-12-11")).toBe(import_types2.BizAttributeTypes.DateTime);
+    test("should return String for ISO 8601 date only (no T and Z)", () => {
+      expect(getAttributeType("2024-12-11")).toBe(import_types2.BizAttributeTypes.String);
     });
-    test("should return DateTime for MM/DD/YYYY format", () => {
-      expect(getAttributeType("12/12/2024")).toBe(import_types2.BizAttributeTypes.DateTime);
+    test("should return String for MM/DD/YYYY format", () => {
+      expect(getAttributeType("12/12/2024")).toBe(import_types2.BizAttributeTypes.String);
     });
-    test("should return DateTime for YYYY/MM/DD format", () => {
-      expect(getAttributeType("2024/12/11")).toBe(import_types2.BizAttributeTypes.DateTime);
+    test("should return String for YYYY/MM/DD format", () => {
+      expect(getAttributeType("2024/12/11")).toBe(import_types2.BizAttributeTypes.String);
     });
-    test("should return DateTime for MM-DD-YYYY format", () => {
-      expect(getAttributeType("12-12-2024")).toBe(import_types2.BizAttributeTypes.DateTime);
+    test("should return String for MM-DD-YYYY format", () => {
+      expect(getAttributeType("12-12-2024")).toBe(import_types2.BizAttributeTypes.String);
     });
-    test("should return DateTime for DD-MM-YYYY format", () => {
-      expect(getAttributeType("11-12-2024")).toBe(import_types2.BizAttributeTypes.DateTime);
+    test("should return String for DD-MM-YYYY format", () => {
+      expect(getAttributeType("11-12-2024")).toBe(import_types2.BizAttributeTypes.String);
     });
-    test("should return String for invalid date string", () => {
-      expect(getAttributeType("2024-13-45")).toBe(import_types2.BizAttributeTypes.String);
+    test("should return String for invalid ISO 8601 format", () => {
+      expect(getAttributeType("2024-13-45T00:00:00.000Z")).toBe(import_types2.BizAttributeTypes.String);
     });
-    test("should return String for date string with invalid year (< 1900)", () => {
-      expect(getAttributeType("1899-12-11")).toBe(import_types2.BizAttributeTypes.String);
+    test("should return String for ISO 8601 with timezone offset (not UTC)", () => {
+      expect(getAttributeType("2024-12-11T16:00:00.000+08:00")).toBe(import_types2.BizAttributeTypes.String);
     });
-    test("should return String for date string with invalid year (> 2100)", () => {
-      expect(getAttributeType("2101-12-11")).toBe(import_types2.BizAttributeTypes.String);
+    test("should return String for ISO 8601 with lowercase z", () => {
+      expect(getAttributeType("2024-12-11T16:00:00.000z")).toBe(import_types2.BizAttributeTypes.String);
     });
   });
   describe("Boolean type", () => {
@@ -182,8 +176,8 @@ describe("getAttributeType", () => {
     test("should return String for string that is exactly 9 characters", () => {
       expect(getAttributeType("123456789")).toBe(import_types2.BizAttributeTypes.String);
     });
-    test("should return DateTime for string that is exactly 10 characters and valid date", () => {
-      expect(getAttributeType("2024-12-11")).toBe(import_types2.BizAttributeTypes.DateTime);
+    test("should return String for string that is exactly 10 characters but not ISO 8601 UTC", () => {
+      expect(getAttributeType("2024-12-11")).toBe(import_types2.BizAttributeTypes.String);
     });
     test("should return String for string that contains date-like pattern but invalid", () => {
       expect(getAttributeType("2024-99-99")).toBe(import_types2.BizAttributeTypes.String);
@@ -193,3 +187,104 @@ describe("getAttributeType", () => {
     });
   });
 });
+describe("isValidISO8601", () => {
+  describe("Valid ISO 8601 UTC formats", () => {
+    test("should return true for ISO 8601 with milliseconds and Z", () => {
+      expect(isValidISO8601("2024-12-11T16:00:00.000Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 without milliseconds but with Z", () => {
+      expect(isValidISO8601("2024-12-11T16:00:00Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 at midnight", () => {
+      expect(isValidISO8601("2024-12-11T00:00:00.000Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 at end of day", () => {
+      expect(isValidISO8601("2024-12-11T23:59:59.999Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 with single digit month and day", () => {
+      expect(isValidISO8601("2024-01-01T00:00:00.000Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 in year 1900", () => {
+      expect(isValidISO8601("1900-01-01T00:00:00.000Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 in year 2100", () => {
+      expect(isValidISO8601("2100-12-31T23:59:59.999Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 with year before 1900", () => {
+      expect(isValidISO8601("1800-01-01T00:00:00.000Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 with year after 2100", () => {
+      expect(isValidISO8601("2200-01-01T00:00:00.000Z")).toBe(true);
+    });
+  });
+  describe("Invalid ISO 8601 UTC formats", () => {
+    test("should return false for non-string values", () => {
+      expect(isValidISO8601(null)).toBe(false);
+      expect(isValidISO8601(void 0)).toBe(false);
+      expect(isValidISO8601(123)).toBe(false);
+      expect(isValidISO8601(/* @__PURE__ */ new Date())).toBe(false);
+      expect(isValidISO8601({})).toBe(false);
+    });
+    test("should return false for ISO 8601 without T separator", () => {
+      expect(isValidISO8601("2024-12-11 16:00:00.000Z")).toBe(false);
+      expect(isValidISO8601("2024-12-11")).toBe(false);
+    });
+    test("should return false for ISO 8601 without Z (UTC indicator)", () => {
+      expect(isValidISO8601("2024-12-11T16:00:00.000")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00")).toBe(false);
+    });
+    test("should return false for ISO 8601 with timezone offset (including +00:00)", () => {
+      expect(isValidISO8601("2024-12-11T16:00:00.000+08:00")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00.000-05:00")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00.000+01:00")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00.000-01:00")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00.000+00:00")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00.000-00:00")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00+00:00")).toBe(false);
+    });
+    test("should return false for ISO 8601 with lowercase z", () => {
+      expect(isValidISO8601("2024-12-11T16:00:00.000z")).toBe(false);
+    });
+    test("should return false for invalid date values", () => {
+      expect(isValidISO8601("2024-13-45T00:00:00.000Z")).toBe(false);
+      expect(isValidISO8601("2024-02-30T00:00:00.000Z")).toBe(false);
+      expect(isValidISO8601("2024-00-00T00:00:00.000Z")).toBe(false);
+    });
+    test("should return false for other date formats", () => {
+      expect(isValidISO8601("12/12/2024")).toBe(false);
+      expect(isValidISO8601("2024/12/11")).toBe(false);
+      expect(isValidISO8601("12-12-2024")).toBe(false);
+      expect(isValidISO8601("11-12-2024")).toBe(false);
+    });
+    test("should return false for malformed ISO 8601 strings", () => {
+      expect(isValidISO8601("2024-12-11T")).toBe(false);
+      expect(isValidISO8601("T16:00:00.000Z")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00.Z")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00.000Z")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00.000")).toBe(false);
+    });
+    test("should return false for empty string", () => {
+      expect(isValidISO8601("")).toBe(false);
+    });
+    test("should return false for string that looks like ISO 8601 but has extra characters", () => {
+      expect(isValidISO8601("2024-12-11T16:00:00.000Z extra")).toBe(false);
+      expect(isValidISO8601("prefix 2024-12-11T16:00:00.000Z")).toBe(false);
+    });
+  });
+  describe("Edge cases", () => {
+    test("should handle leap year correctly", () => {
+      expect(isValidISO8601("2024-02-29T00:00:00.000Z")).toBe(true);
+      expect(isValidISO8601("2023-02-29T00:00:00.000Z")).toBe(false);
+    });
+    test("should handle different time values correctly", () => {
+      expect(isValidISO8601("2024-12-11T12:30:45.123Z")).toBe(true);
+      expect(isValidISO8601("2024-12-11T00:00:00.000Z")).toBe(true);
+      expect(isValidISO8601("2024-12-11T23:59:59.999Z")).toBe(true);
+    });
+    test("should handle milliseconds correctly", () => {
+      expect(isValidISO8601("2024-12-11T16:00:00.000Z")).toBe(true);
+      expect(isValidISO8601("2024-12-11T16:00:00.999Z")).toBe(true);
+      expect(isValidISO8601("2024-12-11T16:00:00Z")).toBe(true);
+    });
+  });
+});

package/dist/__tests__/get-attribute-type.test.js

@@ -1,6 +1,7 @@
 import {
-  getAttributeType
-} from "../chunk-EEYZG4JJ.js";
+  getAttributeType,
+  isValidISO8601
+} from "../chunk-R4R6MDTW.js";
 import "../chunk-GFH3VWOC.js";
 import "../chunk-XEO3YXBM.js";
 
@@ -38,39 +39,45 @@ describe("getAttributeType", () => {
       expect(getAttributeType("123abc")).toBe(BizAttributeTypes.String);
     });
   });
-  describe("DateTime type", () => {
-    test("should return DateTime for ISO 8601 format with time", () => {
+  describe("DateTime type - ISO 8601 UTC only", () => {
+    test("should return DateTime for ISO 8601 format with milliseconds and Z", () => {
       expect(getAttributeType("2024-12-11T16:00:00.000Z")).toBe(BizAttributeTypes.DateTime);
     });
-    test("should return DateTime for ISO 8601 format without milliseconds", () => {
+    test("should return DateTime for ISO 8601 format without milliseconds but with Z", () => {
       expect(getAttributeType("2024-12-11T16:00:00Z")).toBe(BizAttributeTypes.DateTime);
     });
-    test("should return DateTime for ISO 8601 format without timezone", () => {
-      expect(getAttributeType("2024-12-11T16:00:00")).toBe(BizAttributeTypes.DateTime);
+    test("should return DateTime for ISO 8601 format at midnight", () => {
+      expect(getAttributeType("2024-12-11T00:00:00.000Z")).toBe(BizAttributeTypes.DateTime);
     });
-    test("should return DateTime for ISO 8601 date only", () => {
-      expect(getAttributeType("2024-12-11")).toBe(BizAttributeTypes.DateTime);
+    test("should return DateTime for ISO 8601 format at end of day", () => {
+      expect(getAttributeType("2024-12-11T23:59:59.999Z")).toBe(BizAttributeTypes.DateTime);
     });
-    test("should return DateTime for MM/DD/YYYY format", () => {
-      expect(getAttributeType("12/12/2024")).toBe(BizAttributeTypes.DateTime);
+    test("should return String for ISO 8601 format without timezone (no Z)", () => {
+      expect(getAttributeType("2024-12-11T16:00:00")).toBe(BizAttributeTypes.String);
     });
-    test("should return DateTime for YYYY/MM/DD format", () => {
-      expect(getAttributeType("2024/12/11")).toBe(BizAttributeTypes.DateTime);
+    test("should return String for ISO 8601 date only (no T and Z)", () => {
+      expect(getAttributeType("2024-12-11")).toBe(BizAttributeTypes.String);
     });
-    test("should return DateTime for MM-DD-YYYY format", () => {
-      expect(getAttributeType("12-12-2024")).toBe(BizAttributeTypes.DateTime);
+    test("should return String for MM/DD/YYYY format", () => {
+      expect(getAttributeType("12/12/2024")).toBe(BizAttributeTypes.String);
     });
-    test("should return DateTime for DD-MM-YYYY format", () => {
-      expect(getAttributeType("11-12-2024")).toBe(BizAttributeTypes.DateTime);
+    test("should return String for YYYY/MM/DD format", () => {
+      expect(getAttributeType("2024/12/11")).toBe(BizAttributeTypes.String);
     });
-    test("should return String for invalid date string", () => {
-      expect(getAttributeType("2024-13-45")).toBe(BizAttributeTypes.String);
+    test("should return String for MM-DD-YYYY format", () => {
+      expect(getAttributeType("12-12-2024")).toBe(BizAttributeTypes.String);
     });
-    test("should return String for date string with invalid year (< 1900)", () => {
-      expect(getAttributeType("1899-12-11")).toBe(BizAttributeTypes.String);
+    test("should return String for DD-MM-YYYY format", () => {
+      expect(getAttributeType("11-12-2024")).toBe(BizAttributeTypes.String);
     });
-    test("should return String for date string with invalid year (> 2100)", () => {
-      expect(getAttributeType("2101-12-11")).toBe(BizAttributeTypes.String);
+    test("should return String for invalid ISO 8601 format", () => {
+      expect(getAttributeType("2024-13-45T00:00:00.000Z")).toBe(BizAttributeTypes.String);
+    });
+    test("should return String for ISO 8601 with timezone offset (not UTC)", () => {
+      expect(getAttributeType("2024-12-11T16:00:00.000+08:00")).toBe(BizAttributeTypes.String);
+    });
+    test("should return String for ISO 8601 with lowercase z", () => {
+      expect(getAttributeType("2024-12-11T16:00:00.000z")).toBe(BizAttributeTypes.String);
     });
   });
   describe("Boolean type", () => {
@@ -120,8 +127,8 @@ describe("getAttributeType", () => {
     test("should return String for string that is exactly 9 characters", () => {
       expect(getAttributeType("123456789")).toBe(BizAttributeTypes.String);
     });
-    test("should return DateTime for string that is exactly 10 characters and valid date", () => {
-      expect(getAttributeType("2024-12-11")).toBe(BizAttributeTypes.DateTime);
+    test("should return String for string that is exactly 10 characters but not ISO 8601 UTC", () => {
+      expect(getAttributeType("2024-12-11")).toBe(BizAttributeTypes.String);
     });
     test("should return String for string that contains date-like pattern but invalid", () => {
       expect(getAttributeType("2024-99-99")).toBe(BizAttributeTypes.String);
@@ -131,3 +138,104 @@ describe("getAttributeType", () => {
     });
   });
 });
+describe("isValidISO8601", () => {
+  describe("Valid ISO 8601 UTC formats", () => {
+    test("should return true for ISO 8601 with milliseconds and Z", () => {
+      expect(isValidISO8601("2024-12-11T16:00:00.000Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 without milliseconds but with Z", () => {
+      expect(isValidISO8601("2024-12-11T16:00:00Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 at midnight", () => {
+      expect(isValidISO8601("2024-12-11T00:00:00.000Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 at end of day", () => {
+      expect(isValidISO8601("2024-12-11T23:59:59.999Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 with single digit month and day", () => {
+      expect(isValidISO8601("2024-01-01T00:00:00.000Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 in year 1900", () => {
+      expect(isValidISO8601("1900-01-01T00:00:00.000Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 in year 2100", () => {
+      expect(isValidISO8601("2100-12-31T23:59:59.999Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 with year before 1900", () => {
+      expect(isValidISO8601("1800-01-01T00:00:00.000Z")).toBe(true);
+    });
+    test("should return true for ISO 8601 with year after 2100", () => {
+      expect(isValidISO8601("2200-01-01T00:00:00.000Z")).toBe(true);
+    });
+  });
+  describe("Invalid ISO 8601 UTC formats", () => {
+    test("should return false for non-string values", () => {
+      expect(isValidISO8601(null)).toBe(false);
+      expect(isValidISO8601(void 0)).toBe(false);
+      expect(isValidISO8601(123)).toBe(false);
+      expect(isValidISO8601(/* @__PURE__ */ new Date())).toBe(false);
+      expect(isValidISO8601({})).toBe(false);
+    });
+    test("should return false for ISO 8601 without T separator", () => {
+      expect(isValidISO8601("2024-12-11 16:00:00.000Z")).toBe(false);
+      expect(isValidISO8601("2024-12-11")).toBe(false);
+    });
+    test("should return false for ISO 8601 without Z (UTC indicator)", () => {
+      expect(isValidISO8601("2024-12-11T16:00:00.000")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00")).toBe(false);
+    });
+    test("should return false for ISO 8601 with timezone offset (including +00:00)", () => {
+      expect(isValidISO8601("2024-12-11T16:00:00.000+08:00")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00.000-05:00")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00.000+01:00")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00.000-01:00")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00.000+00:00")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00.000-00:00")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00+00:00")).toBe(false);
+    });
+    test("should return false for ISO 8601 with lowercase z", () => {
+      expect(isValidISO8601("2024-12-11T16:00:00.000z")).toBe(false);
+    });
+    test("should return false for invalid date values", () => {
+      expect(isValidISO8601("2024-13-45T00:00:00.000Z")).toBe(false);
+      expect(isValidISO8601("2024-02-30T00:00:00.000Z")).toBe(false);
+      expect(isValidISO8601("2024-00-00T00:00:00.000Z")).toBe(false);
+    });
+    test("should return false for other date formats", () => {
+      expect(isValidISO8601("12/12/2024")).toBe(false);
+      expect(isValidISO8601("2024/12/11")).toBe(false);
+      expect(isValidISO8601("12-12-2024")).toBe(false);
+      expect(isValidISO8601("11-12-2024")).toBe(false);
+    });
+    test("should return false for malformed ISO 8601 strings", () => {
+      expect(isValidISO8601("2024-12-11T")).toBe(false);
+      expect(isValidISO8601("T16:00:00.000Z")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00.Z")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00.000Z")).toBe(false);
+      expect(isValidISO8601("2024-12-11T16:00:00.000")).toBe(false);
+    });
+    test("should return false for empty string", () => {
+      expect(isValidISO8601("")).toBe(false);
+    });
+    test("should return false for string that looks like ISO 8601 but has extra characters", () => {
+      expect(isValidISO8601("2024-12-11T16:00:00.000Z extra")).toBe(false);
+      expect(isValidISO8601("prefix 2024-12-11T16:00:00.000Z")).toBe(false);
+    });
+  });
+  describe("Edge cases", () => {
+    test("should handle leap year correctly", () => {
+      expect(isValidISO8601("2024-02-29T00:00:00.000Z")).toBe(true);
+      expect(isValidISO8601("2023-02-29T00:00:00.000Z")).toBe(false);
+    });
+    test("should handle different time values correctly", () => {
+      expect(isValidISO8601("2024-12-11T12:30:45.123Z")).toBe(true);
+      expect(isValidISO8601("2024-12-11T00:00:00.000Z")).toBe(true);
+      expect(isValidISO8601("2024-12-11T23:59:59.999Z")).toBe(true);
+    });
+    test("should handle milliseconds correctly", () => {
+      expect(isValidISO8601("2024-12-11T16:00:00.000Z")).toBe(true);
+      expect(isValidISO8601("2024-12-11T16:00:00.999Z")).toBe(true);
+      expect(isValidISO8601("2024-12-11T16:00:00Z")).toBe(true);
+    });
+  });
+});

package/dist/__tests__/url.test.cjs

@@ -321,6 +321,12 @@ describe("URL Condition Evaluation", () => {
       const excludes = [];
       expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
     });
+    test("should handle URL patterns with wildcard in nested path", () => {
+      const url = "http://localhost:3004/client-view/sites/SUPERCONCEPTS/funds/aaaa/queries";
+      const includes = ["/client-view/sites/SUPERCONCEPTS/funds/*/queries"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
     test("should handle URL patterns with fragments", () => {
       const url = "https://example.com/dashboard#overview";
       const includes = ["https://example.com/dashboard#*"];

package/dist/__tests__/url.test.js

@@ -243,6 +243,12 @@ describe("URL Condition Evaluation", () => {
       const excludes = [];
       expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
     });
+    test("should handle URL patterns with wildcard in nested path", () => {
+      const url = "http://localhost:3004/client-view/sites/SUPERCONCEPTS/funds/aaaa/queries";
+      const includes = ["/client-view/sites/SUPERCONCEPTS/funds/*/queries"];
+      const excludes = [];
+      expect(isMatchUrlPattern(url, includes, excludes)).toBe(true);
+    });
     test("should handle URL patterns with fragments", () => {
       const url = "https://example.com/dashboard#overview";
       const includes = ["https://example.com/dashboard#*"];

package/dist/attribute.cjs

@@ -22,7 +22,8 @@ var attribute_exports = {};
 __export(attribute_exports, {
   capitalizeFirstLetter: () => capitalizeFirstLetter,
   filterNullAttributes: () => filterNullAttributes,
-  getAttributeType: () => getAttributeType
+  getAttributeType: () => getAttributeType,
+  isValidISO8601: () => isValidISO8601
 });
 module.exports = __toCommonJS(attribute_exports);
 var import_types = require("@usertour/types");
@@ -38,46 +39,34 @@ var isNull = (x) => {
 };
 
 // src/attribute.ts
-var isValidYear = (date) => {
-  const year = date.getFullYear();
-  return year >= 1900 && year <= 2100;
-};
-var tryParseDate = (parser) => {
-  try {
-    const date = parser();
-    return (0, import_date_fns.isValid)(date) && isValidYear(date);
-  } catch {
+var isValidISO8601 = (value) => {
+  if (typeof value !== "string") {
     return false;
   }
-};
-function isDateString(dateStr) {
-  if (!Number.isNaN(Number(dateStr)) || dateStr.length < 10) {
+  const iso8601Pattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/;
+  if (!iso8601Pattern.test(value)) {
     return false;
   }
-  const dateFormats = [
-    "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
-    "yyyy-MM-dd'T'HH:mm:ss'Z'",
-    "yyyy-MM-dd'T'HH:mm:ss.SSS",
-    "yyyy-MM-dd'T'HH:mm:ss",
-    "yyyy-MM-dd",
-    "MM/dd/yyyy",
-    "dd/MM/yyyy",
-    "yyyy/MM/dd",
-    "MM-dd-yyyy",
-    "dd-MM-yyyy"
-  ];
-  if (tryParseDate(() => (0, import_date_fns.parseISO)(dateStr))) {
-    return true;
+  try {
+    const date = (0, import_date_fns.parseISO)(value);
+    if (!(0, import_date_fns.isValid)(date)) {
+      return false;
+    }
+    const isoString = date.toISOString();
+    const normalizedInput = value.replace(/\.\d{3}Z$/, "Z");
+    const normalizedIso = isoString.replace(/\.\d{3}Z$/, "Z");
+    return normalizedInput === normalizedIso || value === isoString;
+  } catch {
+    return false;
   }
-  return dateFormats.some((format) => tryParseDate(() => (0, import_date_fns.parse)(dateStr, format, /* @__PURE__ */ new Date())));
-}
+};
 var getAttributeType = (attribute) => {
   const t = typeof attribute;
   if (t === "number") {
     return import_types.BizAttributeTypes.Number;
   }
   if (t === "string") {
-    if (isDateString(attribute)) {
+    if (isValidISO8601(attribute)) {
       return import_types.BizAttributeTypes.DateTime;
     }
     return import_types.BizAttributeTypes.String;
@@ -107,5 +96,6 @@ var filterNullAttributes = (attributes) => {
 0 && (module.exports = {
   capitalizeFirstLetter,
   filterNullAttributes,
-  getAttributeType
+  getAttributeType,
+  isValidISO8601
 });

package/dist/attribute.d.cts

@@ -1,5 +1,21 @@
+/**
+ * Validate if a value is a valid ISO 8601 date string in UTC
+ * According to the specification: datetime must be stored as ISO 8601 in UTC
+ *
+ * Following industry best practices (Stripe, GitHub, AWS, etc.), we only accept
+ * the 'Z' format for UTC, not '+00:00' or '-00:00', for consistency and simplicity.
+ *
+ * Why we need additional validation after parseISO:
+ * 1. parseISO is lenient - it may parse invalid dates (e.g., "2024-13-45") and return a valid Date object
+ *    by auto-correcting (e.g., "2024-13-45" becomes "2025-01-14")
+ * 2. We need to ensure the input string exactly matches what would be produced by toISOString()
+ *    This prevents accepting malformed dates that get "fixed" by the parser
+ * 3. The regex pattern ensures strict format compliance (must have T and Z)
+ * 4. The comparison ensures no date normalization occurred (e.g., invalid month/day corrections)
+ */
+declare const isValidISO8601: (value: any) => boolean;
 declare const getAttributeType: (attribute: any) => number;
 declare const capitalizeFirstLetter: (string: string) => string;
 declare const filterNullAttributes: (attributes: Record<string, any>) => Record<string, any>;
 
-export { capitalizeFirstLetter, filterNullAttributes, getAttributeType };
+export { capitalizeFirstLetter, filterNullAttributes, getAttributeType, isValidISO8601 };

package/dist/attribute.d.ts

@@ -1,5 +1,21 @@
+/**
+ * Validate if a value is a valid ISO 8601 date string in UTC
+ * According to the specification: datetime must be stored as ISO 8601 in UTC
+ *
+ * Following industry best practices (Stripe, GitHub, AWS, etc.), we only accept
+ * the 'Z' format for UTC, not '+00:00' or '-00:00', for consistency and simplicity.
+ *
+ * Why we need additional validation after parseISO:
+ * 1. parseISO is lenient - it may parse invalid dates (e.g., "2024-13-45") and return a valid Date object
+ *    by auto-correcting (e.g., "2024-13-45" becomes "2025-01-14")
+ * 2. We need to ensure the input string exactly matches what would be produced by toISOString()
+ *    This prevents accepting malformed dates that get "fixed" by the parser
+ * 3. The regex pattern ensures strict format compliance (must have T and Z)
+ * 4. The comparison ensures no date normalization occurred (e.g., invalid month/day corrections)
+ */
+declare const isValidISO8601: (value: any) => boolean;
 declare const getAttributeType: (attribute: any) => number;
 declare const capitalizeFirstLetter: (string: string) => string;
 declare const filterNullAttributes: (attributes: Record<string, any>) => Record<string, any>;
 
-export { capitalizeFirstLetter, filterNullAttributes, getAttributeType };
+export { capitalizeFirstLetter, filterNullAttributes, getAttributeType, isValidISO8601 };

package/dist/attribute.js

@@ -1,12 +1,14 @@
 import {
   capitalizeFirstLetter,
   filterNullAttributes,
-  getAttributeType
-} from "./chunk-EEYZG4JJ.js";
+  getAttributeType,
+  isValidISO8601
+} from "./chunk-R4R6MDTW.js";
 import "./chunk-GFH3VWOC.js";
 import "./chunk-XEO3YXBM.js";
 export {
   capitalizeFirstLetter,
   filterNullAttributes,
-  getAttributeType
+  getAttributeType,
+  isValidISO8601
 };