@usertour/helpers 0.0.6 → 0.0.8

package/dist/finderx.cjs

@@ -0,0 +1,346 @@
+"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/finderx.ts
+var finderx_exports = {};
+__export(finderx_exports, {
+  finder: () => finder,
+  finderV2: () => finderV2,
+  finderX: () => finderX,
+  parserV2: () => parserV2,
+  parserX: () => parserX
+});
+module.exports = __toCommonJS(finderx_exports);
+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((cn) => cn !== 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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  finder,
+  finderV2,
+  finderX,
+  parserV2,
+  parserX
+});

package/dist/finderx.d.cts

@@ -0,0 +1,47 @@
+type Options = {
+    root: Element;
+    idName: (name: string) => boolean;
+    className: (name: string) => boolean;
+    tagName: (name: string) => boolean;
+    attr: (name: string, value: string) => boolean;
+    seedMinLength: number;
+    optimizedMinLength: number;
+    threshold: number;
+    maxNumberOfTries: number;
+};
+type XNode = {
+    selectors: string[];
+    nextElementSelectors: string[];
+    previousElementSelectors: string[];
+    depth: number;
+    parentNode?: XNode | null;
+};
+type XData = {
+    node: XNode;
+};
+type XResult = {
+    maxDepth: number;
+    failedDepth: number;
+    success: boolean;
+};
+type Target = {
+    selectors?: any;
+    content?: string;
+    sequence?: string;
+    precision?: string;
+    isDynamicContent?: boolean;
+    customSelector?: string;
+    type?: string;
+};
+declare function finder(input: Element, options?: Partial<Options>): string;
+declare function parserX(input: Element): XNode | null;
+type TargetResult = {
+    content: string;
+    selectors: XNode | null;
+    selectorsList: string[];
+};
+declare function parserV2(element: HTMLElement): TargetResult;
+declare function finderV2(target: Target, root: Element | Document): HTMLElement | null;
+declare function finderX(node: XNode, root: Element | Document, precision?: number): Element | null;
+
+export { type Options, type Target, type TargetResult, type XData, type XNode, type XResult, finder, finderV2, finderX, parserV2, parserX };

package/dist/finderx.d.ts

@@ -0,0 +1,47 @@
+type Options = {
+    root: Element;
+    idName: (name: string) => boolean;
+    className: (name: string) => boolean;
+    tagName: (name: string) => boolean;
+    attr: (name: string, value: string) => boolean;
+    seedMinLength: number;
+    optimizedMinLength: number;
+    threshold: number;
+    maxNumberOfTries: number;
+};
+type XNode = {
+    selectors: string[];
+    nextElementSelectors: string[];
+    previousElementSelectors: string[];
+    depth: number;
+    parentNode?: XNode | null;
+};
+type XData = {
+    node: XNode;
+};
+type XResult = {
+    maxDepth: number;
+    failedDepth: number;
+    success: boolean;
+};
+type Target = {
+    selectors?: any;
+    content?: string;
+    sequence?: string;
+    precision?: string;
+    isDynamicContent?: boolean;
+    customSelector?: string;
+    type?: string;
+};
+declare function finder(input: Element, options?: Partial<Options>): string;
+declare function parserX(input: Element): XNode | null;
+type TargetResult = {
+    content: string;
+    selectors: XNode | null;
+    selectorsList: string[];
+};
+declare function parserV2(element: HTMLElement): TargetResult;
+declare function finderV2(target: Target, root: Element | Document): HTMLElement | null;
+declare function finderX(node: XNode, root: Element | Document, precision?: number): Element | null;
+
+export { type Options, type Target, type TargetResult, type XData, type XNode, type XResult, finder, finderV2, finderX, parserV2, parserX };

package/dist/finderx.js

@@ -0,0 +1,15 @@
+import {
+  finder,
+  finderV2,
+  finderX,
+  parserV2,
+  parserX
+} from "./chunk-DEG6MTU7.js";
+import "./chunk-XEO3YXBM.js";
+export {
+  finder,
+  finderV2,
+  finderX,
+  parserV2,
+  parserX
+};

package/dist/globals.d.cts

@@ -3,7 +3,7 @@ import { UserTourTypes } from '@usertour/types/';
 declare const win: (UserTourTypes.WindowWithUsertour & typeof globalThis) | undefined;
 declare const ArrayProto: any[];
 declare const nativeForEach: (callbackfn: (value: any, index: number, array: any[]) => void, thisArg?: any) => void;
-declare const nativeIndexOf: (searchElement: any, fromIndex?: number | undefined) => number;
+declare const nativeIndexOf: (searchElement: any, fromIndex?: number) => number;
 declare const navigator: Navigator | undefined;
 declare const document: Document | undefined;
 declare const location: Location | undefined;

package/dist/globals.d.ts

@@ -3,7 +3,7 @@ import { UserTourTypes } from '@usertour/types/';
 declare const win: (UserTourTypes.WindowWithUsertour & typeof globalThis) | undefined;
 declare const ArrayProto: any[];
 declare const nativeForEach: (callbackfn: (value: any, index: number, array: any[]) => void, thisArg?: any) => void;
-declare const nativeIndexOf: (searchElement: any, fromIndex?: number | undefined) => number;
+declare const nativeIndexOf: (searchElement: any, fromIndex?: number) => number;
 declare const navigator: Navigator | undefined;
 declare const document: Document | undefined;
 declare const location: Location | undefined;