Merge branch 'main' into samehkhamis/kit-styles

This commit is contained in:
Sameh Khamis authored and GitHub committed 2026-11-19 00:17:02 -08:00
commit c58f9fbdc6
14 files changed
+628 -38

No files matched your search

+24 -1
View File
@@ -5,6 +5,7 @@ import {
resolvePanelStackCorridor,
} from '../panelStackLayout.js';
import { measurePanelNaturalHeight } from './panelMeasurement.js';
import { bandBesideMidpointObstacles } from './panelRailGeometry.js';
import { settleSideAccordion } from './panelAccordion.js';
/**
@@ -114,10 +115,12 @@ export function layoutLeftPanelRail({
const baseTop = viewportHeight * 0.26;
const baseBottomInset = viewportHeight * 0.04;
const safeGap = viewportHeight * 0.012;
let obstacleSafeTop = viewportHeight * 0.04;
const topInset = viewportHeight * 0.04;
let obstacleSafeTop = topInset;
let safeTop = baseTop;
let safeBottom = viewportHeight - baseBottomInset;
const bottomObstacles = [];
const inLane = [];
for (const obstacle of obstacles) {
if (stack.contains(obstacle)) continue;
@@ -147,6 +150,7 @@ export function layoutLeftPanelRail({
);
if (!overlapsHorizontally) continue;
inLane.push(rect);
if (rect.top < baseTop && rect.bottom <= viewportHeight * 0.5) {
const obstacleBottom = rect.bottom + safeGap;
obstacleSafeTop = Math.max(obstacleSafeTop, obstacleBottom);
@@ -155,6 +159,25 @@ export function layoutLeftPanelRail({
bottomObstacles.push({ top: rect.top });
}
}
// Obstacles across the midpoint (common in short windows) put the panels
// on whichever side of them has more room, and the panels may use all of
// it, above the corridor's usual top too; with no room on either side the
// obstacles are read as before.
const beside = bandBesideMidpointObstacles({
midpoint: viewportHeight * 0.5,
top: topInset,
bottom: safeBottom,
obstacles: inLane,
gap: safeGap,
// A side thinner than this holds no usable panel.
minimum: viewportHeight * 0.08,
});
if (beside) {
obstacleSafeTop = beside.top;
safeTop = beside.top;
bottomObstacles.length = 0;
bottomObstacles.push({ top: beside.bottom + safeGap });
}
safeBottom = resolveLeftStackBottomBoundary({
baseBottom: safeBottom,
obstacles: bottomObstacles,
+84 -1
View File
@@ -1,6 +1,9 @@
/**
* Resolve a vertically centered panel slot inside a HUD rail while respecting
* live rectangles that intersect that rail above or below the viewport center.
* live rectangles that intersect that rail. A rectangle above the viewport
* center lowers the top and one below it raises the bottom. Rectangles across
* the center put the band beside them (bandBesideMidpointObstacles); with no
* room on either side they are left out, as before.
*/
export function resolveHudRailLayout({
viewportHeight,
@@ -29,6 +32,7 @@ export function resolveHudRailLayout({
const midpoint = viewportHeight * 0.5;
let safeTop = Math.max(0, baseTop);
let safeBottom = Math.min(viewportHeight, baseBottom);
const inLane = [];
for (const rect of obstacles) {
if (
@@ -41,10 +45,21 @@ export function resolveHudRailLayout({
rect.bottom <= rect.top
)
continue;
inLane.push(rect);
if (rect.bottom <= midpoint) safeTop = Math.max(safeTop, rect.bottom + gap);
else if (rect.top >= midpoint)
safeBottom = Math.min(safeBottom, rect.top - gap);
}
const beside = bandBesideMidpointObstacles({
midpoint,
top: Math.max(0, baseTop),
bottom: Math.min(viewportHeight, baseBottom),
obstacles: inLane,
gap,
// A side thinner than this holds no usable panel.
minimum: viewportHeight * 0.08,
});
if (beside) ({ top: safeTop, bottom: safeBottom } = beside);
safeBottom = Math.max(safeTop, safeBottom);
const availableHeight = Math.max(0, safeBottom - safeTop);
@@ -61,6 +76,74 @@ export function resolveHudRailLayout({
};
}
/**
* Where a rail's band goes when obstacles cross the viewport midpoint, as in
* short windows. Those obstacles, and any other that leaves no band between
* itself and them, form one block; the band takes whichever side of the block
* has more room between it and the next obstacle or the band's own edge,
* above on a tie.
* @param {object} input
* @param {number} input.midpoint The viewport's vertical midpoint.
* @param {number} input.top The band's highest top.
* @param {number} input.bottom The band's lowest bottom.
* @param {Array<{top: number, bottom: number}>} input.obstacles Rectangles that reach the rail.
* @param {number} input.gap Space kept between the band and an obstacle.
* @param {number} [input.minimum=0] The least room a side needs to count;
* a thinner side is no room at all.
* @returns {{side: 'above' | 'below', top: number, bottom: number} | null}
* Null when nothing crosses the midpoint or neither side has room.
*/
export function bandBesideMidpointObstacles({
midpoint,
top,
bottom,
obstacles,
gap,
minimum = 0,
}) {
const crossing = obstacles.filter(
(rect) => rect.top < midpoint && rect.bottom > midpoint,
);
if (!crossing.length) return null;
let blockTop = Math.min(...crossing.map((rect) => rect.top));
let blockBottom = Math.max(...crossing.map((rect) => rect.bottom));
for (let grown = true; grown;) {
grown = false;
for (const rect of obstacles) {
const touches =
rect.top <= blockBottom + 2 * gap && rect.bottom >= blockTop - 2 * gap;
if (touches && (rect.top < blockTop || rect.bottom > blockBottom)) {
blockTop = Math.min(blockTop, rect.top);
blockBottom = Math.max(blockBottom, rect.bottom);
grown = true;
}
}
}
let aboveTop = top;
let belowBottom = bottom;
for (const rect of obstacles) {
if (rect.bottom <= blockTop)
aboveTop = Math.max(aboveTop, rect.bottom + gap);
else if (rect.top >= blockBottom)
belowBottom = Math.min(belowBottom, rect.top - gap);
}
const above = {
side: 'above',
top: aboveTop,
bottom: Math.min(bottom, blockTop - gap),
};
const below = {
side: 'below',
top: Math.max(top, blockBottom + gap),
bottom: belowBottom,
};
const roomAbove = above.bottom - above.top;
const roomBelow = below.bottom - below.top;
const fits = (room) => room > 0 && room >= minimum;
if (roomBelow > roomAbove && fits(roomBelow)) return below;
return fits(roomAbove) ? above : null;
}
/**
* Whether the Tactical layout hid collapsed right panels beside an expanded
* one. The rail now enforces one open panel per side in every layout; this
+73
View File
@@ -219,6 +219,79 @@ test('left corridor respects a lower obstacle but ignores an obstacle hidden by
assert.equal(Number(f.stack.dataset.safeBottomPct), 65.47);
});
test('in a short window the left corridor stays clear of an obstacle across the midpoint', () => {
// 480px window, midpoint 240.
const f = fixture('left');
f.options.windowRef.innerHeight = 480;
f.options.obstacles = [element('card', { top: 100, height: 200 })];
f.run();
// More room below the card than above it: the corridor starts under it.
assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 300);
// A card starting below the corridor's usual top (26%, 124.8px) that
// crosses the midpoint counts the same way: more room below it.
f.options.obstacles = [element('card', { top: 130, height: 120 })];
f.run();
assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 250);
// More room above it: the corridor ends over it.
f.options.obstacles = [element('card', { top: 200, height: 250 })];
f.run();
assert(Number(f.stack.dataset.safeBottomPct) * 4.8 <= 200);
});
test('several cards across the midpoint give the left corridor the same room in any order', () => {
const f = fixture('left');
f.options.windowRef.innerHeight = 480;
const a = element('card', { top: 100, height: 160 });
const b = element('card', { top: 110, height: 360 });
f.options.obstacles = [a, b];
f.run();
const first = [f.stack.dataset.safeTopPct, f.stack.dataset.safeBottomPct];
f.options.obstacles = [b, a];
f.run();
assert.deepEqual(
[f.stack.dataset.safeTopPct, f.stack.dataset.safeBottomPct],
first,
);
// Together they cover 100 to 470: the corridor ends above them.
assert(Number(first[1]) * 4.8 <= 100);
});
test('the left corridor counts cards beside those across the midpoint', () => {
const f = fixture('left');
f.options.windowRef.innerHeight = 480;
// A card inside the span below the midpoint: more room below both.
f.options.obstacles = [
element('card', { top: 100, height: 200 }),
element('card', { top: 250, height: 30 }),
];
f.run();
assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 300);
// About 25px above the cards is under the least usable room (8% of the
// window): they are read as before, the upper card pushing the corridor
// down past it rather than into a sliver at the top.
f.options.obstacles = [
element('card', { top: 50, height: 150 }),
element('card', { top: 150, height: 320 }),
];
f.run();
assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 200);
// The room above a card is all the panels' to use, above the corridor's
// usual top (26%) too: 700px window, card 300 to 420, about 263px above
// against 244 below.
f.options.windowRef.innerHeight = 700;
f.options.obstacles = [element('card', { top: 300, height: 120 })];
f.run();
assert(Number(f.stack.dataset.safeBottomPct) * 7 <= 300);
assert(Number(f.stack.dataset.safeTopPct) * 7 <= 30);
// No room on either side: the card is read as before.
f.options.windowRef.innerHeight = 480;
f.options.obstacles = [element('card', { top: 0, height: 480 })];
f.run();
assert.equal(Number(f.stack.dataset.safeTopPct), 26);
});
test('a centered timeline only shortens the corridor when it reaches a laid-out panel', () => {
const f = fixture('left');
f.stack.rect.width = 360;