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

package/bundled-test-harness/assets/flac-audio-def-test-BmVp9dMx.js

@@ -1,143 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL, Co as SupportedMimeType } from "./runtime-common-BTaLJEw-.js";
-import { it as baseRealmRRI } from "./constants-Icc0nFW-.js";
-import { M as waitUntil, k as visit } from "./dist-BOAdzfkP.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, Z as withCachedRealmSetup, a as SYSTEM_CARD_FIXTURE_CONTENTS, ct as setupApplicationTest, j as setupAcceptanceTestRealm, l as capturePrerenderResult, t as setupMockMatrix } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-import { t as setupTestRealmServiceWorker } from "./test-realm-service-worker-OVn3b7N-.js";
-//#region tests/acceptance/audio-def/flac-audio-def-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-function makeMinimalFlac() {
-	let payload = new Uint8Array(34);
-	let view = new DataView(payload.buffer);
-	view.setUint16(0, 4096);
-	view.setUint16(2, 4096);
-	payload[10] = 10;
-	payload[11] = 196;
-	payload[12] = 64;
-	payload[13] = 240;
-	view.setUint32(14, 44100);
-	let blockHeader = new Uint8Array(4);
-	blockHeader[0] = 128;
-	blockHeader[1] = 0;
-	blockHeader[2] = 0;
-	blockHeader[3] = 34;
-	let marker = new Uint8Array([
-		102,
-		76,
-		97,
-		67
-	]);
-	let out = new Uint8Array(marker.length + blockHeader.length + payload.length);
-	out.set(marker, 0);
-	out.set(blockHeader, marker.length);
-	out.set(payload, marker.length + blockHeader.length);
-	return out;
-}
-(0, import_qunit.module)("Acceptance | flac audio def", function(hooks) {
-	setupApplicationTest(hooks);
-	setupLocalIndexing(hooks);
-	setupOnSave(hooks);
-	setupRealmCacheTeardown(hooks);
-	setupTestRealmServiceWorker(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, { loggedInAs: "@testuser:localhost" });
-	let realm;
-	const fileExtractPath = (url, renderOptions, nonce = 0) => `/render/${encodeURIComponent(url)}/${nonce}/${encodeURIComponent(JSON.stringify(renderOptions))}/file-extract`;
-	const fileRenderPath = (url, renderOptions, format = "isolated", ancestorLevel = 0, nonce = 0) => `/render/${encodeURIComponent(url)}/${nonce}/${encodeURIComponent(JSON.stringify(renderOptions))}/html/${format}/${ancestorLevel}`;
-	const makeFileURL = (path) => new URL(path, testRealmURL).href;
-	const flacDefCodeRef = () => ({
-		module: `${baseRealmRRI}flac-audio-def`,
-		name: "FlacDef"
-	});
-	async function captureFileExtractResult(expectedStatus) {
-		await waitUntil(() => {
-			let container = document.querySelector("[data-prerender-file-extract]");
-			if (!container) return false;
-			let status = container.getAttribute("data-prerender-file-extract-status");
-			if (!status) return false;
-			if (expectedStatus && status !== expectedStatus) return false;
-			return status === "ready" || status === "error";
-		}, { timeout: 5e3 });
-		let container = document.querySelector("[data-prerender-file-extract]");
-		if (!container) throw new Error("captureFileExtractResult: missing [data-prerender-file-extract] container after wait");
-		let text = container.querySelector("pre")?.textContent?.trim() ?? "";
-		return JSON.parse(text);
-	}
-	hooks.beforeEach(async function() {
-		let flacBytes = makeMinimalFlac();
-		({realm} = await withCachedRealmSetup(async () => setupAcceptanceTestRealm({
-			mockMatrixUtils,
-			contents: {
-				...SYSTEM_CARD_FIXTURE_CONTENTS,
-				"sample.flac": flacBytes,
-				"not-a-flac.flac": "This is plain text, not a FLAC file."
-			}
-		})));
-	});
-	hooks.afterEach(function() {
-		delete globalThis.__renderModel;
-		delete globalThis.__boxelFileRenderData;
-	});
-	(0, import_qunit.test)("extracts duration from FLAC", async function(assert) {
-		await visit(fileExtractPath(makeFileURL("sample.flac"), {
-			fileExtract: true,
-			fileDefCodeRef: flacDefCodeRef()
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.strictEqual(result.status, "ready");
-		assert.strictEqual(result.searchDoc?.duration, 1, "extracts FLAC duration");
-		assert.strictEqual(result.searchDoc?.name, "sample.flac");
-		assert.ok(String(result.searchDoc?.contentType).includes("flac"), "sets flac content type");
-	});
-	(0, import_qunit.test)("falls back when FlacDef is used for non-FLAC content", async function(assert) {
-		await visit(fileExtractPath(makeFileURL("not-a-flac.flac"), {
-			fileExtract: true,
-			fileDefCodeRef: flacDefCodeRef()
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.strictEqual(result.status, "ready");
-		assert.true(result.mismatch, "marks mismatch when content is not valid FLAC");
-		assert.strictEqual(result.searchDoc?.name, "not-a-flac.flac");
-	});
-	(0, import_qunit.test)("isolated preview renders the player and formatted duration", async function(assert) {
-		let url = makeFileURL("sample.flac");
-		await visit(fileExtractPath(url, {
-			fileExtract: true,
-			fileDefCodeRef: flacDefCodeRef()
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.ok(result.resource, "extraction produced a resource");
-		globalThis.__boxelFileRenderData = {
-			resource: result.resource,
-			fileDefCodeRef: flacDefCodeRef()
-		};
-		await visit(fileRenderPath(url, {
-			fileRender: true,
-			fileDefCodeRef: flacDefCodeRef()
-		}));
-		let { status } = await capturePrerenderResult("innerHTML");
-		assert.strictEqual(status, "ready", "render completed");
-		let preview = document.querySelector("[data-prerender] [data-test-audio-preview]");
-		assert.ok(preview, "audio preview renders in the shared shell");
-		let player = document.querySelector("[data-prerender] [data-test-audio-player]");
-		assert.ok(player, "native audio player is mounted");
-		let duration = document.querySelector("[data-prerender] [data-test-audio-duration]");
-		assert.ok(duration, "duration element is rendered");
-		assert.strictEqual(duration?.textContent?.trim(), "0:01", "duration is formatted as m:ss");
-	});
-	(0, import_qunit.test)("indexing stores FLAC metadata and file meta uses it", async function(assert) {
-		let fileURL = new URL("sample.flac", testRealmURL);
-		let fileEntry = await realm.realmIndexQueryEngine.file(fileURL);
-		assert.ok(fileEntry, "file entry exists");
-		assert.strictEqual(fileEntry?.searchDoc?.duration, 1, "index stores FLAC duration");
-		let response = await getService("network").virtualNetwork.fetch(fileURL, { headers: { Accept: SupportedMimeType.FileMeta } });
-		assert.true(response.ok, "file meta request succeeds");
-		let body = await response.json();
-		assert.strictEqual(body?.data?.type, "file-meta");
-		assert.ok(String(body?.data?.attributes?.contentType).includes("flac"), "file meta uses flac content type");
-		assert.strictEqual(body?.data?.attributes?.duration, 1, "file meta includes FLAC duration");
-		assert.deepEqual(body?.data?.meta?.adoptsFrom, flacDefCodeRef(), "file meta uses FLAC def");
-	});
-});
-//#endregion

package/bundled-test-harness/assets/focus-Dm4wkM72.js

@@ -1,306 +0,0 @@
-import "./chunk-Rp0pCe6z.js";
-import { r as modifier } from "./dist-nMt-N14r.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
-export { focusWhen as a, listenDocumentCapture as c, safeEdgeFor as d, tracksPointer as f, TypeaheadBuffer as i, ownsTimers as l, OwnedTimers as n, listen as o, typeaheadIndex as p, PointerTrack as r, listenDocument as s, OWNS_PRESS as t, rovingTabindex as u };