@portone/docx-editor 0.1.0

package/dist/editor/plugins/numberingDecorations.js

@@ -0,0 +1,110 @@
+// src/editor/plugins/numberingDecorations.ts
+import { Plugin, PluginKey } from "prosemirror-state";
+import { Decoration, DecorationSet } from "prosemirror-view";
+import { toParagraphFormat } from "../../model/format.js";
+import { computeMarkers } from "../../numbering/markers.js";
+import {
+  EMPTY_NUMBERING
+} from "../../numbering/parseNumbering.js";
+import { editorAttributes, editorCssVariables } from "../../styles/classNames.js";
+var FALLBACK_MARKER_WIDTH_PT = 18;
+function paragraphSpots(doc) {
+  const spots = [];
+  doc.descendants((node, pos) => {
+    if (node.type.name !== "paragraph") return true;
+    spots.push({
+      pos,
+      nodeSize: node.nodeSize,
+      format: toParagraphFormat(node.attrs.format)
+    });
+    return false;
+  });
+  return spots;
+}
+function markerPlacement(format, level) {
+  const ownTextIndentPt = format?.textIndentPt;
+  const textIndentPt = ownTextIndentPt ?? level.textIndentPt;
+  const hasOwnLeadingIndent = format?.indentLeftPt !== void 0 || format?.indentStartPt !== void 0;
+  const hasOwnTrailingIndent = format?.indentRightPt !== void 0 || format?.indentEndPt !== void 0;
+  return {
+    widthPt: textIndentPt !== null && textIndentPt !== void 0 && textIndentPt < 0 ? -textIndentPt : FALLBACK_MARKER_WIDTH_PT,
+    indentStartPt: hasOwnLeadingIndent ? null : level.startPt,
+    indentEndPt: hasOwnTrailingIndent ? null : level.endPt,
+    textIndentPt: ownTextIndentPt === void 0 ? level.textIndentPt : null
+  };
+}
+function paragraphMarkers(doc, numbering) {
+  const spots = paragraphSpots(doc);
+  const markers = computeMarkers(
+    spots.map((spot) => spot.format?.numbering ?? null),
+    numbering
+  );
+  return spots.flatMap((spot, index) => {
+    const marker = markers[index];
+    if (!marker) return [];
+    return [
+      {
+        from: spot.pos,
+        to: spot.pos + spot.nodeSize,
+        text: marker.text,
+        ...markerPlacement(spot.format, marker.indent)
+      }
+    ];
+  });
+}
+function markerStyle(marker) {
+  const css = [`${editorCssVariables.markerWidth}:${marker.widthPt}pt`];
+  if (marker.indentStartPt !== null) {
+    css.push(`margin-inline-start:${marker.indentStartPt}pt`);
+  }
+  if (marker.indentEndPt !== null) {
+    css.push(`margin-inline-end:${marker.indentEndPt}pt`);
+  }
+  if (marker.textIndentPt !== null) {
+    css.push(`text-indent:${marker.textIndentPt}pt`);
+  }
+  return css.join(";");
+}
+function markerDecorations(doc, numbering) {
+  const decorations = paragraphMarkers(doc, numbering).map(
+    (marker) => Decoration.node(marker.from, marker.to, {
+      [editorAttributes.listMarker]: marker.text,
+      style: markerStyle(marker)
+    })
+  );
+  return DecorationSet.create(doc, decorations);
+}
+var numberingKey = new PluginKey("docxEditorNumbering");
+function documentNumbering(state) {
+  return numberingKey.getState(state)?.numbering ?? EMPTY_NUMBERING;
+}
+function canStartNewList(state) {
+  return numberingKey.getState(state)?.canStartNewList ?? true;
+}
+function numberingMarkers(numbering = EMPTY_NUMBERING, canStartNewList2 = true) {
+  return new Plugin({
+    key: numberingKey,
+    state: {
+      init: (_config, state) => ({
+        numbering,
+        canStartNewList: canStartNewList2,
+        decorations: markerDecorations(state.doc, numbering)
+      }),
+      apply: (tr, current) => tr.docChanged ? {
+        numbering,
+        canStartNewList: canStartNewList2,
+        decorations: markerDecorations(tr.doc, numbering)
+      } : current
+    },
+    props: {
+      decorations: (state) => numberingKey.getState(state)?.decorations
+    }
+  });
+}
+export {
+  canStartNewList,
+  documentNumbering,
+  markerDecorations,
+  numberingMarkers,
+  paragraphMarkers
+};

package/dist/editor/plugins/rowResize.d.ts

@@ -0,0 +1,15 @@
+import { Plugin } from "prosemirror-state";
+import { DecorationSet } from "prosemirror-view";
+export interface RowEdgeHit {
+    row: number;
+    side: "top" | "bottom";
+}
+/** The row boundary under a pointer, including the end of a vertically merged cell. */
+export declare function rowEdgeAt(clientY: number, cell: {
+    readonly top: number;
+    readonly bottom: number;
+}, covered: {
+    readonly from: number;
+    readonly to: number;
+}, tolerance?: number): RowEdgeHit | null;
+export declare function rowResize(): Plugin<DecorationSet>;

package/dist/editor/plugins/rowResize.js

@@ -0,0 +1,196 @@
+// src/editor/plugins/rowResize.ts
+import { Plugin, PluginKey } from "prosemirror-state";
+import { TableMap } from "prosemirror-tables";
+import { Decoration, DecorationSet } from "prosemirror-view";
+import { isLockedCell } from "../../schema/locks.js";
+import { editorClassNames } from "../../styles/classNames.js";
+import {
+  buildResizeRowTransaction,
+  resizedRowHeight,
+  rowPositionAt
+} from "../../table/rowResize.js";
+var EDGE_TOLERANCE_PX = 4;
+var rowResizeKey = new PluginKey("docxRowResize");
+function rowEdgeAt(clientY, cell, covered, tolerance = EDGE_TOLERANCE_PX) {
+  if (Math.abs(clientY - cell.bottom) <= tolerance) {
+    return { row: covered.to - 1, side: "bottom" };
+  }
+  if (Math.abs(clientY - cell.top) <= tolerance && covered.from > 0) {
+    return { row: covered.from - 1, side: "top" };
+  }
+  return null;
+}
+function cellSpotAt(view, td) {
+  const $pos = view.state.doc.resolve(view.posAtDOM(td, 0));
+  for (let depth = $pos.depth; depth > 1; depth -= 1) {
+    const cell = $pos.node(depth);
+    if (cell.type.spec.tableRole !== "cell") continue;
+    const table = $pos.node(depth - 2);
+    if (table.type.spec.tableRole !== "table") return null;
+    const tablePos = $pos.before(depth - 2);
+    const rect = TableMap.get(table).findCell(
+      $pos.before(depth) - tablePos - 1
+    );
+    return { tablePos, table, from: rect.top, to: rect.bottom };
+  }
+  return null;
+}
+function edgeUnder(view, event) {
+  const node = event.target instanceof Node ? event.target : null;
+  const element = node instanceof Element ? node : node?.parentElement;
+  const td = element?.closest("td");
+  const tableDom = td?.closest("table");
+  if (!td || !tableDom || !view.dom.contains(td)) return null;
+  const spot = cellSpotAt(view, td);
+  if (!spot) return null;
+  const hit = rowEdgeAt(event.clientY, td.getBoundingClientRect(), spot);
+  if (!hit || hit.row < 0 || hit.row >= spot.table.childCount) return null;
+  const row = spot.table.child(hit.row);
+  if (row.children.some(isLockedCell)) return null;
+  const rowPos = rowPositionAt(spot.tablePos, spot.table, hit.row);
+  const rowDom = view.nodeDOM(rowPos);
+  if (!(rowDom instanceof HTMLTableRowElement)) return null;
+  return { ...spot, ...hit, tableDom, rowDom, rowPos };
+}
+function visualScale(view) {
+  const layer = view.dom.closest(`.${editorClassNames.pageLayer}`);
+  const raw = layer instanceof HTMLElement ? getComputedStyle(layer).zoom : "";
+  const parsed = Number.parseFloat(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 1;
+}
+function previewDecorations(doc, preview) {
+  const row = doc.nodeAt(preview.rowPos);
+  if (row?.type.spec.tableRole !== "row") return DecorationSet.empty;
+  return DecorationSet.create(doc, [
+    Decoration.node(preview.rowPos, preview.rowPos + row.nodeSize, {
+      style: `height:${preview.heightPt}pt !important`
+    })
+  ]);
+}
+function createGuide() {
+  const guide = document.createElement("div");
+  guide.className = editorClassNames.rowResizeGuide;
+  document.body.appendChild(guide);
+  return guide;
+}
+function moveGuide(drag) {
+  const table = drag.target.tableDom.getBoundingClientRect();
+  drag.guide.style.left = `${table.left}px`;
+  drag.guide.style.top = `${drag.target.rowDom.getBoundingClientRect().bottom}px`;
+  drag.guide.style.width = `${table.width}px`;
+}
+function showPreview(drag) {
+  drag.view.dispatch(
+    drag.view.state.tr.setMeta(rowResizeKey, {
+      rowPos: drag.target.rowPos,
+      heightPt: drag.heightPt
+    }).setMeta("addToHistory", false)
+  );
+  moveGuide(drag);
+}
+function hidePreview(drag) {
+  drag.view.dispatch(
+    drag.view.state.tr.setMeta(rowResizeKey, null).setMeta("addToHistory", false)
+  );
+  drag.guide.remove();
+}
+function rowResize() {
+  let drag = null;
+  function stop(clearPreview = true) {
+    if (!drag) return;
+    window.removeEventListener("mousemove", onMove, true);
+    window.removeEventListener("mouseup", onUp, true);
+    window.removeEventListener("keydown", onKey, true);
+    if (clearPreview) hidePreview(drag);
+    else drag.guide.remove();
+    drag.view.dom.classList.remove(editorClassNames.rowResize);
+    drag = null;
+  }
+  function onMove(event) {
+    if (!drag) return;
+    event.preventDefault();
+    drag.moved ||= event.clientY !== drag.startY;
+    drag.heightPt = resizedRowHeight(
+      drag.startHeightPt,
+      event.clientY - drag.startY,
+      drag.scale
+    );
+    showPreview(drag);
+  }
+  function onUp() {
+    const current = drag;
+    if (!current) return;
+    stop();
+    if (!current.moved) return;
+    const tr = buildResizeRowTransaction(current.view.state, {
+      tablePos: current.target.tablePos,
+      row: current.target.row,
+      heightPt: current.heightPt
+    });
+    if (tr) current.view.dispatch(tr);
+  }
+  function onKey(event) {
+    if (event.key !== "Escape") return;
+    event.preventDefault();
+    stop();
+  }
+  function start(view, event) {
+    const target = edgeUnder(view, event);
+    if (!target) return false;
+    const scale = visualScale(view);
+    const startHeightPt = target.rowDom.getBoundingClientRect().height / scale * (72 / 96);
+    drag = {
+      view,
+      target,
+      startY: event.clientY,
+      startHeightPt,
+      scale,
+      guide: createGuide(),
+      heightPt: startHeightPt,
+      moved: false
+    };
+    moveGuide(drag);
+    view.dom.classList.add(editorClassNames.rowResize);
+    window.addEventListener("mousemove", onMove, true);
+    window.addEventListener("mouseup", onUp, true);
+    window.addEventListener("keydown", onKey, true);
+    return true;
+  }
+  return new Plugin({
+    key: rowResizeKey,
+    state: {
+      init: () => DecorationSet.empty,
+      apply(tr, decorations) {
+        const preview = tr.getMeta(rowResizeKey);
+        if (preview === void 0) return decorations.map(tr.mapping, tr.doc);
+        return preview === null ? DecorationSet.empty : previewDecorations(tr.doc, preview);
+      }
+    },
+    view: () => ({ destroy: () => stop(false) }),
+    props: {
+      decorations: (state) => rowResizeKey.getState(state),
+      handleDOMEvents: {
+        mousemove(view, event) {
+          if (drag) return false;
+          const over = view.editable && edgeUnder(view, event) !== null;
+          view.dom.classList.toggle(editorClassNames.rowResize, over);
+          return false;
+        },
+        mouseleave(view) {
+          if (!drag) view.dom.classList.remove(editorClassNames.rowResize);
+          return false;
+        },
+        mousedown(view, event) {
+          if (!view.editable || drag || event.button !== 0) return false;
+          if (!start(view, event)) return false;
+          event.preventDefault();
+          return true;
+        }
+      }
+    }
+  });
+}
+export {
+  rowEdgeAt,
+  rowResize
+};

package/dist/editor/plugins/styledParagraphs.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Applies inherited style display values to paragraphs created in the editor. The paragraph under
+ * active IME composition is deferred to avoid redrawing and canceling the composition.
+ */
+import { Plugin } from "prosemirror-state";
+/**
+ * Reads the document's styles into the paragraphs an edit built.
+ *
+ * No transaction of its own goes to the history: ProseMirror hands an appended transaction to the
+ * history as part of the same event, so a single undo takes the edit and these values back together.
+ *
+ * An appended transaction is handed nothing but states, so the view an open composition is read
+ * from is the one the plugin is given when it mounts.
+ */
+export declare function styledParagraphs(): Plugin;

package/dist/editor/plugins/styledParagraphs.js

@@ -0,0 +1,65 @@
+// src/editor/plugins/styledParagraphs.ts
+import { Plugin } from "prosemirror-state";
+import {
+  effectiveParagraphFormat,
+  effectiveParagraphStyle,
+  layerRunFormat
+} from "../../docx/formatting.js";
+import { docxSchema } from "../../schema/index.js";
+import { documentParagraphFormatting } from "../documentStyles.js";
+function needsFormatting(node) {
+  return node.attrs.format === null && node.attrs.styleRun === null;
+}
+function paragraphSpots(doc) {
+  const found = [];
+  doc.descendants((node, pos) => {
+    if (node.type !== docxSchema.nodes.paragraph) return true;
+    if (needsFormatting(node)) found.push({ pos, node });
+    return false;
+  });
+  return found;
+}
+function styledAttrs(node, state) {
+  const context = documentParagraphFormatting(state);
+  const style = effectiveParagraphStyle(node.attrs.pPr, context);
+  const format = effectiveParagraphFormat(node.attrs.pPr, context);
+  const styleRun = style ? layerRunFormat(style.run, null) : null;
+  return { ...node.attrs, format, styleRun };
+}
+function composingAt(view, state) {
+  return view?.composing === true ? state.selection.from : null;
+}
+function holdsComposition(paragraph, composing) {
+  return composing !== null && composing >= paragraph.pos && composing <= paragraph.pos + paragraph.node.nodeSize;
+}
+function styledParagraphs() {
+  let live = null;
+  return new Plugin({
+    view(view) {
+      live = view;
+      return {
+        destroy() {
+          live = null;
+        }
+      };
+    },
+    appendTransaction(transactions, _oldState, newState) {
+      if (!transactions.some((transaction) => transaction.docChanged)) {
+        return null;
+      }
+      const composing = composingAt(live, newState);
+      const tr = newState.tr;
+      for (const paragraph of paragraphSpots(newState.doc)) {
+        if (holdsComposition(paragraph, composing)) continue;
+        const attrs = styledAttrs(paragraph.node, newState);
+        if (!paragraph.node.hasMarkup(paragraph.node.type, attrs)) {
+          tr.setNodeMarkup(paragraph.pos, null, attrs);
+        }
+      }
+      return tr.docChanged ? tr : null;
+    }
+  });
+}
+export {
+  styledParagraphs
+};

package/dist/editor/plugins/tabCaret.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from "prosemirror-state";
+/** Draws a caret from the model boundary because browsers disagree on a tab glyph's caret edge. */
+export declare function tabCaret(): Plugin;

package/dist/editor/plugins/tabCaret.js

@@ -0,0 +1,126 @@
+// src/editor/plugins/tabCaret.ts
+import { Plugin } from "prosemirror-state";
+import { docxSchema } from "../../schema/index.js";
+import { editorClassNames } from "../../styles/classNames.js";
+function isTab(node, edge) {
+  if (!node?.isText || !node.marks.some((mark) => mark.type === docxSchema.marks.tab)) {
+    return false;
+  }
+  return edge === "start" ? node.text?.startsWith("	") === true : node.text?.endsWith("	") === true;
+}
+function tabBoundary(view) {
+  const { selection } = view.state;
+  if (!selection.empty) return null;
+  const position = selection.head;
+  const resolved = view.state.doc.resolve(position);
+  if (isTab(resolved.nodeAfter, "start")) return { position, side: "before" };
+  if (isTab(resolved.nodeBefore, "end")) {
+    return { position: position - 1, side: "after" };
+  }
+  return null;
+}
+function tabSlot(view, position) {
+  return view.dom.querySelector(
+    `.${editorClassNames.tabSlot}[data-tab-position="${position}"]`
+  );
+}
+function tabCaret() {
+  return new Plugin({
+    view(view) {
+      const ownerDocument = view.dom.ownerDocument;
+      const ownerWindow = ownerDocument.defaultView;
+      const caret = ownerDocument.createElement("div");
+      caret.className = editorClassNames.tabCaret;
+      caret.hidden = true;
+      caret.setAttribute("aria-hidden", "true");
+      ownerDocument.body.append(caret);
+      let frame = 0;
+      let live = true;
+      const requestFrame = ownerWindow?.requestAnimationFrame.bind(ownerWindow);
+      const cancelFrame = ownerWindow?.cancelAnimationFrame.bind(ownerWindow);
+      const hide = () => {
+        caret.hidden = true;
+        view.dom.classList.remove(editorClassNames.tabCaretActive);
+      };
+      const draw = () => {
+        frame = 0;
+        if (!live || !view.hasFocus()) {
+          hide();
+          return;
+        }
+        const boundary = tabBoundary(view);
+        const slot = boundary && tabSlot(view, boundary.position);
+        if (!boundary || !slot || !slot.hasAttribute("data-tab-layout")) {
+          hide();
+          return;
+        }
+        const slotRect = slot.getBoundingClientRect();
+        const paragraph = slot.closest(`.${editorClassNames.paragraph}`);
+        const style = ownerWindow?.getComputedStyle(paragraph ?? slot);
+        const rtl = style?.direction === "rtl";
+        const leading = boundary.side === "before";
+        const left = leading === !rtl ? slotRect.left : slotRect.right;
+        const coordinates = view.coordsAtPos(view.state.selection.head);
+        const height = Math.max(1, coordinates.bottom - coordinates.top);
+        caret.style.color = ownerWindow?.getComputedStyle(slot).color ?? "currentcolor";
+        caret.style.left = `${left}px`;
+        caret.style.top = `${coordinates.top}px`;
+        caret.style.height = `${height}px`;
+        caret.hidden = false;
+        view.dom.classList.add(editorClassNames.tabCaretActive);
+      };
+      const schedule = () => {
+        if (!live || frame !== 0) return;
+        frame = (requestFrame ?? requestAnimationFrame)(draw);
+      };
+      const onFocus = () => schedule();
+      const onBlur = () => hide();
+      const onViewportChange = () => schedule();
+      const layer = view.dom.closest(`.${editorClassNames.pageLayer}`);
+      const root = view.dom.closest(`.${editorClassNames.root}`);
+      const workspace = view.dom.closest(`.${editorClassNames.workspace}`);
+      const ResizeObserverClass = ownerWindow?.ResizeObserver;
+      const resize = typeof ResizeObserverClass === "undefined" ? null : new ResizeObserverClass(schedule);
+      resize?.observe(view.dom);
+      if (root) resize?.observe(root);
+      if (workspace) resize?.observe(workspace);
+      const MutationObserverClass = ownerWindow?.MutationObserver;
+      const layoutMutation = typeof MutationObserverClass === "undefined" ? null : new MutationObserverClass(schedule);
+      if (layer) {
+        layoutMutation?.observe(layer, {
+          attributes: true,
+          attributeFilter: ["class", "style"]
+        });
+      }
+      if (workspace) {
+        layoutMutation?.observe(workspace, {
+          attributes: true,
+          attributeFilter: ["class", "data-comments", "style"]
+        });
+      }
+      view.dom.addEventListener("focus", onFocus);
+      view.dom.addEventListener("blur", onBlur);
+      ownerDocument.addEventListener("scroll", onViewportChange, true);
+      ownerWindow?.addEventListener("resize", onViewportChange);
+      schedule();
+      return {
+        update: () => schedule(),
+        destroy() {
+          live = false;
+          if (frame !== 0) (cancelFrame ?? cancelAnimationFrame)(frame);
+          view.dom.removeEventListener("focus", onFocus);
+          view.dom.removeEventListener("blur", onBlur);
+          ownerDocument.removeEventListener("scroll", onViewportChange, true);
+          ownerWindow?.removeEventListener("resize", onViewportChange);
+          resize?.disconnect();
+          layoutMutation?.disconnect();
+          view.dom.classList.remove(editorClassNames.tabCaretActive);
+          caret.remove();
+        }
+      };
+    }
+  });
+}
+export {
+  tabCaret
+};

package/dist/editor/plugins/tabDecorations.d.ts

@@ -0,0 +1,11 @@
+import { type EditorState, Plugin, type Transaction } from "prosemirror-state";
+import { DecorationSet } from "prosemirror-view";
+interface TabDecorationState {
+    widths: ReadonlyMap<number, number>;
+    decorations: DecorationSet;
+}
+export declare function tabWidths(state: EditorState): ReadonlyMap<number, number>;
+export declare function setTabWidths(transaction: Transaction, widths: ReadonlyMap<number, number>): Transaction;
+/** Gives every tab character an independent DOM range without changing the document model. */
+export declare function tabDecorations(): Plugin<TabDecorationState>;
+export {};

package/dist/editor/plugins/tabDecorations.js

@@ -0,0 +1,87 @@
+// src/editor/plugins/tabDecorations.ts
+import {
+  Plugin,
+  PluginKey
+} from "prosemirror-state";
+import { Decoration, DecorationSet } from "prosemirror-view";
+import { editorClassNames, editorCssVariables } from "../../styles/classNames.js";
+var tabDecorationsKey = new PluginKey(
+  "docxEditorTabDecorations"
+);
+function decorationsFor(doc, widths) {
+  const decorations = [];
+  doc.descendants((node, pos) => {
+    if (!node.isText || !node.text?.includes("	")) return true;
+    for (let offset = 0; offset < node.text.length; offset += 1) {
+      if (node.text[offset] !== "	") continue;
+      const from = pos + offset;
+      const width = widths.get(from);
+      const attrs = {
+        class: editorClassNames.tabSlot,
+        // Distinct attributes prevent adjacent ranges from sharing one DOM wrapper.
+        "data-tab-position": `${from}`
+      };
+      if (width !== void 0) {
+        attrs["data-tab-layout"] = "";
+        attrs.style = `${editorCssVariables.tabWidth}:${Math.max(0, width)}px`;
+      }
+      decorations.push(
+        Decoration.inline(from, from + 1, attrs, {
+          inclusiveStart: false,
+          inclusiveEnd: false
+        })
+      );
+    }
+    return true;
+  });
+  return DecorationSet.create(doc, decorations);
+}
+function characterAt(doc, position) {
+  return doc.textBetween(position, position + 1, "", "");
+}
+function mappedWidths(transaction, widths) {
+  const mapped = /* @__PURE__ */ new Map();
+  for (const [position, width] of widths) {
+    const result = transaction.mapping.mapResult(position, 1);
+    if (!result.deleted && result.pos < transaction.doc.content.size && characterAt(transaction.doc, result.pos) === "	") {
+      mapped.set(result.pos, width);
+    }
+  }
+  return mapped;
+}
+function tabWidths(state) {
+  return tabDecorationsKey.getState(state)?.widths ?? /* @__PURE__ */ new Map();
+}
+function setTabWidths(transaction, widths) {
+  return transaction.setMeta(tabDecorationsKey, widths);
+}
+function tabDecorations() {
+  return new Plugin({
+    key: tabDecorationsKey,
+    state: {
+      init: (_config, state) => {
+        const widths = /* @__PURE__ */ new Map();
+        return { widths, decorations: decorationsFor(state.doc, widths) };
+      },
+      apply(transaction, current, _oldState, newState) {
+        const supplied = transaction.getMeta(tabDecorationsKey);
+        if (!transaction.docChanged && !(supplied instanceof Map)) {
+          return current;
+        }
+        const widths = supplied instanceof Map ? supplied : mappedWidths(transaction, current.widths);
+        return {
+          widths,
+          decorations: decorationsFor(newState.doc, widths)
+        };
+      }
+    },
+    props: {
+      decorations: (state) => tabDecorationsKey.getState(state)?.decorations ?? null
+    }
+  });
+}
+export {
+  setTabWidths,
+  tabDecorations,
+  tabWidths
+};

package/dist/editor/plugins/tabLayout.d.ts

@@ -0,0 +1,16 @@
+import { Plugin } from "prosemirror-state";
+import type { TabAlignment, TabStop } from "../../model/tabStops";
+type PositionedAlignment = Exclude<TabAlignment, "num">;
+export interface TabTarget {
+    align: PositionedAlignment;
+    targetPt: number;
+}
+export declare function nextTabTarget(currentPt: number, stops: readonly TabStop[], defaultStopPt: number): TabTarget;
+export interface TabSegmentMetrics {
+    wholePt: number;
+    decimalPrefixPt: number;
+}
+export declare function tabAdvancePt(currentPt: number, target: TabTarget, segment: TabSegmentMetrics): number;
+/** Resolves tab widths against the paragraph's OOXML coordinate system. */
+export declare function tabLayout(): Plugin;
+export {};