@dloizides/game-e2e 1.2.1 → 1.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.mjs CHANGED
@@ -1,5 +1,5 @@
1
1
  import { devices, expect } from '@playwright/test';
2
- import { STANDARD_BUTTON, DIALOG_SELECTOR, MENU_FOCUSABLE_SELECTOR } from '@dloizides/game-input';
2
+ import { STANDARD_BUTTON, DIALOG_SELECTOR, MENU_FOCUSABLE_SELECTOR, MENU_WALK_HOOK } from '@dloizides/game-input';
3
3
 
4
4
  // src/boxes.ts
5
5
  var CONTROL_TEXT_CHARS = 12;
@@ -466,43 +466,87 @@ async function expectNoHorizontalOverflow(page, where) {
466
466
  }
467
467
 
468
468
  // src/gamepad-stub.ts
469
- var STUB_FRAMES = 3;
469
+ var STUB_FRAMES = 1;
470
+ var PRESS_WAIT_FRAMES = 240;
470
471
  var STANDARD_BUTTON_COUNT = 17;
471
472
  var AXIS_COUNT = 4;
473
+ function installStub([buttons, axes]) {
474
+ const pad = { id: "nav-walk-stub", index: 0, connected: true, mapping: "standard", timestamp: 0, axes: new Array(axes).fill(0), buttons: Array.from({ length: buttons }, () => ({ pressed: false, touched: false, value: 0 })) };
475
+ const latch = { button: -1, frame: null, released: true };
476
+ const sample = () => {
477
+ const now = document.timeline.currentTime;
478
+ const held = pad.buttons[latch.button];
479
+ if (held !== void 0 && latch.frame === null) {
480
+ latch.frame = typeof now === "number" ? now : 0;
481
+ } else if (held !== void 0 && now !== latch.frame) {
482
+ held.pressed = false;
483
+ held.value = 0;
484
+ latch.button = -1;
485
+ latch.released = true;
486
+ }
487
+ return [pad, null, null, null];
488
+ };
489
+ Object.assign(window, { __navPad: pad, __navPress: latch });
490
+ Object.defineProperty(navigator, "getGamepads", { configurable: true, value: sample });
491
+ window.addEventListener("load", () => window.dispatchEvent(Object.assign(new Event("gamepadconnected"), { gamepad: pad })));
492
+ }
493
+ async function pressInPage([button, maxFrames]) {
494
+ const { __navPad: pad, __navPress: latch } = window;
495
+ const target = pad.buttons[button];
496
+ if (target === void 0) {
497
+ return;
498
+ }
499
+ target.pressed = true;
500
+ target.value = 1;
501
+ Object.assign(latch, { button, frame: null, released: false });
502
+ await new Promise((resolve) => {
503
+ const step = (left) => {
504
+ if (latch.released || left === 0) {
505
+ target.pressed = false;
506
+ target.value = 0;
507
+ Object.assign(latch, { button: -1, frame: null, released: true });
508
+ resolve();
509
+ return;
510
+ }
511
+ requestAnimationFrame(() => step(left - 1));
512
+ };
513
+ requestAnimationFrame(() => step(maxFrames));
514
+ });
515
+ }
472
516
  async function stubGamepad(page) {
473
- await page.addInitScript(([buttons, axes]) => {
474
- const pad = { id: "nav-walk-stub", index: 0, connected: true, mapping: "standard", timestamp: 0, axes: new Array(axes).fill(0), buttons: Array.from({ length: buttons }, () => ({ pressed: false, touched: false, value: 0 })) };
475
- Object.assign(window, { __navPad: pad });
476
- Object.defineProperty(navigator, "getGamepads", { configurable: true, value: () => [pad, null, null, null] });
477
- window.addEventListener("load", () => window.dispatchEvent(Object.assign(new Event("gamepadconnected"), { gamepad: pad })));
478
- }, [STANDARD_BUTTON_COUNT, AXIS_COUNT]);
517
+ await page.addInitScript(installStub, [STANDARD_BUTTON_COUNT, AXIS_COUNT]);
479
518
  return {
480
- press: (button) => page.evaluate(async ([b, n]) => {
481
- const pad = window.__navPad;
482
- const frames = (k) => new Promise((resolve) => {
483
- const step = (left) => {
484
- if (left === 0) {
485
- resolve();
486
- return;
487
- }
488
- requestAnimationFrame(() => step(left - 1));
489
- };
490
- step(k);
491
- });
492
- const target = pad.buttons[b] ?? { pressed: false, value: 0 };
493
- target.pressed = true;
494
- target.value = 1;
495
- await frames(n);
496
- target.pressed = false;
497
- target.value = 0;
498
- await frames(n);
499
- }, [button, STUB_FRAMES]),
519
+ press: (button) => page.evaluate(pressInPage, [button, PRESS_WAIT_FRAMES]),
500
520
  hold: (axis, value) => page.evaluate(([a, v]) => {
501
521
  window.__navPad.axes[a] = v;
502
522
  }, [axis, value])
503
523
  };
504
524
  }
505
525
 
526
+ // src/menu-walk-report.ts
527
+ var WALK_INPUTS = { keys: "keys", pad: "pad" };
528
+ var walkFailed = (r) => r.unreached.length > 0 || r.problems.length > 0;
529
+ function renderWalk(results) {
530
+ return results.map((r) => [
531
+ `${r.screen} [${r.via}] reached ${r.reached}/${r.total}`,
532
+ ...r.unreached.map((n) => ` unreached: ${n}`),
533
+ ...r.problems.map((p) => ` problem: ${p}`),
534
+ ...r.exempt.map((e) => ` exempt: ${e}`),
535
+ ...r.notes.map((n) => ` note: ${n}`)
536
+ ].join("\n")).join("\n");
537
+ }
538
+
539
+ // src/menu-walk-driver.ts
540
+ var DIRS = ["up", "down", "left", "right"];
541
+ var KEYS = { up: "ArrowUp", down: "ArrowDown", left: "ArrowLeft", right: "ArrowRight" };
542
+ var PAD_BUTTONS = { up: STANDARD_BUTTON.dpadUp, down: STANDARD_BUTTON.dpadDown, left: STANDARD_BUTTON.dpadLeft, right: STANDARD_BUTTON.dpadRight };
543
+ function driverFor(page, via, pad) {
544
+ if (via === WALK_INPUTS.pad && pad !== null) {
545
+ return { dir: (d) => pad.press(PAD_BUTTONS[d]), back: () => pad.press(STANDARD_BUTTON.east), activate: () => pad.press(STANDARD_BUTTON.south) };
546
+ }
547
+ return { dir: (d) => page.keyboard.press(KEYS[d]), back: () => page.keyboard.press("Escape"), activate: () => page.keyboard.press("Enter") };
548
+ }
549
+
506
550
  // src/menu-walk-listeners.ts
507
551
  var POINTER_EVENTS = ["click", "pointerdown", "pointerup"];
508
552
  var NO_CDP_NOTE = "CDP unavailable (not Chromium): click/pointer listeners added with addEventListener were not checked; only [onclick] and handler properties were";
@@ -582,33 +626,11 @@ function rootOpen(rootAttr) {
582
626
  return r !== null && r.getClientRects().length > 0 && r.closest("[hidden]") === null;
583
627
  }
584
628
 
585
- // src/menu-walk-report.ts
586
- var WALK_INPUTS = { keys: "keys", pad: "pad" };
587
- var walkFailed = (r) => r.unreached.length > 0 || r.problems.length > 0;
588
- function renderWalk(results) {
589
- return results.map((r) => [
590
- `${r.screen} [${r.via}] reached ${r.reached}/${r.total}`,
591
- ...r.unreached.map((n) => ` unreached: ${n}`),
592
- ...r.problems.map((p) => ` problem: ${p}`),
593
- ...r.exempt.map((e) => ` exempt: ${e}`),
594
- ...r.notes.map((n) => ` note: ${n}`)
595
- ].join("\n")).join("\n");
596
- }
597
-
598
629
  // src/menu-walk.ts
599
630
  var WALK_ATTR = "data-walk-id";
600
631
  var ROOT_ATTR = "data-walk-root";
601
632
  var PROBE_ATTR = "data-walk-probe";
602
633
  var PRESSES_PER_CONTROL = 4;
603
- var DIRS = ["up", "down", "left", "right"];
604
- var KEYS = { up: "ArrowUp", down: "ArrowDown", left: "ArrowLeft", right: "ArrowRight" };
605
- var PAD_BUTTONS = { up: STANDARD_BUTTON.dpadUp, down: STANDARD_BUTTON.dpadDown, left: STANDARD_BUTTON.dpadLeft, right: STANDARD_BUTTON.dpadRight };
606
- function driverFor(page, via, pad) {
607
- if (via === WALK_INPUTS.pad && pad !== null) {
608
- return { dir: (d) => pad.press(PAD_BUTTONS[d]), back: () => pad.press(STANDARD_BUTTON.east) };
609
- }
610
- return { dir: (d) => page.keyboard.press(KEYS[d]), back: () => page.keyboard.press("Escape") };
611
- }
612
634
  var active = (page) => page.evaluate(activeWalkId, WALK_ATTR);
613
635
  var focusId = (page, id) => page.evaluate(focusWalkId, [WALK_ATTR, id]);
614
636
  async function bfs(page, driver, total) {
@@ -693,6 +715,184 @@ ${renderWalk(results)}`);
693
715
  }
694
716
  }
695
717
 
696
- export { ANTI_ALIAS_TOLERANCE, CANVAS_TIMEOUT_MS, CONTROL_SELECTOR, DEFAULT_CANVAS_SELECTOR, DESKTOP_DEVICE, DESKTOP_SIZE, EXACT, FIT_TIMEOUT_MS, GAME_SHELL_HEIGHT_VAR, MAX_REPORTED, MIN_TARGET_PX, PHONE_DEVICE, PHONE_SIZE, RELAYOUT_TIMEOUT_MS, STUB_FRAMES, WALK_INPUTS, armVisibleHeight, auditRoute, auditTouchTargets, canvasBoxToPage, controlName, countDiff, desktop, deviceDescriptor, diffPngs, domControls, expectCanvasHeight, expectCanvasInside, expectFitTo, expectMenuWalkable, expectNoHorizontalOverflow, expectNoHorizontalOverflowAcrossRoutes, expectTouchTargets, expectTouchTargetsAcrossRoutes, findOverlaps, findOverlapsWithin, gameProjects, horizontalOverflowPx, measureHorizontalOverflow, overlaps, phone, readHorizontalOverflow, regionDiff, renderFindings, renderOverflow, renderRouteAudit, renderWalk, routeProblems, shrinkVisibleHeight, stubGamepad, summariseOverflow, summariseTouchTargets, toOverflowReading, walkFailed, walkMenus };
718
+ // src/menu-walk-graph.ts
719
+ var PRESSES_PER_ITEM = 16;
720
+ function shortestPath(edges, from, to) {
721
+ if (from === null) {
722
+ return null;
723
+ }
724
+ const prev = /* @__PURE__ */ new Map([[from, []]]);
725
+ const queue = [from];
726
+ while (queue.length > 0) {
727
+ const at2 = queue.shift();
728
+ const steps = prev.get(at2);
729
+ if (at2 === to) {
730
+ return steps;
731
+ }
732
+ for (const [d, next] of edges.get(at2) ?? []) {
733
+ if (next !== null && !prev.has(next)) {
734
+ prev.set(next, [...steps, d]);
735
+ queue.push(next);
736
+ }
737
+ }
738
+ }
739
+ return null;
740
+ }
741
+ function pendingDir(edges, node) {
742
+ const out = edges.get(node);
743
+ return out === void 0 ? void 0 : DIRS.find((x) => !out.has(x));
744
+ }
745
+ function nextUnexplored(edges, cur) {
746
+ const seen = new Set(cur === null ? [] : [cur]);
747
+ const queue = cur === null ? [] : [cur];
748
+ while (queue.length > 0) {
749
+ const at2 = queue.shift();
750
+ const d = pendingDir(edges, at2);
751
+ if (d !== void 0) {
752
+ return [at2, d];
753
+ }
754
+ for (const next of edges.get(at2)?.values() ?? []) {
755
+ if (next !== null && !seen.has(next)) {
756
+ seen.add(next);
757
+ queue.push(next);
758
+ }
759
+ }
760
+ }
761
+ for (const node of edges.keys()) {
762
+ const d = pendingDir(edges, node);
763
+ if (d !== void 0) {
764
+ return [node, d];
765
+ }
766
+ }
767
+ return null;
768
+ }
769
+ async function travel(m, edges, cur, node) {
770
+ let at2 = cur;
771
+ let steps = shortestPath(edges, at2, node);
772
+ if (steps === null) {
773
+ at2 = await m.reset();
774
+ steps = shortestPath(edges, at2, node) ?? [];
775
+ }
776
+ for (const d of steps) {
777
+ at2 = await m.press(d);
778
+ }
779
+ return at2;
780
+ }
781
+ async function exploreFocus(m, itemCount) {
782
+ const edges = /* @__PURE__ */ new Map();
783
+ let cur = await m.reset();
784
+ if (cur === null) {
785
+ cur = await m.press("down");
786
+ }
787
+ if (cur !== null) {
788
+ edges.set(cur, /* @__PURE__ */ new Map());
789
+ }
790
+ let budget = PRESSES_PER_ITEM * Math.max(itemCount, 1);
791
+ for (let next = nextUnexplored(edges, cur); next !== null && budget > 0; next = nextUnexplored(edges, cur)) {
792
+ const [node, d] = next;
793
+ const out = edges.get(node);
794
+ cur = await travel(m, edges, cur, node);
795
+ budget -= 1;
796
+ if (cur !== node) {
797
+ out.set(d, null);
798
+ continue;
799
+ }
800
+ cur = await m.press(d);
801
+ out.set(d, cur);
802
+ if (cur !== null && !edges.has(cur)) {
803
+ edges.set(cur, /* @__PURE__ */ new Map());
804
+ }
805
+ }
806
+ return { reached: new Set(edges.keys()), path: (from, to) => shortestPath(edges, from, to) };
807
+ }
808
+
809
+ // src/menu-walk-hook.ts
810
+ var HOOK_WALK_SIZES = [["phone", PHONE_SIZE], ["desktop", DESKTOP_SIZE]];
811
+ function readHook(name) {
812
+ const hook = window[name];
813
+ return hook === void 0 ? null : { screen: hook.screen(), items: hook.items(), focused: hook.focused() };
814
+ }
815
+ var read = (page) => page.evaluate(readHook, MENU_WALK_HOOK);
816
+ async function reopen(w) {
817
+ await w.opts.open(w.page, w.screen.name);
818
+ return read(w.page);
819
+ }
820
+ function machine(w) {
821
+ return {
822
+ press: async (d) => {
823
+ await w.driver.dir(d);
824
+ return (await read(w.page))?.focused ?? null;
825
+ },
826
+ reset: async () => (await reopen(w))?.focused ?? null
827
+ };
828
+ }
829
+ async function activationProblem(w, graph, target) {
830
+ const steps = graph.path((await reopen(w))?.focused ?? null, target.item);
831
+ if (steps === null) {
832
+ return `cannot reach ${target.item} to activate it`;
833
+ }
834
+ for (const d of steps) {
835
+ await w.driver.dir(d);
836
+ }
837
+ await w.driver.activate();
838
+ const landed = (await read(w.page))?.screen;
839
+ const key = w.via === WALK_INPUTS.pad ? "A" : "Enter";
840
+ return landed === target.to ? null : `${key} on ${target.item} opens "${String(landed)}", expected "${target.to}"`;
841
+ }
842
+ async function actionProblems(w, graph) {
843
+ const problems = [];
844
+ const target = w.screen.activates;
845
+ const activation = target === void 0 ? null : await activationProblem(w, graph, target);
846
+ if (activation !== null) {
847
+ problems.push(activation);
848
+ }
849
+ if (w.screen.leaves !== false) {
850
+ await reopen(w);
851
+ await w.driver.back();
852
+ const key = w.via === WALK_INPUTS.pad ? "B" : "Escape";
853
+ if ((await read(w.page))?.screen === w.screen.name) {
854
+ problems.push(`${key} does not leave ${w.screen.name}`);
855
+ }
856
+ }
857
+ return problems;
858
+ }
859
+ async function walkHookScreen(w, size) {
860
+ const exempt = w.screen.exempt ?? [];
861
+ const base = { screen: `${w.screen.name} @${size}`, via: w.via, exempt: exempt.map((e) => `${e.item}: ${e.reason}`), notes: [] };
862
+ const first = await reopen(w);
863
+ if (first === null) {
864
+ return { ...base, reached: 0, total: 0, unreached: [], problems: [`window.${MENU_WALK_HOOK} is not installed`] };
865
+ }
866
+ const problems = first.screen === w.screen.name ? [] : [`open landed on screen "${first.screen}"`];
867
+ const items = first.items.filter((i) => !exempt.some((e) => e.item === i));
868
+ const graph = await exploreFocus(machine(w), first.items.length);
869
+ const unreached = items.filter((i) => !graph.reached.has(i));
870
+ problems.push(...await actionProblems(w, graph));
871
+ return { ...base, reached: items.length - unreached.length, total: items.length, unreached, problems };
872
+ }
873
+ async function walkHookMenus(page, opts) {
874
+ const via = opts.via ?? [WALK_INPUTS.keys, WALK_INPUTS.pad];
875
+ const pad = via.includes(WALK_INPUTS.pad) ? await stubGamepad(page) : null;
876
+ const results = [];
877
+ for (const [label, size] of opts.sizes ?? HOOK_WALK_SIZES) {
878
+ await page.setViewportSize(size);
879
+ for (const s of opts.screens) {
880
+ const screen = typeof s === "string" ? { name: s } : s;
881
+ for (const v of via) {
882
+ results.push(await walkHookScreen({ page, opts, screen, driver: driverFor(page, v, pad), via: v }, label));
883
+ }
884
+ }
885
+ }
886
+ return results;
887
+ }
888
+ async function expectHookMenuWalkable(page, opts) {
889
+ const results = await walkHookMenus(page, opts);
890
+ if (results.some(walkFailed)) {
891
+ throw new Error(`Canvas menus not walkable by arrow keys / pad:
892
+ ${renderWalk(results)}`);
893
+ }
894
+ }
895
+
896
+ export { ANTI_ALIAS_TOLERANCE, CANVAS_TIMEOUT_MS, CONTROL_SELECTOR, DEFAULT_CANVAS_SELECTOR, DESKTOP_DEVICE, DESKTOP_SIZE, EXACT, FIT_TIMEOUT_MS, GAME_SHELL_HEIGHT_VAR, HOOK_WALK_SIZES, MAX_REPORTED, MIN_TARGET_PX, PHONE_DEVICE, PHONE_SIZE, RELAYOUT_TIMEOUT_MS, STUB_FRAMES, WALK_INPUTS, armVisibleHeight, auditRoute, auditTouchTargets, canvasBoxToPage, controlName, countDiff, desktop, deviceDescriptor, diffPngs, domControls, expectCanvasHeight, expectCanvasInside, expectFitTo, expectHookMenuWalkable, expectMenuWalkable, expectNoHorizontalOverflow, expectNoHorizontalOverflowAcrossRoutes, expectTouchTargets, expectTouchTargetsAcrossRoutes, findOverlaps, findOverlapsWithin, gameProjects, horizontalOverflowPx, measureHorizontalOverflow, overlaps, phone, readHorizontalOverflow, regionDiff, renderFindings, renderOverflow, renderRouteAudit, renderWalk, routeProblems, shrinkVisibleHeight, stubGamepad, summariseOverflow, summariseTouchTargets, toOverflowReading, walkFailed, walkHookMenus, walkMenus };
697
897
  //# sourceMappingURL=index.mjs.map
698
898
  //# sourceMappingURL=index.mjs.map