@cardstack/boxel-cli 0.9.0 → 0.10.0-unstable.0

package/bundled-test-harness/assets/card-chooser-paging-test-y8OfboYd.js

@@ -0,0 +1,235 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Ar as testRealmURL, Sc as Deferred, a as chooseCard } from "./runtime-common-ClpqhbwG.js";
+import { y as rri } from "./paths-BYHDgqsT.js";
+import { D as baseRealm } from "./constants-CqKWhRfY.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as OperatorModeContainer } from "./container-Dj-5prh9.js";
+import { M as waitUntil, T as settled, d as click, o as waitFor, s as fillIn } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { D as realmConfigCardJSON, F as setupLocalIndexing, P as setupIntegrationTestRealm, lt as setupRenderingTest, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-DPQ0j2MD.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { n as renderComponent } from "./render-component-B15Z0e2v.js";
+//#region tests/integration/components/card-chooser-paging-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var realmName = "Local Workspace";
+var specCount = 103;
+var gizmoCount = 2;
+var totalCount = 105;
+var section = `[data-test-realm="${realmName}"]`;
+function widgetName(n) {
+	return `Widget ${String(n).padStart(3, "0")}`;
+}
+function widgetSpecId(n) {
+	return `${testRealmURL}cards/widgets/Spec/widget-${String(n).padStart(3, "0")}`;
+}
+function gizmoSpecId(n) {
+	return `${testRealmURL}cards/gizmos/Spec/gizmo-${n}`;
+}
+function isSearchRequest(request) {
+	let path = new URL(request.url).pathname;
+	return path.endsWith("/_federated-search") || path.endsWith("/_search");
+}
+async function isExtendedPageFetch(request) {
+	if (!isSearchRequest(request)) return false;
+	let wire = decodeURIComponent(request.url) + await request.clone().text();
+	return /"size":\s*(2|3)00\b|size\]=(2|3)00\b/.test(wire);
+}
+async function openCreateChooser() {
+	await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+	await click("[data-test-create-new-card-button]");
+	await waitForSection();
+}
+async function waitForSection() {
+	try {
+		await waitFor(section);
+	} catch {
+		let rendered = [...document.querySelectorAll("[data-test-realm-url]")].map((n) => `${n.getAttribute("data-test-realm-url")} as "${n.getAttribute("data-test-realm")}"${n.hasAttribute("data-test-realm-info-placeholder") ? " (placeholder name)" : ""}`);
+		throw new Error(`timed out waiting for ${section}; chooser ${document.querySelector("[data-test-card-chooser-cancel-button]") ? "is open" : "is not open"}, realm sections: ${rendered.length ? rendered.join(", ") : "none"}`);
+	}
+}
+async function showAllInSection() {
+	await click(`${section} [data-test-search-sheet-show-only]`);
+	await waitUntilLabeled("the first page", () => shownIds().length === 100);
+	await click(`${section} [data-test-show-more-cards]`);
+}
+async function waitUntilLabeled(label, check) {
+	try {
+		await waitUntil(check, { timeout: 1e4 });
+	} catch {
+		throw new Error(`timed out waiting for ${label}; section shows "${sectionCountText()}" with ${shownIds().length} rows`);
+	}
+}
+function sectionCountText() {
+	return document.querySelector(`${section} [data-test-results-count]`)?.textContent?.replace(/\s+/g, " ").trim();
+}
+function shownIds() {
+	return [...document.querySelectorAll(`${section} [data-test-item-button]`)].map((n) => n.getAttribute("data-test-item-button"));
+}
+(0, import_qunit.module)("Integration | card-chooser | paging", function(hooks) {
+	setupRenderingTest(hooks);
+	setupOperatorModeStateCleanup(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [baseRealm.url, testRealmURL],
+		autostart: true
+	});
+	const noop = () => {};
+	hooks.beforeEach(async function() {
+		let loader = getService("loader-service").loader;
+		let cardApi;
+		let string;
+		let cardsGrid;
+		let spec;
+		cardApi = await loader.import("@cardstack/base/card-api");
+		string = await loader.import("@cardstack/base/string");
+		cardsGrid = await loader.import("@cardstack/base/cards-grid");
+		spec = await loader.import("@cardstack/base/spec");
+		let { field, contains, CardDef } = cardApi;
+		let { default: StringField } = string;
+		let { CardsGrid } = cardsGrid;
+		let { Spec } = spec;
+		class Widget extends CardDef {
+			static displayName = "Widget";
+			static {
+				decorateFieldV2(this.prototype, "label", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#label = (initializeDeferredDecorator(this, "label"), void 0);
+		}
+		class Gizmo extends CardDef {
+			static displayName = "Gizmo";
+			static {
+				decorateFieldV2(this.prototype, "label", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#label = (initializeDeferredDecorator(this, "label"), void 0);
+		}
+		let contents = {
+			"cards/widgets/widget.gts": { Widget },
+			"cards/gizmos/gizmo.gts": { Gizmo },
+			"realm.json": realmConfigCardJSON({ name: realmName }),
+			"index.json": new CardsGrid()
+		};
+		for (let n = 1; n <= specCount; n++) contents[`cards/widgets/Spec/widget-${String(n).padStart(3, "0")}.json`] = new Spec({
+			cardTitle: widgetName(n),
+			specType: "card",
+			ref: {
+				module: `${testRealmURL}cards/widgets/widget`,
+				name: "Widget"
+			}
+		});
+		for (let n = 1; n <= gizmoCount; n++) contents[`cards/gizmos/Spec/gizmo-${n}.json`] = new Spec({
+			cardTitle: `Gizmo ${n}`,
+			specType: "card",
+			ref: {
+				module: `${testRealmURL}cards/gizmos/gizmo`,
+				name: "Gizmo"
+			}
+		});
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents
+		});
+		getService("operator-mode-state-service").restore({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "RXXvme1E",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/card-chooser-paging-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor(`[data-test-stack-card="${testRealmURL}index"]`);
+	});
+	hooks.afterEach(function() {
+		for (let handler of mountedHandlers) getService("network").virtualNetwork.unmount(handler);
+		mountedHandlers = [];
+	});
+	let mountedHandlers = [];
+	function interceptSearch(handler) {
+		mountedHandlers.push(handler);
+		getService("network").virtualNetwork.mount(handler, { prepend: true });
+	}
+	(0, import_qunit.test)("a realm section reports its full match count and pages past the first page", async function(assert) {
+		await openCreateChooser();
+		assert.dom(`${section} [data-test-results-count]`).hasText(`${totalCount} results`);
+		await click(`${section} [data-test-search-sheet-show-only]`);
+		assert.strictEqual(shownIds().length, 100, "focus shows the first page");
+		assert.dom(`${section} [data-test-show-more-cards]`).containsText("Show 5 more results (5 not shown)");
+		await click(`${section} [data-test-show-more-cards]`);
+		await waitUntilLabeled("every row", () => shownIds().length === totalCount);
+		let ids = shownIds();
+		assert.strictEqual(ids[ids.length - 1], widgetSpecId(specCount), "the last card alphabetically is reachable");
+		assert.strictEqual(new Set(ids).size, totalCount, "no row appears twice");
+		assert.dom(`${section} [data-test-show-more-cards]`).doesNotExist();
+	});
+	(0, import_qunit.test)("Select All keeps a row selected from past the first page", async function(assert) {
+		let chosen = chooseCard({ filter: { type: {
+			module: rri(`${baseRealm.url}spec`),
+			name: "Spec"
+		} } }, { multiSelect: true });
+		await settled();
+		await waitForSection();
+		await showAllInSection();
+		let lastId = widgetSpecId(specCount);
+		await waitFor(`${section} [data-test-item-button="${lastId}"]`);
+		await click(`${section} [data-test-item-button="${lastId}"]`);
+		assert.dom(`${section} [data-test-item-button="${lastId}"]`).hasAttribute("data-test-item-button-selected", "true");
+		await click("[data-test-selection-dropdown-trigger]");
+		await waitFor("[data-test-boxel-menu-item-text=\"Select All\"]");
+		await click("[data-test-boxel-menu-item-text=\"Select All\"]");
+		assert.dom(`${section} [data-test-item-button="${lastId}"]`).hasAttribute("data-test-item-button-selected", "true", "the paged row stays selected");
+		assert.dom(`${section} [data-test-item-button-selected]`).exists({ count: totalCount }, "every loaded row is selected");
+		await click("[data-test-card-chooser-cancel-button]");
+		await chosen;
+	});
+	(0, import_qunit.test)("a failed page fetch can be retried from the show-more button", async function(assert) {
+		await openCreateChooser();
+		let failing = true;
+		interceptSearch(async (request) => failing && await isExtendedPageFetch(request) ? new Response("unavailable", { status: 500 }) : null);
+		await showAllInSection();
+		await waitFor(`${section} [data-test-show-more-failed]`);
+		assert.dom(`${section} [data-test-show-more-cards]`).containsText("Retry", "the failure is shown on the button");
+		assert.strictEqual(shownIds().length, 100, "the first page stays shown");
+		failing = false;
+		await click(`${section} [data-test-show-more-cards]`);
+		await waitUntilLabeled("every row after retry", () => shownIds().length === totalCount);
+		assert.dom(`${section} [data-test-show-more-cards]`).doesNotExist();
+	});
+	(0, import_qunit.test)("a changed search does not show the previous search rows while paging catches up", async function(assert) {
+		await openCreateChooser();
+		await fillIn("[data-test-search-field]", "Widget");
+		await waitUntilLabeled("the Widget search count", () => sectionCountText() === `${specCount} results`);
+		await showAllInSection();
+		await waitUntilLabeled("every Widget row", () => shownIds().length === specCount);
+		assert.strictEqual(shownIds()[0], widgetSpecId(1));
+		let release = new Deferred();
+		interceptSearch(async (request) => {
+			if (await isExtendedPageFetch(request)) await release.promise;
+			return null;
+		});
+		let cleared = fillIn("[data-test-search-field]", "");
+		await waitUntilLabeled("the cleared search count", () => sectionCountText() === `${totalCount} results`);
+		assert.strictEqual(shownIds()[0], gizmoSpecId(1), "the rows are the new search, not the previous one");
+		assert.strictEqual(shownIds().length, 100, "the new first page is shown");
+		release.fulfill();
+		await cleared;
+		await waitUntilLabeled("the paged rows of the cleared search", () => shownIds().length === specCount);
+		assert.strictEqual(shownIds()[0], gizmoSpecId(1));
+	});
+});
+//#endregion

package/bundled-test-harness/assets/card-chooser-test-nmg2zkDj.js

@@ -0,0 +1,393 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Ar as testRealmURL } from "./runtime-common-ClpqhbwG.js";
+import { D as baseRealm } from "./constants-CqKWhRfY.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as OperatorModeContainer } from "./container-Dj-5prh9.js";
+import { c as triggerKeyEvent, d as click, f as focus, o as waitFor, r as typeIn, s as fillIn, u as doubleClick } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { D as realmConfigCardJSON, F as setupLocalIndexing, P as setupIntegrationTestRealm, lt as setupRenderingTest, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-DPQ0j2MD.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { n as renderComponent } from "./render-component-B15Z0e2v.js";
+//#region tests/integration/components/card-chooser-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var realmName = "Local Workspace";
+(0, import_qunit.module)("Integration | card-chooser", function(hooks) {
+	setupRenderingTest(hooks);
+	setupOperatorModeStateCleanup(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [baseRealm.url, testRealmURL],
+		autostart: true
+	});
+	const noop = () => {};
+	hooks.beforeEach(async function() {
+		let loader = getService("loader-service").loader;
+		let cardApi;
+		let string;
+		let textArea;
+		let cardsGrid;
+		let spec;
+		cardApi = await loader.import("@cardstack/base/card-api");
+		string = await loader.import("@cardstack/base/string");
+		textArea = await loader.import("@cardstack/base/text-area");
+		cardsGrid = await loader.import("@cardstack/base/cards-grid");
+		spec = await loader.import("@cardstack/base/spec");
+		let { field, contains, linksTo, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		let { default: TextAreaField } = textArea;
+		let { CardsGrid } = cardsGrid;
+		let { Spec } = spec;
+		class Author extends CardDef {
+			static displayName = "Author";
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "lastName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#lastName = (initializeDeferredDecorator(this, "lastName"), void 0);
+		}
+		class Person extends CardDef {
+			static displayName = "Person";
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "lastName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#lastName = (initializeDeferredDecorator(this, "lastName"), void 0);
+		}
+		class Pet extends CardDef {
+			static displayName = "Pet";
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+		}
+		class Tree extends CardDef {
+			static displayName = "Tree";
+			static {
+				decorateFieldV2(this.prototype, "species", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#species = (initializeDeferredDecorator(this, "species"), void 0);
+		}
+		class BlogPost extends CardDef {
+			static displayName = "Blog Post";
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "body", [field], function() {
+					return contains(TextAreaField);
+				});
+			}
+			#body = (initializeDeferredDecorator(this, "body"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "authorBio", [field], function() {
+					return linksTo(Author);
+				});
+			}
+			#authorBio = (initializeDeferredDecorator(this, "authorBio"), void 0);
+		}
+		class Address extends FieldDef {
+			static displayName = "Address";
+			static {
+				decorateFieldV2(this.prototype, "street", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#street = (initializeDeferredDecorator(this, "street"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "city", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#city = (initializeDeferredDecorator(this, "city"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "state", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#state = (initializeDeferredDecorator(this, "state"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "zip", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#zip = (initializeDeferredDecorator(this, "zip"), void 0);
+		}
+		class PublishingPacket extends CardDef {
+			static displayName = "Publishing Packet";
+			static {
+				decorateFieldV2(this.prototype, "blogPost", [field], function() {
+					return linksTo(BlogPost);
+				});
+			}
+			#blogPost = (initializeDeferredDecorator(this, "blogPost"), void 0);
+		}
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"blog-post.gts": { BlogPost },
+				"address.gts": { Address },
+				"author.gts": { Author },
+				"person.gts": { Person },
+				"pet.gts": { Pet },
+				"tree.gts": { Tree },
+				"publishing-packet.gts": { PublishingPacket },
+				"realm.json": realmConfigCardJSON({
+					name: realmName,
+					iconURL: "/test-fixtures/realm-images/boxel-logo.png"
+				}),
+				"index.json": new CardsGrid(),
+				"Spec/publishing-packet.json": new Spec({
+					cardTitle: "Publishing Packet",
+					cardDescription: "Spec for PublishingPacket",
+					specType: "card",
+					ref: {
+						module: `${testRealmURL}publishing-packet`,
+						name: "PublishingPacket"
+					}
+				}),
+				"Spec/author.json": new Spec({
+					cardTitle: "Author",
+					cardDescription: "Spec for Author — covers biographical sketches by ornithologists",
+					specType: "card",
+					ref: {
+						module: `${testRealmURL}author`,
+						name: "Author"
+					}
+				}),
+				"Spec/person.json": new Spec({
+					cardTitle: "Person",
+					cardDescription: "Spec for Person",
+					specType: "card",
+					ref: {
+						module: `${testRealmURL}person`,
+						name: "Person"
+					}
+				}),
+				"Spec/pet.json": new Spec({
+					cardTitle: "Pet",
+					cardDescription: "Spec for Pet",
+					specType: "card",
+					ref: {
+						module: `${testRealmURL}pet`,
+						name: "Pet"
+					}
+				}),
+				"Spec/tree.json": new Spec({
+					cardTitle: "Tree",
+					cardDescription: "Spec for Tree",
+					specType: "card",
+					ref: {
+						module: `${testRealmURL}tree`,
+						name: "Tree"
+					}
+				}),
+				"Spec/blog-post.json": new Spec({
+					cardTitle: "BlogPost",
+					cardDescription: "Spec for BlogPost",
+					specType: "card",
+					ref: {
+						module: `${testRealmURL}blog-post`,
+						name: "BlogPost"
+					}
+				}),
+				"Spec/address.json": new Spec({
+					cardTitle: "Address",
+					cardDescription: "Spec for Address field — also frequented by ornithologists",
+					specType: "field",
+					ref: {
+						module: `${testRealmURL}address`,
+						name: "Address"
+					}
+				})
+			}
+		});
+		getService("operator-mode-state-service").restore({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "d++pM9FC",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/card-chooser-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor(`[data-test-stack-card="${testRealmURL}index"]`);
+		await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+		await click("[data-test-create-new-card-button]");
+		await waitFor("[data-test-realm=\"Local Workspace\"]");
+		await waitFor("[data-test-realm=\"Base Workspace\"]");
+	});
+	(0, import_qunit.module)("realm filters", function() {
+		(0, import_qunit.test)("displays all realms by default", async function(assert) {
+			await waitFor(`[data-test-realm="${realmName}"]`);
+			await waitFor("[data-test-realm=\"Base Workspace\"]");
+			assert.dom("[data-test-realm]").exists({ count: 2 });
+			assert.dom(`[data-test-realm="${realmName}"] [data-test-results-count]`).hasText("6 results");
+			assert.dom(`[data-test-realm="${realmName}"] [data-test-item-button]`).exists({ count: 5 });
+			assert.dom("[data-test-realm=\"Base Workspace\"] [data-test-item-button]").exists();
+			assert.dom("[data-test-realm-picker]").exists("realm picker is displayed");
+			let localResults = [...document.querySelectorAll("[data-test-realm=\"Local Workspace\"] [data-test-item-button]")].map((n) => n.getAttribute("data-test-item-button"));
+			assert.deepEqual(localResults, [
+				"http://test-realm/test/Spec/author",
+				"http://test-realm/test/Spec/blog-post",
+				"http://test-realm/test/Spec/person",
+				"http://test-realm/test/Spec/pet",
+				"http://test-realm/test/Spec/publishing-packet"
+			]);
+		});
+		(0, import_qunit.test)("can filter cards by selecting a realm", async function(assert) {
+			await click("[data-test-realm-picker] [data-test-boxel-picker-trigger]");
+			assert.dom("[data-test-boxel-picker-search] input").hasAttribute("placeholder", "Search for a realm", "realm picker has correct search placeholder");
+			await click(`[data-test-boxel-picker-option-row="${baseRealm.url}"]`);
+			assert.dom(`[data-test-realm="Base Workspace"] [data-test-item-button]`).exists();
+			assert.dom(`[data-test-realm="${realmName}"]`).doesNotExist();
+		});
+		(0, import_qunit.test)("can paginate results from a realm", async function(assert) {
+			assert.dom(`[data-test-realm="Base Workspace"] [data-test-show-more-cards]`).exists("show pagination button for base realm");
+			assert.dom(`[data-test-realm="${realmName}"] [data-test-show-more-cards]`).exists("show pagination button for test realm");
+			assert.dom(`[data-test-realm="${realmName}"] [data-test-show-more-cards]`).containsText("Show 1 more result (1 not shown)");
+			await click(`[data-test-realm="${realmName}"] [data-test-show-more-cards]`);
+			assert.dom(`[data-test-realm="${realmName}"] [data-test-show-more-cards]`).doesNotExist("don't show pagination button for test realm");
+			assert.dom(`[data-test-realm="${realmName}"] [data-test-item-button]`).exists({ count: 6 });
+			let localResults = [...document.querySelectorAll("[data-test-realm=\"Local Workspace\"] [data-test-item-button]")].map((n) => n.getAttribute("data-test-item-button"));
+			assert.deepEqual(localResults, [
+				"http://test-realm/test/Spec/author",
+				"http://test-realm/test/Spec/blog-post",
+				"http://test-realm/test/Spec/person",
+				"http://test-realm/test/Spec/pet",
+				"http://test-realm/test/Spec/publishing-packet",
+				"http://test-realm/test/Spec/tree"
+			]);
+		});
+		(0, import_qunit.test)("catalog items render with the Adorn visual treatment", async function(assert) {
+			await waitFor(`[data-test-realm="${realmName}"] [data-test-item-button]`);
+			assert.dom(`[data-test-realm="${realmName}"] [data-test-item-button]`).exists({ count: 5 }, "catalog items are rendered");
+			assert.dom(`[data-test-realm="${realmName}"] [data-test-item-button]:not(.adorn)`).doesNotExist("every catalog item renders with the adorn class");
+		});
+	});
+	(0, import_qunit.module)("mouse and key events", function() {
+		(0, import_qunit.test)(`pressing enter on a card selects it and submits the selection`, async function(assert) {
+			const card = `${testRealmURL}Spec/publishing-packet`;
+			assert.dom(`[data-test-stack-card-index="0"] [data-test-boxel-card-header-title]`).hasText("Workspace - Local Workspace");
+			assert.dom("[data-test-stack-card-index=\"1\"]").doesNotExist();
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${card}"]`);
+			assert.dom(`[data-test-item-button-selected]`).doesNotExist();
+			await triggerKeyEvent(`[data-test-item-button="${card}"]`, "keydown", "Enter");
+			await waitFor("[data-test-card-chooser-modal]", { count: 0 });
+			await waitFor(`[data-test-stack-card-index="1"]`);
+			assert.dom(`[data-test-stack-card-index="1"] [data-test-boxel-card-header-title]`).hasText("Publishing Packet - Untitled");
+		});
+		(0, import_qunit.test)(`can select card using mouse click and then submit selection using enter key`, async function(assert) {
+			const card = `${testRealmURL}Spec/blog-post`;
+			assert.dom(`[data-test-stack-card-index="0"] [data-test-boxel-card-header-title]`).hasText("Workspace - Local Workspace");
+			assert.dom("[data-test-stack-card-index=\"1\"]").doesNotExist();
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${card}"]`);
+			assert.dom(`[data-test-item-button-selected]`).doesNotExist();
+			await click(`[data-test-item-button="${card}"]`);
+			assert.dom(`[data-test-item-button="${card}"]`).hasAttribute("data-test-item-button-selected");
+			await triggerKeyEvent(`[data-test-item-button="${card}"]`, "keydown", "Enter");
+			await waitFor("[data-test-card-chooser-modal]", { count: 0 });
+			await waitFor(`[data-test-stack-card-index="1"]`);
+			assert.dom(`[data-test-stack-card-index="1"] [data-test-boxel-card-header-title]`).hasText("Blog Post");
+		});
+		(0, import_qunit.test)(`selecting a card, then focusing on another card and pressing enter submits the focused card`, async function(assert) {
+			const card1 = `${testRealmURL}Spec/blog-post`;
+			const card2 = `${testRealmURL}Spec/author`;
+			assert.dom(`[data-test-stack-card-index="0"] [data-test-boxel-card-header-title]`).hasText("Workspace - Local Workspace");
+			assert.dom("[data-test-stack-card-index=\"1\"]").doesNotExist();
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${card1}"]`);
+			await waitFor(`[data-test-item-button="${card2}"]`);
+			assert.dom(`[data-test-item-button-selected]`).doesNotExist();
+			await click(`[data-test-item-button="${card1}"]`);
+			assert.dom(`[data-test-item-button="${card1}"]`).hasAttribute("data-test-item-button-selected");
+			await focus(`[data-test-item-button="${card2}"]`);
+			await triggerKeyEvent(`[data-test-item-button="${card2}"]`, "keydown", "Enter");
+			await waitFor("[data-test-card-chooser-modal]", { count: 0 });
+			await waitFor(`[data-test-stack-card-index="1"]`);
+			assert.dom(`[data-test-stack-card-index="1"] [data-test-boxel-card-header-title]`).hasText("Author - Untitled");
+		});
+		(0, import_qunit.test)(`double-clicking on a card selects the card and submits the selection`, async function(assert) {
+			const card = `${testRealmURL}Spec/blog-post`;
+			assert.dom(`[data-test-stack-card-index="0"] [data-test-boxel-card-header-title]`).hasText("Workspace - Local Workspace");
+			assert.dom("[data-test-stack-card-index=\"1\"]").doesNotExist();
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${card}"]`);
+			assert.dom(`[data-test-item-button-selected]`).doesNotExist();
+			await doubleClick(`[data-test-item-button="${card}"]`);
+			await waitFor("[data-test-card-chooser-modal]", { count: 0 });
+			await waitFor(`[data-test-stack-card-index="1"]`);
+			assert.dom(`[data-test-stack-card-index="1"] [data-test-boxel-card-header-title]`).hasText("Blog Post");
+		});
+		(0, import_qunit.test)(`pressing escape key closes the modal`, async function(assert) {
+			assert.dom(`[data-test-stack-card-index="0"] [data-test-boxel-card-header-title]`).hasText("Workspace - Local Workspace");
+			assert.dom("[data-test-stack-card-index=\"1\"]").doesNotExist();
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button]`);
+			await triggerKeyEvent(`[data-test-card-chooser-modal]`, "keydown", "Escape");
+			await waitFor("[data-test-card-chooser-modal]", { count: 0 });
+			assert.dom(`[data-test-stack-card-index="0"]`).exists();
+			assert.dom("[data-test-stack-card-index=\"1\"]").doesNotExist();
+		});
+	});
+	(0, import_qunit.module)("content search", function() {
+		(0, import_qunit.test)("finds cards by description content, not just title, and respects type scoping", async function(assert) {
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${testRealmURL}Spec/author"]`);
+			await fillIn("[data-test-search-field]", "ornithologists");
+			await waitFor(`[data-test-realm="${realmName}"] [data-test-item-button="${testRealmURL}Spec/author"]`);
+			assert.dom(`[data-test-realm="${realmName}"] [data-test-item-button]`).exists({ count: 1 }, "only the card-type spec is shown; field-type spec with the same content term is filtered out");
+			assert.dom(`[data-test-realm="${realmName}"] [data-test-item-button="${testRealmURL}Spec/address"]`).doesNotExist("field-type spec is excluded even though its description matches");
+		});
+	});
+	(0, import_qunit.module)("component stability", function() {
+		(0, import_qunit.test)("the search field stays mounted and focused across keystrokes", async function(assert) {
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${testRealmURL}Spec/author"]`);
+			let field = document.querySelector("[data-test-search-field]");
+			assert.ok(field, "the search field is rendered");
+			field = field;
+			await focus("[data-test-search-field]");
+			await typeIn("[data-test-search-field]", "ornithologists");
+			let after = document.querySelector("[data-test-search-field]");
+			assert.strictEqual(after, field, "the search field is the same DOM node after typing (never re-mounted)");
+			assert.strictEqual(document.activeElement, field, "the search field retains focus across every keystroke");
+			assert.strictEqual(field.value, "ornithologists", "every keystroke registered on the stable field");
+		});
+	});
+});
+//#endregion