Files
TREK/shared/src/book/book-element-ops.spec.ts
T
Maurice cbf9325e7e fix(studio): the book tools state every field once, and the server typechecks within its memory again
- The element, spread, document, page operation and card unions carry a
  name of their own, so the declarations of every schema that holds them
  refer to them instead of spelling them out again. The shared declarations
  shrink from 9 to 5.5 MB and the server's typecheck from 4.4 to 2.9 GB, so
  the build fits the image's 4 GB again.
- edit_book_page and revise_book_design take add by what the element is,
  with an id of its own; its look follows with style by that id in the same
  call, every look field described once. A change an assistant card kept
  with its look on add still reads and runs.
- restore_book_page states what every element has once, then each kind's
  own fields and the type the five travel kinds share, without defaults; the
  page is read as a spread again before it goes back.
- The theme links are explained once in the page edit's description, and
  style points a text's face, a shape's paint and outline and a photo's crop
  look at their one full description.
- The lockup roles live in a module of their own, so the operation schemas
  no longer import the lockup engine, whose cycle left the operations unset
  in the shared tests.
- The theme switches no longer fall through a comment, the newer document
  test follows the current revision, the line inspector names its stroke
  keys, a text's anchor reads no physical side, two shapes record the
  proportions they are drawn at, and the photo look and line tests follow
  the slider and the folded ornaments.
2026-10-23 22:08:13 +00:00

367 lines
20 KiB
TypeScript

import type { AutoEntry } from './auto/auto-types';
import { applyBookOps } from './book-ops';
import type { BookOpsContext } from './book-ops-core';
import { editBookPageRequestSchema, type BookPageOpInput } from './book-ops.schema';
import { blankBook } from './book-pages';
import type { BookTravelContext } from './book-travel';
import {
bookPhotoElementSchema,
bookSpreadSchema,
bookTextElementSchema,
type BookDocument,
type BookElement,
type BookSpread,
} from './book.schema';
import type { JourneyStats } from './journey-stats.schema';
import { describe, expect, it } from 'vitest';
/**
* The element operations of the book engine: every kind created at the size
* the Studio's panels give it, restyled, arranged, aligned, distributed,
* locked, duplicated, filled, copied, refreshed, and the grid and the auto
* layout, with their refusals. The page is the default square book: 210 mm
* pages, the fold at 210, 3 mm bleed, 5 mm safe margin.
*/
let seq = 0;
const newId = (p: string) => `${p}-n${++seq}`;
type Frame = { x: number; y: number; w: number; h: number };
type NewElement = Extract<BookPageOpInput, { op: 'add' }>['element'];
const photo = (id: string, photoId: number | null, frame: Frame = { x: 230, y: 20, w: 80, h: 60 }, over = {}) =>
bookPhotoElementSchema.parse({ id, kind: 'photo', frame, photoId, ...over }) as BookElement;
const text = (id: string, words: string, frame: Frame = { x: 230, y: 120, w: 160, h: 40 }, over = {}) =>
bookTextElementSchema.parse({ id, kind: 'text', frame, text: words, size: 10, ...over }) as BookElement;
function book(elements: BookElement[], over: Partial<BookSpread> = {}): BookDocument {
const doc = blankBook({ title: 'Iceland', newId: (p) => `${p}-x` });
const ids = ['sp-cover', 'sp-first', 'sp-in', 'sp-last', 'sp-back'];
const spreads = doc.spreads.map((s, i) => ({ ...s, id: ids[i] as string }));
spreads[2] = { ...(spreads[2] as BookSpread), elements, ...over };
return { ...doc, spreads };
}
const inner = (doc: BookDocument) => doc.spreads[2] as BookSpread;
const find = (doc: BookDocument, id: string) => inner(doc).elements.find((e) => e.id === id);
const ids = (doc: BookDocument) => inner(doc).elements.map((e) => e.id);
type Point = JourneyStats['points'][number];
const pt = (label: string, lat: number, lng: number, country: string, entryId: number): Point => ({
lat,
lng,
label,
date: null,
country,
tripId: null,
photoId: entryId === 7 ? 1 : null,
entryId,
});
const stats: JourneyStats = {
journeyId: 1,
distance: 1_189_000,
days: 14,
steps: 2,
photos: 3,
places: 2,
furthest: 400_000,
countries: [
{ code: 'IS', name: 'Iceland', places: 1, firstVisit: '2026-06-02' },
{ code: 'NO', name: 'Norway', places: 1, firstVisit: '2026-06-09' },
],
points: [pt('Reykjavik', 64.14, -21.94, 'IS', 7), pt('Bergen', 60.39, 5.32, 'NO', 8)],
trips: [],
excluded: [],
start: '2026-06-02',
end: '2026-06-15',
};
const entry: AutoEntry = {
id: 7,
title: 'Harbour',
story: 'A long walk by the water.',
location: 'Reykjavik',
date: '2026-06-02',
photos: [{ photoId: 1, width: 4000, height: 3000 }],
lat: 64.14,
lng: -21.94,
country: 'IS',
dayNumber: 1,
dayCount: 14,
mood: 'amazing',
pros: ['Light'],
cons: ['Wind'],
};
const travel: BookTravelContext = {
locale: 'en',
stats,
path: [],
entries: [entry],
labels: { day: 'DAY', stations: 'S', summary: 'Sum', countries: 'C', distance: 'D', pros: 'Good', cons: 'Bad' },
};
const gallery = [
{ photoId: 1, caption: 'Harbour', width: 4000, height: 3000 },
{ photoId: 2, caption: null, width: 3000, height: 4000 },
];
const journey = { title: 'Iceland', subtitle: 'June', entries: [entry] };
const ctx: BookOpsContext = { photos: gallery, journey, travel };
const bare: BookOpsContext = { photos: gallery };
const run = (doc: BookDocument, ops: BookPageOpInput[], c: BookOpsContext = ctx) =>
applyBookOps(doc, { spreadId: 'sp-in', ops }, { newId, ...c });
function ok(result: ReturnType<typeof applyBookOps>): BookDocument {
if (!result.ok) throw new Error(`refused: ${result.error.code} ${result.error.message}`);
expect(bookSpreadSchema.safeParse(inner(result.doc)).success).toBe(true);
return result.doc;
}
const refusal = (result: ReturnType<typeof applyBookOps>) => (result.ok ? null : result.error.code);
const last = (doc: BookDocument) => inner(doc).elements[inner(doc).elements.length - 1] as BookElement;
const addTo = (element: NewElement, c: BookOpsContext) => run(book([]), [{ op: 'add', element }], c);
/** The element one `add` makes on an empty page. */
const added = (element: NewElement, c: BookOpsContext = ctx) => last(ok(addTo(element, c)));
/** The refusal one `add` gets on an empty page. */
const addRefusal = (element: NewElement, c: BookOpsContext = ctx) => refusal(addTo(element, c));
describe('add', () => {
it('BOOKEL-001: adds a photo frame the size the panel gives it, centred on the right-hand page', () => {
const page = book([], { parked: [photo('p-park', 2)] });
const doc = ok(run(page, [{ op: 'add', element: { kind: 'photo', photoId: 2 } }]));
expect(last(doc)).toMatchObject({ kind: 'photo', photoId: 2 });
expect(last(doc).frame).toEqual({ x: 267.75, y: 57.75, w: 94.5, h: 94.5 });
expect(inner(doc).parked).toEqual([]);
const empty = added({ kind: 'photo', frameStyle: 'polaroid' });
expect(empty).toMatchObject({ photoId: null, frameStyle: 'polaroid', frame: { w: 94.5, h: 109.62 } });
expect(addRefusal({ kind: 'photo', photoId: 99 })).toBe('photo_not_in_gallery');
});
it('BOOKEL-002: adds a text in a preset, its words given or read from its binding', () => {
const heading = added({ kind: 'text', preset: 'heading', text: 'Hi' });
expect(heading).toMatchObject({ size: 30, weight: 700, leading: 1.1, tracking: -0.02, overridden: false });
const caption = added({ kind: 'text', preset: 'caption', text: 'Note', italic: true });
expect(caption).toMatchObject({ size: 7.5, weight: 600, tracking: 0.14, color: '#8a8578', italic: true });
const bound = { source: 'journey.title' as const };
const title = added({ kind: 'text', binding: bound });
expect(title).toMatchObject({ text: 'Iceland', binding: bound, overridden: false });
expect(added({ kind: 'text', binding: bound, text: 'Mine' })).toMatchObject({ text: 'Mine', overridden: true });
expect(addRefusal({ kind: 'text', binding: { source: 'entry.date', entryId: 7 } })).toBe('text_required');
expect(addRefusal({ kind: 'text' })).toBe('invalid_op');
expect(addRefusal({ kind: 'text', binding: { source: 'entry.story' }, text: 'x' })).toBe('invalid_op');
expect(addRefusal({ kind: 'text', binding: { source: 'photo.caption' }, text: 'x' })).toBe('invalid_op');
});
it('BOOKEL-003: adds a rule as a hairline, a banner wide, and any icon the Studio offers, by lucide name only', () => {
expect(added({ kind: 'shape', shape: 'line' })).toMatchObject({ shape: 'rect', frame: { w: 105, h: 0.5 } });
const banner = added({ kind: 'shape', shape: 'banner-ribbon', fill: null });
expect(banner).toMatchObject({ fill: null, frame: { w: 107.1, h: 34.65 } });
const icon = added({ kind: 'icon', name: 'Compass', color: '#c2410c' });
expect(icon).toMatchObject({ name: 'Compass', color: '#c2410c', frame: { w: 37.8, h: 37.8 } });
// Past the travel shelf: the whole library, its old names too, as the icon tab lists it.
expect(added({ kind: 'icon', name: 'Pizza' })).toMatchObject({ kind: 'icon', name: 'Pizza' });
expect(added({ kind: 'icon', name: 'AlertTriangle' })).toMatchObject({ name: 'AlertTriangle' });
for (const name of ['NotAnIcon', 'PizzaIcon', 'pizza', 'Icon']) {
expect(addRefusal({ kind: 'icon', name } as unknown as NewElement), name).toBe('invalid_op');
}
});
it('BOOKEL-004: adds the travel kinds from the journey, and refuses them without its figures', () => {
const map = added({ kind: 'map', scope: 'journey', style: 'dark' });
expect(map).toMatchObject({ kind: 'map', style: 'dark', countries: ['IS', 'NO'] });
const figures = added({ kind: 'stats', metrics: ['distance', 'days'] });
expect(figures).toMatchObject({ kind: 'stats', metrics: ['distance', 'days'], values: { days: 14 } });
expect(added({ kind: 'badge', variant: 'day', entryId: 7 })).toMatchObject({ text: 'DAY 1', style: 'chip' });
expect(added({ kind: 'list', entryId: 7 })).toMatchObject({ kind: 'list', proLabel: 'Good', conLabel: 'Bad' });
expect(addRefusal({ kind: 'badge', variant: 'mood', entryId: 7 })).toBe('text_required');
const mood = added({ kind: 'badge', variant: 'mood', entryId: 7, text: 'Amazing' });
expect(mood).toMatchObject({ code: 'amazing', text: 'Amazing' });
expect(addRefusal({ kind: 'map', scope: 'journey' }, bare)).toBe('travel_unavailable');
expect(addRefusal({ kind: 'badge', variant: 'day', entryId: 99 })).toBe('entry_not_found');
expect(addRefusal({ kind: 'badge', variant: 'day', entryId: 7 }, bare)).toBe('travel_unavailable');
expect(addRefusal({ kind: 'list', entryId: 7 }, bare)).toBe('travel_unavailable');
expect(added({ kind: 'countries', codes: ['pt'] })).toMatchObject({ kind: 'countries', codes: ['PT'] });
});
it('BOOKEL-017: a flag or country mark asked for by its own code is labelled with that country', () => {
// A flag sets the name beside the flag (sub); a country mark has it as its words, the outline beside them.
expect(added({ kind: 'badge', variant: 'flag' })).toMatchObject({ code: 'IS', text: '', sub: 'Iceland' });
const portugal = added({ kind: 'badge', variant: 'flag', code: 'PT' });
expect(portugal).toMatchObject({ code: 'PT', text: '', sub: 'Portugal' });
expect(added({ kind: 'badge', variant: 'country' })).toMatchObject({ code: 'IS', text: 'Iceland', sub: '' });
const norway = added({ kind: 'badge', variant: 'country', entryId: 7, code: 'NO' });
expect(norway).toMatchObject({ code: 'NO', text: 'Norway', sub: '' });
expect(added({ kind: 'badge', variant: 'flag', code: 'PT', sub: 'Lisboa' })).toMatchObject({ sub: 'Lisboa' });
const lisboa = added({ kind: 'badge', variant: 'country', code: 'PT', text: 'Lisboa' });
expect(lisboa).toMatchObject({ code: 'PT', text: 'Lisboa', sub: '' });
// Its own code names the country on a journey whose figures name none; without one there is nothing to show.
const noCountries: BookOpsContext = { ...ctx, travel: { ...travel, stats: { ...stats, countries: [] } } };
expect(added({ kind: 'badge', variant: 'flag', code: 'PT' }, noCountries)).toMatchObject({ sub: 'Portugal' });
expect(addRefusal({ kind: 'badge', variant: 'flag' }, noCountries)).toBe('text_required');
// Another mark's code is its own (a mood, the weather) and names no country.
expect(added({ kind: 'badge', variant: 'mood', code: 'good', text: 'Good' })).toMatchObject({ sub: '' });
});
});
describe('style, lock, arrange', () => {
const one = () => book([text('t-1', 'Hi')]);
it('BOOKEL-005: restyles an element of its own kind, refuses another kind, a locked one and an empty set', () => {
const doc = ok(run(one(), [{ op: 'style', elementId: 't-1', set: { kind: 'text', size: 14 } }]));
expect(find(doc, 't-1')).toMatchObject({ size: 14 });
const photoLook = { kind: 'photo' as const, fit: 'contain' as const };
expect(refusal(run(one(), [{ op: 'style', elementId: 't-1', set: photoLook }]))).toBe('wrong_kind');
const locked = book([text('t-1', 'Hi', undefined, { locked: true })]);
const smaller = { kind: 'text' as const, size: 9 };
expect(refusal(run(locked, [{ op: 'style', elementId: 't-1', set: smaller }]))).toBe('locked');
expect(refusal(run(one(), [{ op: 'style', elementId: 't-1', set: { kind: 'text' } }]))).toBe('invalid_op');
});
it('BOOKEL-006: locks and unlocks, the one operation a locked element accepts', () => {
const locked = ok(run(one(), [{ op: 'lock', elementIds: ['t-1'], locked: true }]));
expect(find(locked, 't-1')?.locked).toBe(true);
expect(refusal(run(locked, [{ op: 'frame', elementId: 't-1', x: 240 }]))).toBe('locked');
const open = ok(run(locked, [{ op: 'lock', elementIds: ['t-1'], locked: false }]));
expect(find(open, 't-1')?.locked).toBe(false);
});
it('BOOKEL-007: moves elements in the paint order, keeping their order among themselves', () => {
const page = book([text('a', 'a'), text('b', 'b'), text('c', 'c'), text('d', 'd')]);
type To = 'front' | 'back' | 'forward' | 'backward';
const arranged = (elementIds: string[], to: To) => ids(ok(run(page, [{ op: 'arrange', elementIds, to }])));
expect(arranged(['a', 'b'], 'front')).toEqual(['c', 'd', 'a', 'b']);
expect(arranged(['d', 'c'], 'back')).toEqual(['c', 'd', 'a', 'b']);
expect(arranged(['a', 'c'], 'forward')).toEqual(['b', 'a', 'd', 'c']);
expect(arranged(['b', 'd'], 'backward')).toEqual(['b', 'a', 'd', 'c']);
});
});
describe('align, distribute', () => {
const three = () =>
book([
text('a', 'a', { x: 230, y: 20, w: 40, h: 10 }),
text('b', 'b', { x: 250, y: 60, w: 20, h: 10 }),
text('c', 'c', { x: 300, y: 100, w: 60, h: 10 }),
]);
const xs = (doc: BookDocument) => ['a', 'b', 'c'].map((id) => find(doc, id)?.frame.x);
const ys = (doc: BookDocument) => ['a', 'b', 'c'].map((id) => find(doc, id)?.frame.y);
it('BOOKEL-008: aligns to the selection, to the page and to its safe area', () => {
const left = ok(run(three(), [{ op: 'align', elementIds: ['a', 'b', 'c'], edge: 'left' }]));
expect(xs(left)).toEqual([230, 230, 230]);
const right = ok(run(three(), [{ op: 'align', elementIds: ['b'], edge: 'right', to: 'page' }]));
expect(find(right, 'b')?.frame.x).toBe(400);
const safe = ok(run(three(), [{ op: 'align', elementIds: ['c'], edge: 'top', to: 'safe' }]));
expect(find(safe, 'c')?.frame.y).toBe(5);
const middle = ok(run(three(), [{ op: 'align', elementIds: ['a', 'c'], edge: 'middle' }]));
expect(find(middle, 'a')?.frame.y).toBe(60);
});
it('BOOKEL-009: spaces three elements evenly or by a gap, and needs three different ones', () => {
const even = ok(run(three(), [{ op: 'distribute', elementIds: ['a', 'b', 'c'], axis: 'horizontal' }]));
expect(xs(even)).toEqual([230, 275, 300]);
const gap = ok(run(three(), [{ op: 'distribute', elementIds: ['c', 'a', 'b'], axis: 'vertical', gap: 5 }]));
expect(ys(gap)).toEqual([20, 35, 50]);
const twice = run(three(), [{ op: 'distribute', elementIds: ['a', 'a', 'b'], axis: 'vertical' }]);
expect(refusal(twice)).toBe('not_enough_elements');
});
});
describe('duplicate, fill, copy', () => {
it('BOOKEL-010: duplicates with new ids, 4 mm down and right unless told otherwise', () => {
const doc = ok(run(book([text('t-1', 'Hi')]), [{ op: 'duplicate', elementIds: ['t-1'] }]));
expect(last(doc)).toMatchObject({ kind: 'text', text: 'Hi', frame: { x: 234, y: 124 } });
expect(last(doc).id).not.toBe('t-1');
const moved = ok(run(book([text('t-1', 'Hi')]), [{ op: 'duplicate', elementIds: ['t-1'], dx: -10, dy: 0 }]));
expect(last(moved).frame).toMatchObject({ x: 220, y: 120 });
});
it('BOOKEL-011: fills a page or the spread to the bleed, unturned, at the back, as the inspector does', () => {
const page = book([text('t-1', 'Hi'), photo('p-1', 1, { x: 300, y: 50, w: 50, h: 40 }, { rotation: 8 })]);
const filled = ok(run(page, [{ op: 'fill', elementId: 'p-1', scope: 'page' }]));
const back = inner(filled).elements[0];
expect(back).toMatchObject({ id: 'p-1', rotation: 0, frame: { x: 207, y: -3, w: 216, h: 216 } });
const spread = ok(run(page, [{ op: 'fill', elementId: 'p-1', scope: 'spread' }]));
expect(inner(spread).elements[0]?.frame).toEqual({ x: -3, y: -3, w: 426, h: 216 });
expect(refusal(run(page, [{ op: 'fill', elementId: 't-1', scope: 'page' }]))).toBe('wrong_kind');
});
it('BOOKEL-012: copies elements of another page with new ids, photos checked against the gallery', () => {
const doc = book([]);
const cover = doc.spreads[0] as BookSpread;
doc.spreads[0] = { ...cover, elements: [text('t-c', 'Cover', { x: 20, y: 20, w: 100, h: 10 })] };
const copied = ok(run(doc, [{ op: 'copy_from', spreadId: 'sp-cover', elementIds: ['t-c'] }]));
expect(last(copied)).toMatchObject({ text: 'Cover', frame: { x: 230 } });
expect(last(copied).id).not.toBe('t-c');
doc.spreads[0] = { ...cover, elements: [photo('p-c', 99)] };
const stranger = run(doc, [{ op: 'copy_from', spreadId: 'sp-cover', elementIds: ['p-c'] }]);
expect(refusal(stranger)).toBe('photo_not_in_gallery');
});
});
describe('travel figures, grids and the auto layout', () => {
it('BOOKEL-013: refreshes the travel figures of a page to the journey, and refuses without its figures', () => {
const placed = ok(run(book([]), [{ op: 'add', element: { kind: 'stats', metrics: ['days'] } }]));
const later = { ...ctx, travel: { ...travel, stats: { ...stats, days: 20 } } };
const fresh = ok(run(placed, [{ op: 'refresh_travel' }], later));
expect(last(fresh)).toMatchObject({ values: { days: 20 }, stale: false });
expect(refusal(run(placed, [{ op: 'refresh_travel' }], bare))).toBe('travel_unavailable');
const named = run(book([text('t-1', 'Hi')]), [{ op: 'refresh_travel', elementIds: ['t-1'] }]);
expect(refusal(named)).toBe('wrong_kind');
});
it('BOOKEL-014: drops a photo grid in as empty frames over the safe area', () => {
const doc = ok(run(book([]), [{ op: 'add_grid', grid: 'grid-4' }]));
const frames = inner(doc).elements.filter((e) => e.kind === 'photo');
expect(frames).toHaveLength(4);
expect(frames.every((f) => f.kind === 'photo' && f.photoId === null)).toBe(true);
});
it('BOOKEL-015: lays a page out again from its entry, keeping its id, its locks and what it parked', () => {
const kept = text('t-lock', 'Kept', undefined, { locked: true });
const page = book([kept], { entryId: 7, parked: [photo('p-p', 2)] });
const doc = ok(run(page, [{ op: 'layout', auto: true }]));
expect(inner(doc).id).toBe('sp-in');
expect(find(doc, 't-lock')).toBeDefined();
expect(inner(doc).parked.map((e) => e.id)).toEqual(['p-p']);
expect(inner(doc).elements.some((e) => e.kind === 'photo' && e.photoId === 1)).toBe(true);
expect(refusal(run(book([]), [{ op: 'layout', auto: true }]))).toBe('layout_not_found');
expect(refusal(run(page, [{ op: 'layout', auto: true }], bare))).toBe('travel_unavailable');
});
it('BOOKEL-016: sets a text in italics, with its own leading and tracking', () => {
const op = { op: 'text' as const, elementId: 't-1', italic: true, leading: 2, tracking: 0.1 };
const doc = ok(run(book([text('t-1', 'Hi')]), [op]));
expect(find(doc, 't-1')).toMatchObject({ italic: true, leading: 2, tracking: 0.1 });
});
});
describe('a new element and its look', () => {
it('BOOKEL-018: add takes an id of its own, style names it in the same call, and a second element cannot take the id', () => {
const doc = ok(
run(book([]), [
{ op: 'add', element: { kind: 'text', text: 'Reykjavik' }, id: 'title' },
{ op: 'style', elementId: 'title', set: { kind: 'text', size: 40, color: '#c0392b' } },
]),
);
expect(find(doc, 'title')).toMatchObject({ kind: 'text', text: 'Reykjavik', size: 40, color: '#c0392b' });
const again = run(doc, [{ op: 'add', element: { kind: 'text', text: 'Again' }, id: 'title' }]);
expect(refusal(again)).toBe('id_in_use');
});
it('BOOKEL-019: the page edit takes add by what the element is, while a change kept with its look still runs', () => {
const edit = (element: Record<string, unknown>) => ({ spreadId: 'sp-in', ops: [{ op: 'add', element }] });
expect(editBookPageRequestSchema.safeParse(edit({ kind: 'text', text: 'Hi' })).success).toBe(true);
expect(editBookPageRequestSchema.safeParse(edit({ kind: 'text', text: 'Hi', size: 30 })).success).toBe(false);
expect(
editBookPageRequestSchema.safeParse(edit({ kind: 'shape', shape: 'ellipse', fill: '#ff0000' })).success,
).toBe(false);
const kept = ok(run(book([]), [{ op: 'add', element: { kind: 'text', text: 'Hi', size: 30 }, id: 'kept' }]));
expect(find(kept, 'kept')).toMatchObject({ size: 30 });
});
});