@usertour/helpers 0.0.15 → 0.0.18

package/dist/chunk-PBZSPV5R.js

@@ -0,0 +1,239 @@
+// src/conditions/attribute.ts
+import { BizAttributeTypes } from "@usertour/types";
+import { subDays, startOfDay, endOfDay } from "date-fns";
+function evaluateFilterConditions(conditions, attributes, userAttributes) {
+  if (!conditions || !conditions.length) {
+    return true;
+  }
+  const result = evaluateAttributeConditionsGroup(conditions, attributes, userAttributes);
+  return evaluateFilterResult(result);
+}
+function evaluateAttributeConditionsGroup(conditions, attributes, userAttributes) {
+  if (!conditions || !conditions.length) {
+    return false;
+  }
+  const AND = [];
+  const OR = [];
+  for (const condition of conditions) {
+    const { operators } = condition;
+    const item = condition.type !== "group" ? evaluateAttributeCondition(condition, attributes, userAttributes) : evaluateAttributeConditionsGroup(condition.conditions || [], attributes, userAttributes);
+    if (!item) {
+      continue;
+    }
+    if (operators === "and") {
+      AND.push(item);
+    } else {
+      OR.push(item);
+    }
+  }
+  const filter = {};
+  if (AND.length > 0) {
+    filter.AND = AND;
+  }
+  if (OR.length > 0) {
+    filter.OR = OR;
+  }
+  if (AND.length === 0 && OR.length === 0) {
+    return false;
+  }
+  return filter;
+}
+function evaluateAttributeCondition(condition, attributes, userAttributes) {
+  const { data } = condition;
+  if (!data) {
+    return false;
+  }
+  const { logic, value, attrId, value2, listValues = [] } = data;
+  if (!attrId) {
+    return false;
+  }
+  const attr = attributes.find((attr2) => attr2.id === attrId);
+  if (!attr) {
+    return false;
+  }
+  const actualValue = getAttributeValue(attr.codeName, userAttributes);
+  if (attr.dataType === BizAttributeTypes.String) {
+    return evaluateStringCondition(logic, actualValue, value);
+  }
+  if (attr.dataType === BizAttributeTypes.Number) {
+    return evaluateNumberCondition(logic, actualValue, value, value2);
+  }
+  if (attr.dataType === BizAttributeTypes.Boolean) {
+    return evaluateBooleanCondition(logic, actualValue);
+  }
+  if (attr.dataType === BizAttributeTypes.List) {
+    return evaluateListCondition(logic, actualValue, listValues);
+  }
+  if (attr.dataType === BizAttributeTypes.DateTime) {
+    return evaluateDateTimeCondition(logic, actualValue, value);
+  }
+  return false;
+}
+function getAttributeValue(codeName, userAttributes) {
+  return userAttributes == null ? void 0 : userAttributes[codeName];
+}
+function evaluateStringCondition(logic, actualValue, expectedValue) {
+  const stringValue = actualValue === null || actualValue === void 0 ? "" : String(actualValue);
+  switch (logic) {
+    case "is":
+      return stringValue === expectedValue;
+    case "not":
+      return stringValue !== expectedValue;
+    case "contains":
+      return stringValue.includes(expectedValue);
+    case "notContain":
+      return !stringValue.includes(expectedValue);
+    case "startsWith":
+      return stringValue.startsWith(expectedValue);
+    case "endsWith":
+      return stringValue.endsWith(expectedValue);
+    case "empty": {
+      const isEmpty = !stringValue || stringValue === "";
+      return isEmpty;
+    }
+    case "any":
+      return Boolean(stringValue && stringValue !== "");
+    default:
+      return false;
+  }
+}
+function evaluateNumberCondition(logic, actualValue, expectedValue, expectedValue2) {
+  const numValue = Number(actualValue);
+  const numValue2 = Number(expectedValue2);
+  if (Number.isNaN(numValue)) {
+    return false;
+  }
+  switch (logic) {
+    case "is":
+      return numValue === expectedValue;
+    case "not":
+      return numValue !== expectedValue;
+    case "isLessThan":
+      return numValue < expectedValue;
+    case "isLessThanOrEqualTo":
+      return numValue <= expectedValue;
+    case "isGreaterThan":
+      return numValue > expectedValue;
+    case "isGreaterThanOrEqualTo":
+      return numValue >= expectedValue;
+    case "between":
+      return numValue >= expectedValue && numValue <= numValue2;
+    case "empty":
+      return actualValue === null || actualValue === void 0 || actualValue === "";
+    case "any":
+      return actualValue !== null && actualValue !== void 0 && actualValue !== "";
+    default:
+      return false;
+  }
+}
+function evaluateBooleanCondition(logic, actualValue) {
+  switch (logic) {
+    case "true":
+      return actualValue === true;
+    case "false":
+      return actualValue === false;
+    case "empty":
+      return actualValue === null || actualValue === void 0 || actualValue === "";
+    case "any":
+      return actualValue !== null && actualValue !== void 0 && actualValue !== "";
+    default:
+      return false;
+  }
+}
+function evaluateListCondition(logic, actualValue, expectedValues) {
+  const arrayValue = Array.isArray(actualValue) ? actualValue : [];
+  if (logic === "empty" || logic === "any") {
+    switch (logic) {
+      case "empty":
+        return !arrayValue || arrayValue.length === 0;
+      case "any":
+        return arrayValue && arrayValue.length > 0;
+      default:
+        return false;
+    }
+  }
+  const filteredValues = expectedValues.filter(
+    (value) => value !== null && value !== void 0 && value !== ""
+  );
+  if (!filteredValues.length) {
+    return false;
+  }
+  switch (logic) {
+    case "includesAtLeastOne":
+      return filteredValues.some((value) => arrayValue.includes(value));
+    case "includesAll":
+      return filteredValues.every((value) => arrayValue.includes(value));
+    case "notIncludesAtLeastOne":
+      return !filteredValues.some((value) => arrayValue.includes(value));
+    case "notIncludesAll":
+      return !filteredValues.every((value) => arrayValue.includes(value));
+    default:
+      return false;
+  }
+}
+function evaluateDateTimeCondition(logic, actualValue, expectedValue) {
+  const actualDate = actualValue ? new Date(actualValue) : null;
+  const now = /* @__PURE__ */ new Date();
+  if (!actualDate || Number.isNaN(actualDate.getTime())) {
+    return false;
+  }
+  switch (logic) {
+    case "lessThan": {
+      const targetDate = subDays(now, Number(expectedValue));
+      return actualDate >= targetDate;
+    }
+    case "exactly": {
+      const targetDate = subDays(now, Number(expectedValue));
+      const start = startOfDay(targetDate);
+      const end = endOfDay(targetDate);
+      return actualDate >= start && actualDate <= end;
+    }
+    case "moreThan": {
+      const targetDate = subDays(now, Number(expectedValue));
+      return actualDate <= targetDate;
+    }
+    case "before": {
+      const expectedDate = new Date(expectedValue);
+      return actualDate <= expectedDate;
+    }
+    case "on": {
+      const expectedDateOn = new Date(expectedValue);
+      const start = startOfDay(expectedDateOn);
+      const end = endOfDay(expectedDateOn);
+      return actualDate >= start && actualDate <= end;
+    }
+    case "after": {
+      const expectedDateAfter = new Date(expectedValue);
+      return actualDate >= expectedDateAfter;
+    }
+    case "empty":
+      return !actualValue || actualValue === "";
+    case "any":
+      return actualValue && actualValue !== "";
+    default:
+      return false;
+  }
+}
+function evaluateFilterResult(filter) {
+  if (!filter) {
+    return false;
+  }
+  if (filter.AND) {
+    return filter.AND.every((item) => evaluateFilterResult(item));
+  }
+  if (filter.OR) {
+    return filter.OR.some((item) => evaluateFilterResult(item));
+  }
+  if (typeof filter === "boolean") {
+    return filter;
+  }
+  if (typeof filter === "object") {
+    return true;
+  }
+  return false;
+}
+
+export {
+  evaluateFilterConditions,
+  evaluateAttributeCondition
+};

package/dist/chunk-YOFQHQ7D.js

@@ -0,0 +1,92 @@
+// src/conditions/condition.ts
+import isEqual from "fast-deep-equal";
+var compareConditionsItem = (item1, item2) => {
+  const { data = {}, ...others1 } = item1;
+  const { data: data2 = {}, ...others2 } = item2;
+  if (!isEqual(others2, others1)) {
+    return false;
+  }
+  for (const key in data) {
+    if (!isEqual(data[key], data2[key])) {
+      return false;
+    }
+  }
+  return true;
+};
+var conditionsIsSame = (rr1, rr2) => {
+  const r1 = [...rr1];
+  const r2 = [...rr2];
+  if (r1.length === 0 && r2.length === 0) {
+    return true;
+  }
+  if (r1.length !== r2.length) {
+    return false;
+  }
+  const group1 = r1.filter((item) => item.type === "group");
+  const group2 = r2.filter((item) => item.type === "group");
+  if (group1.length !== group2.length) {
+    return false;
+  }
+  for (let index = 0; index < r1.length; index++) {
+    const item1 = r1[index];
+    const item2 = r2[index];
+    if (!item1 || !item2) {
+      return false;
+    }
+    if (item1.type === "group") {
+      if (!item2.conditions) {
+        return false;
+      }
+      const c1 = item1.conditions;
+      const c2 = item2.conditions;
+      if (item1.operators !== item2.operators) {
+        return false;
+      }
+      if (!conditionsIsSame(c1, c2)) {
+        return false;
+      }
+    } else {
+      if (!compareConditionsItem(item1, item2)) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+var isConditionsActived = (conditions) => {
+  if (!conditions || conditions.length === 0) {
+    return false;
+  }
+  const operator = conditions[0].operators;
+  const actives = conditions.filter((rule) => {
+    if (!rule.conditions) {
+      return rule.actived;
+    }
+    return isConditionsActived(rule.conditions);
+  });
+  return operator === "and" ? actives.length === conditions.length : actives.length > 0;
+};
+function filterConditionsByType(conditions, allowedTypes) {
+  return conditions.filter((condition) => {
+    if (condition.type === "group" && condition.conditions) {
+      const filteredGroupConditions = filterConditionsByType(condition.conditions, allowedTypes);
+      return filteredGroupConditions.length > 0;
+    }
+    return allowedTypes.includes(condition.type);
+  }).map((condition) => {
+    if (condition.type === "group" && condition.conditions) {
+      return {
+        ...condition,
+        conditions: filterConditionsByType(condition.conditions, allowedTypes)
+      };
+    }
+    return condition;
+  });
+}
+
+export {
+  isEqual,
+  conditionsIsSame,
+  isConditionsActived,
+  filterConditionsByType
+};

package/dist/conditions/attribute.cjs

@@ -0,0 +1,264 @@
+"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/conditions/attribute.ts
+var attribute_exports = {};
+__export(attribute_exports, {
+  evaluateAttributeCondition: () => evaluateAttributeCondition,
+  evaluateFilterConditions: () => evaluateFilterConditions
+});
+module.exports = __toCommonJS(attribute_exports);
+var import_types = require("@usertour/types");
+var import_date_fns = require("date-fns");
+function evaluateFilterConditions(conditions, attributes, userAttributes) {
+  if (!conditions || !conditions.length) {
+    return true;
+  }
+  const result = evaluateAttributeConditionsGroup(conditions, attributes, userAttributes);
+  return evaluateFilterResult(result);
+}
+function evaluateAttributeConditionsGroup(conditions, attributes, userAttributes) {
+  if (!conditions || !conditions.length) {
+    return false;
+  }
+  const AND = [];
+  const OR = [];
+  for (const condition of conditions) {
+    const { operators } = condition;
+    const item = condition.type !== "group" ? evaluateAttributeCondition(condition, attributes, userAttributes) : evaluateAttributeConditionsGroup(condition.conditions || [], attributes, userAttributes);
+    if (!item) {
+      continue;
+    }
+    if (operators === "and") {
+      AND.push(item);
+    } else {
+      OR.push(item);
+    }
+  }
+  const filter = {};
+  if (AND.length > 0) {
+    filter.AND = AND;
+  }
+  if (OR.length > 0) {
+    filter.OR = OR;
+  }
+  if (AND.length === 0 && OR.length === 0) {
+    return false;
+  }
+  return filter;
+}
+function evaluateAttributeCondition(condition, attributes, userAttributes) {
+  const { data } = condition;
+  if (!data) {
+    return false;
+  }
+  const { logic, value, attrId, value2, listValues = [] } = data;
+  if (!attrId) {
+    return false;
+  }
+  const attr = attributes.find((attr2) => attr2.id === attrId);
+  if (!attr) {
+    return false;
+  }
+  const actualValue = getAttributeValue(attr.codeName, userAttributes);
+  if (attr.dataType === import_types.BizAttributeTypes.String) {
+    return evaluateStringCondition(logic, actualValue, value);
+  }
+  if (attr.dataType === import_types.BizAttributeTypes.Number) {
+    return evaluateNumberCondition(logic, actualValue, value, value2);
+  }
+  if (attr.dataType === import_types.BizAttributeTypes.Boolean) {
+    return evaluateBooleanCondition(logic, actualValue);
+  }
+  if (attr.dataType === import_types.BizAttributeTypes.List) {
+    return evaluateListCondition(logic, actualValue, listValues);
+  }
+  if (attr.dataType === import_types.BizAttributeTypes.DateTime) {
+    return evaluateDateTimeCondition(logic, actualValue, value);
+  }
+  return false;
+}
+function getAttributeValue(codeName, userAttributes) {
+  return userAttributes == null ? void 0 : userAttributes[codeName];
+}
+function evaluateStringCondition(logic, actualValue, expectedValue) {
+  const stringValue = actualValue === null || actualValue === void 0 ? "" : String(actualValue);
+  switch (logic) {
+    case "is":
+      return stringValue === expectedValue;
+    case "not":
+      return stringValue !== expectedValue;
+    case "contains":
+      return stringValue.includes(expectedValue);
+    case "notContain":
+      return !stringValue.includes(expectedValue);
+    case "startsWith":
+      return stringValue.startsWith(expectedValue);
+    case "endsWith":
+      return stringValue.endsWith(expectedValue);
+    case "empty": {
+      const isEmpty = !stringValue || stringValue === "";
+      return isEmpty;
+    }
+    case "any":
+      return Boolean(stringValue && stringValue !== "");
+    default:
+      return false;
+  }
+}
+function evaluateNumberCondition(logic, actualValue, expectedValue, expectedValue2) {
+  const numValue = Number(actualValue);
+  const numValue2 = Number(expectedValue2);
+  if (Number.isNaN(numValue)) {
+    return false;
+  }
+  switch (logic) {
+    case "is":
+      return numValue === expectedValue;
+    case "not":
+      return numValue !== expectedValue;
+    case "isLessThan":
+      return numValue < expectedValue;
+    case "isLessThanOrEqualTo":
+      return numValue <= expectedValue;
+    case "isGreaterThan":
+      return numValue > expectedValue;
+    case "isGreaterThanOrEqualTo":
+      return numValue >= expectedValue;
+    case "between":
+      return numValue >= expectedValue && numValue <= numValue2;
+    case "empty":
+      return actualValue === null || actualValue === void 0 || actualValue === "";
+    case "any":
+      return actualValue !== null && actualValue !== void 0 && actualValue !== "";
+    default:
+      return false;
+  }
+}
+function evaluateBooleanCondition(logic, actualValue) {
+  switch (logic) {
+    case "true":
+      return actualValue === true;
+    case "false":
+      return actualValue === false;
+    case "empty":
+      return actualValue === null || actualValue === void 0 || actualValue === "";
+    case "any":
+      return actualValue !== null && actualValue !== void 0 && actualValue !== "";
+    default:
+      return false;
+  }
+}
+function evaluateListCondition(logic, actualValue, expectedValues) {
+  const arrayValue = Array.isArray(actualValue) ? actualValue : [];
+  if (logic === "empty" || logic === "any") {
+    switch (logic) {
+      case "empty":
+        return !arrayValue || arrayValue.length === 0;
+      case "any":
+        return arrayValue && arrayValue.length > 0;
+      default:
+        return false;
+    }
+  }
+  const filteredValues = expectedValues.filter(
+    (value) => value !== null && value !== void 0 && value !== ""
+  );
+  if (!filteredValues.length) {
+    return false;
+  }
+  switch (logic) {
+    case "includesAtLeastOne":
+      return filteredValues.some((value) => arrayValue.includes(value));
+    case "includesAll":
+      return filteredValues.every((value) => arrayValue.includes(value));
+    case "notIncludesAtLeastOne":
+      return !filteredValues.some((value) => arrayValue.includes(value));
+    case "notIncludesAll":
+      return !filteredValues.every((value) => arrayValue.includes(value));
+    default:
+      return false;
+  }
+}
+function evaluateDateTimeCondition(logic, actualValue, expectedValue) {
+  const actualDate = actualValue ? new Date(actualValue) : null;
+  const now = /* @__PURE__ */ new Date();
+  if (!actualDate || Number.isNaN(actualDate.getTime())) {
+    return false;
+  }
+  switch (logic) {
+    case "lessThan": {
+      const targetDate = (0, import_date_fns.subDays)(now, Number(expectedValue));
+      return actualDate >= targetDate;
+    }
+    case "exactly": {
+      const targetDate = (0, import_date_fns.subDays)(now, Number(expectedValue));
+      const start = (0, import_date_fns.startOfDay)(targetDate);
+      const end = (0, import_date_fns.endOfDay)(targetDate);
+      return actualDate >= start && actualDate <= end;
+    }
+    case "moreThan": {
+      const targetDate = (0, import_date_fns.subDays)(now, Number(expectedValue));
+      return actualDate <= targetDate;
+    }
+    case "before": {
+      const expectedDate = new Date(expectedValue);
+      return actualDate <= expectedDate;
+    }
+    case "on": {
+      const expectedDateOn = new Date(expectedValue);
+      const start = (0, import_date_fns.startOfDay)(expectedDateOn);
+      const end = (0, import_date_fns.endOfDay)(expectedDateOn);
+      return actualDate >= start && actualDate <= end;
+    }
+    case "after": {
+      const expectedDateAfter = new Date(expectedValue);
+      return actualDate >= expectedDateAfter;
+    }
+    case "empty":
+      return !actualValue || actualValue === "";
+    case "any":
+      return actualValue && actualValue !== "";
+    default:
+      return false;
+  }
+}
+function evaluateFilterResult(filter) {
+  if (!filter) {
+    return false;
+  }
+  if (filter.AND) {
+    return filter.AND.every((item) => evaluateFilterResult(item));
+  }
+  if (filter.OR) {
+    return filter.OR.some((item) => evaluateFilterResult(item));
+  }
+  if (typeof filter === "boolean") {
+    return filter;
+  }
+  if (typeof filter === "object") {
+    return true;
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  evaluateAttributeCondition,
+  evaluateFilterConditions
+});

package/dist/conditions/attribute.d.cts

@@ -0,0 +1,28 @@
+import { RulesCondition, UserTourTypes } from '@usertour/types';
+
+/**
+ * Simplified attribute type with only required fields
+ */
+interface SimpleAttribute {
+    id: string;
+    codeName: string;
+    dataType: number;
+}
+/**
+ * Evaluate filter conditions and return boolean result
+ * @param conditions - Filter conditions to evaluate
+ * @param attributes - Available attributes
+ * @param context - Filter context with user attributes
+ * @returns boolean indicating if conditions are met
+ */
+declare function evaluateFilterConditions(conditions: RulesCondition[], attributes: SimpleAttribute[], userAttributes: UserTourTypes.Attributes): boolean;
+/**
+ * Evaluate a single attribute condition
+ * @param condition - Single attribute filter condition
+ * @param attributes - Available attributes
+ * @param context - Filter context with user attributes
+ * @returns Evaluation result (boolean or complex structure)
+ */
+declare function evaluateAttributeCondition(condition: RulesCondition, attributes: SimpleAttribute[], userAttributes: UserTourTypes.Attributes): any;
+
+export { type SimpleAttribute, evaluateAttributeCondition, evaluateFilterConditions };

package/dist/conditions/attribute.d.ts

@@ -0,0 +1,28 @@
+import { RulesCondition, UserTourTypes } from '@usertour/types';
+
+/**
+ * Simplified attribute type with only required fields
+ */
+interface SimpleAttribute {
+    id: string;
+    codeName: string;
+    dataType: number;
+}
+/**
+ * Evaluate filter conditions and return boolean result
+ * @param conditions - Filter conditions to evaluate
+ * @param attributes - Available attributes
+ * @param context - Filter context with user attributes
+ * @returns boolean indicating if conditions are met
+ */
+declare function evaluateFilterConditions(conditions: RulesCondition[], attributes: SimpleAttribute[], userAttributes: UserTourTypes.Attributes): boolean;
+/**
+ * Evaluate a single attribute condition
+ * @param condition - Single attribute filter condition
+ * @param attributes - Available attributes
+ * @param context - Filter context with user attributes
+ * @returns Evaluation result (boolean or complex structure)
+ */
+declare function evaluateAttributeCondition(condition: RulesCondition, attributes: SimpleAttribute[], userAttributes: UserTourTypes.Attributes): any;
+
+export { type SimpleAttribute, evaluateAttributeCondition, evaluateFilterConditions };

package/dist/conditions/attribute.js

@@ -0,0 +1,9 @@
+import {
+  evaluateAttributeCondition,
+  evaluateFilterConditions
+} from "../chunk-PBZSPV5R.js";
+import "../chunk-XEO3YXBM.js";
+export {
+  evaluateAttributeCondition,
+  evaluateFilterConditions
+};