@shadow-garden/bapbong-commands 0.1.0

package/dist/index.js

@@ -0,0 +1,752 @@
+// packages/commands/src/lib/marks.ts
+import { toggleMark } from "prosemirror-commands";
+var matches = (mark, attrs) => !attrs || Object.entries(attrs).every(([k, v]) => mark.attrs[k] === v);
+function isMarkActive(state, markName, attrs) {
+  const type = state.schema.marks[markName];
+  if (!type) return false;
+  const { from, to, empty, $from } = state.selection;
+  if (empty) {
+    const mark = type.isInSet(state.storedMarks ?? $from.marks());
+    return !!mark && matches(mark, attrs);
+  }
+  if (!attrs) return state.doc.rangeHasMark(from, to, type);
+  let found = false;
+  state.doc.nodesBetween(from, to, (node) => {
+    if (found || !node.isText) return;
+    const mark = node.marks.find((m) => m.type === type);
+    if (mark && matches(mark, attrs)) found = true;
+  });
+  return found;
+}
+function toggleMarkCommand(name, markName = name, attrs) {
+  return {
+    name,
+    run(state, dispatch) {
+      const type = state.schema.marks[markName];
+      return type ? toggleMark(type, attrs)(state, dispatch) : false;
+    },
+    isActive: (state) => isMarkActive(state, markName, attrs),
+    isEnabled: (state) => !!state.schema.marks[markName]
+  };
+}
+function setMarkAttr(markName, attrs) {
+  return {
+    name: `set-${markName}`,
+    run(state, dispatch) {
+      const type = state.schema.marks[markName];
+      if (!type) return false;
+      if (dispatch) {
+        const { from, to, empty } = state.selection;
+        const tr = state.tr;
+        if (empty) {
+          tr.removeStoredMark(type);
+          if (attrs) tr.addStoredMark(type.create(attrs));
+        } else {
+          tr.removeMark(from, to, type);
+          if (attrs) tr.addMark(from, to, type.create(attrs));
+        }
+        dispatch(tr.scrollIntoView());
+      }
+      return true;
+    },
+    isEnabled: (state) => !!state.schema.marks[markName]
+  };
+}
+function activeMarkValue(state, markName, attrKey) {
+  const type = state.schema.marks[markName];
+  if (!type) return null;
+  const { from, to, empty, $from } = state.selection;
+  const valueOf = (marks) => {
+    const mark = type.isInSet(marks);
+    return mark ? mark.attrs[attrKey] : null;
+  };
+  if (empty) return valueOf(state.storedMarks ?? $from.marks());
+  let value;
+  let seen = false;
+  state.doc.nodesBetween(from, to, (node) => {
+    if (!node.isText) return;
+    const v = valueOf(node.marks);
+    if (!seen) {
+      value = v;
+      seen = true;
+    } else if (value !== v) {
+      value = null;
+    }
+  });
+  return seen ? value : null;
+}
+function setFontSize(pt) {
+  return setMarkAttr("fontSize", pt == null ? null : { size: pt });
+}
+function activeFontSize(state) {
+  const v = activeMarkValue(state, "fontSize", "size");
+  return typeof v === "number" ? v : null;
+}
+function setFontFamily(family) {
+  return setMarkAttr("fontFamily", family ? { family } : null);
+}
+function activeFontFamily(state) {
+  const v = activeMarkValue(state, "fontFamily", "family");
+  return typeof v === "string" ? v : null;
+}
+function setTextColor(color) {
+  return setMarkAttr("textColor", color ? { color } : null);
+}
+function activeTextColor(state) {
+  const v = activeMarkValue(state, "textColor", "color");
+  return typeof v === "string" ? v : null;
+}
+function clearMarks() {
+  return {
+    name: "clear-format",
+    run(state, dispatch) {
+      const { from, to, empty } = state.selection;
+      if (dispatch) {
+        const tr = state.tr;
+        if (empty) tr.setStoredMarks([]);
+        else tr.removeMark(from, to);
+        dispatch(tr.scrollIntoView());
+      }
+      return true;
+    }
+  };
+}
+function setHighlight(color) {
+  return setMarkAttr("highlight", color ? { color } : null);
+}
+function activeHighlight(state) {
+  const v = activeMarkValue(state, "highlight", "color");
+  return typeof v === "string" ? v : null;
+}
+
+// packages/commands/src/lib/paragraph.ts
+var ALIGNMENTS = ["left", "center", "right", "justify"];
+function activeAlign(state) {
+  const { from, to } = state.selection;
+  let seen;
+  state.doc.nodesBetween(from, to, (node) => {
+    if (node.type.name !== "paragraph") return;
+    const a = node.attrs["align"] ?? null;
+    seen = seen === void 0 ? a : seen === a ? seen : null;
+  });
+  return seen ?? null;
+}
+function setAlign(align) {
+  return {
+    name: align ? `align-${align}` : "align-clear",
+    run(state, dispatch) {
+      const { from, to } = state.selection;
+      const tr = state.tr;
+      let changed = false;
+      state.doc.nodesBetween(from, to, (node, pos) => {
+        if (node.type.name !== "paragraph" || node.attrs["align"] === align) return;
+        tr.setNodeAttribute(pos, "align", align);
+        changed = true;
+      });
+      if (changed && dispatch) dispatch(tr);
+      return changed;
+    },
+    isActive: (state) => activeAlign(state) === align
+  };
+}
+function selectedParagraphs(state) {
+  const { from, to } = state.selection;
+  const out = [];
+  state.doc.nodesBetween(from, to, (node, pos) => {
+    if (node.type.name === "paragraph") out.push({ pos, node });
+  });
+  return out;
+}
+function toggleHeading(level) {
+  return {
+    name: `heading-${level}`,
+    run(state, dispatch) {
+      const paras = selectedParagraphs(state);
+      if (paras.length === 0) return false;
+      if (dispatch) {
+        const allThisLevel = paras.every((p) => p.node.attrs["heading"] === level);
+        const next = allThisLevel ? null : level;
+        const tr = state.tr;
+        for (const p of paras) tr.setNodeAttribute(p.pos, "heading", next);
+        dispatch(tr.scrollIntoView());
+      }
+      return true;
+    },
+    isActive: (state) => {
+      const paras = selectedParagraphs(state);
+      return paras.length > 0 && paras.every((p) => p.node.attrs["heading"] === level);
+    },
+    isEnabled: (state) => selectedParagraphs(state).length > 0
+  };
+}
+
+// packages/commands/src/lib/list.ts
+var NUM_ID = { bullet: "bb-bullet", ordered: "bb-ordered" };
+var DEF = {
+  bullet: {
+    key: "bb-bullet",
+    levels: {
+      0: { numFmt: "bullet", lvlText: "\u2022", start: 1 },
+      1: { numFmt: "bullet", lvlText: "\u25E6", start: 1 },
+      2: { numFmt: "bullet", lvlText: "\u25AA", start: 1 }
+    }
+  },
+  ordered: {
+    key: "bb-ordered",
+    levels: {
+      0: { numFmt: "decimal", lvlText: "%1.", start: 1 },
+      1: { numFmt: "lowerLetter", lvlText: "%2.", start: 1 },
+      2: { numFmt: "lowerRoman", lvlText: "%3.", start: 1 }
+    }
+  }
+};
+function paragraphsInSelection(state) {
+  const { from, to } = state.selection;
+  const out = [];
+  state.doc.nodesBetween(from, to, (node, pos) => {
+    if (node.type.name === "paragraph") out.push({ pos, node });
+  });
+  return out;
+}
+function listNumId(node) {
+  return node.attrs["list"]?.numId ?? null;
+}
+function toggleList(kind) {
+  const numId = NUM_ID[kind];
+  return {
+    name: kind === "bullet" ? "bullet-list" : "ordered-list",
+    run(state, dispatch) {
+      const paras = paragraphsInSelection(state);
+      if (paras.length === 0) return false;
+      if (dispatch) {
+        const allThisKind = paras.every((p) => listNumId(p.node) === numId);
+        let tr = state.tr;
+        if (allThisKind) {
+          for (const p of paras) tr = tr.setNodeAttribute(p.pos, "list", null);
+        } else {
+          const defs = { ...state.doc.attrs["numbering"] ?? {} };
+          if (!defs[numId]) {
+            defs[numId] = DEF[kind];
+            tr = tr.setDocAttribute("numbering", defs);
+          }
+          for (const p of paras) {
+            const level = p.node.attrs["list"]?.level ?? 0;
+            tr = tr.setNodeAttribute(p.pos, "list", { numId, level });
+          }
+        }
+        dispatch(tr.scrollIntoView());
+      }
+      return true;
+    },
+    isActive(state) {
+      const paras = paragraphsInSelection(state);
+      return paras.length > 0 && paras.every((p) => listNumId(p.node) === numId);
+    },
+    isEnabled: (state) => paragraphsInSelection(state).length > 0
+  };
+}
+
+// packages/commands/src/lib/table.ts
+function cellAt(state) {
+  const $head = state.selection.$head;
+  for (let d = $head.depth; d > 0; d--) {
+    const node = $head.node(d);
+    if (node.type.name === "table_cell") return { pos: $head.before(d), node };
+  }
+  return null;
+}
+function setCellAttrs(pos, attrs) {
+  return {
+    name: "cell-attrs",
+    run(state, dispatch) {
+      const cell = state.doc.nodeAt(pos);
+      if (!cell || cell.type.name !== "table_cell") return false;
+      if (dispatch) {
+        const tr = state.tr;
+        for (const [key, value] of Object.entries(attrs)) tr.setNodeAttribute(pos, key, value);
+        dispatch(tr);
+      }
+      return true;
+    }
+  };
+}
+function setCellsAttrs(positions, attrs) {
+  return {
+    name: "cells-attrs",
+    run(state, dispatch) {
+      const cells = positions.filter((pos) => state.doc.nodeAt(pos)?.type.name === "table_cell");
+      if (cells.length === 0) return false;
+      if (dispatch) {
+        const tr = state.tr;
+        for (const pos of cells) {
+          for (const [key, value] of Object.entries(attrs)) tr.setNodeAttribute(pos, key, value);
+        }
+        dispatch(tr);
+      }
+      return true;
+    }
+  };
+}
+function setCellBackground(color) {
+  return {
+    name: "cell-background",
+    run: (state, dispatch) => {
+      const cell = cellAt(state);
+      return cell ? setCellAttrs(cell.pos, { background: color }).run(state, dispatch) : false;
+    },
+    isEnabled: (state) => cellAt(state) != null
+  };
+}
+function setColumnWidth(cellPos, width) {
+  return {
+    name: "column-width",
+    run: (state, dispatch) => setCellAttrs(cellPos, { colwidth: [width] }).run(state, dispatch)
+  };
+}
+
+// packages/commands/src/lib/table-structure.ts
+function tableContext(state) {
+  const $head = state.selection.$head;
+  let cellDepth = -1;
+  for (let d = $head.depth; d > 0; d--) {
+    if ($head.node(d).type.name === "table_cell") {
+      cellDepth = d;
+      break;
+    }
+  }
+  if (cellDepth < 2) return null;
+  return {
+    tablePos: $head.before(cellDepth - 2),
+    table: $head.node(cellDepth - 2),
+    rowPos: $head.before(cellDepth - 1),
+    row: $head.node(cellDepth - 1),
+    rowIndex: $head.index(cellDepth - 2),
+    cellIndex: $head.index(cellDepth - 1)
+  };
+}
+function emptyCell(state, attrs) {
+  const cell = state.schema.nodes["table_cell"];
+  const paragraph = state.schema.nodes["paragraph"];
+  return cell.create(attrs, paragraph.create());
+}
+function insertRow(below) {
+  return {
+    name: below ? "insert-row-below" : "insert-row-above",
+    run(state, dispatch) {
+      const cx = tableContext(state);
+      if (!cx) return false;
+      if (dispatch) {
+        const cells = [];
+        cx.row.forEach(
+          (cell) => cells.push(emptyCell(state, { colwidth: cell.attrs["colwidth"], colspan: cell.attrs["colspan"] }))
+        );
+        const newRow = state.schema.nodes["table_row"].create(null, cells);
+        const at = below ? cx.rowPos + cx.row.nodeSize : cx.rowPos;
+        dispatch(state.tr.insert(at, newRow).scrollIntoView());
+      }
+      return true;
+    },
+    isEnabled: (state) => tableContext(state) != null
+  };
+}
+function insertColumn(right) {
+  return {
+    name: right ? "insert-column-right" : "insert-column-left",
+    run(state, dispatch) {
+      const cx = tableContext(state);
+      if (!cx) return false;
+      if (dispatch) {
+        const targetIndex = right ? cx.cellIndex + 1 : cx.cellIndex;
+        const curCell = cx.row.maybeChild(Math.min(cx.cellIndex, cx.row.childCount - 1));
+        const colwidth = curCell?.attrs["colwidth"] ?? null;
+        const inserts = [];
+        let rowStart = cx.tablePos + 1;
+        cx.table.forEach((row) => {
+          let pos = rowStart + 1;
+          row.forEach((cell, offset, index) => {
+            if (index < targetIndex) pos += cell.nodeSize;
+          });
+          inserts.push(pos);
+          rowStart += row.nodeSize;
+        });
+        let tr = state.tr;
+        for (const pos of inserts) {
+          tr = tr.insert(tr.mapping.map(pos), emptyCell(state, { colwidth }));
+        }
+        dispatch(tr.scrollIntoView());
+      }
+      return true;
+    },
+    isEnabled: (state) => tableContext(state) != null
+  };
+}
+function deleteRow() {
+  return {
+    name: "delete-row",
+    run(state, dispatch) {
+      const cx = tableContext(state);
+      if (!cx) return false;
+      if (dispatch) {
+        const tr = cx.table.childCount <= 1 ? state.tr.delete(cx.tablePos, cx.tablePos + cx.table.nodeSize) : state.tr.delete(cx.rowPos, cx.rowPos + cx.row.nodeSize);
+        dispatch(tr.scrollIntoView());
+      }
+      return true;
+    },
+    isEnabled: (state) => tableContext(state) != null
+  };
+}
+function deleteColumn() {
+  return {
+    name: "delete-column",
+    run(state, dispatch) {
+      const cx = tableContext(state);
+      if (!cx) return false;
+      if (dispatch) {
+        if (cx.row.childCount <= 1) {
+          dispatch(state.tr.delete(cx.tablePos, cx.tablePos + cx.table.nodeSize).scrollIntoView());
+          return true;
+        }
+        const dels = [];
+        let rowStart = cx.tablePos + 1;
+        cx.table.forEach((row) => {
+          let pos = rowStart + 1;
+          row.forEach((cell2, _offset, index) => {
+            if (index < cx.cellIndex) pos += cell2.nodeSize;
+          });
+          const cell = row.maybeChild(cx.cellIndex);
+          if (cell) dels.push({ from: pos, to: pos + cell.nodeSize });
+          rowStart += row.nodeSize;
+        });
+        let tr = state.tr;
+        for (const d of dels) {
+          tr = tr.delete(tr.mapping.map(d.from), tr.mapping.map(d.to));
+        }
+        dispatch(tr.scrollIntoView());
+      }
+      return true;
+    },
+    isEnabled: (state) => tableContext(state) != null
+  };
+}
+function mergeCells(cells, rows, cols) {
+  return {
+    name: "merge-cells",
+    run(state, dispatch) {
+      if (cells.length < 2) return false;
+      const located = cells.map((c) => ({ c, node: state.doc.nodeAt(c.pos) })).filter((x) => x.node?.type.name === "table_cell");
+      if (located.length < 2) return false;
+      const tl = located.find((x) => x.c.row === 0 && x.c.col === 0);
+      if (!tl) return false;
+      if (dispatch) {
+        const cellType = state.schema.nodes["table_cell"];
+        let colwidth = [];
+        for (const x of located.filter((x2) => x2.c.row === 0).sort((a, b) => a.c.col - b.c.col)) {
+          const cw = x.node.attrs["colwidth"];
+          if (!cw) {
+            colwidth = null;
+            break;
+          }
+          colwidth.push(...cw);
+        }
+        const content = [];
+        tl.node.forEach((child) => content.push(child));
+        for (const x of located) {
+          if (x === tl) continue;
+          x.node.forEach((child) => {
+            if (!child.isTextblock || child.textContent.trim().length > 0) content.push(child);
+          });
+        }
+        const merged = cellType.create({ ...tl.node.attrs, colspan: cols, rowspan: rows, colwidth }, content);
+        const ops = located.map((x) => ({ from: x.c.pos, to: x.c.pos + x.node.nodeSize, node: x === tl ? merged : null })).sort((a, b) => b.from - a.from);
+        let tr = state.tr;
+        for (const op of ops) tr = op.node ? tr.replaceWith(op.from, op.to, op.node) : tr.delete(op.from, op.to);
+        dispatch(tr.scrollIntoView());
+      }
+      return true;
+    }
+  };
+}
+function deleteTable() {
+  return {
+    name: "delete-table",
+    run(state, dispatch) {
+      const cx = tableContext(state);
+      if (!cx) return false;
+      if (dispatch) dispatch(state.tr.delete(cx.tablePos, cx.tablePos + cx.table.nodeSize).scrollIntoView());
+      return true;
+    },
+    isEnabled: (state) => tableContext(state) != null
+  };
+}
+
+// packages/commands/src/lib/history.ts
+import { undo, redo, undoDepth, redoDepth } from "prosemirror-history";
+var depth = (fn, state) => {
+  try {
+    return fn(state);
+  } catch {
+    return 0;
+  }
+};
+function undoCommand() {
+  return {
+    name: "undo",
+    run: (state, dispatch) => undo(state, dispatch),
+    isEnabled: (state) => depth(undoDepth, state) > 0
+  };
+}
+function redoCommand() {
+  return {
+    name: "redo",
+    run: (state, dispatch) => redo(state, dispatch),
+    isEnabled: (state) => depth(redoDepth, state) > 0
+  };
+}
+
+// packages/commands/src/lib/insert.ts
+function pageBreakCommand() {
+  const paragraphs = (state) => {
+    const { from, to } = state.selection;
+    const out = [];
+    state.doc.nodesBetween(from, to, (node, pos) => {
+      if (node.type.name === "paragraph") out.push({ pos, on: !!node.attrs["pageBreakBefore"] });
+    });
+    return out;
+  };
+  return {
+    name: "page-break",
+    run(state, dispatch) {
+      const ps = paragraphs(state);
+      if (ps.length === 0) return false;
+      if (dispatch) {
+        const next = !ps[0].on;
+        const tr = state.tr;
+        for (const p of ps) tr.setNodeAttribute(p.pos, "pageBreakBefore", next);
+        dispatch(tr);
+      }
+      return true;
+    },
+    isActive: (state) => paragraphs(state).some((p) => p.on)
+  };
+}
+function insertTable(rows = 2, cols = 2) {
+  return {
+    name: "insert-table",
+    run(state, dispatch) {
+      const { table, table_row, table_cell, paragraph } = state.schema.nodes;
+      if (!table || !table_row || !table_cell || !paragraph) return false;
+      const makeRow = () => table_row.create(null, Array.from({ length: cols }, () => table_cell.create(null, paragraph.create())));
+      const node = table.create(null, Array.from({ length: rows }, makeRow));
+      if (dispatch) dispatch(state.tr.replaceSelectionWith(node).scrollIntoView());
+      return true;
+    }
+  };
+}
+function insertImage(src, alt = "") {
+  return {
+    name: "insert-image",
+    run(state, dispatch) {
+      const image = state.schema.nodes["image"];
+      if (!image || !src) return false;
+      if (dispatch) dispatch(state.tr.replaceSelectionWith(image.create({ src, alt }), false).scrollIntoView());
+      return true;
+    }
+  };
+}
+function setLink(href) {
+  return {
+    name: "link",
+    run(state, dispatch) {
+      const type = state.schema.marks["link"];
+      if (!type || state.selection.empty) return false;
+      if (dispatch) {
+        const { from, to } = state.selection;
+        const tr = state.tr.removeMark(from, to, type);
+        if (href) tr.addMark(from, to, type.create({ href }));
+        dispatch(tr);
+      }
+      return true;
+    },
+    isActive: (state) => isMarkActive(state, "link"),
+    isEnabled: (state) => !!state.schema.marks["link"] && !state.selection.empty
+  };
+}
+
+// packages/commands/src/lib/edit.ts
+import { deleteSelection } from "prosemirror-commands";
+function deleteSelectionCommand() {
+  return {
+    name: "delete",
+    run: (state, dispatch) => deleteSelection(state, dispatch),
+    isEnabled: (state) => !state.selection.empty
+  };
+}
+
+// packages/commands/src/lib/sections.ts
+var DEFAULT_GAP = 28;
+function currentSections(state) {
+  const raw = state.doc.attrs["sections"];
+  if (raw && raw.length) return raw.map((s) => ({ ...s, columns: { ...s.columns } }));
+  return [{ blockCount: state.doc.childCount, columns: { count: 1, gap: 0 }, newPage: false }];
+}
+function headBlockIndex(state) {
+  return state.selection.$head.index(0);
+}
+function sectionAt(sections, bi) {
+  let start = 0;
+  for (let i = 0; i < sections.length; i++) {
+    if (bi < start + sections[i].blockCount) return { i, start };
+    start += sections[i].blockCount;
+  }
+  const last = sections.length - 1;
+  return { i: last, start: start - sections[last].blockCount };
+}
+function insertSectionBreak(opts) {
+  return {
+    name: opts.newPage ? "section-break-next-page" : "section-break-continuous",
+    run(state, dispatch) {
+      if (state.doc.childCount < 2) return false;
+      const sections = currentSections(state);
+      const bi = headBlockIndex(state);
+      const { i, start } = sectionAt(sections, bi);
+      const S = sections[i];
+      const firstCount = bi + 1 - start;
+      const secondCount = S.blockCount - firstCount;
+      if (secondCount <= 0) return false;
+      if (dispatch) {
+        const next = [
+          ...sections.slice(0, i),
+          { blockCount: firstCount, columns: { ...S.columns }, newPage: S.newPage },
+          { blockCount: secondCount, columns: { ...S.columns }, newPage: opts.newPage },
+          ...sections.slice(i + 1)
+        ];
+        dispatch(state.tr.setDocAttribute("sections", next).scrollIntoView());
+      }
+      return true;
+    },
+    isEnabled: (state) => state.doc.childCount > 1
+  };
+}
+function removeSectionBreak(boundaryIndex) {
+  return {
+    name: "remove-section-break",
+    run(state, dispatch) {
+      const raw = state.doc.attrs["sections"];
+      const b = boundaryIndex;
+      if (!raw || b < 0 || b >= raw.length - 1) return false;
+      if (dispatch) {
+        const upper = raw[b];
+        const lower = raw[b + 1];
+        const merged = {
+          blockCount: upper.blockCount + lower.blockCount,
+          columns: { ...lower.columns },
+          // following section's layout wins (Word)
+          newPage: upper.newPage
+          // merged range still begins where the upper did
+        };
+        const next = [...raw.slice(0, b), merged, ...raw.slice(b + 2)];
+        dispatch(state.tr.setDocAttribute("sections", next).scrollIntoView());
+      }
+      return true;
+    }
+  };
+}
+function setColumns(count) {
+  return {
+    name: `columns-${count}`,
+    run(state, dispatch) {
+      if (state.doc.childCount === 0) return false;
+      const sections = currentSections(state);
+      const { i } = sectionAt(sections, headBlockIndex(state));
+      if (dispatch) {
+        const gap = count > 1 ? sections[i].columns.gap || DEFAULT_GAP : sections[i].columns.gap;
+        const next = sections.map((s, j) => j === i ? { ...s, columns: { count, gap } } : s);
+        dispatch(state.tr.setDocAttribute("sections", next).scrollIntoView());
+      }
+      return true;
+    },
+    isActive: (state) => {
+      const sections = currentSections(state);
+      return sections[sectionAt(sections, headBlockIndex(state)).i].columns.count === count;
+    }
+  };
+}
+
+// packages/commands/src/lib/registry.ts
+import { Collection } from "@shadow-garden/bapbong-contracts";
+function defaultCommands() {
+  return new Collection(
+    [
+      toggleMarkCommand("bold", "strong"),
+      toggleMarkCommand("italic", "em"),
+      toggleMarkCommand("underline"),
+      toggleMarkCommand("strike"),
+      toggleMarkCommand("superscript", "vertAlign", { value: "super" }),
+      toggleMarkCommand("subscript", "vertAlign", { value: "sub" }),
+      clearMarks(),
+      setAlign("left"),
+      setAlign("center"),
+      setAlign("right"),
+      setAlign("justify"),
+      toggleList("bullet"),
+      toggleList("ordered"),
+      toggleHeading(1),
+      toggleHeading(2),
+      toggleHeading(3),
+      toggleHeading(4),
+      toggleHeading(5),
+      toggleHeading(6),
+      undoCommand(),
+      redoCommand(),
+      pageBreakCommand(),
+      insertSectionBreak({ newPage: true }),
+      insertSectionBreak({ newPage: false }),
+      setColumns(1),
+      setColumns(2),
+      setColumns(3)
+    ],
+    { idProperty: "name" }
+  );
+}
+export {
+  ALIGNMENTS,
+  activeAlign,
+  activeFontFamily,
+  activeFontSize,
+  activeHighlight,
+  activeMarkValue,
+  activeTextColor,
+  cellAt,
+  clearMarks,
+  defaultCommands,
+  deleteColumn,
+  deleteRow,
+  deleteSelectionCommand,
+  deleteTable,
+  insertColumn,
+  insertImage,
+  insertRow,
+  insertSectionBreak,
+  insertTable,
+  isMarkActive,
+  mergeCells,
+  pageBreakCommand,
+  redoCommand,
+  removeSectionBreak,
+  setAlign,
+  setCellAttrs,
+  setCellBackground,
+  setCellsAttrs,
+  setColumnWidth,
+  setColumns,
+  setFontFamily,
+  setFontSize,
+  setHighlight,
+  setLink,
+  setMarkAttr,
+  setTextColor,
+  toggleHeading,
+  toggleList,
+  toggleMarkCommand,
+  undoCommand
+};