@ecsplico/editor 0.0.0-stage → 1.0.0

package/dist/features/composites/feature.js

@@ -0,0 +1,305 @@
+import { ABILITY } from "../../core/schema/abilities.js";
+import { abilitiesAtSelection } from "../../core/abilities.js";
+import { settingsTabsOf } from "../../core/define-editor.js";
+import { downloadText } from "../../core/download.js";
+import { editorEntryOf } from "../../core/editor-ui.js";
+import { compositeKind, defaultCompositeKinds } from "./kinds.js";
+import { blocksFromMarkdown } from "./fences.js";
+import { structureBlocks } from "./heading-composites.js";
+import { CompositeDescriptionNode, CompositeTitleNode, compositeKindsOf } from "./nodes.js";
+import { compositeConversions } from "./convert.js";
+import { migrateLegacyContent } from "./legacy.js";
+import { documentCompositeMarkdown, markdownFileName } from "./markdown-export.js";
+import { compositeNodes } from "./node-views.js";
+import { Structure, structureOf } from "./structure.js";
+import { STRUCTURE_MODE_KEYS } from "./structure-mode.js";
+//#region src/features/composites/feature.ts
+/** Heading level the structure stage starts at when it turns composites into headings (below the document title). */
+const STRUCTURE_STAGE_LEVEL = 2;
+/**
+* Composites („Bausteine“): the node family with its node views, the toolbar group (insert, „In Baustein umwandeln“,
+* „Gliederung umwandeln“), `/` commands, the conversion providers (wrap into / switch kind of / unwrap composites),
+* Markdown `:::` fences, legacy `section` migration, the preferred-structure setting and its `editing` settings tab,
+* the chips on each title line (status, tags) and the details popover on the kind icon (the binding's `chrome` overlay), and
+* the AI view of kinds and structure. Contributes the `parseMarkdown`,
+* `structure` and `migrateContent` stages. Imports no AI, media or transcript code.
+*/
+function compositeFeatureCore(ui, options = {}) {
+	const kindsOf = (ctx) => options.kinds ?? defaultCompositeKinds(ctx.t);
+	const { Composite, CompositeTags } = compositeNodes(ui.nodeViews);
+	return {
+		id: "composites",
+		extensions: (ctx) => [
+			Composite.configure({ kinds: kindsOf(ctx) }),
+			CompositeTitleNode,
+			CompositeDescriptionNode,
+			CompositeTags,
+			Structure.configure({ mode: () => ctx.settings.get().blocks.structure })
+		],
+		toolbar: (ctx) => [{
+			id: "composites",
+			order: 60,
+			items: compositeToolbarItems(ctx, kindsOf(ctx))
+		}],
+		slashCommands: (ctx) => compositeSlashCommands(ctx, kindsOf(ctx)),
+		blockActions: (ctx) => [{
+			id: "document-export",
+			label: ctx.t("composites.blockAction.export"),
+			icon: "i-lucide-download",
+			ability: ABILITY.compositeExport,
+			order: 400,
+			isVisible: ({ node }) => node.attrs.kind === "document",
+			run: ({ editor, node }) => downloadText(markdownFileName(node), documentCompositeMarkdown(editor, node))
+		}],
+		overlays: [ui.chrome],
+		settingsTabs: (ctx) => [{
+			id: "editing",
+			label: ctx.t("composites.tab"),
+			icon: "i-lucide-pencil",
+			component: ui.settingsTab,
+			props: { kinds: kindsOf(ctx) }
+		}],
+		blocks: {
+			parseMarkdown: (editor, markdown) => blocksFromMarkdown((md) => editor.markdown.parse(md), markdown, compositeKindsOf(editor)),
+			structure: (editor, blocks) => {
+				const { schema } = editor;
+				return structureBlocks(schema, blocks.map((block) => schema.nodeFromJSON(block)), structureOf(editor), STRUCTURE_STAGE_LEVEL, compositeKindsOf(editor)).map((node) => node.toJSON());
+			},
+			migrateContent: migrateLegacyContent
+		},
+		conversions: compositeConversions(options.kinds),
+		aiContext: (editor) => ({
+			kinds: compositeKindsOf(editor).map(({ id, label, fields, ai }) => ({
+				id,
+				label,
+				fields,
+				...ai?.purpose && { purpose: ai.purpose }
+			})),
+			structure: structureOf(editor)
+		})
+	};
+}
+function compositeSlashCommands({ settings, t }, kinds) {
+	const insert = (kind) => (editor) => editor.commands.insertComposite(kind);
+	const group = (recursive) => (editor) => {
+		const { editing, blocks } = settings.get();
+		return editor.commands.convertHeadingsToComposites({
+			recursive,
+			scope: editing.headingConversionScope,
+			kind: blocks.defaultKind
+		});
+	};
+	const flatten = (recursive) => (editor) => editor.commands.convertCompositesToHeadings({
+		recursive,
+		scope: settings.get().editing.headingConversionScope
+	});
+	return [
+		{
+			id: "abschnitt",
+			label: t("composites.slash.section"),
+			icon: "i-lucide-layers",
+			ability: ABILITY.composite,
+			run: insert("section")
+		},
+		...kinds.filter((kind) => kind.id !== "section").map((kind) => ({
+			id: kind.id,
+			label: kind.label,
+			icon: kind.icon,
+			ability: ABILITY.composite,
+			run: insert(kind.id)
+		})),
+		{
+			id: "gliedern",
+			label: t("composites.slash.group"),
+			icon: "i-lucide-layers",
+			ability: ABILITY.composite,
+			run: group(false)
+		},
+		{
+			id: "gliedern-alle",
+			label: t("composites.slash.groupAll"),
+			icon: "i-lucide-list-tree",
+			ability: ABILITY.composite,
+			run: group(true)
+		},
+		{
+			id: "aufloesen",
+			label: t("composites.slash.flatten"),
+			icon: "i-lucide-heading",
+			ability: ABILITY.headings,
+			run: flatten(false)
+		},
+		{
+			id: "aufloesen-alle",
+			label: t("composites.slash.flattenAll"),
+			icon: "i-lucide-align-left",
+			ability: ABILITY.headings,
+			run: flatten(true)
+		}
+	];
+}
+/**
+* The toolbar group beside the inserts: the default kind's insert button (it follows the setting, so label/icon/shortcut
+* are getters read at render time), „In Baustein umwandeln“ (one entry per kind for the caret's block) and „Gliederung
+* umwandeln“ (headings <-> composites in both directions, the preferred structure's direction first).
+*/
+function compositeToolbarItems({ settings, t }, kinds) {
+	const defaultKind = () => compositeKind(kinds, settings.get().blocks.defaultKind);
+	const insert = (chain) => chain.insertComposite(defaultKind().id);
+	const scope = () => settings.get().editing.headingConversionScope;
+	const canGroup = (editor, recursive) => editor.can().convertHeadingsToComposites({
+		recursive,
+		scope: scope(),
+		kind: settings.get().blocks.defaultKind
+	});
+	const canFlatten = (editor, recursive) => editor.can().convertCompositesToHeadings({
+		recursive,
+		scope: scope()
+	});
+	function kindItems(editor) {
+		return [{
+			type: "label",
+			label: t("composites.menu.kindHeading")
+		}, ...compositeKindsOf(editor).map((kind) => {
+			const target = {
+				type: "composite",
+				kind: kind.id
+			};
+			return {
+				label: kind.label,
+				icon: kind.icon,
+				disabled: !editor.can().convertBlockTo(target),
+				onSelect: () => editor.chain().focus().convertBlockTo(target).run()
+			};
+		})];
+	}
+	function structureItems(editor) {
+		const structure = settings.get().blocks.structure;
+		const abilities = abilitiesAtSelection(editor);
+		const composite = abilities.has(ABILITY.composite);
+		const headings = abilities.has(ABILITY.headings);
+		const run = (command) => () => void command();
+		const sep = { type: "separator" };
+		const toComposites = [
+			{
+				type: "label",
+				label: t("composites.menu.toComposites")
+			},
+			{
+				label: t("composites.menu.toComposites.top"),
+				description: t("composites.menu.toComposites.top.description"),
+				icon: "i-lucide-layers",
+				disabled: !composite || !canGroup(editor, false),
+				onSelect: run(() => editor.chain().focus().convertHeadingsToComposites({
+					recursive: false,
+					scope: scope(),
+					kind: settings.get().blocks.defaultKind
+				}).run())
+			},
+			{
+				label: t("composites.menu.toComposites.all"),
+				description: t("composites.menu.toComposites.all.description"),
+				icon: "i-lucide-list-tree",
+				disabled: !composite || !canGroup(editor, true),
+				onSelect: run(() => editor.chain().focus().convertHeadingsToComposites({
+					recursive: true,
+					scope: scope(),
+					kind: settings.get().blocks.defaultKind
+				}).run())
+			}
+		];
+		const toHeadings = [
+			{
+				type: "label",
+				label: t("composites.menu.toHeadings")
+			},
+			{
+				label: t("composites.menu.toHeadings.top"),
+				description: t("composites.menu.toHeadings.top.description"),
+				icon: "i-lucide-heading",
+				disabled: !headings || !canFlatten(editor, false),
+				onSelect: run(() => editor.chain().focus().convertCompositesToHeadings({
+					recursive: false,
+					scope: scope()
+				}).run())
+			},
+			{
+				label: t("composites.menu.toHeadings.all"),
+				description: t("composites.menu.toHeadings.all.description"),
+				icon: "i-lucide-align-left",
+				disabled: !headings || !canFlatten(editor, true),
+				onSelect: run(() => editor.chain().focus().convertCompositesToHeadings({
+					recursive: true,
+					scope: scope()
+				}).run())
+			}
+		];
+		const entry = editorEntryOf(editor);
+		const settingsEntry = entry && settingsTabsOf(entry.preset, entry.ctx.app).length ? [sep, {
+			label: t("composites.menu.settings"),
+			icon: "i-lucide-settings-2",
+			onSelect: () => entry.ui.openSettings("editing")
+		}] : [];
+		return [
+			{
+				type: "label",
+				label: t("composites.menu.preferred", { mode: t(STRUCTURE_MODE_KEYS[structure].labelKey) })
+			},
+			...structure === "composite" ? [
+				...toComposites,
+				sep,
+				...toHeadings
+			] : [
+				...toHeadings,
+				sep,
+				...toComposites
+			],
+			...settingsEntry
+		];
+	}
+	return [
+		{
+			id: "insert",
+			order: 10,
+			get icon() {
+				return defaultKind().icon;
+			},
+			get label() {
+				return defaultKind().label;
+			},
+			get kbds() {
+				return defaultKind().id === "section" ? [
+					"meta",
+					"shift",
+					"a"
+				] : void 0;
+			},
+			ability: ABILITY.composite,
+			disabled: (editor) => !insert(editor.can().chain()).run(),
+			run: (editor) => {
+				insert(editor.chain().focus()).run();
+			}
+		},
+		{
+			id: "to-kind",
+			order: 20,
+			icon: "i-lucide-replace",
+			label: t("composites.toolbar.toKind"),
+			ability: ABILITY.composite,
+			disabled: (editor) => kindItems(editor).every((item) => item.type === "label" || item.disabled),
+			menu: kindItems
+		},
+		{
+			id: "structure",
+			order: 30,
+			icon: "i-lucide-list-tree",
+			label: t("composites.toolbar.structure"),
+			disabled: (editor) => !canGroup(editor, true) && !canFlatten(editor, true),
+			menu: structureItems
+		}
+	];
+}
+//#endregion
+export { compositeFeatureCore };
+
+//# sourceMappingURL=feature.js.map

package/dist/features/composites/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.js","names":[],"sources":["../../../src/features/composites/feature.ts"],"sourcesContent":["import type { ChainedCommands, Editor } from '@tiptap/core'\nimport type { EditorFeature, FeatureContext, MenuItem, SlashCommandItem, ToolbarItem } from '../../core'\nimport { abilitiesAtSelection, downloadText, editorEntryOf, settingsTabsOf } from '../../core'\nimport type { Translate } from '../../i18n'\nimport { ABILITY } from '../../core/schema'\nimport { compositeConversions } from './convert'\nimport { blocksFromMarkdown } from './fences'\nimport { structureBlocks } from './heading-composites'\nimport { type CompositeKind, compositeKind, defaultCompositeKinds } from './kinds'\nimport { migrateLegacyContent } from './legacy'\nimport { documentCompositeMarkdown, markdownFileName } from './markdown-export'\nimport { type CompositeNodeViews, compositeNodes } from './node-views'\nimport { CompositeDescriptionNode, CompositeTitleNode, compositeKindsOf } from './nodes'\nimport { Structure, structureOf } from './structure'\nimport { STRUCTURE_MODE_KEYS } from './structure-mode'\n\n/** What a framework binding supplies to the composites feature. */\nexport interface CompositesUi<C> {\n  /** The chips on each title line and the details popover on the kind icon; mounted as an overlay. */\n  chrome: C\n  /** The „Bearbeiten“ settings tab; receives `{ kinds }` as props. */\n  settingsTab: C\n  /** The composite block view of the framework. */\n  nodeViews: CompositeNodeViews\n}\n\n/** Options of `compositeFeature`. */\nexport interface CompositeFeatureOptions {\n  /** The composite kinds („Bausteine“) offered in the editor, with their own labels (default: `defaultCompositeKinds(t)`, the built-in kinds in the editor's language); read once. */\n  kinds?: readonly CompositeKind[]\n}\n\n/** Heading level the structure stage starts at when it turns composites into headings (below the document title). */\nconst STRUCTURE_STAGE_LEVEL = 2\n\n/**\n * Composites („Bausteine“): the node family with its node views, the toolbar group (insert, „In Baustein umwandeln“,\n * „Gliederung umwandeln“), `/` commands, the conversion providers (wrap into / switch kind of / unwrap composites),\n * Markdown `:::` fences, legacy `section` migration, the preferred-structure setting and its `editing` settings tab,\n * the chips on each title line (status, tags) and the details popover on the kind icon (the binding's `chrome` overlay), and\n * the AI view of kinds and structure. Contributes the `parseMarkdown`,\n * `structure` and `migrateContent` stages. Imports no AI, media or transcript code.\n */\nexport function compositeFeatureCore<C>(ui: CompositesUi<C>, options: CompositeFeatureOptions = {}): EditorFeature<C> {\n  // Host kinds keep their labels; the built-in ones are produced from the context's translator (memoized per `t`).\n  const kindsOf = (ctx: { t: Translate }) => options.kinds ?? defaultCompositeKinds(ctx.t)\n  const { Composite, CompositeTags } = compositeNodes(ui.nodeViews)\n  return {\n    id: 'composites',\n    extensions: ctx => [\n      Composite.configure({ kinds: kindsOf(ctx) }),\n      CompositeTitleNode,\n      CompositeDescriptionNode,\n      CompositeTags,\n      Structure.configure({ mode: () => ctx.settings.get().blocks.structure }),\n    ],\n    toolbar: ctx => [{\n      id: 'composites',\n      order: 60,\n      items: compositeToolbarItems(ctx, kindsOf(ctx)),\n    }],\n    slashCommands: ctx => compositeSlashCommands(ctx, kindsOf(ctx)),\n    blockActions: ctx => [{\n      id: 'document-export',\n      label: ctx.t('composites.blockAction.export'),\n      icon: 'i-lucide-download',\n      ability: ABILITY.compositeExport,\n      order: 400,\n      isVisible: ({ node }) => node.attrs.kind === 'document',\n      run: ({ editor, node }) => downloadText(markdownFileName(node), documentCompositeMarkdown(editor, node)),\n    }],\n    overlays: [ui.chrome],\n    settingsTabs: ctx => [{ id: 'editing', label: ctx.t('composites.tab'), icon: 'i-lucide-pencil', component: ui.settingsTab, props: { kinds: kindsOf(ctx) } }],\n    blocks: {\n      parseMarkdown: (editor, markdown) => blocksFromMarkdown(md => editor.markdown!.parse(md), markdown, compositeKindsOf(editor)),\n      structure: (editor, blocks) => {\n        const { schema } = editor\n        return structureBlocks(schema, blocks.map(block => schema.nodeFromJSON(block)), structureOf(editor), STRUCTURE_STAGE_LEVEL, compositeKindsOf(editor)).map(node => node.toJSON())\n      },\n      migrateContent: migrateLegacyContent,\n    },\n    conversions: compositeConversions(options.kinds),\n    aiContext: editor => ({\n      kinds: compositeKindsOf(editor).map(({ id, label, fields, ai }) => ({ id, label, fields, ...(ai?.purpose && { purpose: ai.purpose }) })),\n      structure: structureOf(editor),\n    }),\n  }\n}\n\nfunction compositeSlashCommands({ settings, t }: FeatureContext, kinds: readonly CompositeKind[]): SlashCommandItem[] {\n  const insert = (kind: string) => (editor: Editor) => editor.commands.insertComposite(kind)\n  const group = (recursive: boolean) => (editor: Editor) => {\n    const { editing, blocks } = settings.get()\n    return editor.commands.convertHeadingsToComposites({ recursive, scope: editing.headingConversionScope, kind: blocks.defaultKind })\n  }\n  const flatten = (recursive: boolean) => (editor: Editor) => editor.commands.convertCompositesToHeadings({ recursive, scope: settings.get().editing.headingConversionScope })\n  return [\n    { id: 'abschnitt', label: t('composites.slash.section'), icon: 'i-lucide-layers', ability: ABILITY.composite, run: insert('section') },\n    ...kinds.filter(kind => kind.id !== 'section').map((kind): SlashCommandItem => (\n      { id: kind.id, label: kind.label, icon: kind.icon, ability: ABILITY.composite, run: insert(kind.id) }\n    )),\n    { id: 'gliedern', label: t('composites.slash.group'), icon: 'i-lucide-layers', ability: ABILITY.composite, run: group(false) },\n    { id: 'gliedern-alle', label: t('composites.slash.groupAll'), icon: 'i-lucide-list-tree', ability: ABILITY.composite, run: group(true) },\n    { id: 'aufloesen', label: t('composites.slash.flatten'), icon: 'i-lucide-heading', ability: ABILITY.headings, run: flatten(false) },\n    { id: 'aufloesen-alle', label: t('composites.slash.flattenAll'), icon: 'i-lucide-align-left', ability: ABILITY.headings, run: flatten(true) },\n  ]\n}\n\n/**\n * The toolbar group beside the inserts: the default kind's insert button (it follows the setting, so label/icon/shortcut\n * are getters read at render time), „In Baustein umwandeln“ (one entry per kind for the caret's block) and „Gliederung\n * umwandeln“ (headings <-> composites in both directions, the preferred structure's direction first).\n */\nfunction compositeToolbarItems<C>({ settings, t }: FeatureContext, kinds: readonly CompositeKind[]): ToolbarItem<C>[] {\n  const defaultKind = () => compositeKind(kinds, settings.get().blocks.defaultKind)\n  const insert = (chain: ChainedCommands) => chain.insertComposite(defaultKind().id)\n  const scope = () => settings.get().editing.headingConversionScope\n\n  const canGroup = (editor: Editor, recursive: boolean) => editor.can().convertHeadingsToComposites({ recursive, scope: scope(), kind: settings.get().blocks.defaultKind })\n  const canFlatten = (editor: Editor, recursive: boolean) => editor.can().convertCompositesToHeadings({ recursive, scope: scope() })\n\n  function kindItems(editor: Editor): MenuItem[] {\n    return [\n      { type: 'label', label: t('composites.menu.kindHeading') },\n      ...compositeKindsOf(editor).map((kind): MenuItem => {\n        const target = { type: 'composite', kind: kind.id } as const\n        return { label: kind.label, icon: kind.icon, disabled: !editor.can().convertBlockTo(target), onSelect: () => editor.chain().focus().convertBlockTo(target).run() }\n      }),\n    ]\n  }\n\n  function structureItems(editor: Editor): MenuItem[] {\n    const structure = settings.get().blocks.structure\n    const abilities = abilitiesAtSelection(editor)\n    const composite = abilities.has(ABILITY.composite)\n    const headings = abilities.has(ABILITY.headings)\n    const run = (command: () => boolean) => () => void command()\n    const sep: MenuItem = { type: 'separator' }\n    const toComposites: MenuItem[] = [\n      { type: 'label', label: t('composites.menu.toComposites') },\n      { label: t('composites.menu.toComposites.top'), description: t('composites.menu.toComposites.top.description'), icon: 'i-lucide-layers', disabled: !composite || !canGroup(editor, false), onSelect: run(() => editor.chain().focus().convertHeadingsToComposites({ recursive: false, scope: scope(), kind: settings.get().blocks.defaultKind }).run()) },\n      { label: t('composites.menu.toComposites.all'), description: t('composites.menu.toComposites.all.description'), icon: 'i-lucide-list-tree', disabled: !composite || !canGroup(editor, true), onSelect: run(() => editor.chain().focus().convertHeadingsToComposites({ recursive: true, scope: scope(), kind: settings.get().blocks.defaultKind }).run()) },\n    ]\n    const toHeadings: MenuItem[] = [\n      { type: 'label', label: t('composites.menu.toHeadings') },\n      { label: t('composites.menu.toHeadings.top'), description: t('composites.menu.toHeadings.top.description'), icon: 'i-lucide-heading', disabled: !headings || !canFlatten(editor, false), onSelect: run(() => editor.chain().focus().convertCompositesToHeadings({ recursive: false, scope: scope() }).run()) },\n      { label: t('composites.menu.toHeadings.all'), description: t('composites.menu.toHeadings.all.description'), icon: 'i-lucide-align-left', disabled: !headings || !canFlatten(editor, true), onSelect: run(() => editor.chain().focus().convertCompositesToHeadings({ recursive: true, scope: scope() }).run()) },\n    ]\n    const entry = editorEntryOf(editor)\n    // The settings entry exists only while some feature contributes a tab to open.\n    const settingsEntry: MenuItem[] = entry && settingsTabsOf(entry.preset, entry.ctx.app).length\n      ? [sep, { label: t('composites.menu.settings'), icon: 'i-lucide-settings-2', onSelect: () => entry.ui.openSettings('editing') }]\n      : []\n    return [\n      { type: 'label', label: t('composites.menu.preferred', { mode: t(STRUCTURE_MODE_KEYS[structure].labelKey) }) },\n      ...(structure === 'composite' ? [...toComposites, sep, ...toHeadings] : [...toHeadings, sep, ...toComposites]),\n      ...settingsEntry,\n    ]\n  }\n\n  return [\n    {\n      id: 'insert',\n      order: 10,\n      // Getters: the default kind arrives with the server settings; the toolbar reads them at render time.\n      get icon() { return defaultKind().icon },\n      get label() { return defaultKind().label },\n      // Mod-Shift-a (CompositeNode) always inserts a `section`, so only then is it shown as the shortcut.\n      get kbds() { return defaultKind().id === 'section' ? ['meta', 'shift', 'a'] : undefined },\n      ability: ABILITY.composite,\n      disabled: editor => !insert(editor.can().chain()).run(),\n      run: (editor) => { insert(editor.chain().focus()).run() },\n    },\n    {\n      id: 'to-kind',\n      order: 20,\n      icon: 'i-lucide-replace',\n      label: t('composites.toolbar.toKind'),\n      ability: ABILITY.composite,\n      disabled: editor => kindItems(editor).every(item => item.type === 'label' || item.disabled),\n      menu: kindItems,\n    },\n    {\n      id: 'structure',\n      order: 30,\n      icon: 'i-lucide-list-tree',\n      label: t('composites.toolbar.structure'),\n      disabled: editor => !canGroup(editor, true) && !canFlatten(editor, true),\n      menu: structureItems,\n    },\n  ]\n}\n"],"mappings":"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"}

package/dist/features/composites/fences.d.ts

@@ -0,0 +1,20 @@
+import { CompositeKind } from "./kinds.js";
+import { CompositeFence, FenceSegment, splitCompositeFences } from "../../core/fences.js";
+import { JSONContent } from "@tiptap/core";
+//#region src/features/composites/fences.d.ts
+/** `inner` fenced as composite of `kind`: `::: kind {meta}` (meta JSON only when non-empty), `inner`, `:::`. */
+export declare function compositeFence(kind: string, meta: Record<string, unknown>, inner: string): string;
+/**
+ * Markdown segments parsed, fences of a registered kind turned into composites, in order. A fence of any other kind
+ * becomes an `opaqueFence` that keeps its text verbatim.
+ */
+export declare function blocksFromMarkdown(parse: (md: string) => JSONContent, markdown: string, kinds: readonly CompositeKind[]): JSONContent[];
+/**
+ * JSON of a composite built from the fence body: first `#`-heading → title, first blockquote directly after →
+ * description, a `Tags:` line → tags, rest → body (recursing for nested fences). Missing title → empty title; empty
+ * body → [paragraph]. Meta of a known kind keeps only that kind's fields.
+ */
+export declare function compositeFromMarkdown(parse: (md: string) => JSONContent, fence: CompositeFence, kinds: readonly CompositeKind[]): JSONContent;
+//#endregion
+export { type CompositeFence, type FenceSegment, splitCompositeFences };
+//# sourceMappingURL=fences.d.ts.map

package/dist/features/composites/fences.js

@@ -0,0 +1,86 @@
+import { opaqueFenceJSON, splitCompositeFences } from "../../core/fences.js";
+//#region src/features/composites/fences.ts
+/** `inner` fenced as composite of `kind`: `::: kind {meta}` (meta JSON only when non-empty), `inner`, `:::`. */
+function compositeFence(kind, meta, inner) {
+	return `${Object.keys(meta).length ? `::: ${kind} ${JSON.stringify(meta)}` : `::: ${kind}`}\n${inner}\n:::`;
+}
+/**
+* Markdown segments parsed, fences of a registered kind turned into composites, in order. A fence of any other kind
+* becomes an `opaqueFence` that keeps its text verbatim.
+*/
+function blocksFromMarkdown(parse, markdown, kinds) {
+	return splitCompositeFences(markdown).flatMap((segment) => {
+		if (!("inner" in segment)) return parse(segment.markdown).content ?? [];
+		return kinds.some((kind) => kind.id === segment.kind) ? [compositeFromMarkdown(parse, segment, kinds)] : [opaqueFenceJSON(segment)];
+	});
+}
+/** Inline content of the first textblock `parse` makes of `md`. */
+function inlineOf(parse, md) {
+	let found;
+	const walk = (node) => {
+		if (found) return;
+		if (node.content?.some((child) => child.type === "text")) found = node.content;
+		else node.content?.forEach(walk);
+	};
+	if (md.trim()) walk(parse(md));
+	return found?.length ? found : void 0;
+}
+/**
+* JSON of a composite built from the fence body: first `#`-heading → title, first blockquote directly after →
+* description, a `Tags:` line → tags, rest → body (recursing for nested fences). Missing title → empty title; empty
+* body → [paragraph]. Meta of a known kind keeps only that kind's fields.
+*/
+function compositeFromMarkdown(parse, fence, kinds) {
+	const lines = fence.inner.split("\n");
+	let i = 0;
+	const skipBlank = () => {
+		while (i < lines.length && !lines[i].trim()) i++;
+	};
+	skipBlank();
+	let title;
+	const heading = /^\s*#{1,6}(?:\s+(.*?))?\s*#*\s*$/.exec(lines[i] ?? "");
+	if (heading) {
+		title = inlineOf(parse, heading[1] ?? "");
+		i++;
+		skipBlank();
+	}
+	const quote = [];
+	while (i < lines.length && /^\s*>/.test(lines[i])) quote.push(lines[i++].replace(/^\s*>\s?/, ""));
+	const description = quote.length ? inlineOf(parse, quote.join("\n")) : void 0;
+	skipBlank();
+	let tags = [];
+	const tagLine = /^\s*Tags:\s*(.*)$/i.exec(lines[i] ?? "");
+	if (tagLine) {
+		tags = [...new Set([...tagLine[1].matchAll(/#?([\p{L}\p{N}_-]+)/gu)].map((m) => m[1].toLowerCase()))];
+		i++;
+	}
+	const body = blocksFromMarkdown(parse, lines.slice(i).join("\n"), kinds);
+	const fields = kinds.find((kind) => kind.id === fence.kind)?.fields.map((field) => field.key);
+	const meta = fields ? Object.fromEntries(Object.entries(fence.meta).filter(([key]) => fields.includes(key))) : fence.meta;
+	return {
+		type: "composite",
+		attrs: {
+			kind: fence.kind,
+			meta
+		},
+		content: [
+			title ? {
+				type: "compositeTitle",
+				content: title
+			} : { type: "compositeTitle" },
+			description ? {
+				type: "compositeDescription",
+				content: description
+			} : { type: "compositeDescription" },
+			{
+				type: "compositeTags",
+				attrs: { tags }
+			},
+			...body.length ? body : [{ type: "paragraph" }]
+		]
+	};
+}
+//#endregion
+export { blocksFromMarkdown, compositeFence, compositeFromMarkdown, splitCompositeFences };
+
+//# sourceMappingURL=fences.js.map

package/dist/features/composites/fences.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fences.js","names":[],"sources":["../../../src/features/composites/fences.ts"],"sourcesContent":["import type { JSONContent } from '@tiptap/core'\nimport { type CompositeFence, opaqueFenceJSON, splitCompositeFences } from '../../core/fences'\nimport type { CompositeKind } from './kinds'\n\n// Inverse of the composite nodes' renderMarkdown: `::: kind {meta}`, `## title`, `> description`, `Tags: #a #b`, body,\n// `:::`. The fence grammar itself (`splitCompositeFences`) is shared with the Markdown entry (`core/fences`).\nexport { type CompositeFence, type FenceSegment, splitCompositeFences } from '../../core/fences'\n\n/** `inner` fenced as composite of `kind`: `::: kind {meta}` (meta JSON only when non-empty), `inner`, `:::`. */\nexport function compositeFence(kind: string, meta: Record<string, unknown>, inner: string): string {\n  const opener = Object.keys(meta).length ? `::: ${kind} ${JSON.stringify(meta)}` : `::: ${kind}`\n  return `${opener}\\n${inner}\\n:::`\n}\n\n/**\n * Markdown segments parsed, fences of a registered kind turned into composites, in order. A fence of any other kind\n * becomes an `opaqueFence` that keeps its text verbatim.\n */\nexport function blocksFromMarkdown(parse: (md: string) => JSONContent, markdown: string, kinds: readonly CompositeKind[]): JSONContent[] {\n  return splitCompositeFences(markdown).flatMap((segment) => {\n    if (!('inner' in segment)) return parse(segment.markdown).content ?? []\n    return kinds.some(kind => kind.id === segment.kind) ? [compositeFromMarkdown(parse, segment, kinds)] : [opaqueFenceJSON(segment)]\n  })\n}\n\n/** Inline content of the first textblock `parse` makes of `md`. */\nfunction inlineOf(parse: (md: string) => JSONContent, md: string): JSONContent[] | undefined {\n  let found: JSONContent[] | undefined\n  const walk = (node: JSONContent): void => {\n    if (found) return\n    if (node.content?.some(child => child.type === 'text')) found = node.content\n    else node.content?.forEach(walk)\n  }\n  if (md.trim()) walk(parse(md))\n  return found?.length ? found : undefined\n}\n\n/**\n * JSON of a composite built from the fence body: first `#`-heading → title, first blockquote directly after →\n * description, a `Tags:` line → tags, rest → body (recursing for nested fences). Missing title → empty title; empty\n * body → [paragraph]. Meta of a known kind keeps only that kind's fields.\n */\nexport function compositeFromMarkdown(parse: (md: string) => JSONContent, fence: CompositeFence, kinds: readonly CompositeKind[]): JSONContent {\n  const lines = fence.inner.split('\\n')\n  let i = 0\n  const skipBlank = () => {\n    while (i < lines.length && !lines[i]!.trim()) i++\n  }\n  skipBlank()\n  let title: JSONContent[] | undefined\n  const heading = /^\\s*#{1,6}(?:\\s+(.*?))?\\s*#*\\s*$/.exec(lines[i] ?? '')\n  if (heading) {\n    title = inlineOf(parse, heading[1] ?? '')\n    i++\n    skipBlank()\n  }\n  const quote: string[] = []\n  while (i < lines.length && /^\\s*>/.test(lines[i]!)) quote.push(lines[i++]!.replace(/^\\s*>\\s?/, ''))\n  const description = quote.length ? inlineOf(parse, quote.join('\\n')) : undefined\n  skipBlank()\n  let tags: string[] = []\n  const tagLine = /^\\s*Tags:\\s*(.*)$/i.exec(lines[i] ?? '')\n  if (tagLine) {\n    tags = [...new Set([...tagLine[1]!.matchAll(/#?([\\p{L}\\p{N}_-]+)/gu)].map(m => m[1]!.toLowerCase()))]\n    i++\n  }\n  const body = blocksFromMarkdown(parse, lines.slice(i).join('\\n'), kinds)\n\n  // A kind outside `kinds` (only reachable when called directly; `blocksFromMarkdown` makes those fences opaque) keeps its id (the views fall back via `compositeKind()`) and its meta as given.\n  const fields = kinds.find(kind => kind.id === fence.kind)?.fields.map(field => field.key)\n  const meta = fields ? Object.fromEntries(Object.entries(fence.meta).filter(([key]) => fields.includes(key))) : fence.meta\n  return {\n    type: 'composite',\n    attrs: { kind: fence.kind, meta },\n    content: [\n      title ? { type: 'compositeTitle', content: title } : { type: 'compositeTitle' },\n      description ? { type: 'compositeDescription', content: description } : { type: 'compositeDescription' },\n      { type: 'compositeTags', attrs: { tags } },\n      ...(body.length ? body : [{ type: 'paragraph' }]),\n    ],\n  }\n}\n"],"mappings":";;;AASA,SAAgB,eAAe,MAAc,MAA+B,OAAuB;CAEjG,OAAO,GADQ,OAAO,KAAK,IAAI,CAAC,CAAC,SAAS,OAAO,KAAK,GAAG,KAAK,UAAU,IAAI,MAAM,OAAO,OACxE,IAAI,MAAM;AAC7B;;;;;AAMA,SAAgB,mBAAmB,OAAoC,UAAkB,OAAgD;CACvI,OAAO,qBAAqB,QAAQ,CAAC,CAAC,SAAS,YAAY;EACzD,IAAI,EAAE,WAAW,UAAU,OAAO,MAAM,QAAQ,QAAQ,CAAC,CAAC,WAAW,CAAC;EACtE,OAAO,MAAM,MAAK,SAAQ,KAAK,OAAO,QAAQ,IAAI,IAAI,CAAC,sBAAsB,OAAO,SAAS,KAAK,CAAC,IAAI,CAAC,gBAAgB,OAAO,CAAC;CAClI,CAAC;AACH;;AAGA,SAAS,SAAS,OAAoC,IAAuC;CAC3F,IAAI;CACJ,MAAM,QAAQ,SAA4B;EACxC,IAAI,OAAO;EACX,IAAI,KAAK,SAAS,MAAK,UAAS,MAAM,SAAS,MAAM,GAAG,QAAQ,KAAK;OAChE,KAAK,SAAS,QAAQ,IAAI;CACjC;CACA,IAAI,GAAG,KAAK,GAAG,KAAK,MAAM,EAAE,CAAC;CAC7B,OAAO,OAAO,SAAS,QAAQ,KAAA;AACjC;;;;;;AAOA,SAAgB,sBAAsB,OAAoC,OAAuB,OAA8C;CAC7I,MAAM,QAAQ,MAAM,MAAM,MAAM,IAAI;CACpC,IAAI,IAAI;CACR,MAAM,kBAAkB;EACtB,OAAO,IAAI,MAAM,UAAU,CAAC,MAAM,EAAE,CAAE,KAAK,GAAG;CAChD;CACA,UAAU;CACV,IAAI;CACJ,MAAM,UAAU,mCAAmC,KAAK,MAAM,MAAM,EAAE;CACtE,IAAI,SAAS;EACX,QAAQ,SAAS,OAAO,QAAQ,MAAM,EAAE;EACxC;EACA,UAAU;CACZ;CACA,MAAM,QAAkB,CAAC;CACzB,OAAO,IAAI,MAAM,UAAU,QAAQ,KAAK,MAAM,EAAG,GAAG,MAAM,KAAK,MAAM,IAAI,CAAE,QAAQ,YAAY,EAAE,CAAC;CAClG,MAAM,cAAc,MAAM,SAAS,SAAS,OAAO,MAAM,KAAK,IAAI,CAAC,IAAI,KAAA;CACvE,UAAU;CACV,IAAI,OAAiB,CAAC;CACtB,MAAM,UAAU,qBAAqB,KAAK,MAAM,MAAM,EAAE;CACxD,IAAI,SAAS;EACX,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,QAAQ,EAAE,CAAE,SAAS,uBAAuB,CAAC,CAAC,CAAC,KAAI,MAAK,EAAE,EAAE,CAAE,YAAY,CAAC,CAAC,CAAC;EACpG;CACF;CACA,MAAM,OAAO,mBAAmB,OAAO,MAAM,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,KAAK;CAGvE,MAAM,SAAS,MAAM,MAAK,SAAQ,KAAK,OAAO,MAAM,IAAI,CAAC,EAAE,OAAO,KAAI,UAAS,MAAM,GAAG;CACxF,MAAM,OAAO,SAAS,OAAO,YAAY,OAAO,QAAQ,MAAM,IAAI,CAAC,CAAC,QAAQ,CAAC,SAAS,OAAO,SAAS,GAAG,CAAC,CAAC,IAAI,MAAM;CACrH,OAAO;EACL,MAAM;EACN,OAAO;GAAE,MAAM,MAAM;GAAM;EAAK;EAChC,SAAS;GACP,QAAQ;IAAE,MAAM;IAAkB,SAAS;GAAM,IAAI,EAAE,MAAM,iBAAiB;GAC9E,cAAc;IAAE,MAAM;IAAwB,SAAS;GAAY,IAAI,EAAE,MAAM,uBAAuB;GACtG;IAAE,MAAM;IAAiB,OAAO,EAAE,KAAK;GAAE;GACzC,GAAI,KAAK,SAAS,OAAO,CAAC,EAAE,MAAM,YAAY,CAAC;EACjD;CACF;AACF"}

package/dist/features/composites/heading-composites.d.ts

@@ -0,0 +1,36 @@
+import { StructureMode } from "../../settings/values.js";
+import "../../settings/index.js";
+import { CompositeKind } from "./kinds.js";
+import { Node, Schema } from "@tiptap/pm/model";
+//#region src/features/composites/heading-composites.d.ts
+/**
+ * `blocks` (siblings) with headings grouped into composites of `kind`. Flat: only headings of the lowest level present
+ * become composites; everything before the first such heading is kept. Recursive: bodies, the part before the first
+ * heading and the bodies of existing composites are grouped the same way. `null` when nothing changed.
+ */
+export declare function groupHeadingsIntoComposites(schema: Schema, blocks: readonly Node[], recursive: boolean, kind: string): Node[] | null;
+/** Index range `[from, to)` of the heading at `index` in `parent` plus its content: up to the next sibling heading of the same or a higher level. */
+export declare function headingGroupRange(parent: Node, index: number): {
+  from: number;
+  to: number;
+};
+/**
+ * Description, tags and meta of `composite` as plain paragraphs, in this order, each only when non-empty: the
+ * description italic, the tags as tag chips (`#name` text without a `tag` node), the meta as one `Label: Wert · …` line
+ * (labels and option labels from the composite's kind in `kinds`; raw keys and values for an unknown kind).
+ */
+export declare function compositeChromeBlocks(schema: Schema, composite: Node, kinds: readonly CompositeKind[]): Node[];
+/**
+ * Inverse of `groupHeadingsIntoComposites`: every composite in `blocks` (siblings) becomes a heading of `level` (max 6)
+ * with its title, then its chrome (`compositeChromeBlocks`), then its body (dropped when it is one empty paragraph).
+ * Recursive: nested composites in bodies become headings of `level + 1` and so on; flat: they stay. `null` when
+ * `blocks` holds no composite. Created blocks carry no id; carried-over body blocks keep theirs.
+ */
+export declare function flattenCompositesToHeadings(schema: Schema, blocks: readonly Node[], recursive: boolean, level: number, kinds: readonly CompositeKind[]): Node[] | null;
+/**
+ * `blocks` (siblings) in the preferred `structure`: `'composite'` groups headings into `section` composites at every
+ * level, `'flat'` turns composites into headings starting at `level`. Unchanged blocks come back as a copy of the array.
+ */
+export declare function structureBlocks(schema: Schema, blocks: readonly Node[], structure: StructureMode, level: number, kinds: readonly CompositeKind[]): Node[];
+//#endregion
+//# sourceMappingURL=heading-composites.d.ts.map

package/dist/features/composites/heading-composites.js

@@ -0,0 +1,140 @@
+import { compositeKind } from "./kinds.js";
+import { Fragment } from "@tiptap/pm/model";
+//#region src/features/composites/heading-composites.ts
+const HEADING = "heading";
+const COMPOSITE = "composite";
+const TITLE = "compositeTitle";
+const DESCRIPTION = "compositeDescription";
+const TAGS = "compositeTags";
+const PARAGRAPH = "paragraph";
+/** Title, description and tags: the fixed children in front of a composite's body. */
+const CHROME_COUNT = 3;
+const isHeading = (node) => node.type.name === HEADING;
+const levelOf = (node) => node.attrs.level;
+/**
+* `blocks` (siblings) with headings grouped into composites of `kind`. Flat: only headings of the lowest level present
+* become composites; everything before the first such heading is kept. Recursive: bodies, the part before the first
+* heading and the bodies of existing composites are grouped the same way. `null` when nothing changed.
+*/
+function groupHeadingsIntoComposites(schema, blocks, recursive, kind) {
+	let changed = false;
+	let input = [...blocks];
+	if (recursive) input = input.map((block) => {
+		if (block.type.name !== COMPOSITE) return block;
+		const children = [];
+		block.forEach((child) => children.push(child));
+		const body = groupHeadingsIntoComposites(schema, children.slice(CHROME_COUNT), true, kind);
+		if (!body) return block;
+		changed = true;
+		return block.copy(Fragment.from([...children.slice(0, CHROME_COUNT), ...body]));
+	});
+	let minLevel = Infinity;
+	for (const block of input) if (isHeading(block)) minLevel = Math.min(minLevel, levelOf(block));
+	if (minLevel === Infinity) return changed ? input : null;
+	const { nodes } = schema;
+	let preamble = [];
+	const groups = [];
+	for (const block of input) if (isHeading(block) && levelOf(block) <= minLevel) groups.push({
+		heading: block,
+		body: []
+	});
+	else if (groups.length) groups[groups.length - 1].body.push(block);
+	else preamble.push(block);
+	if (recursive) preamble = groupHeadingsIntoComposites(schema, preamble, true, kind) ?? preamble;
+	const composites = groups.map(({ heading, body }) => {
+		let content = body;
+		if (recursive) content = groupHeadingsIntoComposites(schema, content, true, kind) ?? content;
+		if (!content.length) content = [nodes[PARAGRAPH].create()];
+		return nodes[COMPOSITE].create({ kind }, [
+			nodes[TITLE].create(null, heading.content),
+			nodes[DESCRIPTION].create(),
+			nodes[TAGS].create(),
+			...content
+		]);
+	});
+	return [...preamble, ...composites];
+}
+/** Index range `[from, to)` of the heading at `index` in `parent` plus its content: up to the next sibling heading of the same or a higher level. */
+function headingGroupRange(parent, index) {
+	const level = levelOf(parent.child(index));
+	for (let i = index + 1; i < parent.childCount; i++) {
+		const child = parent.child(i);
+		if (isHeading(child) && levelOf(child) <= level) return {
+			from: index,
+			to: i
+		};
+	}
+	return {
+		from: index,
+		to: parent.childCount
+	};
+}
+/**
+* Description, tags and meta of `composite` as plain paragraphs, in this order, each only when non-empty: the
+* description italic, the tags as tag chips (`#name` text without a `tag` node), the meta as one `Label: Wert · …` line
+* (labels and option labels from the composite's kind in `kinds`; raw keys and values for an unknown kind).
+*/
+function compositeChromeBlocks(schema, composite, kinds) {
+	const n = schema.nodes;
+	const paragraph = n[PARAGRAPH];
+	const description = composite.child(1);
+	const tags = composite.child(2).attrs.tags;
+	const blocks = [];
+	if (description.content.size) {
+		const italic = schema.marks.italic;
+		const content = [];
+		description.forEach((child) => content.push(italic && child.isText ? child.mark(italic.create().addToSet(child.marks)) : child));
+		blocks.push(paragraph.create(null, content));
+	}
+	const names = Array.isArray(tags) ? tags.filter((tag) => typeof tag === "string" && tag !== "") : [];
+	if (names.length) {
+		const chips = names.flatMap((name, index) => [...index ? [schema.text(" ")] : [], n.tag ? n.tag.create({ name }) : schema.text(`#${name}`)]);
+		blocks.push(paragraph.create(null, chips));
+	}
+	const kind = composite.attrs.kind;
+	const fields = kinds.some((known) => known.id === kind) ? compositeKind(kinds, kind).fields : [];
+	const meta = composite.attrs.meta ?? {};
+	const entries = Object.entries(meta).filter(([, value]) => value !== "" && value !== null && value !== void 0).map(([key, value]) => {
+		const field = fields.find((candidate) => candidate.key === key);
+		const display = field?.options?.find((option) => option.value === value)?.label ?? String(value);
+		return `${field?.label ?? key}: ${display}`;
+	});
+	if (entries.length) blocks.push(paragraph.create(null, schema.text(entries.join(" · "))));
+	return blocks;
+}
+/**
+* Inverse of `groupHeadingsIntoComposites`: every composite in `blocks` (siblings) becomes a heading of `level` (max 6)
+* with its title, then its chrome (`compositeChromeBlocks`), then its body (dropped when it is one empty paragraph).
+* Recursive: nested composites in bodies become headings of `level + 1` and so on; flat: they stay. `null` when
+* `blocks` holds no composite. Created blocks carry no id; carried-over body blocks keep theirs.
+*/
+function flattenCompositesToHeadings(schema, blocks, recursive, level, kinds) {
+	if (!blocks.some((block) => block.type.name === COMPOSITE)) return null;
+	const heading = schema.nodes[HEADING];
+	return blocks.flatMap((block) => {
+		if (block.type.name !== COMPOSITE) return [block];
+		let body = [];
+		block.forEach((child, _offset, index) => {
+			if (index >= CHROME_COUNT) body.push(child);
+		});
+		if (body.length === 1 && body[0].type.name === PARAGRAPH && !body[0].content.size) body = [];
+		if (recursive) body = flattenCompositesToHeadings(schema, body, true, level + 1, kinds) ?? body;
+		return [
+			heading.create({ level: Math.min(level, 6) }, block.child(0).content),
+			...compositeChromeBlocks(schema, block, kinds),
+			...body
+		];
+	});
+}
+/**
+* `blocks` (siblings) in the preferred `structure`: `'composite'` groups headings into `section` composites at every
+* level, `'flat'` turns composites into headings starting at `level`. Unchanged blocks come back as a copy of the array.
+*/
+function structureBlocks(schema, blocks, structure, level, kinds) {
+	if (structure === "composite") return groupHeadingsIntoComposites(schema, blocks, true, "section") ?? [...blocks];
+	return flattenCompositesToHeadings(schema, blocks, true, level, kinds) ?? [...blocks];
+}
+//#endregion
+export { compositeChromeBlocks, flattenCompositesToHeadings, groupHeadingsIntoComposites, headingGroupRange, structureBlocks };
+
+//# sourceMappingURL=heading-composites.js.map