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

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

import {
  initialResourceBookState,
  isResourceBookAllTarget,
  RESOURCE_BOOK_ALL_TARGET,
  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);
  });
});

describe('resource book all-resources target', () => {
  it('takes the overview stack as the first tile on the main canvas', () => {
    expect(
      resourceBookCategoryCardPresentation(
        initialResourceBookState,
        RESOURCE_BOOK_ALL_TARGET,
      ),
    ).toBe('overview');
  });

  it('lets the all-resources page render every category without a second copy', () => {
    const all = resourceBookReducer(
      resourceBookReducer(initialResourceBookState, {
        type: 'open-category',
        category: RESOURCE_BOOK_ALL_TARGET,
        token: 1,
      }),
      { type: 'finish-transition', token: 1 },
    );

    expect(all).toMatchObject({
      view: 'child',
      category: RESOURCE_BOOK_ALL_TARGET,
      phase: 'idle',
    });
    expect(resourceBookSceneCategory(all)).toBe(RESOURCE_BOOK_ALL_TARGET);
    // 「所有资源」页自己按栏目渲染全部资源卡；画本场景不再复制一份，否则同一张
    // 资源卡会挂载两次（DOM 查询与 FLIP 键都会撞车）。
    for (const category of [
      'ui-interaction',
      'character',
      'scene',
      'audio',
      'document',
      'unclassified',
      'version',
    ] as const) {
      expect(resourceBookCategoryCardPresentation(all, category)).toBeNull();
    }
    expect(
      resourceBookCategoryCardPresentation(all, RESOURCE_BOOK_ALL_TARGET),
    ).toBeNull();
  });

  it('identifies the render-layer sentinel without widening the section contract', () => {
    expect(isResourceBookAllTarget(RESOURCE_BOOK_ALL_TARGET)).toBe(true);
    expect(isResourceBookAllTarget('unclassified')).toBe(false);
    expect(isResourceBookAllTarget(null)).toBe(false);
  });
});