Genarrative/apps/ai-game-creator-shell/tests/resourceBookModel.test.ts

import { describe, expect, it } from 'vitest';

import {
  initialResourceBookState,
  resourceBookCategoryCardPresentation,
  resourceBookReducer,
  resourceBookSceneCategory,
  resourceBookShowsExitingCards,
  resourceBookShowsOverviewCards,
} from '../src/view/project-development/resourceBookModel';

describe('resource book state machine', () => {
  it('keeps overview titles and preview cards visible on the steady main canvas', () => {
    expect(resourceBookShowsOverviewCards(initialResourceBookState)).toBe(true);
  });

  it('commits the child target immediately and only keeps the motion phase transient', () => {
    const entering = resourceBookReducer(initialResourceBookState, {
      type: 'open-category',
      category: 'document',
      token: 1,
    });
    expect(entering).toMatchObject({
      view: 'child',
      category: 'document',
      phase: 'entering',
      token: 1,
    });
    expect(resourceBookSceneCategory(entering)).toBe('document');
  });

  it('retargets directly from one child canvas to another', () => {
    const current = resourceBookReducer(initialResourceBookState, {
      type: 'open-category',
      category: 'document',
      token: 1,
    });
    const switching = resourceBookReducer(current, {
      type: 'open-category',
      category: 'scene',
      token: 2,
    });
    expect(switching).toMatchObject({
      view: 'child',
      category: 'scene',
      phase: 'entering',
    });
    expect(resourceBookSceneCategory(switching)).toBe('scene');
  });

  it('marks a return to the main canvas separately from a child enter transition', () => {
    const entering = resourceBookReducer(initialResourceBookState, {
      type: 'open-category',
      category: 'document',
      token: 1,
    });
    const returning = resourceBookReducer(entering, {
      type: 'return-to-main',
      token: 2,
    });
    expect(returning).toMatchObject({
      view: 'main',
      category: null,
      phase: 'returning-main',
    });
  });

  it('lets an explicit collapse cancel an in-flight child switch', () => {
    const entering = resourceBookReducer(initialResourceBookState, {
      type: 'open-category',
      category: 'document',
      token: 1,
    });
    const switching = resourceBookReducer(entering, {
      type: 'open-category',
      category: 'scene',
      token: 2,
    });
    const main = resourceBookReducer(switching, {
      type: 'return-to-main',
      token: 3,
    });

    expect(main).toMatchObject({
      view: 'main',
      category: null,
      phase: 'returning-main',
      token: 3,
    });
  });

  it('ignores stale transition callbacks', () => {
    const entering = resourceBookReducer(initialResourceBookState, {
      type: 'open-category',
      category: 'document',
      token: 1,
    });
    const switched = resourceBookReducer(entering, {
      type: 'open-category',
      category: 'scene',
      token: 2,
    });
    expect(
      resourceBookReducer(switched, { type: 'finish-transition', token: 1 }),
    ).toEqual(switched);
  });
});

describe('resource book card presentation', () => {
  it('uses the overview stack on the steady main canvas', () => {
    expect(
      resourceBookCategoryCardPresentation(initialResourceBookState, 'scene'),
    ).toBe('overview');
  });

  it('keeps other categories mounted while entering so they can fade out', () => {
    const entering = resourceBookReducer(initialResourceBookState, {
      type: 'open-category',
      category: 'scene',
      token: 1,
    });

    expect(resourceBookCategoryCardPresentation(entering, 'scene')).toBe(
      'child',
    );
    expect(resourceBookCategoryCardPresentation(entering, 'code')).toBe(
      'overview',
    );
  });

  it('drops other categories once the child canvas is steady', () => {
    const steady = resourceBookReducer(
      resourceBookReducer(initialResourceBookState, {
        type: 'open-category',
        category: 'scene',
        token: 1,
      }),
      { type: 'finish-transition', token: 1 },
    );

    expect(resourceBookCategoryCardPresentation(steady, 'scene')).toBe('child');
    expect(resourceBookCategoryCardPresentation(steady, 'code')).toBeNull();
  });

  it('returns every category to the stack and exposes the exiting window', () => {
    const returning = resourceBookReducer(
      resourceBookReducer(initialResourceBookState, {
        type: 'open-category',
        category: 'scene',
        token: 1,
      }),
      { type: 'return-to-main', token: 2 },
    );

    expect(resourceBookCategoryCardPresentation(returning, 'scene')).toBe(
      'overview',
    );
    expect(resourceBookCategoryCardPresentation(returning, 'code')).toBe(
      'overview',
    );
    expect(resourceBookShowsExitingCards(returning)).toBe(true);
    expect(resourceBookShowsExitingCards(initialResourceBookState)).toBe(false);
  });
});