@cardstack/boxel-cli 0.13.0-unstable.4 → 0.13.0-unstable.6

package/bundled-test-harness/assets/overlay-D2rQi8lJ.js

@@ -0,0 +1,427 @@
+import "./chunk-Rp0pCe6z.js";
+import { r as modifier } from "./dist-nMt-N14r.js";
+import { i as firstDefined } from "./pretui-primitives-CRs8NRm0.js";
+//#region ../pretui/focus.gts
+/** Focuses the element whenever the modifier runs with `should` true: when
+* it's inserted, and whenever `should` is computed again, even when it stays
+* true (a keyed list redrawn from new objects does this without inserting
+* anything). Clear the flag once focus has moved on. */
+var focusWhen = modifier((el, [should]) => {
+	if (should) el.focus();
+});
+/** Roving tabindex, set as a property rather than an attribute: exactly one
+* member of a composite is in the tab sequence, the rest are -1. Set as a
+* property because the no-positive-tabindex lint rule cannot statically
+* verify a dynamic template attribute. */
+var rovingTabindex = modifier((el, [active]) => {
+	el.tabIndex = active ? 0 : -1;
+});
+/** One delegated listener on a composite root, removed on cleanup. This is
+* how a `role='tree'` / `role='menu'` container gets its keyboard without
+* `{{on}}` on a non-interactive element (lint: no-invalid-interactive) and
+* without one listener per node. */
+var listen = modifier((el, [type, handler]) => {
+	el.addEventListener(type, handler);
+	return () => el.removeEventListener(type, handler);
+});
+/** A document-level listener whose lifetime is an element's lifetime. Used
+* for outside-pointer dismissal and for the Alt/Option watch — both of which
+* must hear events that never reach the overlay. Passive by default; pass
+* `capture` for dismissal so a stopPropagation inside the page cannot
+* strand an open overlay. */
+var listenDocument = modifier((_el, [type, handler, capture]) => {
+	let options = {
+		capture: capture ?? false,
+		passive: true
+	};
+	document.addEventListener(type, handler, options);
+	return () => document.removeEventListener(type, handler, options);
+});
+/**
+* A document-level listener in the CAPTURE phase, non-passive so the handler
+* may `preventDefault`.
+*
+* This is how an open overlay takes ownership of a key. Handlers for one
+* event type share a single listener that calls them newest first and stops
+* at the first one that calls `stopPropagation`, so an Escape inside nested
+* overlays closes only the innermost one.
+*/
+var captureStacks = /* @__PURE__ */ new Map();
+function dispatchCapture(event) {
+	let stack = captureStacks.get(event.type);
+	if (!stack) return;
+	for (let handler of [...stack].reverse()) {
+		handler(event);
+		if (event.cancelBubble) return;
+	}
+}
+var listenDocumentCapture = modifier((_el, [type, handler]) => {
+	let stack = captureStacks.get(type);
+	if (!stack) {
+		stack = [];
+		captureStacks.set(type, stack);
+		document.addEventListener(type, dispatchCapture, true);
+	}
+	stack.push(handler);
+	return () => {
+		let current = captureStacks.get(type);
+		if (!current) return;
+		let at = current.lastIndexOf(handler);
+		if (at !== -1) current.splice(at, 1);
+		if (current.length === 0) {
+			captureStacks.delete(type);
+			document.removeEventListener(type, dispatchCapture, true);
+		}
+	};
+});
+/**
+* A set of `setTimeout` handles whose owner is an `ember-modifier`.
+*
+* `after()` is inert until `adopt()` has been called and inert again after
+* `release()`, so a handle can never outlive the element that owns it — the
+* exact property the realm's no-unowned-timers law protects. Install
+* `{{ownsTimers this.timers}}` on the element whose life the timers should
+* share.
+*/
+var OwnedTimers = class {
+	handles = /* @__PURE__ */ new Set();
+	owned = false;
+	/** Called by `ownsTimers`. */
+	adopt() {
+		this.owned = true;
+	}
+	/** Called by `ownsTimers`' destructor: clears every outstanding handle. */
+	release() {
+		this.owned = false;
+		this.clear();
+	}
+	/** True once a modifier has taken ownership — consumers branch on this to
+	* pick their timer-free degradation. */
+	get active() {
+		return this.owned;
+	}
+	/** Schedules `run` in `ms`. Returns a handle for `cancel`, or undefined
+	* when unowned (in which case nothing was scheduled). */
+	after(ms, run) {
+		if (!this.owned) return;
+		let handle = setTimeout(() => {
+			this.handles.delete(handle);
+			run();
+		}, ms);
+		this.handles.add(handle);
+		return handle;
+	}
+	cancel(handle) {
+		if (handle !== void 0) {
+			clearTimeout(handle);
+			this.handles.delete(handle);
+		}
+	}
+	/** Clears every outstanding handle without giving up ownership. */
+	clear() {
+		for (let handle of this.handles) clearTimeout(handle);
+		this.handles.clear();
+	}
+};
+/** Ties an `OwnedTimers` set to the lifetime of the element it is installed
+* on. This modifier IS the ownership the ruling requires. */
+var ownsTimers = modifier((_el, [timers]) => {
+	timers.adopt();
+	return () => timers.release();
+});
+/**
+* The multi-character type-ahead buffer the APG asks for: letters accumulate,
+* and the buffer resets after `window` ms of no typing.
+*
+* Degradation is the point of the design. With owned timers the buffer is a
+* real multi-character prefix ("pr" jumps to "Preferences"); without them it
+* collapses to single-character cycling — which is what `Tree` shipped when
+* timers were categorically forbidden, and is still a usable behaviour rather
+* than a broken one.
+*/
+var TypeaheadBuffer = class {
+	text = "";
+	handle;
+	constructor(timers, window = 700) {
+		this.timers = timers;
+		this.window = window;
+	}
+	/** Adds a character and returns the prefix to search for. */
+	push(character) {
+		if (!this.timers.active) {
+			this.text = character;
+			return this.text;
+		}
+		this.timers.cancel(this.handle);
+		this.text += character;
+		this.handle = this.timers.after(this.window, () => {
+			this.text = "";
+			this.handle = void 0;
+		});
+		return this.text;
+	}
+	/** True when the buffer is one character repeated — the APG's signal to
+	* CYCLE through matches on that character rather than narrow. */
+	get isCycling() {
+		return this.text.length > 1 && new Set(this.text).size === 1;
+	}
+	get value() {
+		return this.text;
+	}
+	reset() {
+		this.timers.cancel(this.handle);
+		this.handle = void 0;
+		this.text = "";
+	}
+};
+/**
+* The index of the next item matching a type-ahead prefix, searching forward
+* from `from` and wrapping. Returns -1 when nothing matches.
+*
+* `cycling` implements the APG rule: when the buffer is one repeated
+* character, match on that single character and step to the NEXT match rather
+* than staying on the current one.
+*/
+function typeaheadIndex(labels, prefix, from, cycling = false) {
+	let needle = (cycling ? prefix.slice(0, 1) : prefix).toLowerCase();
+	if (!needle) return -1;
+	let start = cycling || prefix.length > 1 ? 0 : 1;
+	for (let step = start; step <= labels.length; step++) {
+		let index = (from + step) % labels.length;
+		if (labels[index]?.toLowerCase().startsWith(needle)) return index;
+	}
+	return -1;
+}
+/** The near vertical edge of an open submenu: the base of the safe triangle. */
+/**
+* The base of the safe triangle for a submenu occupying `rect`, opened on
+* `side` of its parent item. The near edge is the one facing the pointer:
+* a submenu opened to the RIGHT is approached across its LEFT edge.
+*
+* `tolerance` grows the edge vertically so a pointer aiming a few pixels
+* above or below the panel still counts as travelling toward it.
+*/
+function safeEdgeFor(rect, side, tolerance = 10) {
+	return {
+		x: side === "right" ? rect.left : rect.right,
+		top: rect.top - tolerance,
+		bottom: rect.bottom + tolerance
+	};
+}
+function cross(ax, ay, bx, by) {
+	return ax * by - ay * bx;
+}
+/** Inclusive point-in-triangle by consistent sign of the three edge crosses. */
+function pointInTriangle(p, a, b, c) {
+	let d1 = cross(p.x - a.x, p.y - a.y, b.x - a.x, b.y - a.y);
+	let d2 = cross(p.x - b.x, p.y - b.y, c.x - b.x, c.y - b.y);
+	let d3 = cross(p.x - c.x, p.y - c.y, a.x - c.x, a.y - c.y);
+	return !((d1 < 0 || d2 < 0 || d3 < 0) && (d1 > 0 || d2 > 0 || d3 > 0));
+}
+/**
+* **The Amazon mega-dropdown rule.** True when the pointer's travel from
+* `from` to `to` is aimed at the open submenu — i.e. `to` lies inside the
+* triangle whose apex is `from` and whose base is the submenu's near `edge`.
+*
+* While this is true, a sibling item the pointer happens to cross must NOT
+* take over the hover: the reader is travelling to the submenu, not choosing
+* the row under the cursor. That diagonal is the single most common menu
+* defect on the web, and the naive `mouseenter`-wins implementation makes the
+* submenu flicker away exactly as it is reached for.
+*
+* A pointer that has not moved (`from` equals `to`) is not travelling
+* anywhere: it returns false, which is what stops a stationary cursor from
+* deferring the sibling forever.
+*/
+function inSafeTriangle(from, to, edge) {
+	if (from.x === to.x && from.y === to.y) return false;
+	if (edge.x >= from.x ? to.x > edge.x : to.x < edge.x) return false;
+	return pointInTriangle(to, from, {
+		x: edge.x,
+		y: edge.top
+	}, {
+		x: edge.x,
+		y: edge.bottom
+	});
+}
+/**
+* Pointer position tracking for the safe triangle, plus the submenu edge it
+* is measured against. The component holds one of these; `tracksPointer`
+* gives it its listener and its lifetime.
+*/
+var PointerTrack = class {
+	previous;
+	current;
+	moves = 0;
+	/** The open submenu's near edge, set when the submenu opens/resizes. */
+	edge;
+	/** Increments on every pointer move. A consumer that defers on the strength
+	* of `travellingToSubmenu` must record this stamp and refuse to defer twice
+	* on the SAME move — otherwise a pointer that stops inside the triangle
+	* defers forever, which is both a stuck menu and a timer that re-arms
+	* without end (Kamens guards the same case with `lastDelayLoc`). */
+	get stamp() {
+		return this.moves;
+	}
+	record(x, y) {
+		this.previous = this.current;
+		this.current = {
+			x,
+			y
+		};
+		this.moves++;
+	}
+	/** True while the pointer is travelling toward the open submenu. */
+	get travellingToSubmenu() {
+		if (!this.edge || !this.previous || !this.current) return false;
+		return inSafeTriangle(this.previous, this.current, this.edge);
+	}
+	clear() {
+		this.previous = void 0;
+		this.current = void 0;
+		this.edge = void 0;
+	}
+};
+/**
+* Owns the `pointermove` listener feeding a `PointerTrack`, and removes it on
+* teardown. `pointermove` rather than `mousemove` so pens and touch report
+* too; passive because the handler only reads coordinates. Listening on
+* `document` (not the panel) keeps the track continuous across the gap
+* between a menu and its submenu.
+*/
+var tracksPointer = modifier((_el, [track]) => {
+	let onMove = (event) => {
+		let pointer = event;
+		track.record(pointer.clientX, pointer.clientY);
+	};
+	document.addEventListener("pointermove", onMove, { passive: true });
+	return () => {
+		document.removeEventListener("pointermove", onMove);
+		track.clear();
+	};
+});
+/** Elements whose press is their own: a container's pointer gesture skips
+*  presses that start inside one. */
+var OWNS_PRESS = "a[href], button, input, select, textarea, label, summary, [role=\"button\"], [role=\"link\"], [contenteditable=\"\"], [contenteditable=\"true\"]";
+//#endregion
+//#region ../pretui/internal/overlay.gts
+var GUTTER = 8;
+var SIDE_ALIASES = {
+	top: "top",
+	bottom: "bottom",
+	left: "left",
+	right: "right",
+	start: "left",
+	end: "right",
+	"inline-start": "left",
+	"inline-end": "right",
+	"block-start": "top",
+	"block-end": "bottom",
+	before: "left",
+	after: "right",
+	up: "top",
+	down: "bottom"
+};
+var ALIGN_ALIASES = {
+	center: "",
+	centre: "",
+	middle: "",
+	start: "-start",
+	end: "-end",
+	top: "-start",
+	bottom: "-end",
+	left: "-start",
+	right: "-end"
+};
+/** Split a composite placement without shredding `inline-start`. */
+function splitPlacement(p) {
+	if (SIDE_ALIASES[p]) return [p, void 0];
+	let i = p.lastIndexOf("-");
+	return i === -1 ? [p, void 0] : [p.slice(0, i), p.slice(i + 1)];
+}
+function resolvePlacement(args, fallback) {
+	let composite = firstDefined(args.placement, args.position, args.direction, args.side);
+	let [sideToken, alignToken] = composite ? splitPlacement(composite) : [void 0, void 0];
+	let side = SIDE_ALIASES[sideToken ?? ""];
+	if (!side) return fallback;
+	return side + (ALIGN_ALIASES[alignToken ?? args.align ?? "center"] ?? "");
+}
+/** Every spelling of "is this layer showing". */
+function resolveOpen(args) {
+	return firstDefined(args.open, args.isOpen, args.opened);
+}
+var OPPOSITE = {
+	top: "bottom",
+	bottom: "top",
+	left: "right",
+	right: "left"
+};
+function positionPopup(a, w, h, placement, distance) {
+	let [side, align] = placement.split("-");
+	let vw = window.innerWidth;
+	let vh = window.innerHeight;
+	let space = {
+		top: a.top - distance,
+		bottom: vh - a.bottom - distance,
+		left: a.left - distance,
+		right: vw - a.right - distance
+	};
+	let need = side === "top" || side === "bottom" ? h : w;
+	if (space[side] < need && space[OPPOSITE[side]] >= need) side = OPPOSITE[side];
+	let top = 0;
+	let left = 0;
+	if (side === "top") top = a.top - h - distance;
+	if (side === "bottom") top = a.bottom + distance;
+	if (side === "left") left = a.left - w - distance;
+	if (side === "right") left = a.right + distance;
+	if (side === "top" || side === "bottom") {
+		left = align === "start" ? a.left : align === "end" ? a.right - w : a.left + a.width / 2 - w / 2;
+		left = Math.min(Math.max(left, GUTTER), Math.max(vw - w - GUTTER, GUTTER));
+	} else {
+		top = align === "start" ? a.top : align === "end" ? a.bottom - h : a.top + a.height / 2 - h / 2;
+		top = Math.min(Math.max(top, GUTTER), Math.max(vh - h - GUTTER, GUTTER));
+	}
+	return {
+		top,
+		left,
+		side
+	};
+}
+var anchorTo = modifier((el, [anchor, placement, distance, matchWidth, scale]) => {
+	if (!anchor) return;
+	let apply = () => {
+		if (scale !== void 0 && scale !== 1) {
+			let s = Math.min(2.5, Math.max(.4, scale));
+			el.style.transformOrigin = "top left";
+			el.style.transform = `scale(${s})`;
+		}
+		if (matchWidth) el.style.minWidth = `${anchor.getBoundingClientRect().width}px`;
+		let r = el.getBoundingClientRect();
+		let p = positionPopup(anchor.getBoundingClientRect(), r.width, r.height, placement, distance);
+		el.style.top = `${p.top}px`;
+		el.style.left = `${p.left}px`;
+	};
+	apply();
+	window.addEventListener("scroll", apply, {
+		capture: true,
+		passive: true
+	});
+	window.addEventListener("resize", apply);
+	return () => {
+		window.removeEventListener("scroll", apply, true);
+		window.removeEventListener("resize", apply);
+	};
+});
+var POPUPS_IN_PLACE = "pretui-popups-in-place";
+var modalBehavior = modifier((el, [open, onCancel, onClick]) => {
+	if (open && !el.open) el.showModal();
+	else if (!open && el.open) el.close();
+	el.addEventListener("cancel", onCancel);
+	el.addEventListener("click", onClick);
+	return () => {
+		el.removeEventListener("cancel", onCancel);
+		el.removeEventListener("click", onClick);
+	};
+});
+//#endregion
+export { safeEdgeFor as _, resolveOpen as a, OwnedTimers as c, focusWhen as d, listen as f, rovingTabindex as g, ownsTimers as h, positionPopup as i, PointerTrack as l, listenDocumentCapture as m, anchorTo as n, resolvePlacement as o, listenDocument as p, modalBehavior as r, OWNS_PRESS as s, POPUPS_IN_PLACE as t, TypeaheadBuffer as u, tracksPointer as v, typeaheadIndex as y };