@tonys-software/mimic 0.0.0-stage → 0.1.0-stg.3.1

package/dist/inject.js

@@ -0,0 +1,209 @@
+"use strict";
+(() => {
+  // ../extension/src/content/locate.ts
+  function normalizeText(text) {
+    return (text ?? "").replace(/\s+/g, " ").trim();
+  }
+  function elementText(el) {
+    if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+      return normalizeText(el.value);
+    }
+    return normalizeText(el.textContent);
+  }
+  function querySelectorAllSafe(root, selector) {
+    try {
+      return Array.from(root.querySelectorAll(selector));
+    } catch {
+      return [];
+    }
+  }
+  function resolveText(locator, root) {
+    const needle = normalizeText(locator.text);
+    if (!needle) return [];
+    const matches = querySelectorAllSafe(root, locator.selector || "body *").filter((el) => {
+      if (el instanceof HTMLScriptElement || el instanceof HTMLStyleElement) return false;
+      const text = elementText(el);
+      return locator.mode === "Contains" ? text.includes(needle) : text === needle;
+    });
+    return matches.filter((el) => !matches.some((other) => other !== el && el.contains(other)));
+  }
+  function resolveLocator(locator, root = document) {
+    switch (locator.type) {
+      case "Text":
+        return resolveText(locator, root);
+      case "Css":
+        return querySelectorAllSafe(root, locator.selector);
+      case "Anchored": {
+        const containers = /* @__PURE__ */ new Set();
+        for (const anchor of resolveLocator(locator.anchor, root)) {
+          const container = anchor.closest(locator.container);
+          if (container && (root === document || root.contains(container))) containers.add(container);
+        }
+        if (!locator.target) return Array.from(containers);
+        const results = /* @__PURE__ */ new Set();
+        for (const container of containers) {
+          for (const el of resolveLocator(locator.target, container)) results.add(el);
+        }
+        return Array.from(results);
+      }
+    }
+  }
+  function locate(locator) {
+    if (!locator) return { element: null, error: "step has no locator" };
+    const matches = resolveLocator(locator);
+    if (matches.length === 1) return { element: matches[0] };
+    return { element: null, error: matches.length > 1 ? `target is ambiguous (${matches.length} matches)` : "element not found" };
+  }
+
+  // ../extension/src/content/actionability.ts
+  function waitForContentSettle(quietMs = 300, timeoutMs = 1500) {
+    return new Promise((resolve) => {
+      if (!document.documentElement) {
+        resolve();
+        return;
+      }
+      let quietTimer;
+      function finish() {
+        clearTimeout(quietTimer);
+        clearTimeout(overallTimer);
+        observer.disconnect();
+        resolve();
+      }
+      const overallTimer = setTimeout(finish, timeoutMs);
+      const observer = new MutationObserver(() => {
+        clearTimeout(quietTimer);
+        quietTimer = setTimeout(finish, quietMs);
+      });
+      observer.observe(document.documentElement, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        characterData: true
+      });
+      quietTimer = setTimeout(finish, quietMs);
+    });
+  }
+  function clickPoint(el) {
+    const rect = Array.from(el.getClientRects()).find((r) => r.width > 0 && r.height > 0) ?? el.getBoundingClientRect();
+    if (rect.width === 0 || rect.height === 0) return void 0;
+    return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
+  }
+  function describe(el) {
+    const id = el.id ? `#${el.id}` : "";
+    const classes = typeof el.className === "string" ? el.className.trim().split(/\s+/).filter(Boolean) : [];
+    return `<${el.tagName.toLowerCase()}${id}${classes.map((c) => `.${c}`).join("")}>`;
+  }
+  function isVisible(el) {
+    return el.checkVisibility({ visibilityProperty: true }) && clickPoint(el) !== void 0;
+  }
+  function visibilityProblem(el) {
+    if (!isVisible(el)) return "element is not visible";
+    if (el.matches(":disabled")) return "element is disabled";
+    return void 0;
+  }
+  function clickProblem(el) {
+    const problem = visibilityProblem(el);
+    if (problem) return problem;
+    el.scrollIntoView({ block: "center", inline: "center" });
+    const point = clickPoint(el);
+    const hit = point && document.elementFromPoint(point.x, point.y);
+    if (!hit) return "element is outside the page";
+    if (hit === el || el.contains(hit) || hit.closest("label")?.control === el) return void 0;
+    return `element is covered by ${describe(hit)}`;
+  }
+  function inputProblem(el) {
+    return visibilityProblem(el);
+  }
+  function fillProblem(el) {
+    return el instanceof HTMLSelectElement ? clickProblem(el) : inputProblem(el);
+  }
+  function isSelectable(option) {
+    return !option.matches(":disabled") && getComputedStyle(option).display !== "none";
+  }
+  function pickOption(el, label) {
+    if (!(el instanceof HTMLSelectElement)) return "target is not a <select>";
+    if (el.multiple || el.size > 1) return "target is a list box, not a dropdown";
+    const wanted = normalizeText(label);
+    const matches = Array.from(el.options).filter((o) => normalizeText(o.label) === wanted);
+    if (matches.length === 0) return `no option "${label}"`;
+    if (matches.length > 1) return `option "${label}" is ambiguous (${matches.length} matches)`;
+    const [option] = matches;
+    if (option.matches(":disabled")) return `option "${label}" is disabled`;
+    if (!isSelectable(option)) return `option "${label}" is hidden`;
+    return option;
+  }
+  function optionMoves(el, label) {
+    const option = pickOption(el, label);
+    if (typeof option === "string") return option;
+    const select = el;
+    const from = select.selectedIndex;
+    const to = option.index;
+    const passed = Array.from(select.options).filter((o) => isSelectable(o) && (to > from ? o.index > from && o.index <= to : o.index < from && o.index >= to));
+    return to > from ? passed.length : -passed.length;
+  }
+  function editProblem(el) {
+    if ((el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) && el.readOnly) return "element is read-only";
+    return void 0;
+  }
+
+  // ../extension/src/content/assertions.ts
+  function expectedUrl(value) {
+    try {
+      return new URL(value, location.href).href;
+    } catch {
+      return value;
+    }
+  }
+  function assertionCheck(step) {
+    const expected = step.value ?? "";
+    if (step.assertionType === "UrlEquals") {
+      const url = expectedUrl(expected);
+      return location.href === url ? void 0 : `expected URL "${url}", but got "${location.href}"`;
+    }
+    const { element, error } = locate(step.locator);
+    if (!element) return error ?? "element not found";
+    switch (step.assertionType) {
+      case "ElementExists":
+        return void 0;
+      case "ElementVisible":
+        return isVisible(element) ? void 0 : "element is not visible";
+      case "TextContains": {
+        const actual = elementText(element);
+        return actual.includes(normalizeText(expected)) ? void 0 : `expected text containing "${expected}", but got "${actual}"`;
+      }
+      case "TextEquals": {
+        const actual = elementText(element);
+        return actual === normalizeText(expected) ? void 0 : `expected text "${expected}", but got "${actual}"`;
+      }
+      case "InputValueEquals":
+        if (!(element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement)) {
+          return `<${element.tagName.toLowerCase()}> is not an input element`;
+        }
+        return element.value === expected ? void 0 : `expected value "${expected}", but got "${element.value}"`;
+      default: {
+        const unhandled = step.assertionType;
+        return `unknown assertion type: ${unhandled}`;
+      }
+    }
+  }
+  function assertionProblem(step) {
+    const problem = assertionCheck(step);
+    return problem && `${step.assertionType} assertion failed: ${problem}`;
+  }
+
+  // src/shared/inject.ts
+  var runner = {
+    find(locator, kind) {
+      const { element, error } = locate(locator);
+      if (!element) return error ?? "element not found";
+      return (kind === "click" ? clickProblem : fillProblem)(element) ?? element;
+    },
+    isConnected: (el) => el.isConnected,
+    editProblem,
+    optionMoves,
+    assertionProblem,
+    assertionCheck,
+    settle: () => waitForContentSettle()
+  };
+  Object.defineProperty(window, "__scenarioRunner", { value: runner, configurable: true });
+})();

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "@tonys-software/mimic",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "type": "module",
+  "version": "0.1.0-stg.3.1",
+  "description": "Run Mimic scenarios from the command line",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tonys-software/service.git",
+    "directory": "cli"
+  },
+  "bin": {
+    "mimic": "dist/cli.js"
+  },
+  "files": [
+    "dist/cli.js",
+    "dist/inject.js"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "postinstall": "playwright install chromium",
+    "build": "tsc --noEmit && node build.mjs",
+    "run-all": "node dist/cli.js run"
+  },
+  "dependencies": {
+    "playwright": "^1.64.0"
+  },
+  "devDependencies": {
+    "@service/jsclient": "file:../jsclient",
+    "@types/node": "^22.18.0",
+    "esbuild": "^0.25.10",
+    "typescript": "~5.9.3"
+  }
+}