feuerwerk/tools/e2e/14-overflow.mjs

/**
 * Labels must be shortened to fit their control, not written past it. Runs last because it renames
 * assets to absurd lengths to provoke the case.
 */

/** A name far wider than a tab may grow, so a tab that does not cut it must spill. */
const LONG_NAME = 'Player movement with jumping and coyote time';

export async function overflow(t) {
  const { check, sleep, json, evaluate, shot, mutate, drag, clickText, showTab } = t;

  await mutate(`
    for (const asset of __gm.state.project.assets) {
      if (asset.type === 'behavior' || asset.type === 'texture' || asset.type === 'container')
        asset.name = ${JSON.stringify(LONG_NAME)};
    }
    __gm.state.select(null)`);
  // 14a. A document's tab shows its name, but a long one is cut instead of taking the row (#171).
  //      The three do not fit side by side at this width, so each is measured while it shows.
  const widths = [];
  for (const tab of ['graph', 'texture', 'container']) {
    await showTab(tab);
    const { active } = await json('__gm.documents()');
    const shown = (await json('__gm.tabRow()')).shown.find((b) => b.tab === active);
    widths.push(shown ? Math.round(shown.right - shown.x) : null);
  }
  await sleep(600);
  check(
    'three documents with long names each keep a tab of bounded width',
    (await json('__gm.documents()')).docs.length === 3 && widths.every((w) => w !== null && w < 300),
    JSON.stringify(widths),
  );

  // 14b. The tab row itself: a button past the centre column's edge sits under the inspector, and
  //      a click on it lands there (nine tabs on a 90 px floor did exactly that at 1280 px wide).
  await showTab('scene');
  const columnRight = async () => {
    const column = await json('__gm.viewportRect()');
    return column.x + column.w;
  };
  const spillOf = (row, right) => row.shown.filter((b) => b.right > right);
  const wide = await json('__gm.tabRow()');
  check(
    'every tab button ends inside the centre column',
    spillOf(wide, await columnRight()).length === 0,
    JSON.stringify({ spilled: spillOf(wide, await columnRight()), hidden: wide.hidden }),
  );
  // Three open documents on top of the fixed tabs no longer fit a 1280 px window.
  check(
    'at the test window’s width the row already needs its overflow, and still shows what is edited',
    wide.hidden.length > 0 && wide.shown.some((b) => b.tab === 'scene'),
    JSON.stringify({ hidden: wide.hidden, shown: wide.shown.map((b) => b.tab) }),
  );

  // 14b-ii. Narrowed until the row cannot hold nine tabs, the leftovers go behind the overflow
  //         button instead of under the inspector – the guard against the tenth tab (#84).
  const widenPanels = async (by) => {
    const bars = await json('__gm.panelSplitters()');
    await drag(bars.left.x, bars.left.y, bars.left.x + by, bars.left.y, { steps: 8 });
    const after = await json('__gm.panelSplitters()');
    await drag(after.right.x, after.right.y, after.right.x - by, after.right.y, { steps: 8 });
  };
  await widenPanels(250);
  const narrow = await json('__gm.tabRow()');
  const narrowRight = await columnRight();
  check(
    'a row too narrow for its tabs puts the leftovers away instead of past the edge',
    narrow.hidden.length > 0 && spillOf(narrow, narrowRight).length === 0,
    JSON.stringify({ hidden: narrow.hidden, spilled: spillOf(narrow, narrowRight) }),
  );
  check(
    'the tab being edited stays in the row',
    narrow.shown.some((b) => b.tab === 'scene'),
    JSON.stringify(narrow.shown.map((b) => b.tab)),
  );
  await shot('35-tab-overflow');
  // The overflow button names them, and picking one brings it into the row.
  await clickText('»');
  const offered = (await json('__gm.menuRows()')).filter(Boolean);
  const offeredIcons = (await json('__gm.menuIcons()')).filter((icon) => icon !== null);
  check(
    'the overflow button offers every tab that had to go, a document with the icon of its kind',
    offered.length === narrow.hidden.length &&
      offeredIcons.filter(Boolean).length === narrow.hidden.filter((tab) => tab.startsWith('asset:')).length,
    JSON.stringify({ offered, offeredIcons, hidden: narrow.hidden }),
  );
  const wanted = narrow.hidden[narrow.hidden.length - 1];
  const item = await t.locate(offered[offered.length - 1], true);
  await t.click(item.x, item.y);
  const picked = await json('__gm.tabRow()');
  check(
    'picking a document from the overflow menu opens it and puts it in the row',
    (await json('__gm.documents()')).active === wanted && picked.shown.some((b) => b.tab === wanted),
    JSON.stringify({ wanted, docs: await json('__gm.documents()'), shown: picked.shown.map((b) => b.tab) }),
  );
  await widenPanels(-250);
  await showTab('scene');
  const back = await json('__gm.tabRow()');
  check(
    'giving the room back brings tabs into the row again, and none past the edge',
    back.hidden.length < narrow.hidden.length && spillOf(back, await columnRight()).length === 0,
    JSON.stringify({ hidden: back.hidden, narrow: narrow.hidden }),
  );

  // 14b-iii. The divider between asset panel and scene objects moves the height from one to the
  //          other, and dragged shut either keeps its header to grab it by again.
  const column = () => json('__gm.leftColumn()');
  const near = (a, b) => Math.abs(a - b) <= 1;
  const start = await column();
  await drag(start.splitter.x, start.splitter.y, start.splitter.x, start.splitter.y + 80, { steps: 6 });
  const lower = await column();
  check(
    'dragging the left column’s divider down gives the assets 80 px the scene objects lose',
    near(lower.assets.h, start.assets.h + 80) && near(lower.objects.h, start.objects.h - 80),
    JSON.stringify({ start, lower }),
  );
  await drag(lower.splitter.x, lower.splitter.y, lower.splitter.x, lower.splitter.y - 2000, { steps: 10 });
  const shut = await column();
  check(
    'dragged all the way up the asset panel stops at its header',
    near(shut.assets.h, 30) && shut.objects.y > shut.assets.y,
    JSON.stringify(shut),
  );
  await drag(shut.splitter.x, shut.splitter.y, shut.splitter.x, start.splitter.y, { steps: 10 });
  const restored = await column();
  check(
    'and dragged back it returns to the split it started with',
    near(restored.assets.h, start.assets.h) && near(restored.objects.h, start.objects.h),
    JSON.stringify({ start, restored }),
  );

  // 14c. Every tab, because each one owns a different set of controls.
  for (const tab of ['scene', 'graph', 'texture', 'game', 'container', 'particles']) {
    await showTab(tab);
    const spills = await json('__gm.textOverflows()');
    check(
      `no label is drawn past its control in the ${tab} tab`,
      spills.length === 0,
      JSON.stringify(spills),
    );
  }

  // 14d. Shortened, not simply dropped: the value must still be readable and marked as cut.
  await showTab('graph');
  const shown = (await json('__gm.textOverflows(true)')).find((e) => e.text.startsWith('Player movement'));
  check(
    'a name too wide for its tab is cut with an ellipsis',
    Boolean(shown) && shown.text.endsWith('…') && shown.text.length > 8,
    JSON.stringify(shown),
  );
  await shot('36-long-labels');

  // 14e. An inspector full of dropdowns – the parent row and the enum fields – with a selection
  //      whose asset name is now overlong too.
  await showTab('scene');
  await evaluate("__gm.state.select({ kind: 'object', objectId: 'otex' })");
  await sleep(500);
  const inspector = await json('__gm.textOverflows()');
  check('no label spills in the inspector', inspector.length === 0, JSON.stringify(inspector));

  // 14f. The other direction: a control narrow enough to swallow its whole label draws nothing
  //      at all, which the overflow walk cannot see – an empty text spills over no edge.
  for (const tab of ['scene', 'graph', 'texture', 'container', 'particles']) {
    await showTab(tab);
    const dropped = await json('__gm.labelsDropped()');
    check(
      `no button is left without its label in the ${tab} tab`,
      dropped.length === 0,
      JSON.stringify(dropped),
    );
  }
  // The narrowest buttons in the editor sit on a behaviour's variable rows.
  await evaluate("__gm.state.select({ kind: 'asset', assetId: 'mover' })");
  const onVariables = await json('__gm.labelsDropped()');
  check(
    'the variable rows keep their buttons labelled',
    onVariables.length === 0,
    JSON.stringify(onVariables),
  );
  for (const doc of (await json('__gm.documents()')).docs)
    await evaluate(`__gm.closeDocument(${JSON.stringify(doc)})`);
}