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

package/bundled-test-harness/assets/choreo-gallery-hang-test-BqJLmeFF.js

@@ -0,0 +1,426 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { T as settled } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { t as animationsSettled } from "./test-support-BOFeeYuE.js";
+import { a as setupChoreoGalleryTest, l as trigger, o as setupStageViewport, r as frames, s as sleep, t as $ } from "./choreo-gallery-stage-DcKKsdcu.js";
+//#region tests/integration/choreo-gallery-hang-test.gts
+/**
+* Hang's argument, asserted: a throw is READ, and the reading is what puts
+* the puck where it lands.
+*
+* The rules themselves are covered without a DOM in the second module below.
+* What can only be checked against the stage is the join — that the release velocity Motion reports
+* actually reaches the projection, and that the shooting-area WALL does its
+* job of making the drag useless on its own. If a change ever breaks the
+* join, these fail while every rule test still passes.
+*/ var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var gallery;
+var Hang;
+var RUNWAY;
+var hang;
+var SHOT = "[data-test-shot]";
+var lane = () => $(".hang-lane").getBoundingClientRect();
+var pucks = () => document.querySelectorAll(".hang-lane > .hang-puck");
+var seat = () => parseFloat(pucks()[0].style.left) / 100;
+var note = () => $(".hang-note").textContent.trim();
+/**
+* Press on the puck in the pen, after whatever the last throw or rack set
+* moving has finished: a re-keyed cradle puck can still be leaving while its
+* replacement arrives, and a press on the leaving one starts no throw at all.
+* A Choreo flight advances by a capped step per frame, so on a starved
+* machine it takes longer than its authored length — the settle is given
+* room for that rather than the default.
+*
+* `trigger` measures its x/y from the element's CURRENT top-left, and the
+* element moves under the drag, so every throw here goes through `init` with
+* absolute clientX instead — and starts and ends at the same two points, so
+* the only variable between two throws is how fast the hand was going.
+*/
+async function press() {
+	await animationsSettled({ timeout: 15e3 });
+	const el = $(SHOT);
+	const r = el.getBoundingClientRect();
+	const y = r.top + r.height / 2;
+	const from = r.left + r.width / 2;
+	const to = lane().left + lane().width * (RUNWAY - .02);
+	const trace = traceDrag();
+	trace.mark(`down(shots=${document.querySelectorAll(SHOT).length})`);
+	trigger(el, "pointerdown", 0, 0, {
+		clientX: from,
+		clientY: y
+	});
+	const at = (clientX) => ({
+		clientX,
+		clientY: y
+	});
+	return {
+		el,
+		from,
+		to,
+		at,
+		trace
+	};
+}
+/**
+* `onDragEnd` is dispatched on Motion's frameloop rather than in the pointerup
+* handler — and `settled()` knows nothing about that loop. So every release is
+* followed by real frames, or the assertion would read the board from before
+* the throw landed.
+*/
+async function release({ el, to, at, trace }) {
+	trigger(el, "pointerup", 0, 0, at(to));
+	trace.mark("up");
+	await frames(3);
+	await settled();
+	return trace.stop();
+}
+/**
+* A fast throw: the hand is pressed and still, then crosses the whole drag
+* and lets go in the same instant.
+*
+* Motion reads a release from the pointer samples of the last 100ms, and once
+* a drag is under way it takes one EVERY frame — a pointer that has not moved
+* still lays down a sample where it is. So a throw paced by timers measures
+* the machine: under load a frame can land between the last move and the
+* lift, and a hand that was still for 100ms before letting go threw nothing.
+* Here the final move and the lift go out in one task, so no frame can fall
+* between them, and the velocity is the whole drag over a little more than
+* the 100ms window — fast unless a single frame stalls for most of a second
+* just before the lift, which the trace shows as a large jump in ms with no
+* jump in frames between `nudge` and `move`.
+*
+* The opening nudge takes the pointer past Motion's 3px start threshold, so
+* the drag is live and sampling while the hand waits out that window.
+*/
+async function flick() {
+	const shot = await press();
+	trigger(shot.el, "pointermove", 0, 0, shot.at(shot.from + 4));
+	shot.trace.mark("nudge");
+	await frames(1);
+	await sleep(120);
+	trigger(shot.el, "pointermove", 0, 0, shot.at(shot.to));
+	shot.trace.mark("move");
+	return release(shot);
+}
+/**
+* A slow push over the same drag: `steps` moves `ms` apart in all, and the
+* hand comes to rest at the wall before it lets go.
+*/
+async function push(ms, steps = 6) {
+	const shot = await press();
+	for (let i = 1; i <= steps; i++) {
+		trigger(shot.el, "pointermove", 0, 0, shot.at(shot.from + (shot.to - shot.from) * i / steps));
+		shot.trace.mark(`move${i}`);
+		await sleep(ms / steps);
+	}
+	return release(shot);
+}
+/**
+* When each pointer event went out, and how many animation frames had run by
+* then. A failing comparison prints it, so the next reader can tell a throw
+* the machine stretched from one the stage misread.
+*/
+function traceDrag() {
+	const start = performance.now();
+	let ticks = 0;
+	let running = true;
+	const tick = () => {
+		ticks++;
+		if (running) requestAnimationFrame(tick);
+	};
+	requestAnimationFrame(tick);
+	const marks = [];
+	return {
+		mark(name) {
+			marks.push(`${name}@${Math.round(performance.now() - start)}ms/f${ticks}`);
+		},
+		stop() {
+			running = false;
+			return marks.join(" ");
+		}
+	};
+}
+/** what the stage said about the throw it just read, and how it was paced */
+function report(trace) {
+	return `speed="${$(".hang-speed").textContent.trim()}" note="${note()}" pucks=${pucks().length} [${trace}]`;
+}
+/**
+* Where the throw ended up, on one scale, so two throws can be compared
+* whatever became of them: the seat if it is on the board, the wall if it
+* never left the pen, and past the far edge if it was thrown away. The two
+* ways to end up with an empty board are opposite ends of the same axis, and
+* a test that folded them together would call a gutter shot a dud.
+*/
+function outcome() {
+	if (pucks().length) return seat();
+	return note().startsWith("too soft") ? RUNWAY : 1.2;
+}
+async function takeShot(throwIt) {
+	const trace = await throwIt();
+	return {
+		rest: outcome(),
+		speed: parseInt($(".hang-speed").textContent.trim(), 10) || 0,
+		report: report(trace)
+	};
+}
+(0, import_qunit.module)("Integration | Choreo gallery | hang", function(hooks) {
+	gallery = setupChoreoGalleryTest(hooks);
+	setupStageViewport(hooks);
+	hooks.beforeEach(async function() {
+		hang = await gallery.import("stages/hang");
+		Hang = hang.Hang;
+		RUNWAY = hang.RUNWAY;
+	});
+	(0, import_qunit.test)("a flick carries the puck out of the pen under its own speed", async function(assert) {
+		await gallery.renderStage(Hang);
+		assert.strictEqual(pucks().length, 0, "the board starts empty");
+		const trace = await flick();
+		/**
+		* How FAR it went is a function of the machine's frame pacing and is
+		* not this test's business — the claim is only that a flick gets the puck
+		* out of a pen the drag itself cannot leave. Whether it stopped in a band
+		* or carried into the gutter, the coast is what took it there.
+		*/
+		assert.ok(outcome() > RUNWAY, `it left the pen under its own speed: ${report(trace)}`);
+		assert.strictEqual($(".hang-tally").textContent.trim(), "1/8", "and the throw was spent");
+	});
+	(0, import_qunit.test)("the speed is what carries it, not the distance dragged", async function(assert) {
+		await gallery.renderStage(Hang);
+		/**
+		* Two identical drags — same start, same release point — at two speeds.
+		* The only variable between them is how fast the hand was moving when it
+		* let go, which is the whole claim the stage makes.
+		*
+		* The assertion is made against the velocity the component actually
+		* REPORTS rather than against the pacing that produced it: a
+		* `setTimeout(5)` in a busy CI browser is not five milliseconds, and a
+		* test that assumed it was would be measuring the machine, not the code.
+		*/
+		const quick = await takeShot(flick);
+		$(".chip").click();
+		await settled();
+		const gentle = await takeShot(() => push(1200));
+		assert.ok(quick.speed > gentle.speed, `the first throw was the faster one (${quick.speed} vs ${gentle.speed} px/s) — quick: ${quick.report}; gentle: ${gentle.report}`);
+		assert.ok(quick.rest > gentle.rest + .05, `and it rested further along (${quick.rest.toFixed(3)} vs ${gentle.rest.toFixed(3)}) — quick: ${quick.report}; gentle: ${gentle.report}`);
+	});
+	(0, import_qunit.test)("a throw too soft to leave the pen comes back, and costs nothing", async function(assert) {
+		await gallery.renderStage(Hang);
+		/** slow enough that the projection never clears the wall */
+		await push(2400);
+		assert.strictEqual(pucks().length, 0, "nothing reached the board");
+		assert.ok(note().startsWith("too soft"), `the note says so: "${note()}"`);
+		assert.strictEqual($(".hang-tally").textContent.trim(), "0/8", "and the throw is still to come — a dud is not a penalty");
+		assert.ok($(SHOT), "the puck is back in the pen, ready to throw again");
+	});
+	(0, import_qunit.test)("the aim preview names the same landing the throw produces", async function(assert) {
+		await gallery.renderStage(Hang);
+		const el = $(SHOT);
+		const r = el.getBoundingClientRect();
+		const y = r.top + r.height / 2;
+		const from = r.left + r.width / 2;
+		const to = lane().left + lane().width * (RUNWAY - .02);
+		/**
+		* DRIVEN ON FRAMES, NOT ON A TIMER — and the reason is a burst, not a lag.
+		*
+		* Both halves of the claim read Motion's WINDOWED velocity: `aim` previews
+		* it from the frameloop, `onDragEnd` takes it at release. So the assertion
+		* is only ever as good as the samples those two share, and a drag paced by
+		* `setTimeout` does not control that.
+		*
+		* A drag paced by timers lets the last moves bunch up under load and
+		* fire almost together: a large displacement over a tiny real interval,
+		* which is a velocity spike at the exact moment of release, after the
+		* ghost's last frame previewed an ordinary throw.
+		*
+		* One frame per move makes bunching impossible: every sample is separated
+		* by a real frame, so the windowed velocity is built from the same six
+		* moves at the same spacing on every machine, however busy it is. The
+		* release then goes out in the SAME TASK as the reading below, which
+		* removes the last interval that load could stretch.
+		*/
+		trigger(el, "pointerdown", 0, 0, {
+			clientX: from,
+			clientY: y
+		});
+		await frames(1);
+		const STEPS = 6;
+		for (let i = 1; i <= STEPS; i++) {
+			trigger(el, "pointermove", 0, 0, {
+				clientX: from + (to - from) * i / STEPS,
+				clientY: y
+			});
+			await frames(1);
+		}
+		const ghost = $(".hang-ghost");
+		const called = ghost.dataset["call"];
+		/** the raw projection, not the clamped paint position */
+		const previewed = parseFloat(ghost.dataset["at"] || "0");
+		trigger(el, "pointerup", 0, 0, {
+			clientX: to,
+			clientY: y
+		});
+		assert.ok(called, `the ghost was showing a landing: "${called}"`);
+		await frames(3);
+		await settled();
+		assert.strictEqual(ghost.dataset["call"], void 0, "and it is gone the moment the finger lifts");
+		/**
+		* Compared as POSITIONS rather than as band names. `onDrag` is dispatched
+		* a frame behind the pointer, so a hand that is still accelerating gets
+		* previewed slightly slow — near a band edge the name can flip while the
+		* number barely moves. The honest claim is that the ghost is the throw
+		* asked early, accurate to about a band, and that is what is asserted.
+		*/
+		const OVER = 1.05;
+		const landed = pucks().length ? seat() : note().startsWith("too soft") ? RUNWAY : OVER;
+		assert.ok(Math.abs(Math.min(previewed, OVER) - landed) < .15, `the puck landed near where the ghost said (${landed.toFixed(3)} vs ${previewed.toFixed(3)}, "${called}")`);
+	});
+});
+/**
+* Hang's rules, which are the part of a game that has to be right before any
+* of it is worth animating.
+*
+* The stage's whole claim is that a throw is READ and a resting place is
+* RESOLVED from it, with the flight authored afterwards. That makes the rules
+* pure functions over a board, and it makes them testable without a DOM.
+*/
+var red = (id, x) => ({
+	id,
+	side: "red",
+	x
+});
+var blue = (id, x) => ({
+	id,
+	side: "blue",
+	x
+});
+/** one puck across a 660px lane — the gap every collision is measured against */
+var GAP;
+var at = (r, id) => r.pucks.find((p) => p.id === id).x;
+(0, import_qunit.module)("Integration | Choreo gallery | hang rules", function(hooks) {
+	let gallery = setupChoreoGalleryTest(hooks);
+	hooks.beforeEach(async function() {
+		hang = await gallery.import("stages/hang");
+		RUNWAY = hang.RUNWAY;
+		GAP = hang.PUCK / 660;
+	});
+	(0, import_qunit.test)("the projection and the flight are the same physics", function(assert) {
+		/**
+		* An overdamped spring decays over damping/stiffness; a puck released at
+		* v under exponential decay travels v·τ. If these two numbers ever come
+		* apart, the puck lies about how hard it was thrown — it coasts past and
+		* is hauled back, or it arrives early and creeps the last inch. This is
+		* the assertion that stops someone retuning SLIDE and leaving COAST.
+		*/
+		assert.strictEqual(hang.COAST, 28 / 100, "the shipped default");
+		/**
+		* The stage's spring is now live off a dial, so the constant is only the
+		* starting point — what has to hold for EVERY value the slider can reach
+		* is the relationship, which is what `coastOf` is.
+		*/
+		assert.strictEqual(hang.coastOf({
+			damping: 40,
+			stiffness: 100
+		}), .4);
+		assert.strictEqual(hang.coastOf({
+			damping: 10,
+			stiffness: 200
+		}), .05);
+	});
+	(0, import_qunit.test)("a zone is the band a puck rests in, and short of the first is nothing", function(assert) {
+		assert.strictEqual(hang.scoreOf(.1), 0, "behind everything");
+		assert.strictEqual(hang.scoreOf(.43), 0, "a hair short of the 1");
+		assert.strictEqual(hang.scoreOf(.44), 1, "exactly on the line is in");
+		assert.strictEqual(hang.scoreOf(.7), 2);
+		assert.strictEqual(hang.scoreOf(.85), 3);
+		assert.strictEqual(hang.scoreOf(.96), 4, "the hang");
+		assert.strictEqual(hang.scoreOf(1), 4, "still on the board at the very edge");
+	});
+	(0, import_qunit.test)("a throw that hits nothing moves nothing", function(assert) {
+		const board = [red(0, .4), blue(1, .9)];
+		const r = hang.settle(board, red(2, .65), GAP);
+		assert.deepEqual(r.pucks.map((p) => p.x), [
+			.4,
+			.65,
+			.9
+		], "three pucks, none disturbed");
+		assert.strictEqual(r.off.length, 0);
+	});
+	(0, import_qunit.test)("an arrival shoves what it lands on exactly clear", function(assert) {
+		const r = hang.settle([blue(1, .7)], red(2, .68), GAP);
+		assert.strictEqual(at(r, 2), .68, "the arrival keeps its place");
+		assert.ok(Math.abs(at(r, 1) - (.68 + GAP)) < 1e-9, "the puck it hit is pushed to exactly one puck clear");
+	});
+	(0, import_qunit.test)("a shove passes down the line", function(assert) {
+		/** three touching pucks: the arrival should move all three, not one */ const board = [
+			blue(1, .7),
+			red(2, .7 + GAP),
+			blue(3, .7 + GAP * 2)
+		];
+		const r = hang.settle(board, red(4, .69), GAP);
+		assert.ok(at(r, 1) > .7, "the first was hit");
+		assert.ok(at(r, 2) > .7 + GAP, "and passed it on");
+		assert.ok(at(r, 3) > .7 + GAP * 2, "and so did the second");
+		assert.ok(Math.abs(at(r, 3) - at(r, 2) - GAP) < 1e-9, "the chain comes to rest exactly touching, not overlapping");
+	});
+	(0, import_qunit.test)("a puck shoved past the far end leaves the board", function(assert) {
+		const r = hang.settle([blue(1, .99)], red(2, .98), GAP);
+		assert.deepEqual(r.off.map((p) => p.id), [1], "the one that was already hanging goes over");
+		assert.deepEqual(r.pucks.map((p) => p.id), [2], "and the thrower takes its place");
+	});
+	(0, import_qunit.test)("only one colour scores, and only ahead of the other", function(assert) {
+		/**
+		* Red is further along, so blue scores nothing at all — not even for the
+		* puck it has sitting in the 3. This is the rule that makes a board worth
+		* building: every throw re-reads the whole thing.
+		*/
+		const board = [
+			red(0, .96),
+			red(1, .85),
+			blue(2, .84),
+			blue(3, .5)
+		];
+		const s = hang.standing(board);
+		assert.strictEqual(s.lead, "red");
+		assert.strictEqual(s.score, 7, "the hang (4) and the 3, and nothing else");
+	});
+	(0, import_qunit.test)("a puck behind the opponent's best does not count", function(assert) {
+		const s = hang.standing([
+			red(0, .85),
+			red(1, .5),
+			blue(2, .7)
+		]);
+		assert.strictEqual(s.lead, "red");
+		assert.strictEqual(s.score, 3, "the 3 counts; the 1 is behind blue");
+	});
+	(0, import_qunit.test)("a knock can hand the round over", function(assert) {
+		const before = hang.standing([red(0, .9), blue(1, .86)]);
+		assert.strictEqual(before.lead, "red", "red leads by four hundredths");
+		/** blue throws short and shoves red's puck clean off the end */
+		const r = hang.settle([red(0, .99), blue(1, .86)], blue(2, .98), GAP);
+		const after = hang.standing(r.pucks);
+		assert.deepEqual(r.off.map((p) => p.side), ["red"]);
+		assert.strictEqual(after.lead, "blue", "and takes the lead with it");
+	});
+	(0, import_qunit.test)("an empty board is tied and scores nothing", function(assert) {
+		const s = hang.standing([]);
+		assert.strictEqual(s.lead, null);
+		assert.strictEqual(s.score, 0);
+	});
+	(0, import_qunit.test)("the preview calls the same landing the score does", function(assert) {
+		/**
+		* The ghost is the throw asked early, so whatever it names has to be the
+		* name the board would give the same fraction. The two ends are the ones
+		* worth pinning: below the wall is a dud, past the far edge is the gutter.
+		*/
+		assert.strictEqual(hang.callIt(RUNWAY - .01), "too soft");
+		assert.strictEqual(hang.callIt(1.02), "off the end");
+		assert.strictEqual(hang.callIt(.4), "short", "past the wall, short of the 1");
+		assert.strictEqual(hang.callIt(.7), "2");
+		assert.strictEqual(hang.callIt(.96), "the hang");
+	});
+	(0, import_qunit.test)("the first scoring band is where the lede says it is", function(assert) {
+		assert.strictEqual(hang.ZONES[0].from, .44);
+		assert.strictEqual(hang.ZONES.at(-1).score, 4, "the hang is worth four");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/choreo-gallery-highlight-test-B1Q7-ICm.js

@@ -0,0 +1,60 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { t as choreoGalleryContents } from "./choreo-gallery-DZm1KZ20.js";
+import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-DcKKsdcu.js";
+//#region tests/integration/choreo-gallery-highlight-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var highlightSample;
+var html = (source) => highlightSample(source).toString();
+/** the text of every span with the given class */
+function spans(source, cls) {
+	const el = document.createElement("div");
+	el.innerHTML = html(source);
+	return [...el.querySelectorAll(`.syn-${cls}`)].map((s) => s.textContent ?? "");
+}
+/** every demo instance in the gallery realm, with its usage example */
+function demoSamples() {
+	return Object.entries(choreoGalleryContents()).filter(([path]) => /^demos\/[^/]+\.json$/.test(path)).map(([, source]) => {
+		let { attributes } = JSON.parse(source).data;
+		return {
+			slug: attributes.slug,
+			sample: attributes.sample ?? ""
+		};
+	});
+}
+(0, import_qunit.module)("Integration | Choreo gallery | highlight", function(hooks) {
+	let gallery = setupChoreoGalleryTest(hooks);
+	hooks.beforeEach(async function() {
+		({highlightSample} = await gallery.import("lib/highlight"));
+	});
+	(0, import_qunit.test)("an apostrophe in prose does not open a string", function(assert) {
+		const source = [
+			"<:gate as |f|>…the door, in the film's own type…</:gate>",
+			"",
+			"{ id: 'gaudi', ch: 2 }"
+		].join("\n");
+		assert.deepEqual(spans(source, "string"), ["'gaudi'"], "the only string is the real one; the apostrophe is punctuation");
+	});
+	(0, import_qunit.test)("a string still closes on its own line", function(assert) {
+		assert.deepEqual(spans("vo: 'On the seventh of June 1926.'", "string"), ["'On the seventh of June 1926.'"], "and it is one span, not one per word");
+	});
+	(0, import_qunit.test)("a quote that never closes is punctuation, not the rest of the file", function(assert) {
+		const source = "// the fan's incline\nconst k = 2;";
+		assert.deepEqual(spans(source, "string"), [], "no string at all");
+		assert.true(html(source).includes("const"), "and the code after it is still tokenised");
+	});
+	(0, import_qunit.test)("a named block is a tag", function(assert) {
+		const tags = spans("<:gate as |f|>hi</:gate>", "tag");
+		assert.true(tags.length > 0, `<:gate> is read as a tag rather than loose atoms (${tags.join("|")})`);
+	});
+	(0, import_qunit.test)("every demo sample highlights without a runaway string", async function(assert) {
+		const samples = demoSamples();
+		assert.true(samples.length > 40, `read ${samples.length} demo samples`);
+		const runaway = samples.map((demo) => ({
+			id: demo.slug,
+			longest: Math.max(0, ...spans(demo.sample, "string").map((s) => s.length))
+		})).filter((row) => row.longest > 120);
+		assert.deepEqual(runaway.map((r) => `${r.id} (${r.longest})`), [], "no sample has a string span that ran past its line");
+	});
+});
+//#endregion