// fixtures/sizes.mjs — the font-size vocabulary, in one place.
//
// fonts.mjs's counterpart, and it follows that module's shape
// deliberately: a closed list, a default that carries NO mark, and a
// pair of functions mapping between a chosen value and the mark that
// says it. Read fonts.mjs's head comment for the reasoning; what
// follows is only what is different about size.
//
// WHY POINTS AND NOT FOUR NAMED STEPS. This control used to offer
// Small / Normal / Large / Extra large, stored as three marks whose CSS
// was a multiplier of the body size (0.85em, 1.25em, 1.5em). That is a
// perfectly good way to build a text editor and a poor way to build a
// word processor: people arrive knowing what 12pt is, documents specify
// point sizes, and "Large" does not survive a conversation with someone
// holding a printout. The ladder below is Google Docs' own.
//
// WHY A CLOSED ENUMERATION AND NOT A NUMBER ON A MARK. This is the
// constraint that shaped the whole feature, and it is not a stylistic
// preference. core/src/fragment.rs renders the CRDT to HTML that
// internal/docs/store.go returns as template.HTML and views/show.html
// writes into the page UNESCAPED. That is safe only because no byte
// from a document ever reaches attribute position: every mark is
// attribute-free, and its markup is a compile-time literal chosen by
// lookup. A mark carrying "14pt" would be a valued mark — and
// POST /d/{sqid}/updates accepts arbitrary Yjs bytes that never went
// through ProseMirror's schema, so the value would be genuinely
// arbitrary. Eleven more attribute-free marks spend no new safety
// property at all; a single sized mark would spend the one the whole
// renderer rests on.
//
// So the ladder is not "the sizes we happened to pick". It is the set
// of sizes this design can express, and adding 13pt later is a row in
// four places rather than a schema change.

// The sizes a person can choose, in the order the control shows them.
//
// DEFAULT FIRST, for the reason internal/docs/export.go's own comment
// records having learned the hard way: a <select> shows its first
// option until something sets a value, and with no JavaScript nothing
// ever does. The list used to open with Small over body text that was
// Normal — wrong on every page load, and wrong permanently without
// scripts.
export const SIZES = [12, 8, 9, 10, 11, 14, 18, 24, 36, 48, 72]

// The size an unmarked run is set in — views/show.html's [docs-text]
// rule and internal/export/pdf.go's BodySizePt say the same number, and
// internal/docs's TestPageGeometryMatchesTheStylesheet holds all three
// equal.
export const DEFAULT_SIZE = 12

// Every size mark, including the default's — except that the default
// has none, which is the rule. This list is what the toolbar CLEARS
// when a size is chosen, so it must contain every mark that could be on
// a run, including the three legacy ones below; missing one would leave
// a run at two sizes at once.
export const SIZE_MARKS = [
  ...SIZES.filter((pt) => pt !== DEFAULT_SIZE).map((pt) => 'size_' + pt),
  // The four-step scale this replaced. They stay in the vocabulary
  // PERMANENTLY and are simply no longer offered.
  //
  // Not politeness to old documents — correctness for them. Documents
  // in the wild carry these marks, core/src/fragment.rs still renders
  // them, and dropping one from the editor's schema would strip it out
  // of every document carrying it on the next edit (editor-entry.js's
  // own comment makes the same argument about font_sans). They are
  // mapped to their nearest ladder step everywhere a size is measured.
  'size_sm',
  'size_lg',
  'size_xl',
]

// What each legacy mark means in points, so one document does not read
// at two sizes depending on which renderer looked at it.
//
// The old marks were multipliers of a 12pt body: 0.85, 1.25 and 1.5,
// which is 10.2, 15 and 18pt. Ten and eighteen are on the ladder
// exactly; fifteen is not, and rounds to fourteen. So a document set in
// "Large" gets one point smaller than it used to be. That is a real,
// if small, change to existing documents, and it is the price of the
// ladder being closed — the alternative is a fifteenth mark that exists
// only to preserve a number nobody chose deliberately, since "Large"
// never told anyone it meant 15pt.
export const LEGACY_SIZES = { size_sm: 10, size_lg: 14, size_xl: 18 }

// sizeMark maps a chosen size to the mark to set: null for the default,
// which is spelled as the absence of one, and undefined for a value
// this module does not know.
//
// null and undefined are different answers, exactly as in fonts.mjs's
// fontMark: null means "clear the group", a real edit; undefined means
// "not one of ours", and a caller treating it as null would clear a
// person's size because a stale page sent an option this build dropped.
export function sizeMark(value) {
  const pt = Number(value)
  if (!SIZES.includes(pt)) return undefined
  if (pt === DEFAULT_SIZE) return null
  return 'size_' + pt
}

// sizeForMarks is the inverse, and it is what keeps the control honest:
// given the marks active on the selection, what size is it.
//
// SIZE_MARKS order decides a run carrying two size marks, which the
// schema's `excludes` makes impossible through the editor and
// POST /d/{sqid}/updates makes possible anyway. The ladder comes before
// the legacy names, so a run carrying both a new mark and an old one
// reports the new one — the same "first hit wins, in a fixed order"
// rule fontForMarks uses, and for the same reason: a stable answer
// beats a random one.
export function sizeForMarks(names) {
  for (const mark of SIZE_MARKS) {
    if (!names.includes(mark)) continue
    if (mark in LEGACY_SIZES) return LEGACY_SIZES[mark]
    return Number(mark.slice('size_'.length))
  }
  return DEFAULT_SIZE
}

// Every offered size has a mark, every mark has a size, the default is
// one of them and is listed first, and every legacy mark maps onto the
// ladder.
//
// Runs at module load, like fonts.mjs's fontsAreCovered and align.mjs's
// alignmentsAreCovered, and for the reason those comments give at
// length: a guard that only runs when a browser mounts the editor is
// dead code in the gate, so a vocabulary that had drifted would pass CI
// and throw for every user. fixtures/sizes.test.mjs imports this
// module, which is what makes this call execute on every gate run.
function sizesAreCovered() {
  if (!SIZES.includes(DEFAULT_SIZE)) {
    throw new Error(`sizes: the default ${DEFAULT_SIZE} is not one of [${SIZES}]`)
  }
  if (SIZES[0] !== DEFAULT_SIZE) {
    throw new Error(
      `sizes: the control lists ${SIZES[0]} first but the default is ${DEFAULT_SIZE} — ` +
        'with no JavaScript the control would name a size the text is not set in',
    )
  }
  for (const [mark, pt] of Object.entries(LEGACY_SIZES)) {
    if (!SIZES.includes(pt)) {
      throw new Error(`sizes: the legacy mark ${mark} maps to ${pt}pt, which is not on the ladder [${SIZES}]`)
    }
    if (!SIZE_MARKS.includes(mark)) {
      throw new Error(`sizes: the legacy mark ${mark} is not in the group the toolbar clears`)
    }
  }
  // Every offered size other than the default has exactly one mark in
  // the group, and nothing else does.
  const offered = SIZES.filter((pt) => pt !== DEFAULT_SIZE).map((pt) => 'size_' + pt)
  const inGroup = SIZE_MARKS.filter((m) => !(m in LEGACY_SIZES))
  if (offered.join() !== inGroup.join()) {
    throw new Error(`sizes: the marks [${inGroup}] do not match the offered sizes [${offered}]`)
  }
}

sizesAreCovered()