@treegress.com/treegress-browser-core 1.59.0-treegress.3

package/lib/tools/customDomLocatorCompiler.js

@@ -0,0 +1,239 @@
+"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);
+var customDomLocatorCompiler_exports = {};
+__export(customDomLocatorCompiler_exports, {
+  compileLocatorCandidatesFromPlan: () => compileLocatorCandidatesFromPlan,
+  compileLocatorFromPlan: () => compileLocatorFromPlan,
+  inspectLocatorCandidates: () => inspectLocatorCandidates
+});
+module.exports = __toCommonJS(customDomLocatorCompiler_exports);
+const kPriorityOrder = [
+  "getByTestId",
+  "getByRole",
+  "filtered_getByRole",
+  "chained_getByRole",
+  "getByText",
+  "filtered_getByText",
+  "chained_getByText",
+  "getByPlaceholder",
+  "getByCss",
+  "getByXpath"
+];
+function compileLocatorFromPlan(frame, locatorPlan) {
+  return compileLocatorCandidatesFromPlan(frame, locatorPlan)[0]?.locator;
+}
+function compileLocatorCandidatesFromPlan(frame, locatorPlan) {
+  const plan = readRecord(locatorPlan);
+  if (!plan)
+    return [];
+  const candidates = [];
+  const seenSelectors = /* @__PURE__ */ new Set();
+  const addCandidate = (strategy, locator) => {
+    if (!locator)
+      return;
+    if (seenSelectors.has(locator._selector))
+      return;
+    seenSelectors.add(locator._selector);
+    candidates.push({ strategy, locator });
+  };
+  for (const strategyName of kPriorityOrder) {
+    const details = readRecord(plan[strategyName]);
+    if (!details)
+      continue;
+    addCandidate(strategyName, compileByStrategy(frame, strategyName, details));
+  }
+  const priority = Array.isArray(plan.priority) ? plan.priority : [];
+  for (const candidate of priority) {
+    if (typeof candidate !== "string")
+      continue;
+    const details = readRecord(plan[candidate]);
+    if (!details)
+      continue;
+    addCandidate(candidate, compileByStrategy(frame, candidate, details));
+  }
+  return candidates;
+}
+async function inspectLocatorCandidates(candidates) {
+  const attempts = [];
+  let ambiguousSeen = false;
+  for (const candidate of candidates) {
+    try {
+      const count = await candidate.locator.count();
+      const status = count === 1 ? "unique" : count > 1 ? "ambiguous" : "no-match";
+      attempts.push({
+        strategy: candidate.strategy,
+        selector: candidate.locator._selector,
+        count,
+        status
+      });
+      if (count === 1)
+        return { selected: candidate, attempts, outcome: "unique" };
+      if (count > 1)
+        ambiguousSeen = true;
+    } catch (error) {
+      attempts.push({
+        strategy: candidate.strategy,
+        selector: candidate.locator._selector,
+        status: "error",
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return {
+    attempts,
+    outcome: ambiguousSeen ? "ambiguous" : "no-match"
+  };
+}
+function compileByStrategy(root, strategy, details) {
+  if (strategy === "filtered_getByRole" || strategy === "filtered_getByText")
+    return compileFiltered(root, details);
+  if (strategy === "chained_getByRole" || strategy === "chained_getByText")
+    return compileChained(root, details);
+  return compileSimple(root, strategy, details);
+}
+function compileSimple(root, strategy, details) {
+  if (strategy === "getByTestId") {
+    const testId = readString(details.testId);
+    if (!testId)
+      return;
+    return root.getByTestId(testId);
+  }
+  if (strategy === "getByRole") {
+    const role = readString(details.role);
+    if (!role)
+      return;
+    return root.getByRole(role, roleOptionsFromDetails(details));
+  }
+  if (strategy === "getByText") {
+    const text = readString(details.text);
+    if (!text)
+      return;
+    const exact = typeof details.exact === "boolean" ? details.exact : void 0;
+    return root.getByText(text, exact === void 0 ? void 0 : { exact });
+  }
+  if (strategy === "getByPlaceholder") {
+    const placeholder = readString(details.placeholder);
+    if (!placeholder)
+      return;
+    const exact = typeof details.exact === "boolean" ? details.exact : void 0;
+    return root.getByPlaceholder(placeholder, exact === void 0 ? void 0 : { exact });
+  }
+  if (strategy === "getByCss") {
+    const css = readString(details.css);
+    if (!css)
+      return;
+    return root.locator(css);
+  }
+  if (strategy === "getByXpath") {
+    const xpath = readString(details.xpath);
+    if (!xpath)
+      return;
+    const expression = xpath.startsWith("xpath=") ? xpath : `xpath=${xpath}`;
+    return root.locator(expression);
+  }
+  if (strategy === "getByTitle") {
+    const title = readString(details.title);
+    if (!title)
+      return;
+    const exact = typeof details.exact === "boolean" ? details.exact : void 0;
+    return root.getByTitle(title, exact === void 0 ? void 0 : { exact });
+  }
+  return;
+}
+function compileFiltered(root, details) {
+  const base = readStrategyDescriptor(details.base);
+  if (!base)
+    return;
+  const baseLocator = compileByStrategy(root, base.strategy, base.details);
+  if (!baseLocator)
+    return;
+  const filter = readStrategyDescriptor(details.filter);
+  if (!filter)
+    return baseLocator;
+  if (filter.strategy === "getByText") {
+    const filterText = readString(filter.details.text);
+    if (filterText)
+      return baseLocator.filter({ hasText: filterText });
+  }
+  const filterLocator = compileByStrategy(baseLocator, filter.strategy, filter.details);
+  if (!filterLocator)
+    return baseLocator;
+  return baseLocator.filter({ has: filterLocator });
+}
+function compileChained(root, details) {
+  const anchor = readStrategyDescriptor(details.anchor);
+  const target = readStrategyDescriptor(details.target);
+  if (!anchor || !target)
+    return;
+  const anchorLocator = compileByStrategy(root, anchor.strategy, anchor.details);
+  if (!anchorLocator)
+    return;
+  return compileByStrategy(anchorLocator, target.strategy, target.details);
+}
+function roleOptionsFromDetails(details) {
+  const options = {};
+  if (typeof details.name === "string" && details.name)
+    options.name = details.name;
+  if (typeof details.exact === "boolean")
+    options.exact = details.exact;
+  if (typeof details.checked === "boolean")
+    options.checked = details.checked;
+  if (typeof details.disabled === "boolean")
+    options.disabled = details.disabled;
+  if (typeof details.selected === "boolean")
+    options.selected = details.selected;
+  if (typeof details.expanded === "boolean")
+    options.expanded = details.expanded;
+  if (typeof details.includeHidden === "boolean")
+    options.includeHidden = details.includeHidden;
+  if (typeof details.level === "number")
+    options.level = details.level;
+  if (typeof details.pressed === "boolean")
+    options.pressed = details.pressed;
+  return options;
+}
+function readStrategyDescriptor(value) {
+  const record = readRecord(value);
+  if (!record)
+    return;
+  const strategy = readString(record.strategy);
+  const details = readRecord(record.details);
+  if (!strategy || !details)
+    return;
+  return { strategy, details };
+}
+function readRecord(value) {
+  if (!value || typeof value !== "object")
+    return;
+  return value;
+}
+function readString(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return;
+  return trimmed;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileLocatorCandidatesFromPlan,
+  compileLocatorFromPlan,
+  inspectLocatorCandidates
+});

package/lib/tools/customDomResolverDiagnostics.js

@@ -0,0 +1,100 @@
+"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);
+var customDomResolverDiagnostics_exports = {};
+__export(customDomResolverDiagnostics_exports, {
+  CustomDomResolverError: () => CustomDomResolverError,
+  formatCustomDomResolverDiagnostics: () => formatCustomDomResolverDiagnostics
+});
+module.exports = __toCommonJS(customDomResolverDiagnostics_exports);
+class CustomDomResolverError extends Error {
+  constructor(diagnostics) {
+    super(formatCustomDomResolverDiagnostics(diagnostics));
+    this.name = "CustomDomResolverError";
+    this.diagnostics = diagnostics;
+  }
+}
+function formatCustomDomResolverDiagnostics(diagnostics) {
+  const lines = [
+    `Ref ${diagnostics.ref} not found in the current page snapshot.`,
+    "Custom DOM resolver diagnostics:",
+    `- alias: ${formatAlias(diagnostics)}`,
+    `- locator plan: ${formatLocatorPlan(diagnostics)}`,
+    `- frame: ${formatFrame(diagnostics)}`,
+    `- candidates: ${diagnostics.candidates.total}`
+  ];
+  for (const attempt of diagnostics.candidates.attempts)
+    lines.push(`- candidate ${attempt.strategy}: ${formatAttempt(attempt)}`);
+  lines.push(`- outcome: ${formatOutcome(diagnostics)}`);
+  lines.push("- action: capture a fresh snapshot if the DOM or frame tree changed.");
+  return lines.join("\n");
+}
+function formatAlias(diagnostics) {
+  if (diagnostics.alias.status === "missing")
+    return "not found";
+  return `found (stableId=${diagnostics.alias.stableId}, framePath=${formatFramePath(diagnostics.alias.framePath)})`;
+}
+function formatLocatorPlan(diagnostics) {
+  if (diagnostics.locatorPlan.status === "not-checked")
+    return "not checked";
+  if (diagnostics.locatorPlan.status === "missing")
+    return diagnostics.locatorPlan.key ? `not found (key=${diagnostics.locatorPlan.key})` : "not found";
+  return diagnostics.locatorPlan.key ? `found (key=${diagnostics.locatorPlan.key})` : "found";
+}
+function formatFrame(diagnostics) {
+  if (diagnostics.frame.status === "not-checked")
+    return "not checked";
+  return `${diagnostics.frame.status} (framePath=${formatFramePath(diagnostics.frame.framePath)})`;
+}
+function formatAttempt(attempt) {
+  const parts = [`status=${attempt.status}`];
+  if (typeof attempt.count === "number")
+    parts.push(`count=${attempt.count}`);
+  parts.push(`selector=${attempt.selector}`);
+  if (attempt.error)
+    parts.push(`error=${attempt.error}`);
+  return parts.join(", ");
+}
+function formatOutcome(diagnostics) {
+  switch (diagnostics.outcome.status) {
+    case "resolved":
+      return diagnostics.outcome.selectedStrategy ? `resolved via ${diagnostics.outcome.selectedStrategy}` : "resolved";
+    case "alias-missing":
+      return "alias missing";
+    case "locator-plan-missing":
+      return "locator plan missing";
+    case "frame-stale":
+      return "frame stale";
+    case "no-candidates":
+      return "no locator candidates compiled from locator plan";
+    case "no-match":
+      return "no candidate matched any element";
+    case "ambiguous":
+      return "ambiguity: one or more candidates matched multiple elements and none matched uniquely";
+  }
+}
+function formatFramePath(framePath) {
+  if (!framePath?.length)
+    return "root";
+  return framePath.join(".");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CustomDomResolverError,
+  formatCustomDomResolverDiagnostics
+});