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

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

@@ -1,426 +0,0 @@
-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-E6Q5r-zU.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-BFgbdesP.js

@@ -1,60 +0,0 @@
-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-E6Q5r-zU.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