@usertour/helpers 0.0.33 → 0.0.35

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-E2APTIR7.js → chunk-KYDXF7SU.js}

@@ -1,3 +1,7 @@
+import {
+  isArray
+} from "./chunk-GFH3VWOC.js";
+
 // src/conditions/attribute.ts
 import {
   BizAttributeTypes,
@@ -108,26 +112,27 @@ function evaluateStringCondition(logic, actualValue, expectedValue) {
   }
 }
 function evaluateNumberCondition(logic, actualValue, expectedValue, expectedValue2) {
-  const numValue = Number(actualValue);
-  const numValue2 = Number(expectedValue2);
-  if (Number.isNaN(numValue)) {
+  const numActualValue = Number(actualValue);
+  const numExpectedValue = Number(expectedValue);
+  const numExpectedValue2 = Number(expectedValue2);
+  if (Number.isNaN(numActualValue)) {
     return false;
   }
   switch (logic) {
     case "is":
-      return numValue === expectedValue;
+      return numActualValue === numExpectedValue;
     case "not":
-      return numValue !== expectedValue;
+      return numActualValue !== numExpectedValue;
     case "isLessThan":
-      return numValue < expectedValue;
+      return numActualValue < numExpectedValue;
     case "isLessThanOrEqualTo":
-      return numValue <= expectedValue;
+      return numActualValue <= numExpectedValue;
     case "isGreaterThan":
-      return numValue > expectedValue;
+      return numActualValue > numExpectedValue;
     case "isGreaterThanOrEqualTo":
-      return numValue >= expectedValue;
+      return numActualValue >= numExpectedValue;
     case "between":
-      return numValue >= expectedValue && numValue <= numValue2;
+      return numActualValue >= numExpectedValue && numActualValue <= numExpectedValue2;
     case "empty":
       return actualValue === null || actualValue === void 0 || actualValue === "";
     case "any":
@@ -151,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-YZQBWYCU.js → chunk-NVSDWUJP.js}

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