@usertour/helpers 0.0.5 → 0.0.7

package/dist/index.cjs

@@ -39,11 +39,17 @@ __export(src_exports, {
   ArrayProto: () => ArrayProto,
   JWTLicenseSigner: () => JWTLicenseSigner,
   JWTLicenseValidator: () => JWTLicenseValidator,
+  PRIORITIES: () => PRIORITIES,
   XMLHttpRequest: () => XMLHttpRequest,
   absoluteUrl: () => absoluteUrl,
+  activedContentCondition: () => activedContentCondition,
+  activedContentRulesConditions: () => activedContentRulesConditions,
+  activedRulesConditions: () => activedRulesConditions,
   assignableWindow: () => assignableWindow,
   autoStartConditions: () => autoStartConditions,
   buildConfig: () => buildConfig,
+  checklistIsDimissed: () => checklistIsDimissed,
+  checklistIsSeen: () => checklistIsSeen,
   cn: () => cn,
   conditionsIsSame: () => conditionsIsSame,
   convertSettings: () => convertSettings,
@@ -52,9 +58,16 @@ __export(src_exports, {
   deepClone: () => deepClone,
   defaultContentConfig: () => defaultContentConfig,
   defaultStep: () => defaultStep,
-  document: () => document,
+  document: () => document2,
   evalCode: () => evalCode,
   fetch: () => fetch,
+  filterAutoStartContent: () => filterAutoStartContent,
+  findLatestEvent: () => findLatestEvent,
+  finder: () => finder,
+  finderV2: () => finderV2,
+  finderX: () => finderX,
+  flowIsDismissed: () => flowIsDismissed,
+  flowIsSeen: () => flowIsSeen,
   formatDate: () => formatDate,
   generateAutoStateColors: () => generateAutoStateColors,
   getAuthToken: () => getAuthToken,
@@ -77,6 +90,8 @@ __export(src_exports, {
   hexToHSLString: () => hexToHSLString,
   hexToRGBStr: () => hexToRGBStr,
   hexToRgb: () => hexToRgb,
+  isActive: () => isActive,
+  isActiveContent: () => isActiveContent,
   isArray: () => isArray,
   isBoolean: () => isBoolean,
   isDark: () => isDark,
@@ -88,6 +103,7 @@ __export(src_exports, {
   isFile: () => isFile,
   isFormData: () => isFormData,
   isFunction: () => isFunction,
+  isHasActivedContents: () => isHasActivedContents,
   isMatchUrlPattern: () => isMatchUrlPattern,
   isNull: () => isNull,
   isNullish: () => isNullish,
@@ -95,21 +111,28 @@ __export(src_exports, {
   isObject: () => isObject,
   isPublishedAtLeastOneEnvironment: () => isPublishedAtLeastOneEnvironment,
   isPublishedInAllEnvironments: () => isPublishedInAllEnvironments,
+  isSameContents: () => isSameContents,
   isString: () => isString,
   isUint8Array: () => isUint8Array,
   isUndefined: () => isUndefined,
   isUrl: () => isUrl,
+  isValidContent: () => isValidContent,
   isValidSelector: () => isValidSelector,
+  isVisible: () => isVisible,
   location: () => location,
   mergeThemeDefaultSettings: () => mergeThemeDefaultSettings,
   nativeForEach: () => nativeForEach,
   nativeIndexOf: () => nativeIndexOf,
   navigator: () => navigator,
+  parseUrlParams: () => parseUrlParams,
+  parserV2: () => parserV2,
+  parserX: () => parserX,
   removeAuthToken: () => removeAuthToken,
   setAuthToken: () => setAuthToken,
   storage: () => storage,
   userAgent: () => userAgent,
   uuidV4: () => uuidV4,
+  wait: () => wait,
   window: () => win
 });
 module.exports = __toCommonJS(src_exports);
@@ -813,7 +836,7 @@ var ArrayProto = Array.prototype;
 var nativeForEach = ArrayProto.forEach;
 var nativeIndexOf = ArrayProto.indexOf;
 var navigator = global == null ? void 0 : global.navigator;
-var document = global == null ? void 0 : global.document;
+var document2 = global == null ? void 0 : global.document;
 var location = global == null ? void 0 : global.location;
 var fetch = global == null ? void 0 : global.fetch;
 var XMLHttpRequest = (global == null ? void 0 : global.XMLHttpRequest) && "withCredentials" in new global.XMLHttpRequest() ? global.XMLHttpRequest : void 0;
@@ -1373,17 +1396,888 @@ var JWTLicenseValidator = {
     }
   }
 };
+
+// src/conditions.ts
+var import_dom = require("@floating-ui/dom");
+
+// src/finderx.ts
+var import_finder = require("@medv/finder");
+var finderAttrs = [
+  "data-for",
+  "data-id",
+  "data-testid",
+  "data-test-id",
+  "for",
+  "id",
+  "name",
+  "placeholder",
+  "role"
+];
+var defaultConfig = {
+  idName: () => false,
+  className: () => false,
+  tagName: () => false,
+  attr: () => false,
+  seedMinLength: 1,
+  optimizedMinLength: 2,
+  threshold: 1e3,
+  maxNumberOfTries: 1e4
+};
+var finderConfigs = [
+  {
+    ...defaultConfig,
+    tagName: () => true
+  },
+  {
+    ...defaultConfig,
+    idName: () => true
+  },
+  {
+    ...defaultConfig,
+    tagName: () => true,
+    attr: (name) => finderAttrs.includes(name)
+  },
+  {
+    ...defaultConfig,
+    className: () => true,
+    attr: (name) => finderAttrs.includes(name)
+  },
+  {
+    ...defaultConfig,
+    tagName: () => true,
+    idName: () => true,
+    className: () => true,
+    attr: () => false
+  },
+  {
+    ...defaultConfig,
+    tagName: () => true,
+    idName: () => true,
+    className: () => true,
+    attr: (name) => finderAttrs.includes(name)
+  }
+];
+function getMaxDepth(node) {
+  if (node.parentNode) {
+    return getMaxDepth(node.parentNode);
+  }
+  return node.depth;
+}
+function queryNodeListBySelectors(selectors, rootDocument, removeRepeat = true) {
+  const nodes = [];
+  if (!selectors) {
+    return nodes;
+  }
+  for (const s of selectors) {
+    const els = rootDocument.querySelectorAll(s.replace(/\\\\/g, "\\"));
+    if (els && els.length > 0) {
+      nodes.push(...Array.from(els));
+    }
+  }
+  return removeRepeat ? [...new Set(nodes)] : nodes;
+}
+function findMostRecurringNode(nodes) {
+  const m = /* @__PURE__ */ new Map();
+  let finalNode = nodes[0];
+  let count = 0;
+  for (const node of nodes) {
+    const i = m.get(node) ? m.get(node) + 1 : 1;
+    m.set(node, i);
+  }
+  m.forEach((value, key) => {
+    if (value > count) {
+      count = value;
+      finalNode = key;
+    }
+  });
+  return finalNode;
+}
+function compareParentNode(node, el, rootDocument, isCompareSibings = false) {
+  let nodeParentNode = node.parentNode;
+  let elParentElement = el.parentElement;
+  const maxDepth = getMaxDepth(node);
+  const xresult = {
+    maxDepth,
+    failedDepth: 0,
+    success: true
+  };
+  while (nodeParentNode && elParentElement) {
+    if (elParentElement === rootDocument) {
+      break;
+    }
+    if (elParentElement === document.body || elParentElement === document.documentElement || elParentElement.parentElement === document.body) {
+      break;
+    }
+    const parentNodes = queryNodeListBySelectors(nodeParentNode.selectors, rootDocument);
+    const isMatchSibings = isCompareSibings ? compareSibingsNode(nodeParentNode, elParentElement, rootDocument) : true;
+    if (!parentNodes || parentNodes.length === 0 || !parentNodes.includes(elParentElement) || !isMatchSibings) {
+      xresult.failedDepth = nodeParentNode.depth;
+      xresult.success = false;
+    }
+    nodeParentNode = nodeParentNode.parentNode;
+    elParentElement = elParentElement.parentElement;
+  }
+  return xresult;
+}
+function compareSibingsNode(node, el, rootDocument) {
+  let isMatchNext = true;
+  let isMatchPrevious = true;
+  const { previousElementSelectors, nextElementSelectors } = node;
+  if (nextElementSelectors && nextElementSelectors.length > 0) {
+    const nextElementSiblings = queryNodeListBySelectors(nextElementSelectors, rootDocument);
+    isMatchNext = el.nextElementSibling && nextElementSiblings.includes(el.nextElementSibling);
+  }
+  if (previousElementSelectors && previousElementSelectors.length > 0) {
+    const previousElementSiblings = queryNodeListBySelectors(
+      previousElementSelectors,
+      rootDocument
+    );
+    isMatchPrevious = el.previousElementSibling && previousElementSiblings.includes(el.previousElementSibling);
+  }
+  return isMatchNext && isMatchPrevious;
+}
+function queryElementSelectors(input) {
+  const classes = Array.from(input.classList);
+  const selectors = [];
+  const configs = [...finderConfigs];
+  for (const className of classes) {
+    configs.push({
+      ...defaultConfig,
+      className: (name) => {
+        if (classes.filter((cn2) => cn2 !== className).includes(name)) {
+          return false;
+        }
+        return true;
+      }
+    });
+  }
+  try {
+    for (const cfg of configs) {
+      selectors.push(finder(input, cfg));
+    }
+  } catch (_) {
+    return selectors;
+  }
+  return [...new Set(selectors)];
+}
+function parseSelectorsTree(input, parentNode, depth = 0) {
+  const selectors = queryElementSelectors(input);
+  if (selectors.length === 0) {
+    return parentNode;
+  }
+  const currentNode = {
+    previousElementSelectors: [],
+    nextElementSelectors: [],
+    selectors,
+    depth
+  };
+  if (input.previousElementSibling) {
+    currentNode.previousElementSelectors = queryElementSelectors(input.previousElementSibling);
+  }
+  if (input.nextElementSibling) {
+    currentNode.nextElementSelectors = queryElementSelectors(input.nextElementSibling);
+  }
+  if (parentNode === null) {
+    if (input.parentElement) {
+      parseSelectorsTree(input.parentElement, currentNode, depth + 1);
+    }
+    return currentNode;
+  }
+  parentNode.parentNode = currentNode;
+  if (input.parentElement) {
+    parseSelectorsTree(input.parentElement, currentNode, depth + 1);
+  }
+  return parentNode;
+}
+function finderMostPrecisionElement(elements, node, rootDocument, precision) {
+  const successEls = [];
+  let failedData = {
+    el: null,
+    failedDepth: 0,
+    maxDepth: 0
+  };
+  for (const el of elements) {
+    const { success, failedDepth, maxDepth } = compareParentNode(node, el, rootDocument);
+    if (success) {
+      successEls.push(el);
+    } else if (!failedData.el || failedDepth > failedData.failedDepth) {
+      failedData = { el, failedDepth, maxDepth };
+    }
+  }
+  if (successEls.length === 1) {
+    return successEls[0];
+  }
+  if (successEls.length > 1) {
+    let tempEl = successEls[0];
+    let tempFailedDepth = 0;
+    for (const el of successEls) {
+      const { success, failedDepth } = compareParentNode(node, el, rootDocument, true);
+      if (success) {
+        return el;
+      }
+      if (failedDepth > tempFailedDepth) {
+        tempFailedDepth = failedDepth;
+        tempEl = el;
+      }
+    }
+    return tempEl;
+  }
+  if (failedData.el) {
+    const { failedDepth, maxDepth, el } = failedData;
+    const rate = (failedDepth - 1) / maxDepth * 10;
+    if (rate >= precision) {
+      return el;
+    }
+  }
+  return null;
+}
+function finder(input, options) {
+  return (0, import_finder.finder)(input, options);
+}
+function parserX(input) {
+  return parseSelectorsTree(input, null);
+}
+function parserV2(element) {
+  var _a;
+  const content = (_a = element.innerText) != null ? _a : "";
+  const selectors = parseSelectorsTree(element, null);
+  const selectorsList = queryElementSelectors(element);
+  return { content, selectors, selectorsList };
+}
+function finderV2(target, root) {
+  const {
+    selectors,
+    content = "",
+    sequence = 0,
+    precision = "strict",
+    isDynamicContent = false,
+    customSelector = "",
+    type = "auto"
+  } = target;
+  if (type === "auto") {
+    const mapping = {
+      looser: 1,
+      loose: 3,
+      loosest: 5,
+      strict: 7,
+      stricter: 8,
+      strictest: 10
+    };
+    const el = finderX(selectors, root, mapping[precision]);
+    if (el) {
+      if (isDynamicContent && content && el.innerText !== content) {
+        return null;
+      }
+      return el;
+    }
+  } else {
+    const sequenceMapping = {
+      "1st": 0,
+      "2st": 1,
+      "3st": 2,
+      "4st": 3,
+      "5st": 4
+    };
+    if (customSelector) {
+      const selector = customSelector.replace(/\\\\/g, "\\");
+      const els = root.querySelectorAll(selector);
+      if (els.length > 0) {
+        const el = els[sequenceMapping[sequence]] || els[0];
+        if (content && el.innerText.trim() !== content) {
+          return null;
+        }
+        return el;
+      }
+    }
+  }
+  return null;
+}
+function finderX(node, root, precision = 10) {
+  if (!node || node.selectors.length === 0) {
+    return null;
+  }
+  const rootDocument = root || document;
+  const elements = [];
+  const nodeList = queryNodeListBySelectors(node.selectors, rootDocument, false);
+  if (!nodeList || nodeList.length === 0) {
+    return null;
+  }
+  if ([...new Set(nodeList)].length !== nodeList.length) {
+    const el = findMostRecurringNode(nodeList);
+    elements.push(el);
+  } else {
+    elements.push(...nodeList);
+  }
+  return finderMostPrecisionElement(elements, node, rootDocument, precision);
+}
+
+// src/conditions.ts
+var import_types4 = require("@usertour/types");
+var import_date_fns = require("date-fns");
+
+// src/listener.ts
+function on(obj, ...args) {
+  if (obj == null ? void 0 : obj.addEventListener) {
+    obj.addEventListener(...args);
+  }
+}
+function off(obj, ...args) {
+  if (obj == null ? void 0 : obj.removeEventListener) {
+    obj.removeEventListener(...args);
+  }
+}
+
+// src/conditions.ts
+var rulesTypes = Object.values(import_types4.RulesType);
+var PRIORITIES = [
+  import_types4.ContentPriority.HIGHEST,
+  import_types4.ContentPriority.HIGH,
+  import_types4.ContentPriority.MEDIUM,
+  import_types4.ContentPriority.LOW,
+  import_types4.ContentPriority.LOWEST
+];
+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_types4.ContentConditionLogic.ACTIVED || logic === import_types4.ContentConditionLogic.UNACTIVED) {
+    if (!latestSession) {
+      return logic === import_types4.ContentConditionLogic.UNACTIVED;
+    }
+    const isActived = !(flowIsDismissed(latestSession) || checklistIsDimissed(latestSession));
+    return logic === import_types4.ContentConditionLogic.ACTIVED ? isActived : !isActived;
+  }
+  const isSeen = seenSessions > 0;
+  const isCompleted = completedSessions > 0;
+  if (logic === import_types4.ContentConditionLogic.SEEN || logic === import_types4.ContentConditionLogic.UNSEEN) {
+    return logic === import_types4.ContentConditionLogic.SEEN ? isSeen : !isSeen;
+  }
+  if (logic === import_types4.ContentConditionLogic.COMPLETED || logic === import_types4.ContentConditionLogic.UNCOMPLETED) {
+    return logic === import_types4.ContentConditionLogic.COMPLETED ? isCompleted : !isCompleted;
+  }
+  return false;
+};
+var isVisible = async (el) => {
+  var _a, _b;
+  if (!((_a = document2) == null ? void 0 : _a.body)) {
+    return false;
+  }
+  const { middlewareData } = await (0, import_dom.computePosition)(el, document2.body, {
+    strategy: "fixed",
+    middleware: [(0, import_dom.hide)()]
+  });
+  if ((_b = middlewareData == null ? void 0 : middlewareData.hide) == null ? void 0 : _b.referenceHidden) {
+    return false;
+  }
+  return true;
+};
+var cache = /* @__PURE__ */ new Map();
+var isClicked = (el) => {
+  if (cache.has(el)) {
+    return cache.get(el);
+  }
+  const onClick = () => {
+    cache.set(el, true);
+    off(el, "click", onClick);
+  };
+  on(el, "click", onClick);
+  cache.set(el, false);
+  return false;
+};
+var isActiveRulesByElement = async (rules) => {
+  const { data } = rules;
+  if (!document2) {
+    return false;
+  }
+  const el = finderV2(data.elementData, document2);
+  const isPresent = el ? await isVisible(el) : false;
+  const isDisabled = el ? el.disabled : false;
+  switch (data.logic) {
+    case import_types4.ElementConditionLogic.PRESENT:
+      return isPresent;
+    case import_types4.ElementConditionLogic.UNPRESENT:
+      return !isPresent;
+    case import_types4.ElementConditionLogic.DISABLED:
+      return el && isDisabled;
+    case import_types4.ElementConditionLogic.UNDISABLED:
+      return el && !isDisabled;
+    case import_types4.ElementConditionLogic.CLICKED:
+      return el && isClicked(el);
+    case import_types4.ElementConditionLogic.UNCLICKED:
+      return el && !isClicked(el);
+    default:
+      return false;
+  }
+};
+var isActiveRulesByTextInput = async (rules) => {
+  const {
+    data: { elementData, logic, value }
+  } = rules;
+  if (!document2) {
+    return false;
+  }
+  const el = finderV2(elementData, document2);
+  if (!el) {
+    return false;
+  }
+  const elValue = el.value;
+  switch (logic) {
+    case import_types4.StringConditionLogic.IS:
+      return elValue === value;
+    case import_types4.StringConditionLogic.NOT:
+      return elValue !== value;
+    case import_types4.StringConditionLogic.CONTAINS:
+      return elValue.includes(value);
+    case import_types4.StringConditionLogic.NOT_CONTAIN:
+      return !elValue.includes(value);
+    case import_types4.StringConditionLogic.STARTS_WITH:
+      return elValue.startsWith(value);
+    case import_types4.StringConditionLogic.ENDS_WITH:
+      return elValue.endsWith(value);
+    case import_types4.StringConditionLogic.MATCH:
+      return elValue.search(value) !== -1;
+    case import_types4.StringConditionLogic.UNMATCH:
+      return elValue.search(value) === -1;
+    case import_types4.StringConditionLogic.ANY:
+      return true;
+    case import_types4.StringConditionLogic.EMPTY:
+      return !elValue;
+    default:
+      return false;
+  }
+};
+var fillCache = /* @__PURE__ */ new Map();
+var isActiveRulesByTextFill = async (rules) => {
+  const {
+    data: { elementData }
+  } = rules;
+  if (!document2) {
+    return false;
+  }
+  const el = finderV2(elementData, document2);
+  if (!el) {
+    return false;
+  }
+  const now = (/* @__PURE__ */ new Date()).getTime();
+  const onKeyup = () => {
+    const cacheData = fillCache.get(el);
+    const data = { ...cacheData, timestamp: (/* @__PURE__ */ new Date()).getTime() };
+    fillCache.set(el, data);
+  };
+  if (fillCache.has(el)) {
+    const { timestamp, value, isActive: isActive2 } = fillCache.get(el);
+    if (isActive2) {
+      return true;
+    }
+    if (timestamp !== -1 && now - timestamp > 1e3 && value !== el.value) {
+      off(document2, "click", onKeyup);
+      fillCache.set(el, { timestamp, value, isActive: true });
+      return true;
+    }
+    return false;
+  }
+  on(document2, "keyup", onKeyup);
+  fillCache.set(el, { timestamp: -1, value: el.value, isActive: false });
+  return false;
+};
+var isValidRulesType = (type) => {
+  return rulesTypes.includes(type);
+};
+var isActiveRules = async (rules) => {
+  if (!isValidRulesType(rules.type)) {
+    return true;
+  }
+  switch (rules.type) {
+    case import_types4.RulesType.CURRENT_PAGE:
+      return isActiveRulesByCurrentPage(rules);
+    case import_types4.RulesType.TIME:
+      return isActiveRulesByCurrentTime(rules);
+    case import_types4.RulesType.ELEMENT:
+      return await isActiveRulesByElement(rules);
+    case import_types4.RulesType.TEXT_INPUT:
+      return await isActiveRulesByTextInput(rules);
+    case import_types4.RulesType.TEXT_FILL:
+      return await isActiveRulesByTextFill(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_types4.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 showEventMapping = {
+  [import_types4.ContentDataType.FLOW]: import_types4.BizEvents.FLOW_STEP_SEEN,
+  [import_types4.ContentDataType.LAUNCHER]: import_types4.BizEvents.LAUNCHER_SEEN,
+  [import_types4.ContentDataType.CHECKLIST]: import_types4.BizEvents.CHECKLIST_SEEN
+};
+var isGreaterThenDuration = (dateLeft, dateRight, unit, duration) => {
+  switch (unit) {
+    case import_types4.FrequencyUnits.SECONDS: {
+      if ((0, import_date_fns.differenceInSeconds)(dateLeft, dateRight) >= duration) {
+        return true;
+      }
+      return false;
+    }
+    case import_types4.FrequencyUnits.MINUTES:
+      if ((0, import_date_fns.differenceInMinutes)(dateLeft, dateRight) >= duration) {
+        return true;
+      }
+      return false;
+    case import_types4.FrequencyUnits.HOURS:
+      if ((0, import_date_fns.differenceInHours)(dateLeft, dateRight) >= duration) {
+        return true;
+      }
+      return false;
+    case import_types4.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_types4.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_types4.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_types4.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_types4.BizEvents.CHECKLIST_SEEN;
+    }
+  );
+};
+var isValidContent = (content, contents) => {
+  var _a;
+  const now = /* @__PURE__ */ new Date();
+  if (content.type === import_types4.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_types4.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_types4.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_types4.Frequency.MULTIPLE) {
+    if (frequency.every.times && dismissedSessions >= frequency.every.times) {
+      return false;
+    }
+  }
+  if (frequency.frequency === import_types4.Frequency.MULTIPLE || frequency.frequency === import_types4.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((resolve2, reject) => {
+    try {
+      setTimeout(resolve2, seconds * 1e3);
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AbortController,
   ArrayProto,
   JWTLicenseSigner,
   JWTLicenseValidator,
+  PRIORITIES,
   XMLHttpRequest,
   absoluteUrl,
+  activedContentCondition,
+  activedContentRulesConditions,
+  activedRulesConditions,
   assignableWindow,
   autoStartConditions,
   buildConfig,
+  checklistIsDimissed,
+  checklistIsSeen,
   cn,
   conditionsIsSame,
   convertSettings,
@@ -1395,6 +2289,13 @@ var JWTLicenseValidator = {
   document,
   evalCode,
   fetch,
+  filterAutoStartContent,
+  findLatestEvent,
+  finder,
+  finderV2,
+  finderX,
+  flowIsDismissed,
+  flowIsSeen,
   formatDate,
   generateAutoStateColors,
   getAuthToken,
@@ -1417,6 +2318,8 @@ var JWTLicenseValidator = {
   hexToHSLString,
   hexToRGBStr,
   hexToRgb,
+  isActive,
+  isActiveContent,
   isArray,
   isBoolean,
   isDark,
@@ -1428,6 +2331,7 @@ var JWTLicenseValidator = {
   isFile,
   isFormData,
   isFunction,
+  isHasActivedContents,
   isMatchUrlPattern,
   isNull,
   isNullish,
@@ -1435,20 +2339,27 @@ var JWTLicenseValidator = {
   isObject,
   isPublishedAtLeastOneEnvironment,
   isPublishedInAllEnvironments,
+  isSameContents,
   isString,
   isUint8Array,
   isUndefined,
   isUrl,
+  isValidContent,
   isValidSelector,
+  isVisible,
   location,
   mergeThemeDefaultSettings,
   nativeForEach,
   nativeIndexOf,
   navigator,
+  parseUrlParams,
+  parserV2,
+  parserX,
   removeAuthToken,
   setAuthToken,
   storage,
   userAgent,
   uuidV4,
+  wait,
   window
 });