// fixtures/toolbar.mjs — the formatting bar.
//
// Chrome, so it lives outside [docs-editor]: ProseMirror's {mount: el}
// takes over everything inside that element, and a toolbar rendered
// inside it would be replaced by the document on the first mount.
// views/show.html renders the markup, server-side, with every label
// resolved from the catalog — this module carries no copy of its own,
// the same rule the save-status indicator already follows.
//
// It never holds an EditorView. attemptResync (editor-entry.js)
// destroys and rebuilds the view wholesale, so anything holding one
// dispatches into a dead view after a resync; every command here reads
// getView() at the moment it runs instead.
//
// The button state is kept in step by a ProseMirror plugin rather than
// by listening for clicks and keystrokes: the selection also moves
// under the arrow keys, under a click on the page, and under a remote
// edit arriving through the CRDT, and a bar that only updates on its
// own buttons is wrong most of the time.

import { Plugin } from 'prosemirror-state'
import { toggleMark, setBlockType, wrapIn, lift, selectAll, chainCommands } from 'prosemirror-commands'
import { wrapInList, liftListItem, sinkListItem } from 'prosemirror-schema-list'
import { undoCommand, redoCommand } from 'y-prosemirror'
import { setAttr, setProp } from './dom-writes.mjs'
import { setupRoving } from './toolbar-roving.mjs'
import { ALIGNMENTS, alignClass, setAlign, currentAlign } from './align.mjs'
import { FONT_MARKS, fontMark, fontForMarks } from './fonts.mjs'
import { changeIndent } from './indent.mjs'
import { SIZE_MARKS, sizeMark, sizeForMarks } from './sizes.mjs'

// The two exclusive mark groups. A run is in one font and at one size,
// so choosing one has to clear the others — the schema's own
// `excludes` handles that for a toggle, but the select controls set a
// value rather than toggling, which is what setExclusive below is for.
//
// The font group is fonts.mjs's, not a second list here. It has to be
// every font mark including the default's, or clearing would leave the
// mark it missed in place and the run would be in two faces at once —
// and the default's mark is precisely the one a toolbar might think it
// could skip, since this toolbar never writes it. It is also the one
// most documents that predate the move actually carry: sans was a
// choice people made when it was not the default, so font_sans is out
// there in quantity. The size group has no such subtlety — "normal" has
// never had a mark — so it stays a literal beside its own use.


// The three alignment commands: each button's data-docs-command name,
// and the attribute value that button sets.
//
// A module-level table, not three entries inside buildCommands, because
// the guard below has to be able to check it with no schema and no
// browser — see alignmentsAreCovered.
//
// The names are literal keys, and that matters: internal/docs's
// TestToolbarOptionValuesMatchTheBundle checks that every
// data-docs-command in views/show.html is a name this file implements,
// and it does that by looking for the name in this file's source. A
// loop building "align_" + value would leave it nothing to find, so it
// would pass by seeing nothing rather than by agreeing with anything.
//
// Left is `null`, not the string "left": ProseMirror's default for the
// attribute is null and y-prosemirror removes a null attribute from the
// CRDT rather than storing it, so choosing left returns a paragraph to
// exactly the bytes it had before anyone aligned it.
export const ALIGN_COMMANDS = {
  align_left: null,
  align_center: 'center',
  align_right: 'right',
}

// Every alignment align.mjs offers has a command in that table, every
// command in it is one align.mjs offers, and each command's NAME
// matches the VALUE it sets.
//
// That last clause is the half nothing else can check. This guard's
// first version compared names only, and so does
// TestToolbarOptionValuesMatchTheBundle — so `align_center: 'centre'`
// had the right name, sat under the right button, satisfied both, and
// wrote an alignment that core/src/fragment.rs and both exporters drop
// on the floor. A person would click Centre and watch nothing happen,
// with no error anywhere.
//
// It runs on the line below, at module load, rather than inside
// createToolbar where it used to sit. That was the finding: nothing in
// the gate imports this module, and inside createToolbar it ran only
// when a browser actually mounted the editor — dead code in CI, so a
// mismatch the other tests missed would have passed the entire gate and
// then thrown at startup for every user. fixtures/align.test.mjs now
// imports this module, which is what makes the call below execute on
// every gate run.
//
// A module-load throw does abort the whole bundle, earlier than
// editor-entry.js's own try/catch, so [docs-editor] would not get its
// data-editor-failed marker — the page would keep the server-rendered
// read view without saying why. That is the right trade now that this
// cannot reach production without failing CI first, and it is stated
// here rather than left for someone to discover.
function alignmentsAreCovered() {
  const names = Object.keys(ALIGN_COMMANDS)
  for (const name of names) {
    const value = ALIGN_COMMANDS[name]
    const expected = 'align_' + (value === null ? 'left' : value)
    if (name !== expected) {
      throw new Error(
        `toolbar: ${name} sets the alignment ${JSON.stringify(value)}, which belongs to ${expected}`,
      )
    }
    // alignClass, not a bare lookup: it is the allowlist, so a value
    // align.mjs does not know is rejected here rather than stored.
    if (value !== null && !alignClass(value)) {
      throw new Error(`toolbar: ${name} sets ${JSON.stringify(value)}, which align.mjs does not know`)
    }
  }
  const covered = names.map((name) => name.slice('align_'.length)).sort()
  const offered = [...ALIGNMENTS].sort()
  if (covered.join() !== offered.join()) {
    throw new Error(`toolbar: alignment commands [${covered}] do not match align.mjs's [${offered}]`)
  }
}

alignmentsAreCovered()

// comboInputFor returns the text input ui/select.js built for a
// <select>, or null if the enhancement has not run (or was opted out
// of, or the script never loaded).
//
// select.js inserts its [rst-combo] wrapper immediately BEFORE the
// native select and leaves the select in place, visually hidden — see
// its own `native.parentNode.insertBefore(wrap, native)`. So the
// wrapper is the select's previous sibling, and that relationship is
// the only handle we get; there is no id linking the two.
//
// Null-safe everywhere it is used, because "the enhancement did not
// run" is a state this bar must keep working in: the whole point of
// select.js is that it enhances a real <select> which goes on working
// without it.
function comboInputFor(select) {
  const wrap = select.previousElementSibling
  if (!wrap || !wrap.hasAttribute('rst-combo')) return null
  return wrap.querySelector('input')
}

// nameCombo gives the combobox the name the select had.
//
// select.js transfers a <label for> onto its input, and nothing else.
// These three selects are named by aria-label — they sit in a toolbar
// with no visible labels — so without this the control a person
// actually reaches has no accessible name at all beyond its
// placeholder, and all three announce as "Type to filter". SC 4.1.2,
// and AGENTS.md allows no exemptions.
function nameCombo(select, input) {
  if (!input) return
  const name = select.getAttribute('aria-label')
  if (name) setAttr(input, 'aria-label', name)
}

// showInCombo keeps the combobox's visible text in step with the
// select's value.
//
// select.js writes input.value at enhancement, on a user's pick, and on
// blur — and never again. Everything in this file sets select.value
// programmatically, which fires no event and moves nothing a person can
// see: put the caret in a 24pt heading and the native select becomes
// "24" while the combobox still reads whatever was last chosen by hand.
//
// That is not cosmetic. The spec's argument for keeping Font and Size
// out of the Format menu was precisely that a person needs to SEE what
// they are in without opening anything, so a control that displays a
// stale value is the one failure this design cannot absorb.
//
// Skipped while the input has focus: overwriting what somebody is
// halfway through typing into the filter is worse than a stale display.
function showInCombo(select, input) {
  if (!input || document.activeElement === input) return
  const option = select.options[select.selectedIndex]
  setProp(input, 'value', option ? option.text : '')
}

// onSync, when given, is called after every sync with the live view. It
// is how the menu bar (fixtures/menu.mjs) keeps its items in step
// without a second ProseMirror plugin: one plugin means the two
// surfaces cannot disagree about the same selection, which they would
// eventually do if each watched the editor for itself.
export function createToolbar({ root, schema, getView, onSync }) {
  // The command table is built even with no toolbar in the DOM, and
  // returned either way — the menu bar reads it, and a template that
  // renders a menu without a formatting bar (or a future one that drops
  // the bar entirely) must still get working menu commands.
  // focusStop is in the early return too, and its absence was a real
  // bug for one commit: editor-entry.js binds Escape to it and its
  // comment promises that with no toolbar there is "nowhere to go" and
  // false comes back — but this branch returned no focusStop at all, so
  // Escape would have thrown a TypeError inside ProseMirror's keymap.
  // Unreachable today because show.html always renders the bar, which
  // is exactly why a comment asserting the guarantee needed the code to
  // hold it. toolbar-roving.mjs's own early return already did.
  if (!root) return { plugin: null, commands: buildCommands(schema), focusStop: () => false }

  const buttons = Array.from(root.querySelectorAll('[data-docs-command]'))
  const selects = Array.from(root.querySelectorAll('[data-docs-select]'))

  const commands = buildCommands(schema)

  for (const button of buttons) {
    // Without this the browser blurs the editor on mousedown, which
    // collapses the very selection the command is about to act on.
    button.addEventListener('mousedown', (e) => e.preventDefault())
    button.addEventListener('click', () => {
      const view = getView()
      const run = commands[button.getAttribute('data-docs-command')]
      if (!view || !run) return
      run(view.state, view.dispatch, view)
      view.focus()
    })
  }

  for (const select of selects) {
    select.addEventListener('mousedown', (e) => e.stopPropagation())
    // The caret goes back to the document after a choice, always.
    //
    // Every other control in this bar is a <button>, which cannot hold
    // a caret, so nothing needed this before. Once ui/select.js has
    // enhanced these, choosing a size leaves focus in a text input —
    // and the next thing a person types goes into the font filter
    // rather than into their document. The change handler below already
    // dispatches; this is the other half of what a toolbar control owes
    // the editor.
    //
    // On the native select too, not only the combobox: without the
    // enhancement (a browser that never ran the script, or a future
    // opt-out) the behaviour should be the same.
    select.addEventListener('change', () => {
      const view = getView()
      if (view) view.focus()
    })
    select.addEventListener('change', () => {
      const view = getView()
      if (!view) return
      const kind = select.getAttribute('data-docs-select')
      const value = select.value
      if (kind === 'block') setBlock(schema, value)(view.state, view.dispatch)
      // fontMark returns undefined for a face this build does not know,
      // which must change nothing — null is a real instruction to clear
      // the group, and treating the two alike would reset a person's
      // font because a stale page offered an option that has since gone.
      if (kind === 'font') {
        const mark = fontMark(value)
        if (mark !== undefined) setExclusive(schema, FONT_MARKS, mark)(view.state, view.dispatch)
      }
      // sizeMark, not 'size_' + value: it is the allowlist, and it
      // returns undefined for a size this build does not offer where
      // null means the default. The same undefined/null distinction
      // fontMark makes on the line above, and for the same reason — a
      // stale page sending an option this build dropped must not clear
      // a person's size.
      if (kind === 'size') {
        const mark = sizeMark(value)
        if (mark !== undefined) setExclusive(schema, SIZE_MARKS, mark)(view.state, view.dispatch)
      }
      view.focus()
    })
  }

  function sync(view) {
    // Every write below goes through setAttr/setProp, which write only
    // when the value would change. sync runs on EVERY state update, so
    // rewriting a value that is already there costs a style invalidation
    // and a mutation record per control per keystroke — and shows up as a
    // visible flash on the frame a hidden tab comes back. See
    // fixtures/dom-writes.mjs for the measurement.
    const state = view.state
    for (const button of buttons) {
      const name = button.getAttribute('data-docs-command')
      const run = commands[name]
      if (!run) continue
      // A command called with no dispatch reports whether it would do
      // anything, which is exactly "should this button be available".
      //
      // Every command in the table above must honour that contract —
      // see buildCommands for the one that did not, and what it cost.
      // A command that acts anyway turns this line, which runs on
      // every single state update, into an edit nobody asked for.
      const enabled = run(state, null, view)
      setProp(button, 'disabled', !enabled)
      const on = isActive(state, schema, name)
      setAttr(button, 'aria-pressed', on ? 'true' : 'false')
    }
    for (const select of selects) {
      // Enabled here, having been rendered disabled. views/show.html
      // renders every control disabled so that a page with no working
      // JavaScript offers nothing that silently does nothing when
      // operated — the buttons were already doing this and the selects
      // were not, so with scripting off a person could change "Font"
      // to Monospace and watch the document ignore them.
      setProp(select, 'disabled', false)
      // And the combobox, if ui/select.js enhanced this select.
      //
      // The enhancement does not mirror `disabled` — the string does
      // not appear in select.js at all. It mirrors value, options,
      // optgroups, required and reset, and stops there. So without
      // this line the page ships a control that looks usable before the
      // editor has mounted, takes focus and typing, and drives a
      // disabled select behind it.
      //
      // Looked up here rather than captured at mount: select.js runs
      // from the shell's own deferred script and this bundle runs from
      // a later one, so today the wrapper already exists by the time
      // createToolbar runs — but that is an ordering between two files
      // neither of which states it, and a lookup costs nothing.
      const combo = comboInputFor(select)
      if (combo) setProp(combo, 'disabled', false)
      nameCombo(select, combo)
      const kind = select.getAttribute('data-docs-select')
      if (kind === 'block') setProp(select, 'value', currentBlock(state))
      // Not currentGroup: the font group's fallback is not a literal
      // this file gets to choose. An unmarked run is in whatever face
      // fonts.mjs says the default is, and that is the same answer
      // views/show.html and internal/export/pdf.go have to give.
      if (kind === 'font') setProp(select, 'value', currentFont(state, schema))
      // Not currentGroup, for the same reason the font control stopped
      // using it: the fallback is not a literal this file gets to
      // choose, and the answer for a legacy mark is not its own name.
      // sizes.mjs maps size_lg to 14 so the control names a size that
      // is on the ladder and in the list, rather than a value no option
      // carries — which a <select> renders by showing nothing at all.
      if (kind === 'size') {
        setProp(select, 'value', String(sizeForMarks(activeMarkNames(state, schema, SIZE_MARKS))))
      }
      // Every branch above sets select.value programmatically, which
      // fires no event, so the combobox has to be told. See
      // showInCombo — without this the enhanced control displays
      // whatever was last chosen by hand while the document says
      // otherwise.
      showInCombo(select, comboInputFor(select))
    }
    if (onSync) onSync(view)
  }

  // The roving tabindex walks what a person can actually reach.
  //
  // For an enhanced select that is the combobox input, not the select:
  // select.js gives the native one tabindex="-1" and aria-hidden="true"
  // and hides it, so leaving it in this list would put an arrow-key
  // stop on an element no one can see. Where the enhancement has not
  // run, the select itself is still the control and still belongs here.
  //
  // Each select's stand-in takes that select's own place in the list,
  // so this substitution changes nothing about the order. The order
  // itself is buttons-then-selects, which is NOT the visual order —
  // the three selects sit between undo/redo and bold on screen. That
  // predates this change and is left alone here rather than fixed in
  // passing; it is worth someone's attention, because arrow keys that
  // jump around a bar are their own small bug.
  const roving = setupRoving(root, [
    ...buttons,
    ...selects.map((select) => comboInputFor(select) || select),
  ])

  // One Plugin instance, reused by every EditorState this page creates
  // — a plugin is configuration, not state, so a resync's fresh state
  // can take the same one.
  const plugin = new Plugin({
    view: (view) => {
      sync(view)
      roving.ensureReachable()
      return {
        update: (v) => {
          sync(v)
          roving.ensureReachable()
        },
      }
    },
  })

  // isPressed answers the menu bar's check column (menu.mjs): which
  // paragraph style and which alignment the selection is in. Paragraph
  // styles are named as the block select names them.
  const isPressed = (state, name) => {
    if (name.startsWith('block_')) return currentBlock(state) === name.slice('block_'.length)
    return isActive(state, schema, name)
  }
  return { plugin, commands, focusStop: roving.focusStop, isPressed }
}

function buildCommands(schema) {
  const marks = schema.marks
  const nodes = schema.nodes
  return {
    // undoCommand/redoCommand, NOT y-prosemirror's undo/redo.
    //
    // This distinction cost an evening, so it is written down. A
    // ProseMirror command's contract is that calling it with a null
    // dispatch performs nothing and only reports whether it could —
    // which is how `sync` below decides whether to grey a button out.
    // y-prosemirror's exported `undo` does not honour that contract:
    //
    //   export const undo = state =>
    //     yUndoPluginKey.getState(state)?.undoManager?.undo() != null
    //
    // It ignores dispatch entirely and undoes immediately. So a
    // toolbar that asked "could I undo?" on every state update — which
    // is exactly what keeping a button's disabled state honest means —
    // performed a real undo on every state update, and every edit
    // anyone made was silently reverted a moment later. Typing did
    // nothing. Bold did nothing. There was no error, because nothing
    // went wrong: the button asked a question and the library answered
    // it by doing the thing.
    //
    // undoCommand/redoCommand are the library's own dispatch-aware
    // pair (canUndo()/canRedo() when dispatch is null), and they are
    // what a command table read by `sync` must use. The keymap in
    // editor-entry.js keeps the bare undo/redo, correctly: a keymap
    // never calls a command with a null dispatch.
    undo: undoCommand,
    redo: redoCommand,
    strong: toggleMark(marks.strong),
    em: toggleMark(marks.em),
    code: toggleMark(marks.code),
    bullet_list: toggleList(nodes.bullet_list, nodes.list_item),
    ordered_list: toggleList(nodes.ordered_list, nodes.list_item),
    blockquote: toggleWrap(nodes.blockquote),
    // The two menu-only commands. They live here rather than in
    // fixtures/menu.mjs because this is the command table both surfaces
    // read, and a command implemented beside one of them is a command
    // the other cannot offer — which is the duplication the menu was
    // supposed to avoid. Neither has a toolbar button today; both would
    // be reasonable ones later, and that costs a line of markup rather
    // than a move.
    select_all: selectAll,
    clear_formatting: clearFormatting,
    // The paragraph styles, as commands.
    //
    // The Style select already sets these, through setBlock and its own
    // change handler — but a select is not reachable as a command, and
    // the Format menu needs them by name. Rather than a second
    // implementation, each of these IS setBlock, bound to one of the
    // select's own option values, so the two controls cannot come to
    // mean different things.
    //
    // Names are written out rather than built in a loop, for the reason
    // ALIGN_COMMANDS' comment gives at length: internal/docs's tests
    // look for the literal name in this file's source, and a loop would
    // leave them nothing to find, so they would pass by seeing nothing.
    block_paragraph: setBlock(schema, 'paragraph'),
    'block_heading-1': setBlock(schema, 'heading-1'),
    'block_heading-2': setBlock(schema, 'heading-2'),
    'block_heading-3': setBlock(schema, 'heading-3'),
    // Indent and outdent. The same two commands the Tab key runs
    // (editor-entry.js's keymap), chained the same way so the menu and
    // the key cannot disagree about what Tab does in a list: nest the
    // item if there is one, step the block's indent otherwise.
    indent: chainCommands(sinkListItem(nodes.list_item), changeIndent(1)),
    outdent: chainCommands(liftListItem(nodes.list_item), changeIndent(-1)),
    // The three alignments, from the module-level table above — the
    // one place their names and their values are written down.
    ...Object.fromEntries(
      Object.entries(ALIGN_COMMANDS).map(([name, value]) => [name, setAlign(value)]),
    ),
  }
}

// clearFormatting strips every mark from the selection and returns its
// blocks to plain paragraphs — the thing a person reaches for after a
// bad paste, and the one command in this table that is defined by what
// it removes rather than by what it applies.
//
// It honours the null-dispatch contract the whole table is held to (see
// buildCommands' own comment): with a collapsed selection there is
// nothing to strip and nothing to report, so it says no rather than
// quietly clearing the stored marks a person just set up for their next
// word.
//
// removeMark(from, to, null) removes ALL marks in the range, which is
// deliberately not a loop over the schema's mark types: the CRDT can
// carry a mark this build's schema has never heard of — a document
// written by a later version, or bytes posted straight to
// /d/{sqid}/updates — and a loop over known types would leave exactly
// those in place while telling a person the formatting was cleared.
//
// The block reset is separate and comes second, because setBlockType
// maps over the range and would otherwise be undone by the mark
// removal's own mapping.
function clearFormatting(state, dispatch) {
  const { from, to, empty } = state.selection
  if (empty) return false
  if (dispatch) {
    const tr = state.tr.removeMark(from, to, null)
    tr.setBlockType(from, to, state.schema.nodes.paragraph)
    dispatch(tr.scrollIntoView())
  }
  return true
}

// setBlock turns the block containing the selection into a paragraph
// or a heading. The select's values are "paragraph" and "heading-N".
function setBlock(schema, value) {
  if (value === 'paragraph') return setBlockType(schema.nodes.paragraph)
  const level = Number(value.split('-')[1])
  if (!Number.isInteger(level)) return () => false
  return setBlockType(schema.nodes.heading, { level })
}

// setExclusive clears every mark in a group and then applies one of
// them (or none). One transaction, not two: internal/core caps the
// retained update log at 4096 with no compaction yet, and every
// transaction the editor dispatches becomes an update in it, so a
// control that spent two per click would spend that budget twice as
// fast for no benefit a person can see.
function setExclusive(schema, group, wanted) {
  return (state, dispatch) => {
    const types = group.map((n) => schema.marks[n]).filter(Boolean)
    const target = wanted ? schema.marks[wanted] : null
    if (wanted && !target) return false
    if (!dispatch) return true

    const { from, to, empty } = state.selection
    if (empty) {
      // No selection: the choice applies to whatever is typed next,
      // which ProseMirror models as stored marks rather than as a
      // change to the document.
      let stored = (state.storedMarks || state.selection.$from.marks()).filter(
        (m) => !types.includes(m.type),
      )
      if (target) stored = target.create().addToSet(stored)
      dispatch(state.tr.setStoredMarks(stored))
      return true
    }

    const tr = state.tr
    for (const type of types) tr.removeMark(from, to, type)
    if (target) tr.addMark(from, to, target.create())
    dispatch(tr)
    return true
  }
}

// toggleList wraps the selection in a list, or lifts it out if it is
// already in one — a list button that only ever wraps is a button you
// cannot undo without reaching for the keyboard.
function toggleList(listType, itemType) {
  const wrap = wrapInList(listType)
  const unwrap = liftListItem(itemType)
  return (state, dispatch, view) => {
    if (inside(state, listType)) return unwrap(state, dispatch, view)
    return wrap(state, dispatch, view)
  }
}

function toggleWrap(nodeType) {
  const wrap = wrapIn(nodeType)
  return (state, dispatch, view) => {
    if (inside(state, nodeType)) return lift(state, dispatch, view)
    return wrap(state, dispatch, view)
  }
}

// inside reports whether the selection sits anywhere within a node of
// this type.
function inside(state, nodeType) {
  const $from = state.selection.$from
  for (let d = $from.depth; d > 0; d--) {
    if ($from.node(d).type === nodeType) return true
  }
  return false
}

function isActive(state, schema, name) {
  // Exactly one of the three is pressed at any moment, and it is the
  // alignment the block will actually RENDER at — currentAlign reports
  // left for a value this build does not know, because a button
  // pressed for something the reader will never see would be a lie
  // about the document.
  if (name.startsWith('align_')) return currentAlign(state) === name.slice('align_'.length)
  if (name === 'bullet_list') return inside(state, schema.nodes.bullet_list)
  if (name === 'ordered_list') return inside(state, schema.nodes.ordered_list)
  if (name === 'blockquote') return inside(state, schema.nodes.blockquote)
  const type = schema.marks[name]
  if (!type) return false
  return markActive(state, type)
}

// markActive is ProseMirror's own idiom: for an empty selection the
// answer is about the marks that would apply to the next keystroke
// (stored marks, or the marks at the cursor), not about the document.
function markActive(state, type) {
  const { from, $from, to, empty } = state.selection
  if (empty) return !!type.isInSet(state.storedMarks || $from.marks())
  return state.doc.rangeHasMark(from, to, type)
}

// currentBlock is what the block select should read. A selection
// spanning two different block types reports the one it starts in
// rather than blanking the control: a select with no value looks
// broken, and the first block is the one a person's cursor is in.
function currentBlock(state) {
  const parent = state.selection.$from.parent
  if (parent.type.name === 'heading') return 'heading-' + parent.attrs.level
  return 'paragraph'
}

// currentFont is what the font select should read: the face the
// selection is actually in, which for a run carrying no font mark is
// the default rather than "nothing".
//
// The reading is split from the answering on purpose. This function
// knows about ProseMirror state and nothing about which face is the
// default; fonts.mjs's fontForMarks knows which face is the default and
// nothing about ProseMirror. That is what lets the default be pinned by
// a test that needs no editor (fonts.test.mjs) and, through it, held
// equal to the stylesheet's and the exporter's (internal/docs's
// TestTheToolbarDefaultFontIsTheDefaultFace).
function currentFont(state, schema) {
  const active = FONT_MARKS.filter((name) => {
    const type = schema.marks[name]
    return type && markActive(state, type)
  })
  return fontForMarks(active)
}

// currentGroup reads which of an exclusive mark group applies, as the
// select's own value. A selection carrying two different sizes reports
// the fallback rather than picking one of them arbitrarily.
//
// Only the size control uses it now: "normal" is a fallback this file
// can name, because unlike the default FACE nothing outside the editor
// has an opinion about it — no stylesheet rule and no exporter constant
// says what "normal" is, the body size says it.
function currentGroup(state, schema, group, prefix, fallback) {
  for (const name of group) {
    const type = schema.marks[name]
    if (type && markActive(state, type)) return name.slice(prefix.length)
  }
  return fallback
}

// activeMarkNames is currentGroup's raw half: which of a group's marks
// are on the selection, in the group's own order, without deciding what
// they mean.
//
// It exists because the size group stopped being answerable by string
// surgery. currentGroup returns the mark's name with its prefix cut
// off, which was the whole answer while the sizes were called sm, lg
// and xl — the control's option values were those same three strings.
// They are numbers now, and three legacy marks map onto the ladder
// rather than naming themselves, so the mapping is sizes.mjs's job.
// This hands it the names and lets sizeForMarks answer.
function activeMarkNames(state, schema, group) {
  const out = []
  for (const name of group) {
    const type = schema.marks[name]
    if (type && markActive(state, type)) out.push(name)
  }
  return out
}