@ecsplico/editor 2.1.2 → 3.0.0

package/dist/core/block-convert.js

@@ -1,8 +1,9 @@
 import { TYPE_ABILITIES } from "./schema/abilities.js";
 import { abilitiesAt } from "./abilities.js";
+import { conversionsOf } from "./pipeline.js";
+import { guardsAccept } from "./commands.js";
 import { isBlockContainer, isChromeNode } from "./schema/node-flags.js";
 import { convertCoreBlocks, convertTargetId, coreConversionTargets, isCoreTarget, parseCoreTarget } from "./convert.js";
-import { conversionsOf } from "./pipeline.js";
 import { Extension } from "@tiptap/core";
 import { Selection } from "@tiptap/pm/state";
 import { Fragment } from "@tiptap/pm/model";
@@ -120,17 +121,37 @@ function blockConversion(providers, state, $start, target) {
 	if ($end.parent !== parent || !parent.canReplace($start.index(), $end.index(), Fragment.from(conversion.blocks))) return null;
 	return conversion;
 }
+/** The node a conversion into `target` creates, as the insert guards see it (`Creates`). */
+function createdBy(target) {
+	switch (target.type) {
+		case "heading": return {
+			type: "heading",
+			attrs: { level: target.level }
+		};
+		case "composite": return {
+			type: "composite",
+			attrs: { kind: target.kind }
+		};
+		case "custom": return {
+			type: target.id,
+			...target.attrs && { attrs: target.attrs }
+		};
+		default: return { type: target.type };
+	}
+}
 /**
 * Client-only, no schema: the `convertBlockTo` command over the preset's conversion providers — the „Umwandeln in …“
-* block action and the toolbar's conversion groups. One transaction, so one undo step.
+* block action and the toolbar's conversion groups. One transaction, so one undo step. The target must pass the same
+* insert guards as creating that node there (`guardsAccept`): a Baustein kind its parent does not accept is refused.
 */
 const BlockConvert = Extension.create({
 	name: "blockConvert",
 	addCommands() {
 		return { convertBlockTo: (target, pos) => ({ editor, state, tr, dispatch }) => {
 			const $start = blockStart(state, pos);
-			const conversion = $start && blockConversion(conversionsOf(editor), state, $start, target);
-			if (!conversion) return false;
+			if (!$start) return false;
+			const conversion = blockConversion(conversionsOf(editor), state, $start, target);
+			if (!conversion || !guardsAccept(editor, state.doc.resolve($start.start()), createdBy(target))) return false;
 			if (dispatch) {
 				tr.replaceWith(conversion.from, conversion.to, conversion.blocks);
 				const $first = tr.doc.resolve(conversion.from);
@@ -142,7 +163,8 @@ const BlockConvert = Extension.create({
 });
 /**
 * „Umwandeln in …“ entries for the block `target`: the targets the providers offer whose type the block's container
-* allows (`TYPE_ABILITIES`), one separated group per provider in feature order. A list item stands for its list.
+* allows (`TYPE_ABILITIES`), one separated group per provider in feature order; targets the block cannot be converted
+* to right now are disabled. A list item stands for its list.
 */
 function convertMenuItems(editor, target, t) {
 	let { node, pos } = target;
@@ -155,6 +177,7 @@ function convertMenuItems(editor, target, t) {
 	const abilities = abilitiesAt(editor, pos);
 	return conversionTargetGroups(providers, editor, node).map((targets) => targets.filter((to) => !TYPE_ABILITIES[to.type] || abilities.has(TYPE_ABILITIES[to.type])).map((to) => ({
 		...conversionLabel(providers, to, t),
+		disabled: !editor.can().convertBlockTo(to, pos),
 		onSelect: () => editor.chain().focus().convertBlockTo(to, pos).run()
 	}))).filter((items) => items.length > 0).flatMap((items, index) => index ? [{ type: "separator" }, ...items] : items);
 }

package/dist/core/block-convert.js.map

@@ -1 +1 @@
-{"version":3,"file":"block-convert.js","names":[],"sources":["../../src/core/block-convert.ts"],"sourcesContent":["import { type Editor, Extension } from '@tiptap/core'\nimport { Fragment, type Node as PMNode, type ResolvedPos } from '@tiptap/pm/model'\nimport { type EditorState, Selection } from '@tiptap/pm/state'\nimport { abilitiesAt } from './abilities'\nimport { type ConvertTarget, convertCoreBlocks, convertTargetId, coreConversionTargets, isCoreTarget, parseCoreTarget } from './convert'\nimport type { BlockTarget } from './extension-points'\nimport type { ConversionProvider } from './feature'\nimport type { MessageKey, Translate } from '../i18n'\nimport { conversionsOf } from './pipeline'\nimport { isBlockContainer, isChromeNode } from './schema/node-flags'\nimport { TYPE_ABILITIES } from './schema/abilities'\nimport type { MenuItem } from './toolbar'\n\ndeclare module '@tiptap/core' {\n  interface Commands<ReturnType> {\n    blockConvert: {\n      /**\n       * Convert the block at `pos` (default: the caret's block in the document or another block container; a chrome\n       * node stands for its parent) into `target`. False when the conversion changes nothing or is impossible there.\n       */\n      convertBlockTo: (target: ConvertTarget, pos?: number) => ReturnType\n    }\n  }\n}\n\nconst CORE_LABELS: Record<string, { key: MessageKey, icon: string }> = {\n  paragraph: { key: 'block.paragraph', icon: 'i-lucide-pilcrow' },\n  bulletList: { key: 'block.bulletList', icon: 'i-lucide-list' },\n  orderedList: { key: 'block.orderedList', icon: 'i-lucide-list-ordered' },\n  blockquote: { key: 'block.blockquote', icon: 'i-lucide-text-quote' },\n  codeBlock: { key: 'block.codeBlock', icon: 'i-lucide-square-code' },\n}\n\n/**\n * The standard conversions: paragraphs, headings, lists, quotes and code blocks into each other. Declines every other\n * target, so features that add targets (speaker segments, composites) own them in their own providers.\n */\nexport const coreConversions: ConversionProvider = {\n  targets: (_editor, node) => coreConversionTargets(node),\n  parseTarget: parseCoreTarget,\n  label: (target, t) => {\n    if (target.type === 'heading') return { label: t('block.heading', { level: target.level }), icon: `i-lucide-heading-${target.level}` }\n    const core = isCoreTarget(target) ? CORE_LABELS[target.type] : undefined\n    return core ? { label: t(core.key), icon: core.icon } : null\n  },\n  convert: (state, $start, target) => {\n    const node = $start.nodeAfter\n    if (!node) return null\n    const blocks = convertCoreBlocks(state.schema, [node], target)\n    return blocks ? { from: $start.pos, to: $start.pos + node.nodeSize, blocks } : null\n  },\n}\n\n/** The provider that owns `target`: the first, in feature order, that parses its id. */\nexport function targetOwner(providers: readonly ConversionProvider[], target: ConvertTarget): ConversionProvider | undefined {\n  const id = convertTargetId(target)\n  return providers.find(provider => provider.parseTarget(id) !== null)\n}\n\n/** The target `id` names, by its owner; null when no provider knows it. */\nexport function parseConversionTarget(providers: readonly ConversionProvider[], id: string): ConvertTarget | null {\n  for (const provider of providers) {\n    const target = provider.parseTarget(id)\n    if (target) return target\n  }\n  return null\n}\n\n/** Label (in the language of `t`) and icon of `target`, from its owner. */\nexport function conversionLabel(providers: readonly ConversionProvider[], target: ConvertTarget, t: Translate): { label: string, icon: string } {\n  const label = targetOwner(providers, target)?.label(target, t)\n  if (!label) throw new Error(`@ecsplico/editor: no conversion provider owns the target \"${convertTargetId(target)}\"`)\n  return label\n}\n\n/** The targets offered for `node` per provider, in feature order; a target id offered twice is an error. */\nexport function conversionTargetGroups(providers: readonly ConversionProvider[], editor: Editor, node: PMNode): ConvertTarget[][] {\n  const offered = new Set<string>()\n  return providers.map(provider => provider.targets(editor, node).filter((target) => {\n    const id = convertTargetId(target)\n    if (offered.has(id)) throw new Error(`@ecsplico/editor: the conversion target \"${id}\" is advertised by more than one provider`)\n    offered.add(id)\n    return true\n  }))\n}\n\n/** The `$pos` right in front of the block to convert; a chrome node stands for its parent block. */\nfunction blockStart(state: EditorState, pos: number | undefined): ResolvedPos | null {\n  let $start: ResolvedPos\n  if (pos === undefined) {\n    // The caret's block whose parent is a block container (the document, a composite).\n    const { $head } = state.selection\n    let depth = $head.depth\n    while (depth > 0 && !isBlockContainer($head.node(depth - 1))) depth--\n    if (depth === 0) return null\n    $start = state.doc.resolve($head.before(depth))\n  }\n  else {\n    if (pos < 0 || pos >= state.doc.content.size) return null\n    $start = state.doc.resolve(pos)\n  }\n  const node = $start.nodeAfter\n  if (!node) return null\n  return isChromeNode(node) ? state.doc.resolve($start.before()) : $start\n}\n\n/**\n * The conversion of the block right after `$start` into `target`: the range it replaces and the converted blocks.\n * A provider claiming the source block (`handlesSource`) executes; otherwise the target's owner does. Null when the\n * conversion changes nothing or the result does not fit there (`parent.canReplace`). Shared by `convertBlockTo` and\n * the chat's `convert` op.\n */\nexport function blockConversion(providers: readonly ConversionProvider[], state: EditorState, $start: ResolvedPos, target: ConvertTarget): { from: number, to: number, blocks: PMNode[] } | null {\n  const node = $start.nodeAfter\n  if (!node) return null\n  const provider = providers.find(candidate => candidate.handlesSource?.(node)) ?? targetOwner(providers, target)\n  const conversion = provider?.convert(state, $start, target)\n  if (!conversion) return null\n  const parent = $start.parent\n  const $end = state.doc.resolve(conversion.to)\n  if ($end.parent !== parent || !parent.canReplace($start.index(), $end.index(), Fragment.from(conversion.blocks))) return null\n  return conversion\n}\n\n/**\n * Client-only, no schema: the `convertBlockTo` command over the preset's conversion providers — the „Umwandeln in …“\n * block action and the toolbar's conversion groups. One transaction, so one undo step.\n */\nexport const BlockConvert = Extension.create({\n  name: 'blockConvert',\n\n  addCommands() {\n    return {\n      convertBlockTo: (target, pos) => ({ editor, state, tr, dispatch }) => {\n        const $start = blockStart(state, pos)\n        const conversion = $start && blockConversion(conversionsOf(editor), state, $start, target)\n        if (!conversion) return false\n        if (dispatch) {\n          tr.replaceWith(conversion.from, conversion.to, conversion.blocks)\n          const $first = tr.doc.resolve(conversion.from)\n          tr.setSelection(Selection.findFrom($first, 1, true) ?? Selection.near($first)).scrollIntoView()\n        }\n        return true\n      },\n    }\n  },\n})\n\n/**\n * „Umwandeln in …“ entries for the block `target`: the targets the providers offer whose type the block's container\n * allows (`TYPE_ABILITIES`), one separated group per provider in feature order. A list item stands for its list.\n */\nexport function convertMenuItems(editor: Editor, target: BlockTarget, t: Translate): MenuItem[] {\n  let { node, pos } = target\n  if (node.type.name === 'listItem') {\n    const $item = editor.state.doc.resolve(pos)\n    node = $item.parent\n    pos = $item.before()\n  }\n  const providers = conversionsOf(editor)\n  const abilities = abilitiesAt(editor, pos)\n  const groups = conversionTargetGroups(providers, editor, node)\n    .map(targets => targets\n      .filter(to => !TYPE_ABILITIES[to.type] || abilities.has(TYPE_ABILITIES[to.type]!))\n      .map((to): MenuItem => ({\n        ...conversionLabel(providers, to, t),\n        onSelect: () => editor.chain().focus().convertBlockTo(to, pos).run(),\n      })))\n    .filter(items => items.length > 0)\n  return groups.flatMap((items, index) => index ? [{ type: 'separator' } as const, ...items] : items)\n}\n"],"mappings":"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"}
+{"version":3,"file":"block-convert.js","names":[],"sources":["../../src/core/block-convert.ts"],"sourcesContent":["import { type Editor, Extension } from '@tiptap/core'\nimport { Fragment, type Node as PMNode, type ResolvedPos } from '@tiptap/pm/model'\nimport { type EditorState, Selection } from '@tiptap/pm/state'\nimport { abilitiesAt } from './abilities'\nimport type { Creates, MenuItem } from './command-types'\nimport { guardsAccept } from './commands'\nimport { type ConvertTarget, convertCoreBlocks, convertTargetId, coreConversionTargets, isCoreTarget, parseCoreTarget } from './convert'\nimport type { BlockTarget } from './extension-points'\nimport type { ConversionProvider } from './feature'\nimport type { MessageKey, Translate } from '../i18n'\nimport { conversionsOf } from './pipeline'\nimport { isBlockContainer, isChromeNode } from './schema/node-flags'\nimport { TYPE_ABILITIES } from './schema/abilities'\n\ndeclare module '@tiptap/core' {\n  interface Commands<ReturnType> {\n    blockConvert: {\n      /**\n       * Convert the block at `pos` (default: the caret's block in the document or another block container; a chrome\n       * node stands for its parent) into `target`. False when the conversion changes nothing or is impossible there.\n       */\n      convertBlockTo: (target: ConvertTarget, pos?: number) => ReturnType\n    }\n  }\n}\n\nconst CORE_LABELS: Record<string, { key: MessageKey, icon: string }> = {\n  paragraph: { key: 'block.paragraph', icon: 'i-lucide-pilcrow' },\n  bulletList: { key: 'block.bulletList', icon: 'i-lucide-list' },\n  orderedList: { key: 'block.orderedList', icon: 'i-lucide-list-ordered' },\n  blockquote: { key: 'block.blockquote', icon: 'i-lucide-text-quote' },\n  codeBlock: { key: 'block.codeBlock', icon: 'i-lucide-square-code' },\n}\n\n/**\n * The standard conversions: paragraphs, headings, lists, quotes and code blocks into each other. Declines every other\n * target, so features that add targets (speaker segments, composites) own them in their own providers.\n */\nexport const coreConversions: ConversionProvider = {\n  targets: (_editor, node) => coreConversionTargets(node),\n  parseTarget: parseCoreTarget,\n  label: (target, t) => {\n    if (target.type === 'heading') return { label: t('block.heading', { level: target.level }), icon: `i-lucide-heading-${target.level}` }\n    const core = isCoreTarget(target) ? CORE_LABELS[target.type] : undefined\n    return core ? { label: t(core.key), icon: core.icon } : null\n  },\n  convert: (state, $start, target) => {\n    const node = $start.nodeAfter\n    if (!node) return null\n    const blocks = convertCoreBlocks(state.schema, [node], target)\n    return blocks ? { from: $start.pos, to: $start.pos + node.nodeSize, blocks } : null\n  },\n}\n\n/** The provider that owns `target`: the first, in feature order, that parses its id. */\nexport function targetOwner(providers: readonly ConversionProvider[], target: ConvertTarget): ConversionProvider | undefined {\n  const id = convertTargetId(target)\n  return providers.find(provider => provider.parseTarget(id) !== null)\n}\n\n/** The target `id` names, by its owner; null when no provider knows it. */\nexport function parseConversionTarget(providers: readonly ConversionProvider[], id: string): ConvertTarget | null {\n  for (const provider of providers) {\n    const target = provider.parseTarget(id)\n    if (target) return target\n  }\n  return null\n}\n\n/** Label (in the language of `t`) and icon of `target`, from its owner. */\nexport function conversionLabel(providers: readonly ConversionProvider[], target: ConvertTarget, t: Translate): { label: string, icon: string } {\n  const label = targetOwner(providers, target)?.label(target, t)\n  if (!label) throw new Error(`@ecsplico/editor: no conversion provider owns the target \"${convertTargetId(target)}\"`)\n  return label\n}\n\n/** The targets offered for `node` per provider, in feature order; a target id offered twice is an error. */\nexport function conversionTargetGroups(providers: readonly ConversionProvider[], editor: Editor, node: PMNode): ConvertTarget[][] {\n  const offered = new Set<string>()\n  return providers.map(provider => provider.targets(editor, node).filter((target) => {\n    const id = convertTargetId(target)\n    if (offered.has(id)) throw new Error(`@ecsplico/editor: the conversion target \"${id}\" is advertised by more than one provider`)\n    offered.add(id)\n    return true\n  }))\n}\n\n/** The `$pos` right in front of the block to convert; a chrome node stands for its parent block. */\nfunction blockStart(state: EditorState, pos: number | undefined): ResolvedPos | null {\n  let $start: ResolvedPos\n  if (pos === undefined) {\n    // The caret's block whose parent is a block container (the document, a composite).\n    const { $head } = state.selection\n    let depth = $head.depth\n    while (depth > 0 && !isBlockContainer($head.node(depth - 1))) depth--\n    if (depth === 0) return null\n    $start = state.doc.resolve($head.before(depth))\n  }\n  else {\n    if (pos < 0 || pos >= state.doc.content.size) return null\n    $start = state.doc.resolve(pos)\n  }\n  const node = $start.nodeAfter\n  if (!node) return null\n  return isChromeNode(node) ? state.doc.resolve($start.before()) : $start\n}\n\n/**\n * The conversion of the block right after `$start` into `target`: the range it replaces and the converted blocks.\n * A provider claiming the source block (`handlesSource`) executes; otherwise the target's owner does. Null when the\n * conversion changes nothing or the result does not fit there (`parent.canReplace`). Shared by `convertBlockTo` and\n * the chat's `convert` op.\n */\nexport function blockConversion(providers: readonly ConversionProvider[], state: EditorState, $start: ResolvedPos, target: ConvertTarget): { from: number, to: number, blocks: PMNode[] } | null {\n  const node = $start.nodeAfter\n  if (!node) return null\n  const provider = providers.find(candidate => candidate.handlesSource?.(node)) ?? targetOwner(providers, target)\n  const conversion = provider?.convert(state, $start, target)\n  if (!conversion) return null\n  const parent = $start.parent\n  const $end = state.doc.resolve(conversion.to)\n  if ($end.parent !== parent || !parent.canReplace($start.index(), $end.index(), Fragment.from(conversion.blocks))) return null\n  return conversion\n}\n\n/** The node a conversion into `target` creates, as the insert guards see it (`Creates`). */\nfunction createdBy(target: ConvertTarget): Creates {\n  switch (target.type) {\n    case 'heading': return { type: 'heading', attrs: { level: target.level } }\n    case 'composite': return { type: 'composite', attrs: { kind: target.kind } }\n    case 'custom': return { type: target.id, ...(target.attrs && { attrs: target.attrs }) }\n    default: return { type: target.type }\n  }\n}\n\n/**\n * Client-only, no schema: the `convertBlockTo` command over the preset's conversion providers — the „Umwandeln in …“\n * block action and the toolbar's conversion groups. One transaction, so one undo step. The target must pass the same\n * insert guards as creating that node there (`guardsAccept`): a Baustein kind its parent does not accept is refused.\n */\nexport const BlockConvert = Extension.create({\n  name: 'blockConvert',\n\n  addCommands() {\n    return {\n      convertBlockTo: (target, pos) => ({ editor, state, tr, dispatch }) => {\n        const $start = blockStart(state, pos)\n        if (!$start) return false\n        const conversion = blockConversion(conversionsOf(editor), state, $start, target)\n        if (!conversion || !guardsAccept(editor, state.doc.resolve($start.start()), createdBy(target))) return false\n        if (dispatch) {\n          tr.replaceWith(conversion.from, conversion.to, conversion.blocks)\n          const $first = tr.doc.resolve(conversion.from)\n          tr.setSelection(Selection.findFrom($first, 1, true) ?? Selection.near($first)).scrollIntoView()\n        }\n        return true\n      },\n    }\n  },\n})\n\n/**\n * „Umwandeln in …“ entries for the block `target`: the targets the providers offer whose type the block's container\n * allows (`TYPE_ABILITIES`), one separated group per provider in feature order; targets the block cannot be converted\n * to right now are disabled. A list item stands for its list.\n */\nexport function convertMenuItems(editor: Editor, target: BlockTarget, t: Translate): MenuItem[] {\n  let { node, pos } = target\n  if (node.type.name === 'listItem') {\n    const $item = editor.state.doc.resolve(pos)\n    node = $item.parent\n    pos = $item.before()\n  }\n  const providers = conversionsOf(editor)\n  const abilities = abilitiesAt(editor, pos)\n  const groups = conversionTargetGroups(providers, editor, node)\n    .map(targets => targets\n      .filter(to => !TYPE_ABILITIES[to.type] || abilities.has(TYPE_ABILITIES[to.type]!))\n      .map((to): MenuItem => ({\n        ...conversionLabel(providers, to, t),\n        disabled: !editor.can().convertBlockTo(to, pos),\n        onSelect: () => editor.chain().focus().convertBlockTo(to, pos).run(),\n      })))\n    .filter(items => items.length > 0)\n  return groups.flatMap((items, index) => index ? [{ type: 'separator' } as const, ...items] : items)\n}\n"],"mappings":";;;;;;;;;;AA0BA,MAAM,cAAiE;CACrE,WAAW;EAAE,KAAK;EAAmB,MAAM;CAAmB;CAC9D,YAAY;EAAE,KAAK;EAAoB,MAAM;CAAgB;CAC7D,aAAa;EAAE,KAAK;EAAqB,MAAM;CAAwB;CACvE,YAAY;EAAE,KAAK;EAAoB,MAAM;CAAsB;CACnE,WAAW;EAAE,KAAK;EAAmB,MAAM;CAAuB;AACpE;;;;;AAMA,MAAa,kBAAsC;CACjD,UAAU,SAAS,SAAS,sBAAsB,IAAI;CACtD,aAAa;CACb,QAAQ,QAAQ,MAAM;EACpB,IAAI,OAAO,SAAS,WAAW,OAAO;GAAE,OAAO,EAAE,iBAAiB,EAAE,OAAO,OAAO,MAAM,CAAC;GAAG,MAAM,oBAAoB,OAAO;EAAQ;EACrI,MAAM,OAAO,aAAa,MAAM,IAAI,YAAY,OAAO,QAAQ,KAAA;EAC/D,OAAO,OAAO;GAAE,OAAO,EAAE,KAAK,GAAG;GAAG,MAAM,KAAK;EAAK,IAAI;CAC1D;CACA,UAAU,OAAO,QAAQ,WAAW;EAClC,MAAM,OAAO,OAAO;EACpB,IAAI,CAAC,MAAM,OAAO;EAClB,MAAM,SAAS,kBAAkB,MAAM,QAAQ,CAAC,IAAI,GAAG,MAAM;EAC7D,OAAO,SAAS;GAAE,MAAM,OAAO;GAAK,IAAI,OAAO,MAAM,KAAK;GAAU;EAAO,IAAI;CACjF;AACF;;AAGA,SAAgB,YAAY,WAA0C,QAAuD;CAC3H,MAAM,KAAK,gBAAgB,MAAM;CACjC,OAAO,UAAU,MAAK,aAAY,SAAS,YAAY,EAAE,MAAM,IAAI;AACrE;;AAGA,SAAgB,sBAAsB,WAA0C,IAAkC;CAChH,KAAK,MAAM,YAAY,WAAW;EAChC,MAAM,SAAS,SAAS,YAAY,EAAE;EACtC,IAAI,QAAQ,OAAO;CACrB;CACA,OAAO;AACT;;AAGA,SAAgB,gBAAgB,WAA0C,QAAuB,GAA+C;CAC9I,MAAM,QAAQ,YAAY,WAAW,MAAM,CAAC,EAAE,MAAM,QAAQ,CAAC;CAC7D,IAAI,CAAC,OAAO,MAAM,IAAI,MAAM,6DAA6D,gBAAgB,MAAM,EAAE,EAAE;CACnH,OAAO;AACT;;AAGA,SAAgB,uBAAuB,WAA0C,QAAgB,MAAiC;CAChI,MAAM,0BAAU,IAAI,IAAY;CAChC,OAAO,UAAU,KAAI,aAAY,SAAS,QAAQ,QAAQ,IAAI,CAAC,CAAC,QAAQ,WAAW;EACjF,MAAM,KAAK,gBAAgB,MAAM;EACjC,IAAI,QAAQ,IAAI,EAAE,GAAG,MAAM,IAAI,MAAM,4CAA4C,GAAG,0CAA0C;EAC9H,QAAQ,IAAI,EAAE;EACd,OAAO;CACT,CAAC,CAAC;AACJ;;AAGA,SAAS,WAAW,OAAoB,KAA6C;CACnF,IAAI;CACJ,IAAI,QAAQ,KAAA,GAAW;EAErB,MAAM,EAAE,UAAU,MAAM;EACxB,IAAI,QAAQ,MAAM;EAClB,OAAO,QAAQ,KAAK,CAAC,iBAAiB,MAAM,KAAK,QAAQ,CAAC,CAAC,GAAG;EAC9D,IAAI,UAAU,GAAG,OAAO;EACxB,SAAS,MAAM,IAAI,QAAQ,MAAM,OAAO,KAAK,CAAC;CAChD,OACK;EACH,IAAI,MAAM,KAAK,OAAO,MAAM,IAAI,QAAQ,MAAM,OAAO;EACrD,SAAS,MAAM,IAAI,QAAQ,GAAG;CAChC;CACA,MAAM,OAAO,OAAO;CACpB,IAAI,CAAC,MAAM,OAAO;CAClB,OAAO,aAAa,IAAI,IAAI,MAAM,IAAI,QAAQ,OAAO,OAAO,CAAC,IAAI;AACnE;;;;;;;AAQA,SAAgB,gBAAgB,WAA0C,OAAoB,QAAqB,QAA8E;CAC/L,MAAM,OAAO,OAAO;CACpB,IAAI,CAAC,MAAM,OAAO;CAElB,MAAM,cADW,UAAU,MAAK,cAAa,UAAU,gBAAgB,IAAI,CAAC,KAAK,YAAY,WAAW,MAAM,EAAA,EACjF,QAAQ,OAAO,QAAQ,MAAM;CAC1D,IAAI,CAAC,YAAY,OAAO;CACxB,MAAM,SAAS,OAAO;CACtB,MAAM,OAAO,MAAM,IAAI,QAAQ,WAAW,EAAE;CAC5C,IAAI,KAAK,WAAW,UAAU,CAAC,OAAO,WAAW,OAAO,MAAM,GAAG,KAAK,MAAM,GAAG,SAAS,KAAK,WAAW,MAAM,CAAC,GAAG,OAAO;CACzH,OAAO;AACT;;AAGA,SAAS,UAAU,QAAgC;CACjD,QAAQ,OAAO,MAAf;EACE,KAAK,WAAW,OAAO;GAAE,MAAM;GAAW,OAAO,EAAE,OAAO,OAAO,MAAM;EAAE;EACzE,KAAK,aAAa,OAAO;GAAE,MAAM;GAAa,OAAO,EAAE,MAAM,OAAO,KAAK;EAAE;EAC3E,KAAK,UAAU,OAAO;GAAE,MAAM,OAAO;GAAI,GAAI,OAAO,SAAS,EAAE,OAAO,OAAO,MAAM;EAAG;EACtF,SAAS,OAAO,EAAE,MAAM,OAAO,KAAK;CACtC;AACF;;;;;;AAOA,MAAa,eAAe,UAAU,OAAO;CAC3C,MAAM;CAEN,cAAc;EACZ,OAAO,EACL,iBAAiB,QAAQ,SAAS,EAAE,QAAQ,OAAO,IAAI,eAAe;GACpE,MAAM,SAAS,WAAW,OAAO,GAAG;GACpC,IAAI,CAAC,QAAQ,OAAO;GACpB,MAAM,aAAa,gBAAgB,cAAc,MAAM,GAAG,OAAO,QAAQ,MAAM;GAC/E,IAAI,CAAC,cAAc,CAAC,aAAa,QAAQ,MAAM,IAAI,QAAQ,OAAO,MAAM,CAAC,GAAG,UAAU,MAAM,CAAC,GAAG,OAAO;GACvG,IAAI,UAAU;IACZ,GAAG,YAAY,WAAW,MAAM,WAAW,IAAI,WAAW,MAAM;IAChE,MAAM,SAAS,GAAG,IAAI,QAAQ,WAAW,IAAI;IAC7C,GAAG,aAAa,UAAU,SAAS,QAAQ,GAAG,IAAI,KAAK,UAAU,KAAK,MAAM,CAAC,CAAC,CAAC,eAAe;GAChG;GACA,OAAO;EACT,EACF;CACF;AACF,CAAC;;;;;;AAOD,SAAgB,iBAAiB,QAAgB,QAAqB,GAA0B;CAC9F,IAAI,EAAE,MAAM,QAAQ;CACpB,IAAI,KAAK,KAAK,SAAS,YAAY;EACjC,MAAM,QAAQ,OAAO,MAAM,IAAI,QAAQ,GAAG;EAC1C,OAAO,MAAM;EACb,MAAM,MAAM,OAAO;CACrB;CACA,MAAM,YAAY,cAAc,MAAM;CACtC,MAAM,YAAY,YAAY,QAAQ,GAAG;CAUzC,OATe,uBAAuB,WAAW,QAAQ,IAAI,CAAC,CAC3D,KAAI,YAAW,QACb,QAAO,OAAM,CAAC,eAAe,GAAG,SAAS,UAAU,IAAI,eAAe,GAAG,KAAM,CAAC,CAAC,CACjF,KAAK,QAAkB;EACtB,GAAG,gBAAgB,WAAW,IAAI,CAAC;EACnC,UAAU,CAAC,OAAO,IAAI,CAAC,CAAC,eAAe,IAAI,GAAG;EAC9C,gBAAgB,OAAO,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,eAAe,IAAI,GAAG,CAAC,CAAC,IAAI;CACrE,EAAE,CAAC,CAAC,CACL,QAAO,UAAS,MAAM,SAAS,CACtB,CAAC,CAAC,SAAS,OAAO,UAAU,QAAQ,CAAC,EAAE,MAAM,YAAY,GAAY,GAAG,KAAK,IAAI,KAAK;AACpG"}

package/dist/core/command-types.d.ts

@@ -0,0 +1,89 @@
+import { MessageKey } from "../i18n/index.js";
+import { Ability } from "./schema/abilities.js";
+import { Editor } from "@tiptap/core";
+import { ResolvedPos } from "@tiptap/pm/model";
+//#region src/core/command-types.d.ts
+/** One row of a dropdown a command or block action opens; the framework layer renders it. */
+export interface MenuItem {
+  type?: 'label' | 'separator';
+  label?: string;
+  description?: string;
+  /** Iconify name, e.g. `i-lucide-heading-1`. */
+  icon?: string;
+  disabled?: boolean;
+  onSelect?: () => void;
+}
+/** The node a command inserts at the caret; enables the schema and accepted-children fit check. */
+export interface Creates {
+  type: string;
+  attrs?: Record<string, unknown>;
+}
+export interface CommandBase {
+  /** Unique among the commands of one editor (host commands included). */
+  id: string;
+  /** Tooltip, aria-label and `/` menu text. */
+  label: string;
+  /** Iconify name, e.g. `i-lucide-bold`. */
+  icon: string;
+  /** Shortcut keys shown in the tooltip, e.g. `['meta', 'b']`. */
+  kbds?: string[];
+  /** Ability the command needs at the caret (toolbar: at the selection); an active toggle never needs it. Unset: ungated. */
+  ability?: Ability;
+  /** The node the command inserts; the command is enabled only where `canCreateAt` says it fits (schema and registered insert guards). */
+  creates?: Creates;
+  /** Further structural check (`editor.can()` style); with `creates`, both must hold. Default: always. */
+  can?: (editor: Editor) => boolean;
+  /** Whether the command is on at the caret (toggle style). An active command is always enabled. */
+  active?: (editor: Editor) => boolean;
+  /** Hides the command everywhere; evaluated only with a live editor. */
+  visible?: (editor: Editor) => boolean;
+  /** Toolbar placement: the group (declared by a feature's `toolbarGroups`) and the position within it. Default: none. */
+  toolbar?: {
+    group: string;
+    order?: number;
+  } | false;
+  /** `/` menu placement (`run` commands only): `id` is what is typed after `/` (default: the command id). Default: none. */
+  slash?: {
+    id?: string;
+  } | false;
+  /** Listed by the ⌘K palette. Default: true for `run` and `menu` commands, false for `component` commands. */
+  palette?: boolean;
+}
+/**
+ * `run` on click or pick, `menu` (a dropdown of the items it returns), or `component`: a toolbar component that renders
+ * the whole button itself (own popover, badge or state) and receives `{ editor }`; `ability`, `active` and `can` are not
+ * applied to it, and it never has a `slash` placement.
+ */
+export type CommandDef<C = unknown> = CommandBase & ({
+  run: (editor: Editor) => void;
+} | {
+  menu: (editor: Editor) => MenuItem[];
+} | {
+  component: C;
+});
+/** A visually joined set of toolbar buttons; features declare the groups their commands name. */
+export interface ToolbarGroupDef {
+  id: string;
+  /** Position among the groups (ascending, stable). */
+  order?: number;
+  /** Catalog key of the group's heading in the ⌘K palette (default: the group id). */
+  labelKey?: MessageKey;
+  /** Hides the group; evaluated only with a live editor. */
+  visible?: (editor: Editor) => boolean;
+}
+/** A toolbar group with the commands placed in it, in `toolbar.order`. */
+export interface PlacedToolbarGroup<C = unknown> extends ToolbarGroupDef {
+  items: CommandDef<C>[];
+}
+/**
+ * Checks whether `creates` may be inserted into the ancestor that `canCreateAt` found: `$parent.parent` is the node
+ * that would receive it. Features contribute guards (`EditorFeature.insertGuards`), e.g. the accepted children of a Baustein.
+ */
+export type InsertGuard = (editor: Editor, $parent: ResolvedPos, creates: Creates) => boolean;
+export interface CommandState {
+  visible: boolean;
+  enabled: boolean;
+  active: boolean;
+}
+//#endregion
+//# sourceMappingURL=command-types.d.ts.map

package/dist/core/commands.d.ts

@@ -0,0 +1,40 @@
+import { CommandBase, CommandDef, CommandState, Creates, InsertGuard, MenuItem, PlacedToolbarGroup, ToolbarGroupDef } from "./command-types.js";
+import { EditorPreset, FeatureContext } from "./feature.js";
+import { ChainedCommands, Editor } from "@tiptap/core";
+import { ResolvedPos } from "@tiptap/pm/model";
+//#region src/core/commands.d.ts
+/**
+ * A command over a command chain: `run` focuses the editor and executes `command`; the command is disabled while
+ * `can()` says it is structurally impossible (also an empty undo history). With `creates`, `commandState` additionally
+ * requires the node to fit at the caret.
+ */
+export declare function command(def: Omit<CommandBase, 'can'> & {
+  command: (chain: ChainedCommands) => ChainedCommands;
+}): CommandDef<never>;
+/**
+ * Whether every registered insert guard accepts `creates` below the ancestor `$parent` stands for (`$parent.parent` is the
+ * node that would receive it). The one rule behind both creation (`canCreateAt`) and conversion targets (`convertBlockTo`).
+ */
+export declare function guardsAccept(editor: Editor, $parent: ResolvedPos, creates: Creates): boolean;
+/**
+ * Whether a node like `creates` may be inserted at `$pos`: walks from the caret's depth outward to the first ancestor
+ * whose content accepts the type at the caret's index, then every registered insert guard must accept it there.
+ */
+export declare function canCreateAt(editor: Editor, $pos: ResolvedPos, creates: Creates): boolean;
+/**
+ * The state of `cmd` for the toolbar (`'selection'`: abilities of the selection) or the `/` menu (`'caret'`). `$at`
+ * replaces the caret position (the `/` plugin evaluates inside a transaction's `apply`, where `editor.state` is still
+ * the old state); `can` hooks always read `editor.state`.
+ */
+export declare function commandState(editor: Editor, cmd: CommandDef, at: 'selection' | 'caret', $at?: ResolvedPos): CommandState;
+/** The commands of the preset's features in feature order. Throws when two commands share an id. */
+export declare function commandsOf<C>(preset: EditorPreset<C>, ctx: FeatureContext): CommandDef<C>[];
+/**
+ * The toolbar of `preset`: the groups features declare (`toolbarGroups`) with every command that has a `toolbar`
+ * placement, groups and commands sorted by `order` (stable). Throws when a command names a group no feature declares
+ * or two commands share an id.
+ */
+export declare function toolbarOf<C>(preset: EditorPreset<C>, ctx: FeatureContext): PlacedToolbarGroup<C>[];
+//#endregion
+export type { CommandBase, CommandDef, CommandState, Creates, InsertGuard, MenuItem, PlacedToolbarGroup, ToolbarGroupDef };
+//# sourceMappingURL=commands.d.ts.map

package/dist/core/commands.js

@@ -0,0 +1,151 @@
+import { abilitiesAt, abilitiesAtSelection } from "./abilities.js";
+import { byOrder, fail } from "./util.js";
+import { contributions } from "./define-editor.js";
+import { editorEntryOf } from "./editor-ui.js";
+//#region src/core/commands.ts
+const guardCache = /* @__PURE__ */ new WeakMap();
+function guardsOf(editor) {
+	const entry = editorEntryOf(editor);
+	if (!entry) return [];
+	let guards = guardCache.get(entry);
+	if (!guards) {
+		guards = contributions(entry.preset, "insertGuards").flatMap((factory) => factory(entry.ctx));
+		guardCache.set(entry, guards);
+	}
+	return guards;
+}
+/**
+* A command over a command chain: `run` focuses the editor and executes `command`; the command is disabled while
+* `can()` says it is structurally impossible (also an empty undo history). With `creates`, `commandState` additionally
+* requires the node to fit at the caret.
+*/
+function command(def) {
+	const { command: chainOf, ...rest } = def;
+	return {
+		...rest,
+		can: (editor) => chainOf(editor.can().chain()).run(),
+		run: (editor) => {
+			chainOf(editor.chain().focus()).run();
+		}
+	};
+}
+/**
+* Whether every registered insert guard accepts `creates` below the ancestor `$parent` stands for (`$parent.parent` is the
+* node that would receive it). The one rule behind both creation (`canCreateAt`) and conversion targets (`convertBlockTo`).
+*/
+function guardsAccept(editor, $parent, creates) {
+	return guardsOf(editor).every((guard) => guard(editor, $parent, creates));
+}
+/**
+* Whether a node like `creates` may be inserted at `$pos`: walks from the caret's depth outward to the first ancestor
+* whose content accepts the type at the caret's index, then every registered insert guard must accept it there.
+*/
+function canCreateAt(editor, $pos, creates) {
+	const type = editor.schema.nodes[creates.type];
+	if (!type) return false;
+	for (let depth = $pos.depth; depth >= 0; depth--) {
+		const index = $pos.index(depth);
+		if (!$pos.node(depth).canReplaceWith(index, index, type)) continue;
+		return guardsAccept(editor, $pos.doc.resolve($pos.start(depth)), creates);
+	}
+	return false;
+}
+/**
+* The state of `cmd` for the toolbar (`'selection'`: abilities of the selection) or the `/` menu (`'caret'`). `$at`
+* replaces the caret position (the `/` plugin evaluates inside a transaction's `apply`, where `editor.state` is still
+* the old state); `can` hooks always read `editor.state`.
+*/
+function commandState(editor, cmd, at, $at) {
+	const visible = cmd.visible?.(editor) ?? true;
+	if ("component" in cmd) return {
+		visible,
+		enabled: true,
+		active: false
+	};
+	const active = cmd.active?.(editor) ?? false;
+	if (active) return {
+		visible,
+		enabled: true,
+		active
+	};
+	const $from = $at ?? editor.state.selection.$from;
+	if (cmd.ability) {
+		if (!(at === "selection" && !$at ? abilitiesAtSelection(editor) : abilitiesAt(editor, $from)).has(cmd.ability)) return {
+			visible,
+			enabled: false,
+			active
+		};
+	}
+	return {
+		visible,
+		enabled: (!cmd.can || cmd.can(editor)) && (!cmd.creates || canCreateAt(editor, $from, cmd.creates)),
+		active
+	};
+}
+/** The commands of the preset's features in feature order. Throws when two commands share an id. */
+function commandsOf(preset, ctx) {
+	return collect(preset, ctx).commands;
+}
+const ownerOfCommand = /* @__PURE__ */ new WeakMap();
+/**
+* Throws when two of `commands` share an id (`CommandBase.id` is unique per editor), naming the declaring features;
+* a command without a known feature is the host's.
+*/
+function assertUniqueCommandIds(commands) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const cmd of commands) {
+		const first = seen.get(cmd.id);
+		if (first) fail(`command "${cmd.id}" is declared by "${ownerOfCommand.get(first) ?? "host"}" and "${ownerOfCommand.get(cmd) ?? "host"}"`);
+		seen.set(cmd.id, cmd);
+	}
+}
+/**
+* Places `commands` into their toolbar `groups` (every declared group, also empty ones, sorted by `order`; a group's
+* commands sorted by `toolbar.order`, stable). `unplaced` receives each command that has no group to go to: no `toolbar`
+* placement, or one naming a group that is not declared; what that means is the caller's policy.
+*/
+function placeInGroups(groups, commands, unplaced) {
+	const placed = /* @__PURE__ */ new Map();
+	for (const group of groups) placed.set(group.id, {
+		...group,
+		items: []
+	});
+	for (const cmd of commands) {
+		const group = cmd.toolbar ? placed.get(cmd.toolbar.group) : void 0;
+		if (group) group.items.push(cmd);
+		else unplaced(cmd);
+	}
+	return [...placed.values()].sort(byOrder).map((group) => ({
+		...group,
+		items: [...group.items].sort((a, b) => byOrder(a.toolbar || {}, b.toolbar || {}))
+	}));
+}
+/** The toolbar groups the features of `preset` declare, in feature order. */
+const toolbarGroupsOf = (preset) => preset.features.flatMap((feature) => feature.toolbarGroups ?? []);
+/**
+* The toolbar of `preset`: the groups features declare (`toolbarGroups`) with every command that has a `toolbar`
+* placement, groups and commands sorted by `order` (stable). Throws when a command names a group no feature declares
+* or two commands share an id.
+*/
+function toolbarOf(preset, ctx) {
+	const { commands, groups } = collect(preset, ctx);
+	return placeInGroups(groups, commands, (cmd) => {
+		if (cmd.toolbar) fail(`command "${cmd.id}" of "${ownerOfCommand.get(cmd) ?? "?"}" names toolbar group "${cmd.toolbar.group}" that no feature declares`);
+	});
+}
+function collect(preset, ctx) {
+	const commands = [];
+	for (const feature of preset.features) for (const cmd of feature.commands?.(ctx) ?? []) {
+		commands.push(cmd);
+		ownerOfCommand.set(cmd, feature.id);
+	}
+	assertUniqueCommandIds(commands);
+	return {
+		commands,
+		groups: toolbarGroupsOf(preset)
+	};
+}
+//#endregion
+export { assertUniqueCommandIds, canCreateAt, command, commandState, commandsOf, guardsAccept, placeInGroups, toolbarGroupsOf, toolbarOf };
+
+//# sourceMappingURL=commands.js.map

package/dist/core/commands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.js","names":[],"sources":["../../src/core/commands.ts"],"sourcesContent":["import type { ChainedCommands, Editor } from '@tiptap/core'\nimport type { ResolvedPos } from '@tiptap/pm/model'\nimport { abilitiesAt, abilitiesAtSelection } from './abilities'\nimport { contributions } from './define-editor'\nimport { type EditorEntry, editorEntryOf } from './editor-ui'\nimport type { EditorPreset, FeatureContext } from './feature'\nimport type { CommandBase, CommandDef, CommandState, Creates, InsertGuard, PlacedToolbarGroup, ToolbarGroupDef } from './command-types'\nimport { byOrder, fail } from './util'\n\nexport type { CommandBase, CommandDef, CommandState, Creates, InsertGuard, MenuItem, PlacedToolbarGroup, ToolbarGroupDef } from './command-types'\n\n// The guards of an editor are the `insertGuards` of the features of the preset its surface registered\n// (`registerEditor`): looked up by the raw editor instance, built once per entry. An editor without an entry\n// (a headless test editor) has none. Callers holding a framework proxy of the editor pass the raw instance.\nconst guardCache = new WeakMap<EditorEntry, readonly InsertGuard[]>()\n\nfunction guardsOf(editor: Editor): readonly InsertGuard[] {\n  const entry = editorEntryOf(editor)\n  if (!entry) return []\n  let guards = guardCache.get(entry)\n  if (!guards) {\n    guards = contributions(entry.preset, 'insertGuards').flatMap(factory => factory(entry.ctx))\n    guardCache.set(entry, guards)\n  }\n  return guards\n}\n\n/**\n * A command over a command chain: `run` focuses the editor and executes `command`; the command is disabled while\n * `can()` says it is structurally impossible (also an empty undo history). With `creates`, `commandState` additionally\n * requires the node to fit at the caret.\n */\nexport function command(def: Omit<CommandBase, 'can'> & { command: (chain: ChainedCommands) => ChainedCommands }): CommandDef<never> {\n  const { command: chainOf, ...rest } = def\n  return {\n    ...rest,\n    can: editor => chainOf(editor.can().chain()).run(),\n    run: (editor) => { chainOf(editor.chain().focus()).run() },\n  }\n}\n\n/**\n * Whether every registered insert guard accepts `creates` below the ancestor `$parent` stands for (`$parent.parent` is the\n * node that would receive it). The one rule behind both creation (`canCreateAt`) and conversion targets (`convertBlockTo`).\n */\nexport function guardsAccept(editor: Editor, $parent: ResolvedPos, creates: Creates): boolean {\n  return guardsOf(editor).every(guard => guard(editor, $parent, creates))\n}\n\n/**\n * Whether a node like `creates` may be inserted at `$pos`: walks from the caret's depth outward to the first ancestor\n * whose content accepts the type at the caret's index, then every registered insert guard must accept it there.\n */\nexport function canCreateAt(editor: Editor, $pos: ResolvedPos, creates: Creates): boolean {\n  const type = editor.schema.nodes[creates.type]\n  if (!type) return false\n  for (let depth = $pos.depth; depth >= 0; depth--) {\n    const index = $pos.index(depth)\n    if (!$pos.node(depth).canReplaceWith(index, index, type)) continue\n    return guardsAccept(editor, $pos.doc.resolve($pos.start(depth)), creates)\n  }\n  return false\n}\n\n/**\n * The state of `cmd` for the toolbar (`'selection'`: abilities of the selection) or the `/` menu (`'caret'`). `$at`\n * replaces the caret position (the `/` plugin evaluates inside a transaction's `apply`, where `editor.state` is still\n * the old state); `can` hooks always read `editor.state`.\n */\nexport function commandState(editor: Editor, cmd: CommandDef, at: 'selection' | 'caret', $at?: ResolvedPos): CommandState {\n  const visible = cmd.visible?.(editor) ?? true\n  if ('component' in cmd) return { visible, enabled: true, active: false }\n  const active = cmd.active?.(editor) ?? false\n  if (active) return { visible, enabled: true, active }\n  const $from = $at ?? editor.state.selection.$from\n  if (cmd.ability) {\n    const abilities = at === 'selection' && !$at ? abilitiesAtSelection(editor) : abilitiesAt(editor, $from)\n    if (!abilities.has(cmd.ability)) return { visible, enabled: false, active }\n  }\n  const fits = (!cmd.can || cmd.can(editor)) && (!cmd.creates || canCreateAt(editor, $from, cmd.creates))\n  return { visible, enabled: fits, active }\n}\n\n/** The commands of the preset's features in feature order. Throws when two commands share an id. */\nexport function commandsOf<C>(preset: EditorPreset<C>, ctx: FeatureContext): CommandDef<C>[] {\n  return collect(preset, ctx).commands\n}\n\n// The feature each command came from, for error messages; commands of the host's `commands` transformer have none.\nconst ownerOfCommand = new WeakMap<object, string>()\n\n/**\n * Throws when two of `commands` share an id (`CommandBase.id` is unique per editor), naming the declaring features;\n * a command without a known feature is the host's.\n */\nexport function assertUniqueCommandIds<C>(commands: readonly CommandDef<C>[]): void {\n  const seen = new Map<string, CommandDef<C>>()\n  for (const cmd of commands) {\n    const first = seen.get(cmd.id)\n    if (first) fail(`command \"${cmd.id}\" is declared by \"${ownerOfCommand.get(first) ?? 'host'}\" and \"${ownerOfCommand.get(cmd) ?? 'host'}\"`)\n    seen.set(cmd.id, cmd)\n  }\n}\n\n/**\n * Places `commands` into their toolbar `groups` (every declared group, also empty ones, sorted by `order`; a group's\n * commands sorted by `toolbar.order`, stable). `unplaced` receives each command that has no group to go to: no `toolbar`\n * placement, or one naming a group that is not declared; what that means is the caller's policy.\n */\nexport function placeInGroups<C>(groups: readonly ToolbarGroupDef[], commands: readonly CommandDef<C>[], unplaced: (cmd: CommandDef<C>) => void): PlacedToolbarGroup<C>[] {\n  const placed = new Map<string, PlacedToolbarGroup<C>>()\n  // `defineEditor` guarantees every group id is declared once.\n  for (const group of groups) placed.set(group.id, { ...group, items: [] })\n  for (const cmd of commands) {\n    const group = cmd.toolbar ? placed.get(cmd.toolbar.group) : undefined\n    if (group) group.items.push(cmd)\n    else unplaced(cmd)\n  }\n  return [...placed.values()]\n    .sort(byOrder)\n    .map(group => ({ ...group, items: [...group.items].sort((a, b) => byOrder(a.toolbar || {}, b.toolbar || {})) }))\n}\n\n/** The toolbar groups the features of `preset` declare, in feature order. */\nexport const toolbarGroupsOf = <C>(preset: EditorPreset<C>): ToolbarGroupDef[] => preset.features.flatMap(feature => feature.toolbarGroups ?? [])\n\n/**\n * The toolbar of `preset`: the groups features declare (`toolbarGroups`) with every command that has a `toolbar`\n * placement, groups and commands sorted by `order` (stable). Throws when a command names a group no feature declares\n * or two commands share an id.\n */\nexport function toolbarOf<C>(preset: EditorPreset<C>, ctx: FeatureContext): PlacedToolbarGroup<C>[] {\n  const { commands, groups } = collect(preset, ctx)\n  return placeInGroups(groups, commands, (cmd) => {\n    if (cmd.toolbar) fail(`command \"${cmd.id}\" of \"${ownerOfCommand.get(cmd) ?? '?'}\" names toolbar group \"${cmd.toolbar.group}\" that no feature declares`)\n  })\n}\n\nfunction collect<C>(preset: EditorPreset<C>, ctx: FeatureContext) {\n  const commands: CommandDef<C>[] = []\n  for (const feature of preset.features) {\n    for (const cmd of feature.commands?.(ctx) ?? []) {\n      commands.push(cmd)\n      ownerOfCommand.set(cmd, feature.id)\n    }\n  }\n  assertUniqueCommandIds(commands)\n  return { commands, groups: toolbarGroupsOf(preset) }\n}\n"],"mappings":"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"}

package/dist/core/context.d.ts

@@ -1,22 +1,19 @@
+import { ReadonlyStore, Store } from "./store.js";
 import { Locale, Messages, Translate } from "../i18n/index.js";
-import { ModelSlot } from "../settings/values.js";
 import { EditorSettings } from "../settings/index.js";
+import { EditorBackend } from "./backend.js";
+import { EditorPublicConfig } from "../config/index.js";
 import { Notifier } from "./notify.js";
-import { ReadonlyStore, Store } from "./store.js";
-import { $Fetch } from "ofetch";
 //#region src/core/context.d.ts
-/** Inert public AI configuration (set by the Nuxt client plugin); only the AI feature reads it. */
-export interface EditorAiConfig {
-  slots: Record<ModelSlot, string>;
-  transcription: boolean;
-}
+/** Inert public AI configuration (set by the Nuxt client plugin); only the AI feature reads it. Defined with the public config view. */
+export type EditorAiConfig = EditorPublicConfig['ai'];
 export interface EditorContextOptions {
-  /** HTTP client of every feature request (default: ofetch). */
-  fetch?: $Fetch;
-  settings?: {
-    /** Keep the settings per account through `GET`/`PUT /api/editor/settings`; default false (this browser only). */
-    remote?: boolean;
-  };
+  /**
+   * Where documents, uploads, mention lookups, settings, themes and AI come from (default: the HTTP routes of the Nuxt
+   * module over the platform `fetch`, `createFetchBackend`). A backend that offers `settings` keeps the settings per
+   * account (`backend.settings`); without it they stay in this browser.
+   */
+  backend?: EditorBackend;
   ai?: EditorAiConfig;
   /** Shows app-level notices (e.g. model profiles); default: dropped (`silentNotifier`). */
   notify?: Notifier;
@@ -38,7 +35,7 @@ export interface EditorContext {
    * login page).
    */
   load: () => void;
-  fetch: $Fetch;
+  backend: EditorBackend;
   ai: EditorAiConfig | undefined;
   /** Notices of app-level models; surfaces hand features their own `FeatureContext.notify`. */
   notify: Notifier;
@@ -50,13 +47,13 @@ export interface EditorContext {
   dispose: () => void;
 }
 /**
- * The editor context of an app: the settings shared by all editors of the app, and the HTTP client. Framework-free;
+ * The editor context of an app: the settings shared by all editors of the app, and the backend. Framework-free;
  * the Vue layer installs it with `app.use(createEditor())`, the React layer provides it through
  * `EditorContextProvider`. The settings are read from localStorage right away (client only) and every change is
- * written back. With `settings.remote`, `GET /api/editor/settings` (on `load()`, which the settings hooks call) answers:
- * `200` replaces them with the user's account settings (`synced`), `204` (the host's adapter keeps no settings), `401`
- * or a network error keep the local ones; once synced every change is also sent to the server (`PUT`, debounced).
- * Subscription and timer stop with `dispose()`.
+ * written back. With a backend that offers `settings`, `backend.settings.load()` (on `load()`, which
+ * the settings hooks call) answers: the user's account settings replace them (`synced`), `null` (the account has none
+ * yet) makes the account take this browser's, a refusal (`401`, `501`) or a network error keeps the local ones; once
+ * synced every change is also sent to the backend (`save`, debounced). Subscription and timer stop with `dispose()`.
  */
 export declare function createEditorContext(options?: EditorContextOptions): EditorContext;
 //#endregion

package/dist/core/context.js

@@ -1,8 +1,9 @@
+import { BackendError } from "./backend.js";
 import { createTranslator } from "../i18n/index.js";
 import { parseEditorSettings } from "../settings/index.js";
+import { createFetchBackend } from "./http-backend.js";
 import { silentNotifier } from "./notify.js";
 import { createStore } from "./store.js";
-import { ofetch } from "ofetch";
 //#region src/core/context.ts
 const STORAGE_KEY = "tiptap-editor:settings";
 /** Pause after the last change before the settings are sent to the server (ms). */
@@ -20,19 +21,20 @@ function writeLocal(settings) {
 	} catch {}
 }
 /**
-* The editor context of an app: the settings shared by all editors of the app, and the HTTP client. Framework-free;
+* The editor context of an app: the settings shared by all editors of the app, and the backend. Framework-free;
 * the Vue layer installs it with `app.use(createEditor())`, the React layer provides it through
 * `EditorContextProvider`. The settings are read from localStorage right away (client only) and every change is
-* written back. With `settings.remote`, `GET /api/editor/settings` (on `load()`, which the settings hooks call) answers:
-* `200` replaces them with the user's account settings (`synced`), `204` (the host's adapter keeps no settings), `401`
-* or a network error keep the local ones; once synced every change is also sent to the server (`PUT`, debounced).
-* Subscription and timer stop with `dispose()`.
+* written back. With a backend that offers `settings`, `backend.settings.load()` (on `load()`, which
+* the settings hooks call) answers: the user's account settings replace them (`synced`), `null` (the account has none
+* yet) makes the account take this browser's, a refusal (`401`, `501`) or a network error keeps the local ones; once
+* synced every change is also sent to the backend (`save`, debounced). Subscription and timer stop with `dispose()`.
 */
 function createEditorContext(options = {}) {
-	const fetcher = options.fetch ?? ofetch;
-	const remoteMode = options.settings?.remote === true;
+	const backend = options.backend ?? createFetchBackend();
+	let remoteStore = backend.settings;
+	const remoteMode = remoteStore !== void 0;
 	const settings = createStore(parseEditorSettings(null));
-	const ready = createStore(!remoteMode);
+	const ready = createStore(!remoteMode && backend.ready === void 0);
 	const synced = createStore(false);
 	let loading = false;
 	let loadRemote = () => {};
@@ -49,13 +51,14 @@ function createEditorContext(options = {}) {
 		ready,
 		synced,
 		load,
-		fetch: fetcher,
+		backend,
 		ai: options.ai,
 		notify: options.notify ?? silentNotifier,
 		locale,
 		t,
 		dispose: () => dispose()
 	};
+	if (!remoteMode) backend.ready?.then(() => ready.set(true));
 	if (!("window" in globalThis)) return context;
 	settings.set(readLocal());
 	writeLocal(settings.get());
@@ -68,13 +71,10 @@ function createEditorContext(options = {}) {
 		timer = setTimeout(() => {
 			const json = JSON.stringify(value);
 			if (json === remote) return;
-			fetcher("/api/editor/settings", {
-				method: "PUT",
-				body: value
-			}).then(() => {
+			remoteStore?.save(value).then(() => {
 				remote = json;
 			}).catch((error) => {
-				if (error?.statusCode !== 501) console.warn(`tiptap-editor: ${t("settings.saveFailed")}`, error);
+				if (!(error instanceof BackendError && (error.status === 501 || error.status === 404))) console.warn(`tiptap-editor: ${t("settings.saveFailed")}`, error);
 			});
 		}, PUT_DEBOUNCE);
 	}
@@ -87,16 +87,19 @@ function createEditorContext(options = {}) {
 		clearTimeout(timer);
 		unsubscribe();
 	};
-	if (!remoteMode) return context;
-	loadRemote = () => fetcher.raw("/api/editor/settings").then((response) => {
-		if (!active || response.status !== 200) return;
+	if (!remoteStore) return context;
+	loadRemote = () => Promise.resolve(backend.ready).then(() => {
+		remoteStore = backend.settings;
+		return remoteStore?.load();
+	}).then((stored) => {
+		if (!active || !remoteStore) return;
 		synced.set(true);
-		if (response._data) {
-			settings.set(parseEditorSettings(response._data));
+		if (stored) {
+			settings.set(parseEditorSettings(stored));
 			remote = JSON.stringify(settings.get());
 		} else push(settings.get());
 	}).catch((error) => {
-		console.warn(`tiptap-editor: ${t("settings.loadFailed")}`, error);
+		if (!(error instanceof BackendError && (error.status === 501 || error.status === 404))) console.warn(`tiptap-editor: ${t("settings.loadFailed")}`, error);
 	}).finally(() => {
 		ready.set(true);
 	});