malice

import assert from 'node:assert/strict';

import { test } from 'node:test';

import { BackStack, type HistoryLike } from '../src/lib/back-stack.ts';

class FakeHistory implements HistoryLike {

  entries: unknown[] = [{ roomId: 'a' }];

  index = 0;

  onPop: (state: unknown) => void = () => undefined;

  get state(): unknown {

    return this.entries[this.index];

  }

  pushState(state: unknown): void {

    this.entries.splice(this.index + 1, Infinity, state);

    this.index++;

  }

  replaceState(state: unknown): void {

    this.entries[this.index] = state;

  }

  back(): void {

    if (this.index === 0) return;

    this.index--;

    queueMicrotask(() => this.onPop(this.state));

  }

}

function setup() {

  const history = new FakeHistory();

  const stack = new BackStack(history);

  const routed: unknown[] = [];

  history.onPop = (state) => {

    if (!stack.pop(state)) routed.push(state);

  };

  return { history, stack, routed };

}

const tick = () => new Promise((resolve) => setTimeout(resolve, 0));

test('opening a layer adds one entry and back closes it', async () => {

  const { history, stack, routed } = setup();

  let open = true;

  stack.sync('card', true, () => (open = false));

  assert.equal(history.entries.length, 2);

  history.back();

  await tick();

  assert.equal(open, false);

  assert.equal(history.index, 0);

  assert.deepEqual(routed, []);

});

test('closing through the UI pops its entry and swallows the popstate', async () => {

  const { history, stack, routed } = setup();

  stack.sync('card', true, () => undefined);

  stack.sync('card', false, () => undefined);

  await tick();

  assert.equal(history.index, 0);

  assert.deepEqual(routed, []);

  assert.equal(stack.depth, 0);

});

test('back closes only the topmost of several layers', async () => {

  const { history, stack } = setup();

  const closed: string[] = [];

  stack.sync('drawer', true, () => closed.push('drawer'));

  stack.sync('card', true, () => closed.push('card'));

  history.back();

  await tick();

  assert.deepEqual(closed, ['card']);

  assert.equal(stack.depth, 1);

});

test('a route recorded under an open layer replaces its entry', async () => {

  const { history, stack, routed } = setup();

  stack.sync('drawer', true, () => undefined);

  stack.route({ roomId: 'b' }, '/?room=b');

  stack.sync('drawer', false, () => undefined);

  await tick();

  assert.deepEqual(history.entries, [{ roomId: 'a' }, { roomId: 'b' }]);

  history.back();

  await tick();

  assert.deepEqual(routed, [{ roomId: 'a' }]);

});

test('closing a layer then pressing back does not skip a room', async () => {

  const { history, stack, routed } = setup();

  stack.route({ roomId: 'b' }, '/?room=b');

  stack.sync('card', true, () => undefined);

  stack.sync('card', false, () => undefined);

  await tick();

  assert.deepEqual(history.state, { roomId: 'b' });

  history.back();

  await tick();

  assert.deepEqual(routed, [{ roomId: 'a' }]);

});

test('a route recorded right after a UI close waits for the pop', async () => {

  const { history, stack } = setup();

  stack.sync('menu', true, () => undefined);

  stack.sync('menu', false, () => undefined);

  stack.route({ roomId: 'b' }, '/?room=b');

  await tick();

  assert.deepEqual(history.entries, [{ roomId: 'a' }, { roomId: 'b' }]);

});

test('a layer closed under another leaves a stale entry that back skips', async () => {

  const { history, stack, routed } = setup();

  let dialog = true;

  stack.sync('menu', true, () => undefined);

  stack.sync('dialog', true, () => (dialog = false));

  stack.sync('menu', false, () => undefined);

  history.back();

  await tick();

  assert.equal(dialog, false);

  assert.equal(history.index, 0);

  assert.equal(routed.length, 0);

});

test('init strips a layer marker left behind by a reload', () => {

  const { history, stack } = setup();

  history.entries = [{ roomId: 'a' }, { roomId: 'a', backLayer: 'card' }];

  history.index = 1;

  stack.init();

  assert.deepEqual(history.state, { roomId: 'a' });

});

test('a settle timeout releases a pop whose popstate never arrives', async () => {

  const { history, stack } = setup();

  stack.sync('x', true, () => undefined);

  history.back = () => undefined;

  stack.sync('x', false, () => undefined);

  stack.route({ roomId: 'b' }, '/?room=b');

  await new Promise((resolve) => setTimeout(resolve, 500));

  assert.deepEqual(history.state, { roomId: 'b' });

});