@skyramp/mcp 0.1.8 → 0.2.0-rc.2

package/node_modules/playwright/lib/dom-analyzer/logicalNameResolver.test.js

@@ -0,0 +1,182 @@
+"use strict";
+var import_logicalNameResolver = require("./logicalNameResolver");
+const cases = [];
+function test(name, run) {
+  cases.push({ name, run });
+}
+function assertEqual(actual, expected, msg) {
+  const a = JSON.stringify(actual);
+  const e = JSON.stringify(expected);
+  if (a !== e) throw new Error(`${msg ?? "assertEqual"} \u2014 expected ${e}, got ${a}`);
+}
+function input(overrides = {}) {
+  return {
+    initialName: "save_btn",
+    sectionName: "main",
+    testId: null,
+    stableId: null,
+    nearestAncestorId: null,
+    ...overrides
+  };
+}
+test("resolveCollisions: single element no collision, pass through unchanged", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([input({ initialName: "save_btn" })]);
+  assertEqual(out, ["save_btn"]);
+});
+test("resolveCollisions: testId wins when element has one (slugged)", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", testId: "save-action" }),
+    input({ initialName: "save_btn", testId: "confirm-action" })
+  ]);
+  assertEqual(out, ["save_action_save_btn", "confirm_action_save_btn"]);
+});
+test("resolveCollisions: stableId used when testId absent (slugged)", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", stableId: "top-save" }),
+    input({ initialName: "save_btn", stableId: "bottom-save" })
+  ]);
+  assertEqual(out, ["top_save_save_btn", "bottom_save_save_btn"]);
+});
+test("resolveCollisions: nearestAncestorId used when self has no id (slugged)", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", nearestAncestorId: "form-a" }),
+    input({ initialName: "save_btn", nearestAncestorId: "form-b" })
+  ]);
+  assertEqual(out, ["form_a_save_btn", "form_b_save_btn"]);
+});
+test("resolveCollisions: position-hinted fallback when nothing disambiguates", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", sectionName: "main" }),
+    input({ initialName: "save_btn", sectionName: "main" }),
+    input({ initialName: "save_btn", sectionName: "main" })
+  ]);
+  assertEqual(out, ["main_save_btn_1", "main_save_btn_2", "main_save_btn_3"]);
+});
+test("resolveCollisions: duplicate testIds fall through to position-hinted fallback", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", testId: "save", sectionName: "main" }),
+    input({ initialName: "save_btn", testId: "save", sectionName: "main" })
+  ]);
+  assertEqual(out, ["main_save_btn_1", "main_save_btn_2"]);
+});
+test("resolveCollisions: ancestor id with spaces and caps is slugged", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({
+      initialName: "view_details_btn",
+      sectionName: "page",
+      nearestAncestorId: "order-detail-product-Bose QuietComfort 35 II"
+    }),
+    input({
+      initialName: "view_details_btn",
+      sectionName: "page",
+      nearestAncestorId: "order-detail-product-Apple iWatch"
+    })
+  ]);
+  assertEqual(out, [
+    "order_detail_product_bose_quietcomfort_35_ii_view_details_btn",
+    "order_detail_product_apple_iwatch_view_details_btn"
+  ]);
+});
+test("resolveCollisions: testId with capitals is slugged", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", testId: "MainSaveBtn" }),
+    input({ initialName: "save_btn", testId: "FooterSaveBtn" })
+  ]);
+  assertEqual(out, ["mainsavebtn_save_btn", "footersavebtn_save_btn"]);
+});
+test("resolveCollisions: prefix that slugs to empty falls through tier", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", sectionName: "main", nearestAncestorId: "!!!" }),
+    input({ initialName: "save_btn", sectionName: "main", nearestAncestorId: "---" })
+  ]);
+  assertEqual(out, ["main_save_btn_1", "main_save_btn_2"]);
+});
+test("resolveCollisions: ladder falls through when testId slugs to empty", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", testId: "!!!", stableId: "top-save" }),
+    input({ initialName: "save_btn", testId: "???", stableId: "bottom-save" })
+  ]);
+  assertEqual(out, ["top_save_save_btn", "bottom_save_save_btn"]);
+});
+test("resolveCollisions: CJK ancestor id preserved after slugging", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "edit_btn", nearestAncestorId: "\u8CC7\u7523\u7BA1\u7406_\u30D1\u30CD\u30EB" }),
+    input({ initialName: "edit_btn", nearestAncestorId: "\u5C65\u6B74\u60C5\u5831_\u30D1\u30CD\u30EB" })
+  ]);
+  assertEqual(out, ["\u8CC7\u7523\u7BA1\u7406_\u30D1\u30CD\u30EB_edit_btn", "\u5C65\u6B74\u60C5\u5831_\u30D1\u30CD\u30EB_edit_btn"]);
+});
+test("resolveCollisions: no cross-section collision \u2014 same initialName in different sections", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", sectionName: "header" }),
+    input({ initialName: "save_btn", sectionName: "footer" })
+  ]);
+  assertEqual(out, ["save_btn", "save_btn"]);
+});
+test("resolveCollisions: mixed group \u2014 one with testId, one without", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", testId: "save-top" }),
+    input({ initialName: "save_btn" })
+  ]);
+  assertEqual(out, ["main_save_btn_1", "main_save_btn_2"]);
+});
+test("resolveCollisions: preserves document order in position hints", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "item", sectionName: "list" }),
+    input({ initialName: "item", sectionName: "list" }),
+    input({ initialName: "item", sectionName: "list" })
+  ]);
+  assertEqual(out, ["list_item_1", "list_item_2", "list_item_3"]);
+});
+test("resolveCollisions: multi-signal precedence \u2014 testId beats stableId beats nearestAncestorId", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", testId: "save-all", stableId: "id-a", nearestAncestorId: "anc-a" }),
+    input({ initialName: "save_btn", testId: null, stableId: "id-b", nearestAncestorId: "anc-b" })
+  ]);
+  assertEqual(out, ["save_all_save_btn", "id_b_save_btn"]);
+});
+test("resolveCollisions: multiple simultaneous collision groups in one input", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", testId: "save-a", sectionName: "main" }),
+    input({ initialName: "cancel_btn", testId: "cancel-a", sectionName: "main" }),
+    input({ initialName: "save_btn", testId: "save-b", sectionName: "main" }),
+    input({ initialName: "cancel_btn", testId: "cancel-b", sectionName: "main" })
+  ]);
+  assertEqual(out, [
+    "save_a_save_btn",
+    "cancel_a_cancel_btn",
+    "save_b_save_btn",
+    "cancel_b_cancel_btn"
+  ]);
+});
+test("resolveCollisions: mixed collision and non-collision elements in one input", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "unique_btn", testId: "u", sectionName: "main" }),
+    input({ initialName: "save_btn", testId: "a", sectionName: "main" }),
+    input({ initialName: "save_btn", testId: "b", sectionName: "main" }),
+    input({ initialName: "another_btn", testId: "x", sectionName: "main" })
+  ]);
+  assertEqual(out, [
+    "unique_btn",
+    "a_save_btn",
+    "b_save_btn",
+    "another_btn"
+  ]);
+});
+let failed = 0;
+for (const { name, run } of cases) {
+  try {
+    run();
+    console.log("  \u2713", name);
+  } catch (e) {
+    failed++;
+    console.log("  \u2717", name);
+    console.log("     ", e.message);
+  }
+}
+if (failed > 0) {
+  console.log(`
+${failed}/${cases.length} failed`);
+  process.exit(1);
+}
+console.log(`
+${cases.length} passed`);

package/node_modules/playwright/lib/dom-analyzer/possibleAssertions.js

@@ -0,0 +1,150 @@
+"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 possibleAssertions_exports = {};
+__export(possibleAssertions_exports, {
+  buildFullCaptureAssertions: () => buildFullCaptureAssertions,
+  buildPossibleAssertions: () => buildPossibleAssertions
+});
+module.exports = __toCommonJS(possibleAssertions_exports);
+const INTERACTIVE_ROLES = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "textbox",
+  "combobox",
+  "tab",
+  "menuitem",
+  "switch",
+  "checkbox",
+  "radio",
+  "option",
+  "searchbox",
+  "dialog",
+  "alertdialog"
+]);
+function escapeForSingleQuote(s) {
+  let cleaned = s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/[\r\n]+/g, " ");
+  if (cleaned.length > 80)
+    cleaned = cleaned.slice(0, 79) + "\u2026";
+  return cleaned;
+}
+function buildPossibleAssertions(delta) {
+  const results = [];
+  for (const el of delta.elementsAdded) {
+    if (!el.accessibleName.trim()) {
+      continue;
+    }
+    const escapedName = escapeForSingleQuote(el.accessibleName);
+    const code = `await expect(page.getByRole('${el.role}', { name: '${escapedName}' })).toBeVisible();`;
+    let rationale;
+    let tier;
+    if (INTERACTIVE_ROLES.has(el.role)) {
+      rationale = `Element added to DOM after action: ${el.role} "${el.accessibleName}"`;
+      tier = "MEDIUM";
+    } else if (el.role === "heading") {
+      rationale = `Heading appeared after action: "${el.accessibleName}"`;
+      tier = "MEDIUM";
+    } else {
+      rationale = `${el.role} live region appeared: "${el.accessibleName}"`;
+      tier = "LOW";
+    }
+    results.push({ code, rationale, tier });
+  }
+  for (const el of delta.elementsRemoved) {
+    if (!el.accessibleName.trim()) continue;
+    const escapedName = escapeForSingleQuote(el.accessibleName);
+    const code = `await expect(page.getByRole('${el.role}', { name: '${escapedName}' })).not.toBeVisible();`;
+    let tier;
+    if (INTERACTIVE_ROLES.has(el.role)) {
+      tier = "MEDIUM";
+    } else {
+      tier = "LOW";
+    }
+    results.push({
+      code,
+      rationale: `Element removed from DOM after action: ${el.role} "${el.accessibleName}"`,
+      tier
+    });
+  }
+  for (const tc of delta.textChanges) {
+    if (!tc.before.trim() && !tc.after.trim()) continue;
+    if (!tc.accessibleName.trim()) continue;
+    const escapedAccessibleName = escapeForSingleQuote(tc.accessibleName);
+    const escapedAfter = escapeForSingleQuote(tc.after);
+    const code = `await expect(page.getByRole('${tc.role}', { name: '${escapedAccessibleName}' })).toHaveText('${escapedAfter}');`;
+    results.push({
+      code,
+      rationale: `Text changed: "${tc.before}" \u2192 "${tc.after}"`,
+      tier: "HIGH"
+    });
+  }
+  for (const rc of delta.repeatingCountChanges) {
+    if (rc.before === rc.after) continue;
+    if (!rc.accessibleNameTemplate.trim()) continue;
+    const regexPattern = templateToRegex(rc.accessibleNameTemplate);
+    const code = `await expect(page.getByRole('${rc.role}', { name: ${regexPattern} })).toHaveCount(${rc.after});`;
+    results.push({
+      code,
+      rationale: `Repeating element count changed: ${rc.before} \u2192 ${rc.after}`,
+      tier: "HIGH"
+    });
+  }
+  const tierOrder = { HIGH: 0, MEDIUM: 1, LOW: 2 };
+  results.sort((a, b) => tierOrder[a.tier] - tierOrder[b.tier]);
+  return results;
+}
+function buildFullCaptureAssertions(blueprint) {
+  const out = [];
+  if (blueprint.url && blueprint.url.trim()) {
+    const escapedUrl = escapeForSingleQuote(blueprint.url);
+    out.push({
+      code: `await expect(page).toHaveURL('${escapedUrl}');`,
+      rationale: `Page URL after action: ${blueprint.url}`,
+      tier: "HIGH"
+    });
+  }
+  const heading = findFirstHeading(blueprint);
+  if (heading) {
+    const escapedName = escapeForSingleQuote(heading);
+    out.push({
+      code: `await expect(page.getByRole('heading', { name: '${escapedName}' })).toBeVisible();`,
+      rationale: `Heading visible on destination page: "${heading}"`,
+      tier: "LOW"
+    });
+  }
+  return out;
+}
+function findFirstHeading(blueprint) {
+  for (const section of blueprint.sections) {
+    for (const el of section.elements) {
+      if (el.role === "heading" && el.accessibleName.trim())
+        return el.accessibleName;
+    }
+  }
+  return null;
+}
+function templateToRegex(template) {
+  let pattern = template.replace(/[.+*?^$()|[\]\\]/g, "\\$&");
+  pattern = pattern.replace(/\{[a-zA-Z0-9_]+\}/g, ".+");
+  return `/^${pattern}$/i`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildFullCaptureAssertions,
+  buildPossibleAssertions
+});