Regions

import { createEditor, DocumentPreset, RegionsExtension } from '@aionbuilders/nabu';

const engine = createEditor({
  preset: DocumentPreset,
  extensions: [
    RegionsExtension({
      types: {
        part: { level: 1, name: 'Part', label: 'Part {index}' },
        chapter: {
          level: 2,
          name: 'Chapter',
          label: 'Chapter {index}: {title}',
          numbering: 'document',
          fields: { status: { type: 'enum', values: ['draft', 'final'] }, pov: 'text' }
        },
        scene: { level: 3, name: 'Scene', label: '{path} {title}' }
      }
    })
  ]
});

await engine.importMarkdown([
  '<!-- region:part {} -->',
  '# The river',
  '',
  '<!-- region:chapter {"status":"draft"} -->',
  '## Departure',
  '',
  'Dawn.',
  '',
  '<!-- region:scene {} -->',
  '### The bank',
  '',
  'Water.',
  '',
  '<!-- region:chapter {} -->',
  '## Arrival',
  '',
  'Dusk.'
].join('\n'));

expect(engine.regions.list.map((region) => region.label)).toEqual([
  'Part 1',
  'Chapter 1: Departure',
  '1.1.1 The bank',
  'Chapter 2: Arrival'
]);

import { RegionsExtension, createFullEditor } from '@aionbuilders/nabu';

expect(() => RegionsExtension({ types: { x: { level: 0 } } })).toThrow(/level/);
expect(() => RegionsExtension({ types: { x: { level: 1, fields: { a: 'bogus' } } } })).toThrow(/unknown kind/);
expect(() => RegionsExtension({ types: { x: { level: 1, numbering: 'roman' } } })).toThrow(/numbering/);

// The default types.
const full = createFullEditor();
expect([...full.regions.config.types.keys()]).toEqual(['section-1', 'section-2', 'section-3']);

createEditor({
  preset: FullPreset.filter((extension) => extension.name !== 'region'),
  extensions: [RegionsExtension({ types })]
});

import { createEditor, DocumentPreset, RegionsExtension } from '@aionbuilders/nabu';

const engine = createEditor({
  preset: DocumentPreset,
  extensions: [RegionsExtension({
    types: {
      chapter: { level: 1, label: 'Chapter {index}: {title}', fields: { status: { type: 'enum', values: ['draft', 'final'] } } },
      scene: { level: 2, label: '{path} {title}' }
    }
  })]
});

await engine.importMarkdown([
  '<!-- region:chapter {} -->',
  '# Departure',
  '',
  'One two three.',
  '',
  '<!-- region:scene {} -->',
  '## The bank',
  '',
  'Four five.'
].join('\n'));

const chapter = engine.regions.tree[0];
const scene = chapter.children[0];

expect(chapter).toMatchObject({ type: 'chapter', level: 1, index: 1, title: 'Departure', label: 'Chapter 1: Departure', prefix: 'Chapter 1:' });
expect(scene).toMatchObject({ pathString: '1.1', label: '1.1 The bank', parent: chapter });
expect(engine.regions.of(scene.block)).toBe(scene);
expect(engine.regions.next(chapter)).toBe(scene);

// The body of the chapter: its own text, then the scene.
expect(chapter.blocks.map((block) => block.type)).toEqual(['paragraph', 'region']);
expect(chapter.ownBlocks).toHaveLength(1);
expect(chapter.ownWordCount).toBe(3);
expect(chapter.wordCount).toBe(5); // 3 own words + the body of the scene (2 words); no title counts, 'Departure' and 'The bank' included
expect(engine.regions.preamble.blocks).toHaveLength(0);

// Fields are validated against the declaration.
expect(chapter.setField('status', 'final')).toBe(true);
expect(chapter.setField('status', 'someday')).toBe(false); // not in the enum: refused, nothing written
await engine.commit();
expect(chapter.fields.status).toBe('final');
expect(chapter.fields.title).toBe('Departure');

import { createEditor, DocumentPreset, RegionsExtension } from '@aionbuilders/nabu';

const engine = createEditor({
  preset: DocumentPreset,
  extensions: [RegionsExtension({
    types: { chapter: { level: 1, label: 'Chapter {index}' }, scene: { level: 2, label: '{path}' } }
  })]
});

// A new region after an existing one (or at the end of the document, with no region).
await engine.exec('region:insert', { type: 'chapter', title: 'One' });
await engine.exec('region:insert', { type: 'chapter', title: 'Two' });
await engine.exec('region:insert', { type: 'chapter', title: 'Three', at: 'before', region: engine.regions.list[0] });
expect(engine.regions.list.map((region) => region.title)).toEqual(['Three', 'One', 'Two']);

const titles = () => engine.regions.list.map((region) => `${region.type}:${region.title}`);

// Move a region among its siblings (never out of its parent).
await engine.exec('region:move', { region: engine.regions.list[2], direction: 'up' });
expect(titles()).toEqual(['chapter:Three', 'chapter:Two', 'chapter:One']);

// Demote: it becomes the last sub-region of the previous sibling, and takes the type of the deeper level.
await engine.exec('region:demote', { region: engine.regions.list[1] });
expect(titles()).toEqual(['chapter:Three', 'scene:Two', 'chapter:One']);
expect(engine.regions.list[1].parent.title).toBe('Three');

// Promote does the opposite: it leaves its parent, and the following siblings follow it.
await engine.exec('region:promote', { region: engine.regions.list[1] });
expect(titles()).toEqual(['chapter:Three', 'chapter:Two', 'chapter:One']);

// Unwrap: the region disappears, its title becomes a paragraph, its body stays in place.
await engine.exec('region:unwrap', { region: engine.regions.list[0] });
expect(engine.regions.count).toBe(2);

// A sub-region, created INSIDE the body of an existing region (at the end by default; `index` picks the place).
// Without a type it takes the shallowest declared type deeper than its parent.
const one = () => engine.regions.list.find((region) => region.title === 'One');
await engine.exec('region:insert', { at: 'inside', region: one(), title: 'Opening' });
await engine.exec('region:insert', { at: 'inside', region: one(), type: 'scene', index: 0, title: 'First' });
expect(one().children.map((region) => `${region.type}:${region.title}`)).toEqual(['scene:First', 'scene:Opening']);

// The nesting rule holds: a type that is not deeper than the parent is refused (a warning, nothing is created).
await engine.exec('region:insert', { at: 'inside', region: one().children[0], title: 'Too deep' });
await engine.exec('region:insert', { at: 'inside', region: one(), type: 'chapter', title: 'Same level' });
expect(one().children).toHaveLength(2);

{ "type": "region", "props": { "regionType": "chapter", "fields": { ... } },
  "content": [ ...the title... ], "children": [ ...the body... ] }

<!-- region:chapter {"status":"draft"} -->
## La *forêt*

Body, as block markdown (sub-regions included).

import { createEditor, DocumentPreset, RegionsExtension } from '@aionbuilders/nabu';

const make = () => createEditor({
  preset: DocumentPreset,
  extensions: [RegionsExtension({
    types: { chapter: { level: 1, label: 'Chapter {index}' }, scene: { level: 2, label: '{path}' } }
  })]
});

const source = [
  '<!-- region:chapter {} -->',
  '# One',
  '',
  '<!-- region:scene {} -->',
  '## Scene',
  '',
  'Inside the scene.',
  '',
  '<!-- /region -->',
  '',
  'Back in the chapter.',
  '',
  '<!-- region:chapter {} -->',
  '# Two',
  '',
  'The end.'
].join('\n');

const engine = make();
await engine.importMarkdown(source);

// The closing comment is there because text follows the scene inside the chapter; none is needed elsewhere.
expect(engine.serialize('markdown')).toBe(source);
expect(engine.regions.list.map((region) => region.title)).toEqual(['One', 'Scene', 'Two']);
expect(engine.regions.tree[0].ownBlocks.map((block) => block.text)).toEqual(['Back in the chapter.']);

// The JSON export round-trips the structure too.
const copy = make();
await copy.importJSON(engine.serialize('json'));
expect(copy.serialize('markdown')).toBe(source);

import { createEditor, DocumentPreset, RegionsExtension } from '@aionbuilders/nabu';

const engine = createEditor({
  preset: DocumentPreset,
  extensions: [RegionsExtension({
    types: { chapter: { level: 1, name: 'Chapitre' } },
    messages: {
      split: 'Couper ici',
      untitled: 'Sans titre',
      hold: ({ keys, label }) => `Maintenez ${keys} : ${label}`,
      createOption: ({ name }) => name
    }
  })]
});

expect(engine.commands.get('region:split').label).toBe('Couper ici');
expect(engine.commands.get('region:exit').label).toBe('Leave the region'); // not overridden

.editor {
  --nb-region-font: 'Iowan Old Style', serif;
  --nb-region-text-transform: uppercase;
  --nb-region-letter-spacing: 0.08em;
  --nb-region-rule-color: color-mix(in srgb, currentColor 30%, transparent);
  --nb-region-rail-offset: -0.6em; /* no room for the drag handle on the left */
}