@cardstack/boxel-cli 0.3.2-unstable.58 → 0.3.2-unstable.60

package/bundled-test-harness/assets/create-file-test-DOc3YYij.js

@@ -0,0 +1,963 @@
+import { i as __name, s as __toESM } from "./chunk-CGdGNDIi.js";
+import { Yn as testRRI, Zn as testRealmURL, _i as baseRRI, ca as Deferred, ua as rri, vi as baseRealm } from "./runtime-common-C7uLt5dN.js";
+import { I as waitUntil, d as click, o as waitFor, s as fillIn } from "./dist-D1U_uSwt.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+import { r as getService } from "./dist-CY3T64Hs.js";
+import { D as setupAcceptanceTestRealm, F as setupUserSubscription, M as setupOnSave, N as setupRealmCacheTeardown, a as SYSTEM_CARD_FIXTURE_CONTENTS, at as setupAuthEndpoints, b as getMonacoContent, dt as percySnapshot, j as setupLocalIndexing, nt as setupApplicationTest, q as withCachedRealmSetup, t as setupMockMatrix, tt as visitOperatorMode, u as cardDefFieldCount, w as realmConfigCardJSON } from "./mock-matrix-BhFWlMMr.js";
+//#region tests/acceptance/code-submode/create-file-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var testRealmURL2 = "http://test-realm/test2/";
+var testRealmAIconURL = "https://i.postimg.cc/L8yXRvws/icon.png";
+var testPrefixRealmURL2 = `@test-realm/test2/`;
+var files = {
+	"realm.json": realmConfigCardJSON({
+		name: "Test Workspace A",
+		backgroundURL: "https://i.postimg.cc/VNvHH93M/pawel-czerwinski-Ly-ZLa-A5jti-Y-unsplash.jpg",
+		iconURL: testRealmAIconURL
+	}),
+	"index.json": { data: {
+		type: "card",
+		attributes: {},
+		meta: { adoptsFrom: {
+			module: "https://cardstack.com/base/cards-grid",
+			name: "CardsGrid"
+		} }
+	} },
+	"error.gts": `
+    import { CardDef } from 'https://cardstack.com/base/card-api';
+
+    export default class ErrorCard extends CardDef {
+      static displayName = 'error';
+
+      constructor(owner: unknown, args: any) {
+        super(owner, args);
+        throw new Error('A deliberate constructor error');
+      }
+    }
+  `,
+	"pet.gts": `
+    import { contains, linksTo, field, CardDef, Component } from "https://cardstack.com/base/card-api";
+    import StringField from "https://cardstack.com/base/string";
+
+    export default class Pet extends CardDef {
+      static displayName = 'Pet';
+      @field name = contains(StringField);
+
+      static embedded = class Embedded extends Component<typeof this> {
+        <template>
+          <span data-test-pet><@fields.name /></span>
+        </template>
+      }
+    }
+  `,
+	"person.gts": `
+    import { contains, linksTo, field, CardDef } from "https://cardstack.com/base/card-api";
+    import StringField from "https://cardstack.com/base/string";
+    import Pet from "./pet";
+
+    export class Person extends CardDef {
+      static displayName = 'Person';
+      @field firstName = contains(StringField);
+      @field lastName = contains(StringField);
+      @field pet = linksTo(Pet);
+    }
+  `,
+	"spec/error.json": { data: {
+		type: "card",
+		attributes: {
+			cardTitle: "Error",
+			cardDescription: "Spec for Error",
+			specType: "card",
+			ref: {
+				module: "../error",
+				name: "default"
+			}
+		},
+		meta: { adoptsFrom: {
+			module: "https://cardstack.com/base/spec",
+			name: "Spec"
+		} }
+	} },
+	"spec/pet.json": { data: {
+		type: "card",
+		attributes: {
+			cardTitle: "Pet",
+			cardDescription: "Spec for Pet",
+			specType: "card",
+			ref: {
+				module: `../pet`,
+				name: "default"
+			}
+		},
+		meta: { adoptsFrom: {
+			module: "https://cardstack.com/base/spec",
+			name: "Spec"
+		} }
+	} },
+	"spec/person.json": { data: {
+		type: "card",
+		attributes: {
+			cardTitle: "Person",
+			cardDescription: "Spec for Person",
+			specType: "card",
+			ref: {
+				module: `../person`,
+				name: "Person"
+			}
+		},
+		meta: { adoptsFrom: {
+			module: "https://cardstack.com/base/spec",
+			name: "Spec"
+		} }
+	} },
+	"Pet/mango.json": { data: {
+		attributes: { name: "Mango" },
+		meta: { adoptsFrom: {
+			module: `../pet`,
+			name: "default"
+		} }
+	} },
+	"fields/biginteger-field.json": { data: {
+		type: "card",
+		attributes: {
+			cardTitle: "Bigint Field",
+			cardDescription: "A field that captures big int values",
+			specType: "field",
+			ref: {
+				module: `${baseRealm.url}big-integer`,
+				name: "default"
+			}
+		},
+		meta: { adoptsFrom: {
+			module: `${baseRealm.url}spec`,
+			name: "Spec"
+		} }
+	} },
+	"fields/field.json": { data: {
+		type: "card",
+		attributes: {
+			cardTitle: "General Field",
+			cardDescription: "A FieldDef spec",
+			specType: "field",
+			ref: {
+				module: `${baseRealm.url}card-api`,
+				name: "FieldDef"
+			}
+		},
+		meta: { adoptsFrom: {
+			module: `${baseRealm.url}spec`,
+			name: "Spec"
+		} }
+	} }
+};
+var filesB = {
+	"realm.json": realmConfigCardJSON({
+		name: "Test Workspace B",
+		backgroundURL: "https://i.postimg.cc/VNvHH93M/pawel-czerwinski-Ly-ZLa-A5jti-Y-unsplash.jpg",
+		iconURL: "https://i.postimg.cc/L8yXRvws/icon.png"
+	}),
+	"index.json": { data: {
+		type: "card",
+		attributes: {},
+		meta: { adoptsFrom: {
+			module: "https://cardstack.com/base/cards-grid",
+			name: "CardsGrid"
+		} }
+	} },
+	"animal.gts": `
+    import { contains, field, CardDef } from "https://cardstack.com/base/card-api";
+    import StringField from "https://cardstack.com/base/string";
+
+    export class Animal extends CardDef {
+      static displayName = 'Animal';
+      @field name = contains(StringField);
+    }
+  `,
+	"spec/animal.json": { data: {
+		type: "card",
+		attributes: {
+			cardTitle: "Animal",
+			cardDescription: "Spec for Animal",
+			specType: "card",
+			ref: {
+				module: "@test-realm/test2/animal",
+				name: "Animal"
+			}
+		},
+		meta: { adoptsFrom: {
+			module: "https://cardstack.com/base/spec",
+			name: "Spec"
+		} }
+	} }
+};
+(0, import_qunit.module)("Acceptance | code submode | create-file tests", function(hooks) {
+	async function openNewFileModal(menuSelection, expectedRealmName = "Test Workspace A") {
+		await waitFor("[data-test-new-file-button]");
+		await click("[data-test-new-file-button]");
+		await click(`[data-test-boxel-menu-item-text="${menuSelection}"]`);
+		await waitFor(`[data-test-create-file-modal][data-test-ready] [data-test-realm-name="${expectedRealmName}"]`);
+	}
+	async function visitOperatorMode$1(codePath = `${testRealmURL}index.json`) {
+		await visitOperatorMode({
+			submode: "code",
+			codePath
+		});
+	}
+	__name(visitOperatorMode$1, "visitOperatorMode");
+	let adapter;
+	setupApplicationTest(hooks);
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	setupRealmCacheTeardown(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [
+			baseRealm.url,
+			testRealmURL,
+			testRealmURL2
+		]
+	});
+	let { setRealmPermissions, createAndJoinRoom } = mockMatrixUtils;
+	hooks.beforeEach(async function() {
+		if ((import_qunit.default.config.current?.module?.name ?? "").includes("uses a prefix-form ref")) getService("network").virtualNetwork.addRealmMapping(testPrefixRealmURL2, testRealmURL2);
+		({adapter} = await withCachedRealmSetup(async () => {
+			await setupAcceptanceTestRealm({
+				contents: {
+					...SYSTEM_CARD_FIXTURE_CONTENTS,
+					...filesB
+				},
+				realmURL: testRealmURL2,
+				mockMatrixUtils
+			});
+			return await setupAcceptanceTestRealm({
+				contents: {
+					...SYSTEM_CARD_FIXTURE_CONTENTS,
+					...files
+				},
+				mockMatrixUtils
+			});
+		}));
+		createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "room-test"
+		});
+		setupUserSubscription();
+		setupAuthEndpoints();
+		getService("network").mount(async (req) => {
+			if (req.url.includes("fetch-failure")) throw new Error("A deliberate fetch error");
+			return null;
+		}, { prepend: true });
+	});
+	(0, import_qunit.module)("when user has permissions to both test realms", function(hooks) {
+		hooks.beforeEach(async function() {
+			setRealmPermissions({
+				[baseRealm.url]: ["read"],
+				[testRealmURL]: ["read", "write"],
+				[testRealmURL2]: ["read", "write"]
+			});
+		});
+		(0, import_qunit.test)("new file button has options to create card def, field def, card instance, text files, and upload file", async function(assert) {
+			await visitOperatorMode$1();
+			await waitFor("[data-test-code-mode][data-test-save-idle]");
+			await waitFor("[data-test-new-file-button]");
+			await click("[data-test-new-file-button]");
+			assert.dom("[data-test-new-file-dropdown-menu] [data-test-boxel-menu-item-text]").exists({ count: 5 });
+			assert.dom("[data-test-new-file-dropdown-menu] [data-test-boxel-menu-item-text=\"Card Definition\"]").exists();
+			assert.dom("[data-test-new-file-dropdown-menu] [data-test-boxel-menu-item-text=\"Field Definition\"]").exists();
+			assert.dom("[data-test-new-file-dropdown-menu] [data-test-boxel-menu-item-text=\"Card Instance\"]").exists();
+			assert.dom("[data-test-new-file-dropdown-menu] [data-test-boxel-menu-item-text=\"Text File\"]").exists();
+			assert.dom("[data-test-new-file-dropdown-menu] [data-test-boxel-menu-item-text=\"Upload File…\"]").exists();
+		});
+		(0, import_qunit.test)("can create text files with txt and md extensions", async function(assert) {
+			assert.expect(4);
+			await visitOperatorMode$1();
+			let deferred = new Deferred();
+			let savedUrls = [];
+			this.onSave(async (url, content) => {
+				savedUrls.push(url.href);
+				assert.strictEqual(content, "", "text file is created empty");
+				if (savedUrls.length === 2) deferred.fulfill();
+			});
+			await openNewFileModal("Text File");
+			await fillIn("[data-test-text-file-name-field]", "notes");
+			await click("[data-test-create-text-file]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await openNewFileModal("Text File");
+			await fillIn("[data-test-text-file-name-field]", "readme");
+			await click("[data-test-text-file-extension-select]");
+			await click("[data-test-text-file-extension-option=\".md\"]");
+			await click("[data-test-create-text-file]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+			assert.ok(savedUrls.some((url) => url.endsWith("notes.txt")));
+			assert.ok(savedUrls.some((url) => url.endsWith("readme.md")));
+		});
+		(0, import_qunit.test)("can upload a file via the New menu", async function(assert) {
+			await visitOperatorMode$1();
+			await waitFor("[data-test-code-mode][data-test-save-idle]");
+			await waitFor("[data-test-new-file-button]");
+			await click("[data-test-new-file-button]");
+			getService("file-upload").__queueLocalFileBatchForTesting([new File(["hello upload"], "uploaded-via-menu.txt", { type: "text/plain" })]);
+			await click("[data-test-boxel-menu-item-text=\"Upload File…\"]");
+			await waitUntil(() => document.querySelector("[data-test-card-url-bar-input]")?.value?.includes("uploaded-via-menu.txt"), {
+				timeout: 1e4,
+				timeoutMessage: "code editor did not navigate to the uploaded file"
+			});
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${testRealmURL}uploaded-via-menu.txt`, "code editor navigated to the uploaded file");
+		});
+		(0, import_qunit.test)("can upload multiple files via the New menu", async function(assert) {
+			await visitOperatorMode$1();
+			await waitFor("[data-test-code-mode][data-test-save-idle]");
+			await click("[data-test-file-browser-toggle]");
+			await waitFor("[data-test-new-file-button]");
+			await click("[data-test-new-file-button]");
+			let fileUpload = getService("file-upload");
+			fileUpload.__queueLocalFileBatchForTesting([new File(["file one"], "multi-upload-first.txt", { type: "text/plain" }), new File(["file two"], "multi-upload-second.txt", { type: "text/plain" })]);
+			await click("[data-test-boxel-menu-item-text=\"Upload File…\"]");
+			await waitUntil(() => fileUpload.activeUploads.length === 0, {
+				timeout: 2e4,
+				timeoutMessage: "uploads did not all complete"
+			});
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${testRealmURL}multi-upload-first.txt`, "code editor navigated to the first uploaded file");
+			await waitUntil(() => document.querySelector("[data-test-file=\"multi-upload-second.txt\"]") != null, {
+				timeout: 1e4,
+				timeoutMessage: "second uploaded file did not appear in the file tree"
+			});
+			assert.dom("[data-test-file=\"multi-upload-first.txt\"]").exists("first uploaded file is shown in the file tree");
+			assert.dom("[data-test-file=\"multi-upload-second.txt\"]").exists("second uploaded file is shown in the file tree");
+		});
+		(0, import_qunit.test)("cancelling upload file picker does not cause errors", async function(assert) {
+			await visitOperatorMode$1();
+			await waitFor("[data-test-code-mode][data-test-save-idle]");
+			await waitFor("[data-test-new-file-button]");
+			await click("[data-test-new-file-button]");
+			getService("file-upload").__queueLocalFileBatchForTesting([]);
+			await click("[data-test-boxel-menu-item-text=\"Upload File…\"]");
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${testRealmURL}index.json`, "URL bar still shows the original file");
+		});
+		(0, import_qunit.test)("filename is auto-populated from display name", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await fillIn("[data-test-display-name-field]", `Très test's card 😀`);
+			assert.dom("[data-test-file-name-field]").hasValue("tres-tests-card");
+		});
+		(0, import_qunit.test)("filename stops auto-populating after user edits it", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await fillIn("[data-test-file-name-field]", "test_card");
+			await fillIn("[data-test-display-name-field]", "Très test card 😀");
+			assert.dom("[data-test-file-name-field]").hasValue("test_card");
+		});
+		(0, import_qunit.test)("can create new card-instance file in local realm with card type from same realm", async function(assert) {
+			const baseRealmIconURL = "https://boxel-images.boxel.ai/icons/cardstack.png";
+			assert.expect(13);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Instance");
+			assert.dom("[data-test-realm-name]").hasText("Test Workspace A");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			assert.dom(`[data-test-inherits-from-field] [data-test-boxel-field-label]`).hasText("Adopted From");
+			assert.dom(`[data-test-selected-type]`).hasText("General Card");
+			assert.dom(`[data-test-selected-type] [data-test-realm-icon-url]`).hasStyle({ backgroundImage: `url("${baseRealmIconURL}")` });
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-catalog-modal]");
+			await waitFor(`[data-test-card-catalog-item="${testRealmURL}spec/person"]`);
+			await click(`[data-test-card-catalog-item="${testRealmURL}spec/person"]`);
+			await click("[data-test-card-catalog-go-button]");
+			await waitFor(`[data-test-selected-type="Person"]`);
+			assert.dom(`[data-test-selected-type]`).hasText("Person");
+			assert.dom(`[data-test-selected-type] [data-test-realm-icon-url]`).hasStyle({ backgroundImage: `url("${testRealmAIconURL}")` });
+			let deferred = new Deferred();
+			let fileID = "";
+			this.onSave(async (url, json) => {
+				fileID = url.href;
+				if (typeof json === "string") throw new Error("expected JSON save data");
+				assert.strictEqual(json.data.attributes?.firstName, null, "firstName field is empty");
+				assert.strictEqual(json.data.meta.realmURL, testRealmURL, "realm url is correct");
+				assert.deepEqual(json.data.meta.adoptsFrom, {
+					module: rri("../person"),
+					name: "Person"
+				}, "adoptsFrom is correct");
+				assert.deepEqual(json.data.relationships, {
+					pet: { links: { self: null } },
+					"cardInfo.theme": { links: { self: null } }
+				}, "relationships data is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-card-instance]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await waitFor(`[data-test-code-mode-card-renderer-header="${fileID}"]`);
+			assert.dom("[data-test-card-resource-loaded]").containsText("Person");
+			assert.dom("[data-test-field=\"firstName\"] input").hasValue("");
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${fileID}.json`);
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("an error when creating a new card instance is shown", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Instance");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-catalog-modal]");
+			await waitFor(`[data-test-card-catalog-item="${testRealmURL}spec/error"]`);
+			await click(`[data-test-card-catalog-item="${testRealmURL}spec/error"]`);
+			await click("[data-test-card-catalog-go-button]");
+			await waitFor(`[data-test-selected-type="Error"]`);
+			await click("[data-test-create-card-instance]");
+			assert.dom("[data-test-error-container]").exists();
+			assert.dom("[data-test-error-type]").containsText("Error creating card instance");
+			assert.dom("[data-test-create-file-modal] [data-test-error-message]").hasText("A deliberate constructor error");
+			await click("[data-test-toggle-details]");
+			assert.dom("[data-test-error-details]").containsText("A deliberate constructor error");
+			await click("[data-test-cancel-create-file]");
+			await openNewFileModal("Card Instance");
+			assert.dom("[data-test-error-container]").doesNotExist("error is cleared");
+		});
+		(0, import_qunit.test)("can create new card-instance file in local realm with card type from a remote realm", async function(assert) {
+			assert.expect(8);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Instance");
+			assert.dom("[data-test-realm-name]").hasText("Test Workspace A");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			let deferred = new Deferred();
+			let fileURL = "";
+			this.onSave(async (url, json) => {
+				fileURL = url.href;
+				if (typeof json === "string") throw new Error("expected JSON save data");
+				assert.strictEqual(json.data.attributes?.cardTitle, "Untitled Card", "title field defaults to fallback");
+				assert.strictEqual(json.data.meta.realmURL, testRealmURL, "realm url is correct");
+				assert.deepEqual(json.data.meta.adoptsFrom, {
+					module: baseRRI("card-api"),
+					name: "CardDef"
+				}, "adoptsFrom is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-card-instance]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await waitFor("[data-test-code-mode][data-test-save-idle]");
+			await waitFor("[data-test-code-mode-card-renderer-header][data-test-card-resource-loaded]");
+			assert.dom("[data-test-code-mode-card-renderer-header] [data-test-realm-icon-url]").hasAttribute("aria-label", "Test Workspace A");
+			assert.dom("[data-test-card-resource-loaded]").containsText("Card");
+			assert.dom("[data-test-field=\"cardInfo-name\"] input").hasValue("");
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${fileURL}.json`);
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("can create new card-instance file in a remote realm with card type from another realm", async function(assert) {
+			assert.expect(8);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Instance");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			await click(`[data-test-realm-dropdown-trigger]`);
+			await waitFor("[data-test-boxel-dropdown-content] [data-test-boxel-menu-item-text=\"Test Workspace B\"]");
+			await click("[data-test-boxel-menu-item-text=\"Test Workspace B\"]");
+			await waitFor(`[data-test-realm-name="Test Workspace B"]`);
+			assert.dom("[data-test-realm-name]").hasText("Test Workspace B");
+			let deferred = new Deferred();
+			let fileID = "";
+			this.onSave(async (url, json) => {
+				fileID = url.href;
+				if (typeof json === "string") throw new Error("expected JSON save data");
+				assert.strictEqual(json.data.attributes?.cardTitle, "Untitled Card", "title field defaults to fallback");
+				assert.strictEqual(json.data.meta.realmURL, testRealmURL2, "realm url is correct");
+				assert.deepEqual(json.data.meta.adoptsFrom, {
+					module: baseRRI("card-api"),
+					name: "CardDef"
+				}, "adoptsFrom is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-card-instance]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await waitFor(`[data-test-code-mode-card-renderer-header="${fileID}"]`);
+			assert.dom("[data-test-code-mode-card-renderer-header] [data-test-realm-icon-url]").hasAttribute("aria-label", "Test Workspace B");
+			assert.dom("[data-test-card-resource-loaded]").containsText("Card");
+			assert.dom("[data-test-field=\"cardInfo-name\"] input").hasValue("");
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${fileID}.json`);
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("can create new card-instance file in a remote realm with card type from a local realm", async function(assert) {
+			assert.expect(8);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Instance");
+			await click(`[data-test-realm-dropdown-trigger]`);
+			await waitFor("[data-test-boxel-dropdown-content] [data-test-boxel-menu-item-text=\"Test Workspace B\"]");
+			await click("[data-test-boxel-menu-item-text=\"Test Workspace B\"]");
+			await waitFor(`[data-test-realm-name="Test Workspace B"]`);
+			assert.dom("[data-test-realm-name]").hasText("Test Workspace B");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-catalog-modal]");
+			await waitFor(`[data-test-card-catalog-item="${testRealmURL}spec/person"]`);
+			await click(`[data-test-card-catalog-item="${testRealmURL}spec/person"]`);
+			await click("[data-test-card-catalog-go-button]");
+			await waitFor(`[data-test-selected-type="Person"]`);
+			let deferred = new Deferred();
+			let fileID = "";
+			this.onSave(async (url, json) => {
+				fileID = url.href;
+				if (typeof json === "string") throw new Error("expected JSON save data");
+				assert.strictEqual(json.data.attributes?.firstName, null, "firstName field is empty");
+				assert.strictEqual(json.data.meta.realmURL, testRealmURL2, "realm url is correct");
+				assert.deepEqual(json.data.meta.adoptsFrom, {
+					module: testRRI("person"),
+					name: "Person"
+				}, "adoptsFrom is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-card-instance]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await waitFor(`[data-test-code-mode-card-renderer-header="${fileID}"]`);
+			assert.dom("[data-test-code-mode-card-renderer-header] [data-test-realm-icon-url]").hasAttribute("aria-label", "Test Workspace B");
+			assert.dom("[data-test-card-resource-loaded]").containsText("Person");
+			assert.dom("[data-test-field=\"firstName\"] input").hasValue("");
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${fileID}.json`);
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("can create a new card definition in different realm than inherited definition", async function(assert) {
+			assert.expect(12);
+			let expectedSrc = `
+import { CardDef } from 'https://cardstack.com/base/card-api';
+import { Component } from 'https://cardstack.com/base/card-api';
+export class TrèsTestCard extends CardDef {
+  static displayName = "Très test card 😀";
+}`.trim();
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			assert.dom("[data-test-selected-type]").hasText("General Card");
+			assert.dom("[data-test-create-definition]").isDisabled("create button is disabled");
+			await fillIn("[data-test-display-name-field]", "Très test card 😀");
+			assert.dom(`[data-test-inherits-from-field] [data-test-boxel-field-label]`).hasText("Inherits From");
+			assert.dom("[data-test-create-definition]").isEnabled("create button is enabled");
+			await fillIn("[data-test-file-name-field]", "très-test-card");
+			assert.dom("[data-test-create-definition]").isEnabled("create button is enabled");
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, expectedSrc, "the source is correct");
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			assert.strictEqual(getMonacoContent(), expectedSrc, "monaco displays the new definition");
+			await waitFor("[data-test-card-schema=\"Très test card 😀\"]");
+			assert.dom("[data-test-current-module-name]").hasText("très-test-card.gts");
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${testRealmURL}très-test-card.gts`);
+			assert.dom("[data-test-card-schema]").exists({ count: 3 }, "the card hierarchy is displayed in schema editor");
+			assert.dom("[data-test-total-fields]").containsText(`${cardDefFieldCount}`).hasAttribute("title", `${cardDefFieldCount} fields`);
+		});
+		(0, import_qunit.test)("can create a new card definition in same realm as inherited definition", async function(assert) {
+			assert.expect(1);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-catalog-modal]");
+			await waitFor(`[data-test-card-catalog-item="${testRealmURL}spec/person"]`);
+			await click(`[data-test-card-catalog-item="${testRealmURL}spec/person"]`);
+			await click("[data-test-card-catalog-go-button]");
+			await waitFor(`[data-test-selected-type="Person"]`);
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "test-card");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, `
+import { Person } from './person';
+import { Component } from 'https://cardstack.com/base/card-api';
+export class TestCard extends Person {
+  static displayName = "Test Card";
+}`.trim(), "the source is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("can create new card definition in different realm than realm of current file opened in code mode", async function(assert) {
+			let done = assert.async();
+			await visitOperatorMode$1(`${baseRealm.url}card-api.gts`);
+			await openNewFileModal("Card Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-catalog-modal]");
+			await waitFor(`[data-test-card-catalog-item="${testRealmURL}spec/person"]`);
+			await click(`[data-test-card-catalog-item="${testRealmURL}spec/person"]`);
+			await click("[data-test-card-catalog-go-button]");
+			await waitFor(`[data-test-selected-type="Person"]`);
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "test-card");
+			this.onSave((url, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(url.href, `${testRealmURL}test-card.gts`);
+				done();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+		});
+		(0, import_qunit.test)("an error when creating a new card definition is shown", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-catalog-modal]");
+			await waitFor(`[data-test-card-catalog-item="${testRealmURL}spec/person"]`);
+			await click(`[data-test-card-catalog-item="${testRealmURL}spec/person"]`);
+			await click("[data-test-card-catalog-go-button]");
+			await waitFor(`[data-test-selected-type="Person"]`);
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "test-fetch-failure-card");
+			await click("[data-test-create-definition]");
+			assert.dom("[data-test-error-container]").exists();
+			assert.dom("[data-test-error-type]").containsText("Error creating card definition");
+			assert.dom("[data-test-create-file-modal] [data-test-error-message]").hasText("A deliberate fetch error");
+			await click("[data-test-toggle-details]");
+			assert.dom("[data-test-error-details]").containsText("A deliberate fetch error");
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			assert.dom("[data-test-error-container]").doesNotExist("changing a field should clear the error");
+		});
+		(0, import_qunit.test)("modal cannot be dismissed while creation is in progress (CS-10557)", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await fillIn("[data-test-display-name-field]", "Dismiss Test Card");
+			await fillIn("[data-test-file-name-field]", "dismiss-test-card");
+			let saveDeferred = new Deferred();
+			let postIntercepted = false;
+			getService("network").mount(async (req) => {
+				if (req.method === "POST" && req.url.includes("dismiss-test-card.gts")) {
+					postIntercepted = true;
+					await saveDeferred.promise;
+				}
+				return null;
+			}, { prepend: true });
+			let createClickPromise = click("[data-test-create-definition]");
+			await waitUntil(() => postIntercepted, {
+				timeout: 1e4,
+				timeoutMessage: "Timed out waiting for save POST to be intercepted"
+			});
+			let cancelBtn = document.querySelector("[data-test-cancel-create-file]");
+			if (!cancelBtn) throw new Error("Could not find [data-test-cancel-create-file] button while creation is in progress");
+			cancelBtn.click();
+			assert.dom("[data-test-create-file-modal]").exists("modal stays open during creation");
+			this.onSave(() => {});
+			saveDeferred.fulfill();
+			await createClickPromise;
+			assert.dom("[data-test-create-file-modal]").doesNotExist("modal closes after creation completes");
+		});
+		(0, import_qunit.test)("can create a new field definition that extends field definition that uses default export", async function(assert) {
+			assert.expect(3);
+			await visitOperatorMode$1();
+			await openNewFileModal("Field Definition");
+			assert.dom("[data-test-selected-type]").hasText("General Field");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-catalog-modal]");
+			await waitFor(`[data-test-card-catalog-item="${testRealmURL}fields/biginteger-field"]`);
+			await click(`[data-test-card-catalog-item="${testRealmURL}fields/biginteger-field"]`);
+			await click("[data-test-card-catalog-go-button]");
+			assert.dom("[data-test-create-definition]").isDisabled();
+			await fillIn("[data-test-display-name-field]", "Field that extends from big int");
+			await fillIn("[data-test-file-name-field]", "big-int-v2");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, `
+import BigInteger from 'https://cardstack.com/base/big-integer';
+import { Component } from 'https://cardstack.com/base/card-api';
+export class FieldThatExtendsFromBigInt extends BigInteger {
+  static displayName = "Field that extends from big int";
+}`.trim(), "the source is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("an error when creating a new field definition is shown", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Field Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-catalog-modal]");
+			await waitFor(`[data-test-card-catalog-item="${testRealmURL}fields/biginteger-field"]`);
+			await click(`[data-test-card-catalog-item="${testRealmURL}fields/biginteger-field"]`);
+			await click("[data-test-card-catalog-go-button]");
+			await fillIn("[data-test-display-name-field]", "Field that will not save");
+			await fillIn("[data-test-file-name-field]", "test-fetch-failure-card");
+			await click("[data-test-create-definition]");
+			assert.dom("[data-test-error-type]").containsText("Error creating field definition");
+			assert.dom("[data-test-create-file-modal] [data-test-error-message]").hasText("A deliberate fetch error");
+			await click("[data-test-toggle-details]");
+			assert.dom("[data-test-error-details]").containsText("A deliberate fetch error");
+		});
+		(0, import_qunit.test)("can create a new definition that extends card definition which uses default export", async function(assert) {
+			assert.expect(1);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-catalog-modal]");
+			await waitFor(`[data-test-card-catalog-item="${testRealmURL}spec/pet"]`);
+			await click(`[data-test-card-catalog-item="${testRealmURL}spec/pet"]`);
+			await click("[data-test-card-catalog-go-button]");
+			await waitFor(`[data-test-selected-type="Pet"]`);
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "test-card");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, `
+import Pet from './pet';
+import { Component } from 'https://cardstack.com/base/card-api';
+export class TestCard extends Pet {
+  static displayName = "Test Card";
+}`.trim(), "the source is correct");
+				deferred.fulfill();
+			});
+			await percySnapshot(assert);
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("can reconcile a classname collision with the selected name of extending a card definition which uses a default export", async function(assert) {
+			assert.expect(1);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-catalog-modal]");
+			await waitFor(`[data-test-card-catalog-item="${testRealmURL}spec/pet"]`);
+			await click(`[data-test-card-catalog-item="${testRealmURL}spec/pet"]`);
+			await click("[data-test-card-catalog-go-button]");
+			await waitFor(`[data-test-selected-type="Pet"]`);
+			await fillIn("[data-test-display-name-field]", "Pet");
+			await fillIn("[data-test-file-name-field]", "test-card");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, `
+import PetParent from './pet';
+import { Component } from 'https://cardstack.com/base/card-api';
+export class Pet extends PetParent {
+  static displayName = "Pet";
+}`.trim(), "the source is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("can reconcile a classname collision with a javascript builtin object", async function(assert) {
+			assert.expect(1);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-catalog-modal]");
+			await waitFor(`[data-test-card-catalog-item="${testRealmURL}spec/pet"]`);
+			await click(`[data-test-card-catalog-item="${testRealmURL}spec/pet"]`);
+			await click("[data-test-card-catalog-go-button]");
+			await waitFor(`[data-test-selected-type="Pet"]`);
+			await fillIn("[data-test-display-name-field]", "Map");
+			await fillIn("[data-test-file-name-field]", "test-card");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, `
+import Pet from './pet';
+import { Component } from 'https://cardstack.com/base/card-api';
+export class Map0 extends Pet {
+  static displayName = "Map";
+}`.trim(), "the source is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("can specify new directory as part of filename when creating a new definition", async function(assert) {
+			assert.expect(2);
+			let expectedSrc = `
+import { CardDef } from 'https://cardstack.com/base/card-api';
+import { Component } from 'https://cardstack.com/base/card-api';
+export class TestCard extends CardDef {
+  static displayName = "Test Card";
+}`.trim();
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "test-dir/test-card");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, expectedSrc, "the source is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+			let file = await adapter.openFile("test-dir/test-card.gts");
+			assert.strictEqual(file?.content, expectedSrc, "the source exists at the correct location");
+		});
+		(0, import_qunit.test)("can handle filename with .gts extension in filename when creating a new definition", async function(assert) {
+			assert.expect(2);
+			let expectedSrc = `
+import { CardDef } from 'https://cardstack.com/base/card-api';
+import { Component } from 'https://cardstack.com/base/card-api';
+export class TestCard extends CardDef {
+  static displayName = "Test Card";
+}`.trim();
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "test-card.gts");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, expectedSrc, "the source is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+			let file = await adapter.openFile("test-card.gts");
+			assert.strictEqual(file?.content, expectedSrc, "the source exists at the correct location");
+		});
+		(0, import_qunit.test)("can handle leading \"/\" in filename when creating a new definition", async function(assert) {
+			assert.expect(2);
+			let expectedSrc = `
+import { CardDef } from 'https://cardstack.com/base/card-api';
+import { Component } from 'https://cardstack.com/base/card-api';
+export class TestCard extends CardDef {
+  static displayName = "Test Card";
+}`.trim();
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "/test-card");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, expectedSrc, "the source is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+			let file = await adapter.openFile("test-card.gts");
+			assert.strictEqual(file?.content, expectedSrc, "the source exists at the correct location");
+		});
+	});
+	(0, import_qunit.module)("when a selected spec uses a prefix-form ref", function() {
+		(0, import_qunit.test)("can create new card definition in workspace A that extends a card from workspace B via prefix-form ref", async function(assert) {
+			assert.expect(2);
+			await visitOperatorMode$1(`${baseRealm.url}card-api.gts`);
+			await openNewFileModal("Card Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-catalog-modal]");
+			await waitFor(`[data-test-card-catalog-item="${testRealmURL2}spec/animal"]`);
+			await click(`[data-test-card-catalog-item="${testRealmURL2}spec/animal"]`);
+			await click("[data-test-card-catalog-go-button]");
+			await waitFor(`[data-test-selected-type="Animal"]`);
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "test-card");
+			let deferred = new Deferred();
+			this.onSave((url, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, `
+import { Animal } from '${testRealmURL2}animal';
+import { Component } from 'https://cardstack.com/base/card-api';
+export class TestCard extends Animal {
+  static displayName = "Test Card";
+}`.trim(), "The source uses the resolved absolute module URL");
+				assert.strictEqual(url.href, `${testRealmURL}test-card.gts`, [
+					"Saved file URL should point to Test Workspace A",
+					`Expected: ${testRealmURL}test-card.gts`,
+					`Actual: ${url.href}`
+				].join("\n"));
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+		});
+	});
+	(0, import_qunit.module)("when the user lacks write permissions in remote realm", function(hooks) {
+		async function assertRealmDropDownIsCorrect(assert) {
+			await click(`[data-test-realm-dropdown-trigger]`);
+			await waitFor("[data-test-boxel-dropdown-content] [data-test-boxel-menu-item-text=\"Test Workspace A\"]");
+			assert.dom("[data-test-selected-realm]").containsText("Test Workspace A");
+			let menuItems = document.querySelector("[data-test-realm-dropdown-menu]").textContent.replace(/^\s*/gm, "").trim().split("\n");
+			assert.deepEqual(menuItems, ["Test Workspace A"], "the realm dropdown list is correct");
+		}
+		hooks.beforeEach(async function() {
+			setRealmPermissions({
+				[baseRealm.url]: ["read"],
+				[testRealmURL2]: ["read"],
+				[testRealmURL]: ["read", "write"]
+			});
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when creating card definition", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when creating card instance", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Instance");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when duplicating card instance", async function(assert) {
+			await visitOperatorMode$1(`${testRealmURL}Pet/mango.json`);
+			await waitFor(`[data-test-action-button="Duplicate"]`);
+			await click("[data-test-action-button=\"Duplicate\"]");
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when inheriting card definition", async function(assert) {
+			await visitOperatorMode$1(`${testRealmURL}pet.gts`);
+			await waitFor(`[data-test-action-button="Inherit"]`);
+			await click("[data-test-action-button=\"Inherit\"]");
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when creating instance of card definition", async function(assert) {
+			await visitOperatorMode$1(`${testRealmURL}pet.gts`);
+			await waitFor(`[data-test-action-button="Create Instance"]`);
+			await click("[data-test-action-button=\"Create Instance\"]");
+			await assertRealmDropDownIsCorrect(assert);
+		});
+	});
+	(0, import_qunit.module)("when the user lacks write permissions in local realm", function(hooks) {
+		async function assertRealmDropDownIsCorrect(assert) {
+			await click(`[data-test-realm-dropdown-trigger]`);
+			await waitFor("[data-test-boxel-dropdown-content] [data-test-boxel-menu-item-text=\"Test Workspace B\"]");
+			assert.dom("[data-test-selected-realm]").containsText("Test Workspace B");
+			let menuItems = document.querySelector("[data-test-realm-dropdown-menu]").textContent.replace(/^\s*/gm, "").trim().split("\n");
+			assert.deepEqual(menuItems, ["Test Workspace B"], "the realm dropdown list is correct");
+		}
+		hooks.beforeEach(async function() {
+			setRealmPermissions({
+				[baseRealm.url]: ["read"],
+				[testRealmURL2]: ["read", "write"],
+				[testRealmURL]: ["read"]
+			});
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when creating card definition", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition", "Test Workspace B");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when creating card instance", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Instance", "Test Workspace B");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when duplicating card instance", async function(assert) {
+			await visitOperatorMode$1(`${testRealmURL}Pet/mango.json`);
+			await waitFor(`[data-test-action-button="Duplicate"]`);
+			await click("[data-test-action-button=\"Duplicate\"]");
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when inheriting card definition", async function(assert) {
+			await visitOperatorMode$1(`${testRealmURL}pet.gts`);
+			await waitFor(`[data-test-action-button="Inherit"]`);
+			await click("[data-test-action-button=\"Inherit\"]");
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when creating instance of card definition", async function(assert) {
+			await visitOperatorMode$1(`${testRealmURL}pet.gts`);
+			await waitFor(`[data-test-action-button="Create Instance"]`);
+			await click("[data-test-action-button=\"Create Instance\"]");
+			await assertRealmDropDownIsCorrect(assert);
+		});
+	});
+});
+//#endregion