@usertour/helpers 0.0.11 → 0.0.13

package/dist/conditions.cjs

@@ -0,0 +1,615 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/conditions.ts
+var conditions_exports = {};
+__export(conditions_exports, {
+  PRIORITIES: () => PRIORITIES,
+  activedContentCondition: () => activedContentCondition,
+  activedContentRulesConditions: () => activedContentRulesConditions,
+  activedRulesConditions: () => activedRulesConditions,
+  checklistIsDimissed: () => checklistIsDimissed,
+  checklistIsSeen: () => checklistIsSeen,
+  completeEventMapping: () => completeEventMapping,
+  filterAutoStartContent: () => filterAutoStartContent,
+  findLatestEvent: () => findLatestEvent,
+  flowIsDismissed: () => flowIsDismissed,
+  flowIsSeen: () => flowIsSeen,
+  isActive: () => isActive,
+  isActiveContent: () => isActiveContent,
+  isActiveRulesByCurrentPage: () => isActiveRulesByCurrentPage,
+  isActiveRulesByCurrentTime: () => isActiveRulesByCurrentTime,
+  isDismissedEventMapping: () => isDismissedEventMapping,
+  isHasActivedContents: () => isHasActivedContents,
+  isSameContents: () => isSameContents,
+  isValidContent: () => isValidContent,
+  parseUrlParams: () => parseUrlParams,
+  rulesTypes: () => rulesTypes,
+  wait: () => wait
+});
+module.exports = __toCommonJS(conditions_exports);
+
+// src/condition.ts
+var import_fast_deep_equal = __toESM(require("fast-deep-equal"), 1);
+var parseUrl = (url) => {
+  const urlPatterns = url.match(/^(([a-z\d]+):\/\/)?([^/?#]+)?(\/[^?#]*)?(\?([^#]*))?(#.*)?$/i);
+  if (!urlPatterns) {
+    return null;
+  }
+  const [, , scheme = "", domain = "", path = "", , query = "", fragment = ""] = urlPatterns;
+  return { scheme, domain, path, query, fragment };
+};
+var replaceWildcard = (input, s1, s2) => {
+  const withSpecialWords = replaceSpecialWords(input);
+  const withWildcard = withSpecialWords.replace(/\\\*/g, `${s1}*`);
+  if (!s2) {
+    return withWildcard;
+  }
+  return withWildcard.replace(/:[a-z0-9_]+/g, `[^${s2}]+`);
+};
+var replaceSpecialWords = (str) => {
+  return str.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+};
+var parsePattern = (pattern) => {
+  if (!pattern || !pattern.trim()) {
+    return null;
+  }
+  const _pattern = parseUrl(pattern);
+  if (!_pattern) {
+    console.error("Invalid URL pattern:", pattern);
+    return null;
+  }
+  const { scheme, domain, path, query, fragment } = _pattern;
+  const _scheme = scheme ? replaceSpecialWords(scheme) : "[a-z\\d]+";
+  const _domain = domain ? replaceWildcard(domain, "[^/]", ".") : "[^/]*";
+  const _fragment = fragment ? replaceWildcard(fragment, ".", "/") : "(#.*)?";
+  const _path = path ? replaceWildcard(path, "[^?#]", "/") : "/[^?#]*";
+  let _query = "(\\?[^#]*)?";
+  if (query) {
+    new URLSearchParams(query).forEach((value, key) => {
+      const _str = value === "" ? "=?" : value === "*" ? "(=[^&#]*)?" : `=${replaceWildcard(value, "[^#]")}`;
+      _query += `(?=.*[?&]${replaceSpecialWords(key)}${_str}([&#]|$))`;
+    });
+    _query += "\\?[^#]*";
+  }
+  return new RegExp(`^${_scheme}://${_domain}(:\\d+)?${_path}${_query}${_fragment}$`);
+};
+var isMatchUrlPattern = (_url, includes, excludes) => {
+  const isMatchIncludesConditions = includes.length > 0 ? includes.some((_include) => {
+    const reg = parsePattern(_include);
+    if (reg) {
+      return reg.test(_url);
+    }
+    return false;
+  }) : true;
+  const isMatchExcludesConditions = excludes.length > 0 ? excludes.some((_exclude) => {
+    const reg = parsePattern(_exclude);
+    if (reg) {
+      return reg.test(_url);
+    }
+    return false;
+  }) : false;
+  return isMatchIncludesConditions && !isMatchExcludesConditions;
+};
+var compareConditionsItem = (item1, item2) => {
+  const { data = {}, ...others1 } = item1;
+  const { data: data2 = {}, ...others2 } = item2;
+  if (!(0, import_fast_deep_equal.default)(others2, others1)) {
+    return false;
+  }
+  for (const key in data) {
+    if (!(0, import_fast_deep_equal.default)(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;
+};
+
+// src/conditions.ts
+var import_types = require("@usertour/types");
+var import_date_fns = require("date-fns");
+var PRIORITIES = [
+  import_types.ContentPriority.HIGHEST,
+  import_types.ContentPriority.HIGH,
+  import_types.ContentPriority.MEDIUM,
+  import_types.ContentPriority.LOW,
+  import_types.ContentPriority.LOWEST
+];
+var rulesTypes = Object.values(import_types.RulesType);
+var isActiveRulesByCurrentPage = (rules) => {
+  const { excludes, includes } = rules.data;
+  if (location) {
+    const href = location.href;
+    return isMatchUrlPattern(href, includes, excludes);
+  }
+  return false;
+};
+var isActiveRulesByCurrentTime = (rules) => {
+  const { endDate, endDateHour, endDateMinute, startDate, startDateHour, startDateMinute } = rules.data;
+  const startTime = /* @__PURE__ */ new Date(`${startDate} ${startDateHour}:${startDateMinute}:00`);
+  const endTime = /* @__PURE__ */ new Date(`${endDate} ${endDateHour}:${endDateMinute}:00`);
+  const now = /* @__PURE__ */ new Date();
+  if (!endDate) {
+    return (0, import_date_fns.isAfter)(now, startTime);
+  }
+  return (0, import_date_fns.isAfter)(now, startTime) && (0, import_date_fns.isBefore)(now, endTime);
+};
+var isActivedContentRulesCondition = (rules, contentSession) => {
+  const { contentId, logic } = rules.data;
+  const { latestSession, seenSessions, completedSessions } = contentSession;
+  if (!contentId || !logic || contentId !== contentSession.contentId) {
+    return false;
+  }
+  if (logic === import_types.ContentConditionLogic.ACTIVED || logic === import_types.ContentConditionLogic.UNACTIVED) {
+    if (!latestSession) {
+      return logic === import_types.ContentConditionLogic.UNACTIVED;
+    }
+    const isActived = !(flowIsDismissed(latestSession) || checklistIsDimissed(latestSession));
+    return logic === import_types.ContentConditionLogic.ACTIVED ? isActived : !isActived;
+  }
+  const isSeen = seenSessions > 0;
+  const isCompleted = completedSessions > 0;
+  if (logic === import_types.ContentConditionLogic.SEEN || logic === import_types.ContentConditionLogic.UNSEEN) {
+    return logic === import_types.ContentConditionLogic.SEEN ? isSeen : !isSeen;
+  }
+  if (logic === import_types.ContentConditionLogic.COMPLETED || logic === import_types.ContentConditionLogic.UNCOMPLETED) {
+    return logic === import_types.ContentConditionLogic.COMPLETED ? isCompleted : !isCompleted;
+  }
+  return false;
+};
+var isValidRulesType = (type) => {
+  return rulesTypes.includes(type);
+};
+var isActiveRules = async (rules) => {
+  if (!isValidRulesType(rules.type)) {
+    return true;
+  }
+  switch (rules.type) {
+    case import_types.RulesType.CURRENT_PAGE:
+      return isActiveRulesByCurrentPage(rules);
+    case import_types.RulesType.TIME:
+      return isActiveRulesByCurrentTime(rules);
+    default:
+      return rules.actived;
+  }
+};
+var activedRulesConditions = async (conditions, rewrite) => {
+  const rulesCondition = [...conditions];
+  for (let j = 0; j < rulesCondition.length; j++) {
+    const rules = rulesCondition[j];
+    if (rules.type !== "group") {
+      if (rewrite == null ? void 0 : rewrite[rules.type]) {
+        rulesCondition[j].actived = true;
+      } else {
+        rulesCondition[j].actived = await isActiveRules(rules);
+      }
+    } else if (rules.conditions) {
+      rulesCondition[j].conditions = await activedRulesConditions(rules.conditions);
+    }
+  }
+  return rulesCondition;
+};
+var activedContentRulesConditions = async (conditions, contents) => {
+  const rulesCondition = [...conditions];
+  for (let j = 0; j < rulesCondition.length; j++) {
+    const rules = rulesCondition[j];
+    if (rules.type !== "group") {
+      if (rules.type === import_types.RulesType.CONTENT) {
+        const content = contents.find((c) => c.contentId === rules.data.contentId);
+        if (content) {
+          const contentSession = {
+            contentId: content.contentId,
+            latestSession: content.latestSession,
+            totalSessions: content.totalSessions,
+            dismissedSessions: content.dismissedSessions,
+            completedSessions: content.completedSessions,
+            seenSessions: content.seenSessions
+          };
+          rulesCondition[j].actived = isActivedContentRulesCondition(rules, contentSession);
+        }
+      }
+    } else if (rules.conditions) {
+      rulesCondition[j].conditions = await activedContentRulesConditions(
+        rules.conditions,
+        contents
+      );
+    }
+  }
+  return rulesCondition;
+};
+var activedContentCondition = async (contents) => {
+  const _contents = JSON.parse(JSON.stringify(contents));
+  for (let index = 0; index < _contents.length; index++) {
+    const content = _contents[index];
+    const { enabledAutoStartRules, autoStartRules, hideRules, enabledHideRules } = content.config;
+    if (enabledAutoStartRules && autoStartRules && autoStartRules.length > 0) {
+      content.config.autoStartRules = await activedRulesConditions(autoStartRules);
+    }
+    if (enabledHideRules && hideRules && hideRules.length > 0) {
+      content.config.hideRules = await activedRulesConditions(hideRules);
+    }
+  }
+  return _contents;
+};
+var isActive = (autoStartRules) => {
+  if (!autoStartRules || autoStartRules.length === 0) {
+    return false;
+  }
+  const operator = autoStartRules[0].operators;
+  const actives = autoStartRules.filter((rule) => {
+    if (!rule.conditions) {
+      return rule.actived;
+    }
+    return isActive(rule.conditions);
+  });
+  return operator === "and" ? actives.length === autoStartRules.length : actives.length > 0;
+};
+var isActiveContent = (content) => {
+  const { enabledAutoStartRules, autoStartRules } = content.config;
+  if (!enabledAutoStartRules || !isActive(autoStartRules)) {
+    return false;
+  }
+  return true;
+};
+var priorityCompare = (a, b) => {
+  var _a, _b, _c, _d;
+  const a1 = (_b = (_a = a == null ? void 0 : a.config) == null ? void 0 : _a.autoStartRulesSetting) == null ? void 0 : _b.priority;
+  const a2 = (_d = (_c = b == null ? void 0 : b.config) == null ? void 0 : _c.autoStartRulesSetting) == null ? void 0 : _d.priority;
+  if (!a1 || !a2) {
+    return 0;
+  }
+  const index1 = PRIORITIES.indexOf(a1);
+  const index2 = PRIORITIES.indexOf(a2);
+  if (index1 > index2) {
+    return 1;
+  }
+  if (index1 < index2) {
+    return -1;
+  }
+  return 0;
+};
+var filterAutoStartContent = (contents, type) => {
+  return contents.filter((content) => {
+    const isActive2 = isActiveContent(content);
+    const isValid = isValidContent(content, contents);
+    return content.type === type && isActive2 && isValid;
+  }).sort(priorityCompare);
+};
+var isHasActivedContents = (source, dest) => {
+  for (let index = 0; index < source.length; index++) {
+    const content1 = source[index];
+    const content2 = dest.find((c) => c.id === content1.id);
+    if (!content2) {
+      return true;
+    }
+    if (isActiveContent(content1) !== isActiveContent(content2)) {
+      return true;
+    }
+  }
+  return false;
+};
+var isSameContents = (source, dest) => {
+  if (!source || !dest || source.length !== dest.length) {
+    return false;
+  }
+  for (let index = 0; index < source.length; index++) {
+    const content1 = source[index];
+    const content2 = dest.find((c) => c.id === content1.id);
+    if (!content2) {
+      return false;
+    }
+    if (!conditionsIsSame(content1.config.autoStartRules, content2.config.autoStartRules)) {
+      return false;
+    }
+  }
+  return true;
+};
+var getLatestEvent = (currentContent, contents, eventCodeName) => {
+  var _a;
+  const bizEvents = [];
+  const contentId = currentContent.id;
+  const contentType = currentContent.type;
+  for (let index = 0; index < contents.length; index++) {
+    const content = contents[index];
+    if (content.id === contentId || content.type !== contentType) {
+      continue;
+    }
+    const sessionBizEvents = (_a = content.latestSession) == null ? void 0 : _a.bizEvent;
+    if (sessionBizEvents && sessionBizEvents.length > 0) {
+      bizEvents.push(...sessionBizEvents.filter((e) => {
+        var _a2;
+        return ((_a2 = e == null ? void 0 : e.event) == null ? void 0 : _a2.codeName) === eventCodeName;
+      }));
+    }
+  }
+  return findLatestEvent(bizEvents);
+};
+var findLatestEvent = (bizEvents) => {
+  const initialValue = bizEvents[0];
+  const lastEvent = bizEvents.reduce(
+    (accumulator, currentValue) => {
+      if ((0, import_date_fns.isAfter)(new Date(currentValue.createdAt), new Date(accumulator.createdAt))) {
+        return currentValue;
+      }
+      return accumulator;
+    },
+    initialValue
+  );
+  return lastEvent;
+};
+var completeEventMapping = {
+  [import_types.ContentDataType.FLOW]: import_types.BizEvents.FLOW_COMPLETED,
+  [import_types.ContentDataType.LAUNCHER]: import_types.BizEvents.LAUNCHER_ACTIVATED,
+  [import_types.ContentDataType.CHECKLIST]: import_types.BizEvents.CHECKLIST_COMPLETED
+};
+var showEventMapping = {
+  [import_types.ContentDataType.FLOW]: import_types.BizEvents.FLOW_STEP_SEEN,
+  [import_types.ContentDataType.LAUNCHER]: import_types.BizEvents.LAUNCHER_SEEN,
+  [import_types.ContentDataType.CHECKLIST]: import_types.BizEvents.CHECKLIST_SEEN
+};
+var isDismissedEventMapping = {
+  [import_types.ContentDataType.FLOW]: import_types.BizEvents.FLOW_ENDED,
+  [import_types.ContentDataType.LAUNCHER]: import_types.BizEvents.LAUNCHER_DISMISSED,
+  [import_types.ContentDataType.CHECKLIST]: import_types.BizEvents.CHECKLIST_DISMISSED
+};
+var isGreaterThenDuration = (dateLeft, dateRight, unit, duration) => {
+  switch (unit) {
+    case import_types.FrequencyUnits.SECONDS: {
+      if ((0, import_date_fns.differenceInSeconds)(dateLeft, dateRight) >= duration) {
+        return true;
+      }
+      return false;
+    }
+    case import_types.FrequencyUnits.MINUTES:
+      if ((0, import_date_fns.differenceInMinutes)(dateLeft, dateRight) >= duration) {
+        return true;
+      }
+      return false;
+    case import_types.FrequencyUnits.HOURS:
+      if ((0, import_date_fns.differenceInHours)(dateLeft, dateRight) >= duration) {
+        return true;
+      }
+      return false;
+    case import_types.FrequencyUnits.DAYES:
+      if ((0, import_date_fns.differenceInDays)(dateLeft, dateRight) >= duration) {
+        return true;
+      }
+      return false;
+    default:
+      return false;
+  }
+};
+var checklistIsDimissed = (latestSession) => {
+  var _a;
+  return (_a = latestSession == null ? void 0 : latestSession.bizEvent) == null ? void 0 : _a.find(
+    (event) => {
+      var _a2;
+      return ((_a2 = event == null ? void 0 : event.event) == null ? void 0 : _a2.codeName) === import_types.BizEvents.CHECKLIST_DISMISSED;
+    }
+  );
+};
+var flowIsDismissed = (latestSession) => {
+  var _a;
+  return (_a = latestSession == null ? void 0 : latestSession.bizEvent) == null ? void 0 : _a.find((event) => {
+    var _a2;
+    return ((_a2 = event == null ? void 0 : event.event) == null ? void 0 : _a2.codeName) === import_types.BizEvents.FLOW_ENDED;
+  });
+};
+var flowIsSeen = (latestSession) => {
+  var _a;
+  return (_a = latestSession == null ? void 0 : latestSession.bizEvent) == null ? void 0 : _a.find(
+    (event) => {
+      var _a2;
+      return ((_a2 = event == null ? void 0 : event.event) == null ? void 0 : _a2.codeName) === import_types.BizEvents.FLOW_STEP_SEEN;
+    }
+  );
+};
+var checklistIsSeen = (latestSession) => {
+  var _a;
+  return (_a = latestSession == null ? void 0 : latestSession.bizEvent) == null ? void 0 : _a.find(
+    (event) => {
+      var _a2;
+      return ((_a2 = event == null ? void 0 : event.event) == null ? void 0 : _a2.codeName) === import_types.BizEvents.CHECKLIST_SEEN;
+    }
+  );
+};
+var isValidContent = (content, contents) => {
+  var _a;
+  const now = /* @__PURE__ */ new Date();
+  if (content.type === import_types.ContentDataType.FLOW) {
+    if (!content.steps || content.steps.length === 0) {
+      return false;
+    }
+  } else {
+    if (!content.data) {
+      return false;
+    }
+  }
+  if (!content.config.autoStartRulesSetting) {
+    return true;
+  }
+  const { frequency, startIfNotComplete } = content.config.autoStartRulesSetting;
+  const completedSessions = content.completedSessions;
+  const dismissedSessions = content.dismissedSessions;
+  if (startIfNotComplete && completedSessions > 0) {
+    return false;
+  }
+  if (!frequency) {
+    return true;
+  }
+  const contentType = content.type;
+  const lastEventName = showEventMapping[contentType];
+  const lastEvent = getLatestEvent(content, contents, lastEventName);
+  const contentEvents = (_a = content.latestSession) == null ? void 0 : _a.bizEvent;
+  if (lastEvent && frequency && frequency.atLeast && !isGreaterThenDuration(
+    now,
+    new Date(lastEvent.createdAt),
+    frequency.atLeast.unit,
+    frequency.atLeast.duration
+  )) {
+    return false;
+  }
+  if (frequency.frequency === import_types.Frequency.ONCE) {
+    if (dismissedSessions > 0) {
+      return false;
+    }
+    return true;
+  }
+  const showEventName = showEventMapping[contentType];
+  const showEvents = contentEvents == null ? void 0 : contentEvents.filter(
+    (e) => {
+      var _a2, _b;
+      return ((_a2 = e == null ? void 0 : e.event) == null ? void 0 : _a2.codeName) === showEventName && (contentType === import_types.ContentDataType.FLOW ? ((_b = e == null ? void 0 : e.data) == null ? void 0 : _b.flow_step_number) === 0 : true);
+    }
+  );
+  if (!showEvents || showEvents.length === 0) {
+    return true;
+  }
+  const lastShowEvent = findLatestEvent(showEvents);
+  const lastShowEventDate = new Date(lastShowEvent.createdAt);
+  if (frequency.frequency === import_types.Frequency.MULTIPLE) {
+    if (frequency.every.times && dismissedSessions >= frequency.every.times) {
+      return false;
+    }
+  }
+  if (frequency.frequency === import_types.Frequency.MULTIPLE || frequency.frequency === import_types.Frequency.UNLIMITED) {
+    if (!isGreaterThenDuration(now, lastShowEventDate, frequency.every.unit, frequency.every.duration)) {
+      return false;
+    }
+  }
+  return true;
+};
+var parseUrlParams = (url, paramName) => {
+  if (!url || !paramName) {
+    return null;
+  }
+  try {
+    const urlObj = new URL(url);
+    const searchParams = new URLSearchParams(urlObj.search);
+    if (searchParams.has(paramName)) {
+      return searchParams.get(paramName);
+    }
+    if (urlObj.hash) {
+      const hashSearch = urlObj.hash.split("?")[1];
+      if (hashSearch) {
+        const hashParams = new URLSearchParams(hashSearch);
+        if (hashParams.has(paramName)) {
+          return hashParams.get(paramName);
+        }
+      }
+    }
+    return null;
+  } catch (error) {
+    console.error("Error parsing URL:", error);
+    return null;
+  }
+};
+var wait = (seconds) => {
+  if (typeof seconds !== "number" || Number.isNaN(seconds)) {
+    return Promise.reject(new Error("Invalid wait time: must be a number"));
+  }
+  if (seconds < 0) {
+    return Promise.reject(new Error("Invalid wait time: cannot be negative"));
+  }
+  if (seconds === 0) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    try {
+      setTimeout(resolve, seconds * 1e3);
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PRIORITIES,
+  activedContentCondition,
+  activedContentRulesConditions,
+  activedRulesConditions,
+  checklistIsDimissed,
+  checklistIsSeen,
+  completeEventMapping,
+  filterAutoStartContent,
+  findLatestEvent,
+  flowIsDismissed,
+  flowIsSeen,
+  isActive,
+  isActiveContent,
+  isActiveRulesByCurrentPage,
+  isActiveRulesByCurrentTime,
+  isDismissedEventMapping,
+  isHasActivedContents,
+  isSameContents,
+  isValidContent,
+  parseUrlParams,
+  rulesTypes,
+  wait
+});

package/dist/conditions.d.cts

@@ -0,0 +1,35 @@
+import { ContentPriority, RulesType, RulesCondition, SDKContent, BizEvent, BizEvents, BizSession } from '@usertour/types';
+
+declare const PRIORITIES: ContentPriority[];
+declare const rulesTypes: RulesType[];
+declare const isActiveRulesByCurrentPage: (rules: RulesCondition) => boolean;
+declare const isActiveRulesByCurrentTime: (rules: RulesCondition) => boolean;
+type RewriteRulesCondition = Partial<Record<RulesType, boolean>>;
+declare const activedRulesConditions: (conditions: RulesCondition[], rewrite?: RewriteRulesCondition) => Promise<RulesCondition[]>;
+declare const activedContentRulesConditions: (conditions: RulesCondition[], contents: SDKContent[]) => Promise<RulesCondition[]>;
+declare const activedContentCondition: (contents: SDKContent[]) => Promise<SDKContent[]>;
+declare const isActive: (autoStartRules: RulesCondition[]) => boolean;
+declare const isActiveContent: (content: SDKContent) => boolean;
+declare const filterAutoStartContent: (contents: SDKContent[], type: string) => SDKContent[];
+declare const isHasActivedContents: (source: SDKContent[], dest: SDKContent[]) => boolean;
+declare const isSameContents: (source: SDKContent[], dest: SDKContent[]) => boolean;
+declare const findLatestEvent: (bizEvents: BizEvent[]) => BizEvent;
+declare const completeEventMapping: {
+    flow: BizEvents;
+    launcher: BizEvents;
+    checklist: BizEvents;
+};
+declare const isDismissedEventMapping: {
+    flow: BizEvents;
+    launcher: BizEvents;
+    checklist: BizEvents;
+};
+declare const checklistIsDimissed: (latestSession?: BizSession) => BizEvent | undefined;
+declare const flowIsDismissed: (latestSession?: BizSession) => BizEvent | undefined;
+declare const flowIsSeen: (latestSession?: BizSession) => BizEvent | undefined;
+declare const checklistIsSeen: (latestSession?: BizSession) => BizEvent | undefined;
+declare const isValidContent: (content: SDKContent, contents: SDKContent[]) => boolean;
+declare const parseUrlParams: (url: string, paramName: string) => string | null;
+declare const wait: (seconds: number) => Promise<void>;
+
+export { PRIORITIES, activedContentCondition, activedContentRulesConditions, activedRulesConditions, checklistIsDimissed, checklistIsSeen, completeEventMapping, filterAutoStartContent, findLatestEvent, flowIsDismissed, flowIsSeen, isActive, isActiveContent, isActiveRulesByCurrentPage, isActiveRulesByCurrentTime, isDismissedEventMapping, isHasActivedContents, isSameContents, isValidContent, parseUrlParams, rulesTypes, wait };

package/dist/conditions.d.ts

@@ -0,0 +1,35 @@
+import { ContentPriority, RulesType, RulesCondition, SDKContent, BizEvent, BizEvents, BizSession } from '@usertour/types';
+
+declare const PRIORITIES: ContentPriority[];
+declare const rulesTypes: RulesType[];
+declare const isActiveRulesByCurrentPage: (rules: RulesCondition) => boolean;
+declare const isActiveRulesByCurrentTime: (rules: RulesCondition) => boolean;
+type RewriteRulesCondition = Partial<Record<RulesType, boolean>>;
+declare const activedRulesConditions: (conditions: RulesCondition[], rewrite?: RewriteRulesCondition) => Promise<RulesCondition[]>;
+declare const activedContentRulesConditions: (conditions: RulesCondition[], contents: SDKContent[]) => Promise<RulesCondition[]>;
+declare const activedContentCondition: (contents: SDKContent[]) => Promise<SDKContent[]>;
+declare const isActive: (autoStartRules: RulesCondition[]) => boolean;
+declare const isActiveContent: (content: SDKContent) => boolean;
+declare const filterAutoStartContent: (contents: SDKContent[], type: string) => SDKContent[];
+declare const isHasActivedContents: (source: SDKContent[], dest: SDKContent[]) => boolean;
+declare const isSameContents: (source: SDKContent[], dest: SDKContent[]) => boolean;
+declare const findLatestEvent: (bizEvents: BizEvent[]) => BizEvent;
+declare const completeEventMapping: {
+    flow: BizEvents;
+    launcher: BizEvents;
+    checklist: BizEvents;
+};
+declare const isDismissedEventMapping: {
+    flow: BizEvents;
+    launcher: BizEvents;
+    checklist: BizEvents;
+};
+declare const checklistIsDimissed: (latestSession?: BizSession) => BizEvent | undefined;
+declare const flowIsDismissed: (latestSession?: BizSession) => BizEvent | undefined;
+declare const flowIsSeen: (latestSession?: BizSession) => BizEvent | undefined;
+declare const checklistIsSeen: (latestSession?: BizSession) => BizEvent | undefined;
+declare const isValidContent: (content: SDKContent, contents: SDKContent[]) => boolean;
+declare const parseUrlParams: (url: string, paramName: string) => string | null;
+declare const wait: (seconds: number) => Promise<void>;
+
+export { PRIORITIES, activedContentCondition, activedContentRulesConditions, activedRulesConditions, checklistIsDimissed, checklistIsSeen, completeEventMapping, filterAutoStartContent, findLatestEvent, flowIsDismissed, flowIsSeen, isActive, isActiveContent, isActiveRulesByCurrentPage, isActiveRulesByCurrentTime, isDismissedEventMapping, isHasActivedContents, isSameContents, isValidContent, parseUrlParams, rulesTypes, wait };