@usertour/helpers 0.0.34 → 0.0.35

package/dist/__tests__/attribute.test.cjs

@@ -6,6 +6,15 @@ var import_types2 = require("@usertour/types");
 // src/conditions/attribute.ts
 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 isArray = nativeIsArray || ((obj) => objToString.call(obj) === "[object Array]");
+
+// src/conditions/attribute.ts
 function evaluateFilterConditions(conditions, options) {
   if (!conditions || !conditions.length) {
     return true;
@@ -154,7 +163,7 @@ function evaluateBooleanCondition(logic, actualValue) {
   }
 }
 function evaluateListCondition(logic, actualValue, expectedValues) {
-  const arrayValue = Array.isArray(actualValue) ? actualValue : [];
+  const arrayValue = isArray(actualValue) ? actualValue : [];
   if (logic === "empty" || logic === "any") {
     switch (logic) {
       case "empty":

package/dist/__tests__/attribute.test.js

@@ -1,7 +1,8 @@
 import {
   evaluateAttributeCondition,
   evaluateFilterConditions
-} from "../chunk-7JXEY4A2.js";
+} from "../chunk-KYDXF7SU.js";
+import "../chunk-GFH3VWOC.js";
 import "../chunk-XEO3YXBM.js";
 
 // src/__tests__/attribute.test.ts

package/dist/__tests__/condition.test.cjs

@@ -143,6 +143,15 @@ var evaluateTimeCondition = (rules) => {
 // src/conditions/attribute.ts
 var import_types = require("@usertour/types");
 var import_date_fns2 = require("date-fns");
+
+// src/type-utils.ts
+var nativeIsArray = Array.isArray;
+var ObjProto = Object.prototype;
+var objToString = ObjProto.toString;
+var objHasOwn = ObjProto.hasOwnProperty;
+var isArray = nativeIsArray || ((obj) => objToString.call(obj) === "[object Array]");
+
+// src/conditions/attribute.ts
 function evaluateAttributeCondition(condition, options) {
   const { data } = condition;
   if (!data) {
@@ -254,7 +263,7 @@ function evaluateBooleanCondition(logic, actualValue) {
   }
 }
 function evaluateListCondition(logic, actualValue, expectedValues) {
-  const arrayValue = Array.isArray(actualValue) ? actualValue : [];
+  const arrayValue = isArray(actualValue) ? actualValue : [];
   if (logic === "empty" || logic === "any") {
     switch (logic) {
       case "empty":

package/dist/__tests__/condition.test.js

@@ -2,11 +2,12 @@ import {
   evaluateRulesConditions,
   filterConditionsByType,
   isConditionsActived
-} from "../chunk-A4KMGXB3.js";
+} from "../chunk-NVSDWUJP.js";
 import "../chunk-YYIGUZNZ.js";
 import "../chunk-PAESAL23.js";
-import "../chunk-7JXEY4A2.js";
 import "../chunk-CEK3SCQO.js";
+import "../chunk-KYDXF7SU.js";
+import "../chunk-GFH3VWOC.js";
 import "../chunk-3KG2HTZ3.js";
 import "../chunk-XEO3YXBM.js";
 

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

@@ -0,0 +1,195 @@
+"use strict";
+
+// src/__tests__/get-attribute-type.test.ts
+var import_types2 = require("@usertour/types");
+
+// src/attribute.ts
+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;
+
+// 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;
+};
+
+// src/__tests__/get-attribute-type.test.ts
+describe("getAttributeType", () => {
+  describe("Number type", () => {
+    test("should return Number for integer", () => {
+      expect(getAttributeType(42)).toBe(import_types2.BizAttributeTypes.Number);
+    });
+    test("should return Number for float", () => {
+      expect(getAttributeType(3.14)).toBe(import_types2.BizAttributeTypes.Number);
+    });
+    test("should return Number for negative number", () => {
+      expect(getAttributeType(-10)).toBe(import_types2.BizAttributeTypes.Number);
+    });
+    test("should return Number for zero", () => {
+      expect(getAttributeType(0)).toBe(import_types2.BizAttributeTypes.Number);
+    });
+  });
+  describe("String type", () => {
+    test("should return String for regular string", () => {
+      expect(getAttributeType("hello")).toBe(import_types2.BizAttributeTypes.String);
+    });
+    test("should return String for string with special characters", () => {
+      expect(getAttributeType("Nanjing-user-189327")).toBe(import_types2.BizAttributeTypes.String);
+    });
+    test("should return String for email-like string", () => {
+      expect(getAttributeType("user@example.com")).toBe(import_types2.BizAttributeTypes.String);
+    });
+    test("should return String for short string (< 10 chars)", () => {
+      expect(getAttributeType("short")).toBe(import_types2.BizAttributeTypes.String);
+    });
+    test("should return String for string that looks like number but is not pure number", () => {
+      expect(getAttributeType("123abc")).toBe(import_types2.BizAttributeTypes.String);
+    });
+  });
+  describe("DateTime type", () => {
+    test("should return DateTime for ISO 8601 format with time", () => {
+      expect(getAttributeType("2024-12-11T16:00:00.000Z")).toBe(import_types2.BizAttributeTypes.DateTime);
+    });
+    test("should return DateTime for ISO 8601 format without milliseconds", () => {
+      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 date only", () => {
+      expect(getAttributeType("2024-12-11")).toBe(import_types2.BizAttributeTypes.DateTime);
+    });
+    test("should return DateTime for MM/DD/YYYY format", () => {
+      expect(getAttributeType("12/12/2024")).toBe(import_types2.BizAttributeTypes.DateTime);
+    });
+    test("should return DateTime for YYYY/MM/DD format", () => {
+      expect(getAttributeType("2024/12/11")).toBe(import_types2.BizAttributeTypes.DateTime);
+    });
+    test("should return DateTime for MM-DD-YYYY format", () => {
+      expect(getAttributeType("12-12-2024")).toBe(import_types2.BizAttributeTypes.DateTime);
+    });
+    test("should return DateTime for DD-MM-YYYY format", () => {
+      expect(getAttributeType("11-12-2024")).toBe(import_types2.BizAttributeTypes.DateTime);
+    });
+    test("should return String for invalid date string", () => {
+      expect(getAttributeType("2024-13-45")).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 date string with invalid year (> 2100)", () => {
+      expect(getAttributeType("2101-12-11")).toBe(import_types2.BizAttributeTypes.String);
+    });
+  });
+  describe("Boolean type", () => {
+    test("should return Boolean for true", () => {
+      expect(getAttributeType(true)).toBe(import_types2.BizAttributeTypes.Boolean);
+    });
+    test("should return Boolean for false", () => {
+      expect(getAttributeType(false)).toBe(import_types2.BizAttributeTypes.Boolean);
+    });
+  });
+  describe("List type", () => {
+    test("should return List for array of strings", () => {
+      expect(getAttributeType(["a", "b", "c"])).toBe(import_types2.BizAttributeTypes.List);
+    });
+    test("should return List for array of numbers", () => {
+      expect(getAttributeType([1, 2, 3])).toBe(import_types2.BizAttributeTypes.List);
+    });
+    test("should return List for array of mixed types", () => {
+      expect(getAttributeType([1, "a", true])).toBe(import_types2.BizAttributeTypes.List);
+    });
+    test("should return List for empty array", () => {
+      expect(getAttributeType([])).toBe(import_types2.BizAttributeTypes.List);
+    });
+  });
+  describe("Nil type", () => {
+    test("should return Nil for null", () => {
+      expect(getAttributeType(null)).toBe(import_types2.BizAttributeTypes.Nil);
+    });
+    test("should return Nil for undefined", () => {
+      expect(getAttributeType(void 0)).toBe(import_types2.BizAttributeTypes.Nil);
+    });
+    test("should return Nil for object (non-array)", () => {
+      expect(getAttributeType({ key: "value" })).toBe(import_types2.BizAttributeTypes.Nil);
+    });
+    test("should return Nil for function", () => {
+      expect(getAttributeType(() => {
+      })).toBe(import_types2.BizAttributeTypes.Nil);
+    });
+    test("should return Nil for Symbol", () => {
+      expect(getAttributeType(Symbol("test"))).toBe(import_types2.BizAttributeTypes.Nil);
+    });
+  });
+  describe("Edge cases", () => {
+    test("should return String for string that is a number but length < 10", () => {
+      expect(getAttributeType("12345")).toBe(import_types2.BizAttributeTypes.String);
+    });
+    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 contains date-like pattern but invalid", () => {
+      expect(getAttributeType("2024-99-99")).toBe(import_types2.BizAttributeTypes.String);
+    });
+    test("should return String for string starting with numbers but not a date", () => {
+      expect(getAttributeType("2024abc-def-ghi")).toBe(import_types2.BizAttributeTypes.String);
+    });
+  });
+});

package/dist/__tests__/get-attribute-type.test.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/__tests__/get-attribute-type.test.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

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

@@ -0,0 +1,133 @@
+import {
+  getAttributeType
+} from "../chunk-EEYZG4JJ.js";
+import "../chunk-GFH3VWOC.js";
+import "../chunk-XEO3YXBM.js";
+
+// src/__tests__/get-attribute-type.test.ts
+import { BizAttributeTypes } from "@usertour/types";
+describe("getAttributeType", () => {
+  describe("Number type", () => {
+    test("should return Number for integer", () => {
+      expect(getAttributeType(42)).toBe(BizAttributeTypes.Number);
+    });
+    test("should return Number for float", () => {
+      expect(getAttributeType(3.14)).toBe(BizAttributeTypes.Number);
+    });
+    test("should return Number for negative number", () => {
+      expect(getAttributeType(-10)).toBe(BizAttributeTypes.Number);
+    });
+    test("should return Number for zero", () => {
+      expect(getAttributeType(0)).toBe(BizAttributeTypes.Number);
+    });
+  });
+  describe("String type", () => {
+    test("should return String for regular string", () => {
+      expect(getAttributeType("hello")).toBe(BizAttributeTypes.String);
+    });
+    test("should return String for string with special characters", () => {
+      expect(getAttributeType("Nanjing-user-189327")).toBe(BizAttributeTypes.String);
+    });
+    test("should return String for email-like string", () => {
+      expect(getAttributeType("user@example.com")).toBe(BizAttributeTypes.String);
+    });
+    test("should return String for short string (< 10 chars)", () => {
+      expect(getAttributeType("short")).toBe(BizAttributeTypes.String);
+    });
+    test("should return String for string that looks like number but is not pure number", () => {
+      expect(getAttributeType("123abc")).toBe(BizAttributeTypes.String);
+    });
+  });
+  describe("DateTime type", () => {
+    test("should return DateTime for ISO 8601 format with time", () => {
+      expect(getAttributeType("2024-12-11T16:00:00.000Z")).toBe(BizAttributeTypes.DateTime);
+    });
+    test("should return DateTime for ISO 8601 format without milliseconds", () => {
+      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 date only", () => {
+      expect(getAttributeType("2024-12-11")).toBe(BizAttributeTypes.DateTime);
+    });
+    test("should return DateTime for MM/DD/YYYY format", () => {
+      expect(getAttributeType("12/12/2024")).toBe(BizAttributeTypes.DateTime);
+    });
+    test("should return DateTime for YYYY/MM/DD format", () => {
+      expect(getAttributeType("2024/12/11")).toBe(BizAttributeTypes.DateTime);
+    });
+    test("should return DateTime for MM-DD-YYYY format", () => {
+      expect(getAttributeType("12-12-2024")).toBe(BizAttributeTypes.DateTime);
+    });
+    test("should return DateTime for DD-MM-YYYY format", () => {
+      expect(getAttributeType("11-12-2024")).toBe(BizAttributeTypes.DateTime);
+    });
+    test("should return String for invalid date string", () => {
+      expect(getAttributeType("2024-13-45")).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 date string with invalid year (> 2100)", () => {
+      expect(getAttributeType("2101-12-11")).toBe(BizAttributeTypes.String);
+    });
+  });
+  describe("Boolean type", () => {
+    test("should return Boolean for true", () => {
+      expect(getAttributeType(true)).toBe(BizAttributeTypes.Boolean);
+    });
+    test("should return Boolean for false", () => {
+      expect(getAttributeType(false)).toBe(BizAttributeTypes.Boolean);
+    });
+  });
+  describe("List type", () => {
+    test("should return List for array of strings", () => {
+      expect(getAttributeType(["a", "b", "c"])).toBe(BizAttributeTypes.List);
+    });
+    test("should return List for array of numbers", () => {
+      expect(getAttributeType([1, 2, 3])).toBe(BizAttributeTypes.List);
+    });
+    test("should return List for array of mixed types", () => {
+      expect(getAttributeType([1, "a", true])).toBe(BizAttributeTypes.List);
+    });
+    test("should return List for empty array", () => {
+      expect(getAttributeType([])).toBe(BizAttributeTypes.List);
+    });
+  });
+  describe("Nil type", () => {
+    test("should return Nil for null", () => {
+      expect(getAttributeType(null)).toBe(BizAttributeTypes.Nil);
+    });
+    test("should return Nil for undefined", () => {
+      expect(getAttributeType(void 0)).toBe(BizAttributeTypes.Nil);
+    });
+    test("should return Nil for object (non-array)", () => {
+      expect(getAttributeType({ key: "value" })).toBe(BizAttributeTypes.Nil);
+    });
+    test("should return Nil for function", () => {
+      expect(getAttributeType(() => {
+      })).toBe(BizAttributeTypes.Nil);
+    });
+    test("should return Nil for Symbol", () => {
+      expect(getAttributeType(Symbol("test"))).toBe(BizAttributeTypes.Nil);
+    });
+  });
+  describe("Edge cases", () => {
+    test("should return String for string that is a number but length < 10", () => {
+      expect(getAttributeType("12345")).toBe(BizAttributeTypes.String);
+    });
+    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 contains date-like pattern but invalid", () => {
+      expect(getAttributeType("2024-99-99")).toBe(BizAttributeTypes.String);
+    });
+    test("should return String for string starting with numbers but not a date", () => {
+      expect(getAttributeType("2024abc-def-ghi")).toBe(BizAttributeTypes.String);
+    });
+  });
+});

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-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
+};

package/dist/{chunk-7JXEY4A2.js → chunk-KYDXF7SU.js}

@@ -1,3 +1,7 @@
+import {
+  isArray
+} from "./chunk-GFH3VWOC.js";
+
 // src/conditions/attribute.ts
 import {
   BizAttributeTypes,
@@ -152,7 +156,7 @@ function evaluateBooleanCondition(logic, actualValue) {
   }
 }
 function evaluateListCondition(logic, actualValue, expectedValues) {
-  const arrayValue = Array.isArray(actualValue) ? actualValue : [];
+  const arrayValue = isArray(actualValue) ? actualValue : [];
   if (logic === "empty" || logic === "any") {
     switch (logic) {
       case "empty":

package/dist/{chunk-A4KMGXB3.js → chunk-NVSDWUJP.js}

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

package/dist/conditions/attribute.cjs

@@ -26,6 +26,15 @@ __export(attribute_exports, {
 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 isArray = nativeIsArray || ((obj) => objToString.call(obj) === "[object Array]");
+
+// src/conditions/attribute.ts
 function evaluateFilterConditions(conditions, options) {
   if (!conditions || !conditions.length) {
     return true;
@@ -174,7 +183,7 @@ function evaluateBooleanCondition(logic, actualValue) {
   }
 }
 function evaluateListCondition(logic, actualValue, expectedValues) {
-  const arrayValue = Array.isArray(actualValue) ? actualValue : [];
+  const arrayValue = isArray(actualValue) ? actualValue : [];
   if (logic === "empty" || logic === "any") {
     switch (logic) {
       case "empty":

package/dist/conditions/attribute.js

@@ -1,7 +1,8 @@
 import {
   evaluateAttributeCondition,
   evaluateFilterConditions
-} from "../chunk-7JXEY4A2.js";
+} from "../chunk-KYDXF7SU.js";
+import "../chunk-GFH3VWOC.js";
 import "../chunk-XEO3YXBM.js";
 export {
   evaluateAttributeCondition,

package/dist/conditions/condition.cjs

@@ -158,6 +158,15 @@ var evaluateTimeCondition = (rules) => {
 // src/conditions/attribute.ts
 var import_types = require("@usertour/types");
 var import_date_fns2 = require("date-fns");
+
+// src/type-utils.ts
+var nativeIsArray = Array.isArray;
+var ObjProto = Object.prototype;
+var objToString = ObjProto.toString;
+var objHasOwn = ObjProto.hasOwnProperty;
+var isArray = nativeIsArray || ((obj) => objToString.call(obj) === "[object Array]");
+
+// src/conditions/attribute.ts
 function evaluateAttributeCondition(condition, options) {
   const { data } = condition;
   if (!data) {
@@ -269,7 +278,7 @@ function evaluateBooleanCondition(logic, actualValue) {
   }
 }
 function evaluateListCondition(logic, actualValue, expectedValues) {
-  const arrayValue = Array.isArray(actualValue) ? actualValue : [];
+  const arrayValue = isArray(actualValue) ? actualValue : [];
   if (logic === "empty" || logic === "any") {
     switch (logic) {
       case "empty":

package/dist/conditions/condition.js

@@ -8,11 +8,12 @@ import {
   isConditionsActived,
   isEqual,
   regenerateConditionIds
-} from "../chunk-A4KMGXB3.js";
+} from "../chunk-NVSDWUJP.js";
 import "../chunk-YYIGUZNZ.js";
 import "../chunk-PAESAL23.js";
-import "../chunk-7JXEY4A2.js";
 import "../chunk-CEK3SCQO.js";
+import "../chunk-KYDXF7SU.js";
+import "../chunk-GFH3VWOC.js";
 import "../chunk-3KG2HTZ3.js";
 import "../chunk-XEO3YXBM.js";
 export {

package/dist/conditions/index.cjs

@@ -164,6 +164,15 @@ var evaluateTimeCondition = (rules) => {
 // src/conditions/attribute.ts
 var import_types = require("@usertour/types");
 var import_date_fns2 = require("date-fns");
+
+// src/type-utils.ts
+var nativeIsArray = Array.isArray;
+var ObjProto = Object.prototype;
+var objToString = ObjProto.toString;
+var objHasOwn = ObjProto.hasOwnProperty;
+var isArray = nativeIsArray || ((obj) => objToString.call(obj) === "[object Array]");
+
+// src/conditions/attribute.ts
 function evaluateAttributeCondition(condition, options) {
   const { data } = condition;
   if (!data) {
@@ -275,7 +284,7 @@ function evaluateBooleanCondition(logic, actualValue) {
   }
 }
 function evaluateListCondition(logic, actualValue, expectedValues) {
-  const arrayValue = Array.isArray(actualValue) ? actualValue : [];
+  const arrayValue = isArray(actualValue) ? actualValue : [];
   if (logic === "empty" || logic === "any") {
     switch (logic) {
       case "empty":

package/dist/conditions/index.js

@@ -9,18 +9,19 @@ import {
   isConditionsActived,
   isEqual,
   regenerateConditionIds
-} from "../chunk-A4KMGXB3.js";
+} from "../chunk-NVSDWUJP.js";
 import {
   evaluateUrlCondition,
   isMatchUrlPattern
 } from "../chunk-YYIGUZNZ.js";
 import "../chunk-PAESAL23.js";
-import {
-  evaluateAttributeCondition
-} from "../chunk-7JXEY4A2.js";
 import {
   evaluateTimeCondition
 } from "../chunk-CEK3SCQO.js";
+import {
+  evaluateAttributeCondition
+} from "../chunk-KYDXF7SU.js";
+import "../chunk-GFH3VWOC.js";
 import "../chunk-3KG2HTZ3.js";
 import "../chunk-XEO3YXBM.js";
 export {

package/dist/index.cjs

@@ -43,6 +43,7 @@ __export(src_exports, {
   assignConditionIds: () => assignConditionIds,
   assignableWindow: () => assignableWindow,
   buildConfig: () => buildConfig,
+  capitalizeFirstLetter: () => capitalizeFirstLetter,
   cn: () => cn,
   conditionsIsSame: () => conditionsIsSame,
   convertSettings: () => convertSettings,
@@ -60,8 +61,10 @@ __export(src_exports, {
   evaluateUrlCondition: () => evaluateUrlCondition,
   fetch: () => fetch,
   filterConditionsByType: () => filterConditionsByType,
+  filterNullAttributes: () => filterNullAttributes,
   formatDate: () => formatDate,
   generateAutoStateColors: () => generateAutoStateColors,
+  getAttributeType: () => getAttributeType,
   getAuthToken: () => getAuthToken,
   getCodeError: () => getCodeError,
   getContentError: () => getContentError,
@@ -1240,7 +1243,7 @@ function evaluateBooleanCondition(logic, actualValue) {
   }
 }
 function evaluateListCondition(logic, actualValue, expectedValues) {
-  const arrayValue = Array.isArray(actualValue) ? actualValue : [];
+  const arrayValue = isArray(actualValue) ? actualValue : [];
   if (logic === "empty" || logic === "any") {
     switch (logic) {
       case "empty":
@@ -1424,6 +1427,75 @@ var allConditionsHaveIds = (conditions) => {
   }
   return true;
 };
+
+// src/attribute.ts
+var import_types6 = require("@usertour/types");
+var import_date_fns3 = require("date-fns");
+var isValidYear = (date) => {
+  const year = date.getFullYear();
+  return year >= 1900 && year <= 2100;
+};
+var tryParseDate = (parser) => {
+  try {
+    const date = parser();
+    return (0, import_date_fns3.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_fns3.parseISO)(dateStr))) {
+    return true;
+  }
+  return dateFormats.some((format) => tryParseDate(() => (0, import_date_fns3.parse)(dateStr, format, /* @__PURE__ */ new Date())));
+}
+var getAttributeType = (attribute) => {
+  const t = typeof attribute;
+  if (t === "number") {
+    return import_types6.BizAttributeTypes.Number;
+  }
+  if (t === "string") {
+    if (isDateString(attribute)) {
+      return import_types6.BizAttributeTypes.DateTime;
+    }
+    return import_types6.BizAttributeTypes.String;
+  }
+  if (t === "boolean") {
+    return import_types6.BizAttributeTypes.Boolean;
+  }
+  if (t === "object" && Array.isArray(attribute)) {
+    return import_types6.BizAttributeTypes.List;
+  }
+  return import_types6.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 = {
   AbortController,
@@ -1434,6 +1506,7 @@ var allConditionsHaveIds = (conditions) => {
   assignConditionIds,
   assignableWindow,
   buildConfig,
+  capitalizeFirstLetter,
   cn,
   conditionsIsSame,
   convertSettings,
@@ -1451,8 +1524,10 @@ var allConditionsHaveIds = (conditions) => {
   evaluateUrlCondition,
   fetch,
   filterConditionsByType,
+  filterNullAttributes,
   formatDate,
   generateAutoStateColors,
+  getAttributeType,
   getAuthToken,
   getCodeError,
   getContentError,

package/dist/index.d.cts

@@ -13,6 +13,7 @@ export { allConditionsHaveIds, assignConditionIds, conditionsIsSame, evaluateRul
 export { evaluateUrlCondition, isMatchUrlPattern } from './conditions/url.cjs';
 export { evaluateTimeCondition } from './conditions/time.cjs';
 export { evaluateAttributeCondition } from './conditions/attribute.cjs';
+export { capitalizeFirstLetter, filterNullAttributes, getAttributeType } from './attribute.cjs';
 export { default as isEqual } from 'fast-deep-equal';
 import '@usertour/types';
 import './storage.cjs';

package/dist/index.d.ts

@@ -13,6 +13,7 @@ export { allConditionsHaveIds, assignConditionIds, conditionsIsSame, evaluateRul
 export { evaluateUrlCondition, isMatchUrlPattern } from './conditions/url.js';
 export { evaluateTimeCondition } from './conditions/time.js';
 export { evaluateAttributeCondition } from './conditions/attribute.js';
+export { capitalizeFirstLetter, filterNullAttributes, getAttributeType } from './attribute.js';
 export { default as isEqual } from 'fast-deep-equal';
 import '@usertour/types';
 import './storage.js';

package/dist/index.js

@@ -20,18 +20,23 @@ import {
   isConditionsActived,
   isEqual,
   regenerateConditionIds
-} from "./chunk-A4KMGXB3.js";
+} from "./chunk-NVSDWUJP.js";
 import {
   evaluateUrlCondition,
   isMatchUrlPattern
 } from "./chunk-YYIGUZNZ.js";
 import "./chunk-PAESAL23.js";
-import {
-  evaluateAttributeCondition
-} from "./chunk-7JXEY4A2.js";
 import {
   evaluateTimeCondition
 } from "./chunk-CEK3SCQO.js";
+import {
+  evaluateAttributeCondition
+} from "./chunk-KYDXF7SU.js";
+import {
+  capitalizeFirstLetter,
+  filterNullAttributes,
+  getAttributeType
+} from "./chunk-EEYZG4JJ.js";
 import {
   getAuthToken,
   removeAuthToken,
@@ -126,6 +131,7 @@ export {
   assignConditionIds,
   assignableWindow,
   buildConfig,
+  capitalizeFirstLetter,
   cn,
   conditionsIsSame,
   convertSettings,
@@ -143,8 +149,10 @@ export {
   evaluateUrlCondition,
   fetch,
   filterConditionsByType,
+  filterNullAttributes,
   formatDate,
   generateAutoStateColors,
+  getAttributeType,
   getAuthToken,
   getCodeError,
   getContentError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usertour/helpers",
-  "version": "0.0.34",
+  "version": "0.0.35",
   "type": "module",
   "description": "Utility functions and helpers shared across the UserTour project",
   "homepage": "https://www.usertour.io",