@usertour/helpers 0.0.34 → 0.0.36

package/dist/__tests__/time.test.js

@@ -1,11 +1,16 @@
 import {
-  evaluateTimeCondition
-} from "../chunk-CEK3SCQO.js";
+  convertTimeConditionLegacyToV2,
+  evaluateTimeCondition,
+  isTimeConditionDataLegacy,
+  isTimeConditionDataV2,
+  normalizeTimeConditionData
+} from "../chunk-JQWKLXW6.js";
+import "../chunk-GFH3VWOC.js";
 import "../chunk-XEO3YXBM.js";
 
 // src/__tests__/time.test.ts
 describe("Time Condition Evaluation", () => {
-  const mockNow = /* @__PURE__ */ new Date("2024-01-15T12:00:00Z");
+  const mockNow = new Date(2024, 0, 15, 12, 0, 0);
   beforeAll(() => {
     jest.useFakeTimers();
     jest.setSystemTime(mockNow);
@@ -13,36 +18,352 @@ describe("Time Condition Evaluation", () => {
   afterAll(() => {
     jest.useRealTimers();
   });
-  test("should return true when current time is after start time and no end time", () => {
-    const rules = {
-      id: "condition-1",
-      type: "condition",
-      operators: "and",
-      data: {
-        startDate: "2024-01-15",
+  describe("Type Guards", () => {
+    test("isTimeConditionDataV2 should return true for new format", () => {
+      expect(isTimeConditionDataV2({ startTime: "2024-01-15T10:00:00Z" })).toBe(true);
+      expect(isTimeConditionDataV2({ endTime: "2024-01-15T14:00:00Z" })).toBe(true);
+      expect(
+        isTimeConditionDataV2({
+          startTime: "2024-01-15T10:00:00Z",
+          endTime: "2024-01-15T14:00:00Z"
+        })
+      ).toBe(true);
+    });
+    test("isTimeConditionDataV2 should return false for legacy format", () => {
+      expect(isTimeConditionDataV2({ startDate: "01/15/2024" })).toBe(false);
+      expect(isTimeConditionDataV2({})).toBe(false);
+    });
+    test("isTimeConditionDataLegacy should return true for legacy format", () => {
+      expect(isTimeConditionDataLegacy({ startDate: "01/15/2024" })).toBe(true);
+      expect(isTimeConditionDataLegacy({ startDateHour: "10" })).toBe(true);
+      expect(
+        isTimeConditionDataLegacy({
+          startDate: "01/15/2024",
+          startDateHour: "10",
+          startDateMinute: "00"
+        })
+      ).toBe(true);
+    });
+    test("isTimeConditionDataLegacy should return false for new format", () => {
+      expect(isTimeConditionDataLegacy({ startTime: "2024-01-15T10:00:00Z" })).toBe(false);
+      expect(isTimeConditionDataLegacy({})).toBe(false);
+    });
+  });
+  describe("Format Conversion", () => {
+    test("convertTimeConditionLegacyToV2 should convert valid legacy data", () => {
+      const legacyData = {
+        startDate: "01/15/2024",
+        startDateHour: "10",
+        startDateMinute: "00",
+        endDate: "01/15/2024",
+        endDateHour: "14",
+        endDateMinute: "00"
+      };
+      const result = convertTimeConditionLegacyToV2(legacyData);
+      expect(result).not.toBeNull();
+      expect(result == null ? void 0 : result.startTime).toBeDefined();
+      expect(result == null ? void 0 : result.endTime).toBeDefined();
+      expect(result == null ? void 0 : result.startTime).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+    });
+    test("convertTimeConditionLegacyToV2 should convert legacy data without end time", () => {
+      const legacyData = {
+        startDate: "01/15/2024",
         startDateHour: "10",
         startDateMinute: "00",
         endDate: "",
         endDateHour: "",
         endDateMinute: ""
-      }
-    };
-    expect(evaluateTimeCondition(rules)).toBe(true);
-  });
-  test("should return true when current time is within start and end time range", () => {
-    const rules = {
-      id: "condition-2",
-      type: "condition",
-      operators: "and",
-      data: {
-        startDate: "2024-01-15",
+      };
+      const result = convertTimeConditionLegacyToV2(legacyData);
+      expect(result).not.toBeNull();
+      expect(result == null ? void 0 : result.startTime).toBeDefined();
+      expect(result == null ? void 0 : result.endTime).toBeUndefined();
+    });
+    test("convertTimeConditionLegacyToV2 should return null for invalid data", () => {
+      expect(
+        convertTimeConditionLegacyToV2({
+          startDate: "",
+          startDateHour: "10",
+          startDateMinute: "00"
+        })
+      ).toBeNull();
+      expect(
+        convertTimeConditionLegacyToV2({
+          startDate: "01/15/2024",
+          startDateHour: "",
+          startDateMinute: "00"
+        })
+      ).toBeNull();
+      expect(
+        convertTimeConditionLegacyToV2({
+          startDate: "01/15/2024",
+          startDateHour: "10",
+          startDateMinute: ""
+        })
+      ).toBeNull();
+    });
+    test("normalizeTimeConditionData should return new format as-is", () => {
+      const newFormat = { startTime: "2024-01-15T10:00:00Z", endTime: "2024-01-15T14:00:00Z" };
+      expect(normalizeTimeConditionData(newFormat)).toEqual(newFormat);
+    });
+    test("normalizeTimeConditionData should convert legacy format", () => {
+      const legacyData = {
+        startDate: "01/15/2024",
         startDateHour: "10",
-        startDateMinute: "00",
-        endDate: "2024-01-15",
-        endDateHour: "14",
-        endDateMinute: "00"
-      }
-    };
-    expect(evaluateTimeCondition(rules)).toBe(false);
+        startDateMinute: "00"
+      };
+      const result = normalizeTimeConditionData(legacyData);
+      expect(result).not.toBeNull();
+      expect(result == null ? void 0 : result.startTime).toBeDefined();
+    });
+    test("normalizeTimeConditionData should return null for invalid data", () => {
+      expect(normalizeTimeConditionData(null)).toBeNull();
+      expect(normalizeTimeConditionData(void 0)).toBeNull();
+      expect(normalizeTimeConditionData({})).toBeNull();
+    });
+  });
+  describe("Legacy Format Evaluation", () => {
+    test("should return true when current time is after start time and no end time", () => {
+      const rules = {
+        id: "condition-1",
+        type: "time",
+        data: {
+          startDate: "01/15/2024",
+          startDateHour: "10",
+          startDateMinute: "00",
+          endDate: "",
+          endDateHour: "",
+          endDateMinute: ""
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(true);
+    });
+    test("should return true when current time is within start and end time range", () => {
+      const rules = {
+        id: "condition-2",
+        type: "time",
+        data: {
+          startDate: "01/15/2024",
+          startDateHour: "10",
+          startDateMinute: "00",
+          endDate: "01/15/2024",
+          endDateHour: "14",
+          endDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(true);
+    });
+    test("should return false when current time is before start time", () => {
+      const rules = {
+        id: "condition-3",
+        type: "time",
+        data: {
+          startDate: "01/15/2024",
+          startDateHour: "15",
+          startDateMinute: "00",
+          endDate: "",
+          endDateHour: "",
+          endDateMinute: ""
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false when current time is after end time", () => {
+      const rules = {
+        id: "condition-4",
+        type: "time",
+        data: {
+          startDate: "01/15/2024",
+          startDateHour: "10",
+          startDateMinute: "00",
+          endDate: "01/15/2024",
+          endDateHour: "11",
+          endDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false when start date is missing", () => {
+      const rules = {
+        id: "condition-5",
+        type: "time",
+        data: {
+          startDate: "",
+          startDateHour: "10",
+          startDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false when start hour is missing", () => {
+      const rules = {
+        id: "condition-6",
+        type: "time",
+        data: {
+          startDate: "01/15/2024",
+          startDateHour: "",
+          startDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should handle empty endDate string", () => {
+      const rules = {
+        id: "condition-7",
+        type: "time",
+        data: {
+          startDate: "01/15/2024",
+          startDateHour: "10",
+          startDateMinute: "00",
+          endDate: "",
+          endDateHour: "00",
+          endDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(true);
+    });
+    test("should handle cross-day time range", () => {
+      const crossDayTime = new Date(2024, 0, 15, 23, 0, 0);
+      jest.setSystemTime(crossDayTime);
+      const rules = {
+        id: "condition-8",
+        type: "time",
+        data: {
+          startDate: "01/15/2024",
+          startDateHour: "22",
+          startDateMinute: "00",
+          endDate: "01/16/2024",
+          endDateHour: "02",
+          endDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(true);
+      jest.setSystemTime(mockNow);
+    });
+  });
+  describe("New Format (ISO 8601) Evaluation", () => {
+    test("should return true when current time is after start time and no end time", () => {
+      const startTime = new Date(2024, 0, 15, 10, 0, 0).toISOString();
+      const rules = {
+        id: "condition-v2-1",
+        type: "time",
+        data: {
+          startTime
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(true);
+    });
+    test("should return true when current time is within start and end time range", () => {
+      const startTime = new Date(2024, 0, 15, 10, 0, 0).toISOString();
+      const endTime = new Date(2024, 0, 15, 14, 0, 0).toISOString();
+      const rules = {
+        id: "condition-v2-2",
+        type: "time",
+        data: {
+          startTime,
+          endTime
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(true);
+    });
+    test("should return false when current time is before start time", () => {
+      const startTime = new Date(2024, 0, 15, 15, 0, 0).toISOString();
+      const rules = {
+        id: "condition-v2-3",
+        type: "time",
+        data: {
+          startTime
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false when current time is after end time", () => {
+      const startTime = new Date(2024, 0, 15, 10, 0, 0).toISOString();
+      const endTime = new Date(2024, 0, 15, 11, 0, 0).toISOString();
+      const rules = {
+        id: "condition-v2-4",
+        type: "time",
+        data: {
+          startTime,
+          endTime
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false when startTime is missing", () => {
+      const endTime = new Date(2024, 0, 15, 14, 0, 0).toISOString();
+      const rules = {
+        id: "condition-v2-5",
+        type: "time",
+        data: {
+          endTime
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false when startTime is invalid", () => {
+      const rules = {
+        id: "condition-v2-6",
+        type: "time",
+        data: {
+          startTime: "invalid-date"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should handle timezone in ISO format", () => {
+      const rules = {
+        id: "condition-v2-7",
+        type: "time",
+        data: {
+          startTime: "2024-01-15T10:00:00+08:00",
+          endTime: "2024-01-15T14:00:00+08:00"
+        }
+      };
+      expect(typeof evaluateTimeCondition(rules)).toBe("boolean");
+    });
+  });
+  describe("Edge Cases", () => {
+    test("should return false for empty data", () => {
+      const rules = {
+        id: "condition-edge-1",
+        type: "time",
+        data: {}
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false for null data", () => {
+      const rules = {
+        id: "condition-edge-2",
+        type: "time",
+        data: null
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should return false for invalid date format in legacy", () => {
+      const rules = {
+        id: "condition-edge-3",
+        type: "time",
+        data: {
+          startDate: "invalid-date",
+          startDateHour: "10",
+          startDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
+    test("should handle invalid month/day in legacy format", () => {
+      const rules = {
+        id: "condition-edge-4",
+        type: "time",
+        data: {
+          startDate: "13/32/2024",
+          // Invalid month and day
+          startDateHour: "10",
+          startDateMinute: "00"
+        }
+      };
+      expect(evaluateTimeCondition(rules)).toBe(false);
+    });
   });
 });

package/dist/attribute.cjs

@@ -0,0 +1,111 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/attribute.ts
+var attribute_exports = {};
+__export(attribute_exports, {
+  capitalizeFirstLetter: () => capitalizeFirstLetter,
+  filterNullAttributes: () => filterNullAttributes,
+  getAttributeType: () => getAttributeType
+});
+module.exports = __toCommonJS(attribute_exports);
+var import_types = require("@usertour/types");
+var import_date_fns = require("date-fns");
+
+// src/type-utils.ts
+var nativeIsArray = Array.isArray;
+var ObjProto = Object.prototype;
+var objToString = ObjProto.toString;
+var objHasOwn = ObjProto.hasOwnProperty;
+var isNull = (x) => {
+  return x === null;
+};
+
+// 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 {
+    return false;
+  }
+};
+function isDateString(dateStr) {
+  if (!Number.isNaN(Number(dateStr)) || dateStr.length < 10) {
+    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;
+  }
+  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)) {
+      return import_types.BizAttributeTypes.DateTime;
+    }
+    return import_types.BizAttributeTypes.String;
+  }
+  if (t === "boolean") {
+    return import_types.BizAttributeTypes.Boolean;
+  }
+  if (t === "object" && Array.isArray(attribute)) {
+    return import_types.BizAttributeTypes.List;
+  }
+  return import_types.BizAttributeTypes.Nil;
+};
+var capitalizeFirstLetter = (string) => {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+};
+var filterNullAttributes = (attributes) => {
+  const attrs = {};
+  for (const key in attributes) {
+    const v = attributes[key];
+    if (!isNull(v)) {
+      attrs[key] = v;
+    }
+  }
+  return attrs;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  capitalizeFirstLetter,
+  filterNullAttributes,
+  getAttributeType
+});

package/dist/attribute.d.cts

@@ -0,0 +1,5 @@
+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 };

package/dist/attribute.d.ts

@@ -0,0 +1,5 @@
+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 };

package/dist/attribute.js

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

package/dist/{chunk-A4KMGXB3.js → chunk-3UOSPZEP.js}

@@ -1,12 +1,12 @@
 import {
   evaluateUrlCondition
 } from "./chunk-YYIGUZNZ.js";
-import {
-  evaluateAttributeCondition
-} from "./chunk-7JXEY4A2.js";
 import {
   evaluateTimeCondition
-} from "./chunk-CEK3SCQO.js";
+} from "./chunk-JQWKLXW6.js";
+import {
+  evaluateAttributeCondition
+} from "./chunk-KYDXF7SU.js";
 import {
   cuid
 } from "./chunk-3KG2HTZ3.js";

package/dist/chunk-EEYZG4JJ.js

@@ -0,0 +1,78 @@
+import {
+  isNull
+} from "./chunk-GFH3VWOC.js";
+
+// src/attribute.ts
+import { BizAttributeTypes } from "@usertour/types";
+import { isValid, parseISO, parse } from "date-fns";
+var isValidYear = (date) => {
+  const year = date.getFullYear();
+  return year >= 1900 && year <= 2100;
+};
+var tryParseDate = (parser) => {
+  try {
+    const date = parser();
+    return isValid(date) && isValidYear(date);
+  } catch {
+    return false;
+  }
+};
+function isDateString(dateStr) {
+  if (!Number.isNaN(Number(dateStr)) || dateStr.length < 10) {
+    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(() => parseISO(dateStr))) {
+    return true;
+  }
+  return dateFormats.some((format) => tryParseDate(() => parse(dateStr, format, /* @__PURE__ */ new Date())));
+}
+var getAttributeType = (attribute) => {
+  const t = typeof attribute;
+  if (t === "number") {
+    return BizAttributeTypes.Number;
+  }
+  if (t === "string") {
+    if (isDateString(attribute)) {
+      return BizAttributeTypes.DateTime;
+    }
+    return BizAttributeTypes.String;
+  }
+  if (t === "boolean") {
+    return BizAttributeTypes.Boolean;
+  }
+  if (t === "object" && Array.isArray(attribute)) {
+    return BizAttributeTypes.List;
+  }
+  return BizAttributeTypes.Nil;
+};
+var capitalizeFirstLetter = (string) => {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+};
+var filterNullAttributes = (attributes) => {
+  const attrs = {};
+  for (const key in attributes) {
+    const v = attributes[key];
+    if (!isNull(v)) {
+      attrs[key] = v;
+    }
+  }
+  return attrs;
+};
+
+export {
+  getAttributeType,
+  capitalizeFirstLetter,
+  filterNullAttributes
+};