@portone/docx-editor 0.1.0

package/dist/editor/commands/paragraphCommands.js

@@ -0,0 +1,113 @@
+// src/editor/commands/paragraphCommands.ts
+import { layerRunFormat, styleIdOf } from "../../docx/formatting.js";
+import {
+  withParagraphAlign,
+  withParagraphStyle
+} from "../../docx/paraProps.js";
+import { readRunProps } from "../../docx/runProps.js";
+import {
+  toParagraphFormat
+} from "../../model/format.js";
+import { docxSchema } from "../../schema/index.js";
+import { lockedMarkOf } from "../../schema/locks.js";
+import { defaultParagraphStyleId, documentStyles } from "../documentStyles.js";
+import {
+  editableParagraphs,
+  editParagraphs,
+  paragraphPPr,
+  selectedParagraphs
+} from "../paragraphEdits.js";
+function alignOf(node) {
+  return toParagraphFormat(node.attrs.format)?.align ?? "left";
+}
+function setParagraphAlign(align) {
+  return (state, dispatch) => editParagraphs(
+    state,
+    dispatch,
+    (node, styles, defaultStyleId) => (
+      // A paragraph already rendered with that alignment is left untouched, so its original XML survives
+      alignOf(node) === align ? null : withParagraphAlign(paragraphPPr(node), align, styles, defaultStyleId)
+    )
+  );
+}
+function canSetParagraphAlign(state) {
+  return editableParagraphs(state).length > 0;
+}
+function activeParagraphAlign(state) {
+  const aligns = selectedParagraphs(state).map(({ node }) => alignOf(node));
+  const first = aligns[0];
+  return first !== void 0 && aligns.every((align) => align === first) ? { kind: "shared", align: first } : { kind: "mixed" };
+}
+function text(value) {
+  return typeof value === "string" ? value : null;
+}
+function restyledMark(child, style) {
+  const mark = child.marks.find((entry) => entry.type === docxSchema.marks.run);
+  if (mark) {
+    const format2 = layerRunFormat(style, readRunProps(text(mark.attrs.rPr)));
+    return mark.type.create({ ...mark.attrs, format: format2 });
+  }
+  if (!child.isText) return null;
+  const format = layerRunFormat(style, null);
+  if (format === null) return null;
+  return docxSchema.marks.run.create({ rPr: null, rAttrs: null, format });
+}
+function restyledMarks(spot, style) {
+  const changes = [];
+  spot.node.forEach((child, offset) => {
+    if (lockedMarkOf(child)) return;
+    const mark = restyledMark(child, style);
+    if (!mark) return;
+    const from = spot.pos + 1 + offset;
+    changes.push({ from, to: from + child.nodeSize, mark });
+  });
+  return changes;
+}
+function writeStyleChanges(state, changed) {
+  const tr = state.tr;
+  for (const { spot, props, marks } of changed) {
+    tr.setNodeMarkup(tr.mapping.map(spot.pos), void 0, {
+      ...spot.node.attrs,
+      pPr: props.pPr,
+      format: props.format,
+      styleRun: props.styleRun
+    });
+    for (const change of marks) {
+      tr.addMark(change.from, change.to, change.mark);
+    }
+  }
+  return tr;
+}
+function setParagraphStyle(styleId) {
+  return (state, dispatch) => {
+    const styles = documentStyles(state);
+    const defaultStyleId = defaultParagraphStyleId(state);
+    const changed = editableParagraphs(state).flatMap((spot) => {
+      const pPr = paragraphPPr(spot.node);
+      if (styleIdOf(pPr) === styleId) return [];
+      const props = withParagraphStyle(pPr, styleId, styles, defaultStyleId);
+      if (!props) return [];
+      return [
+        { spot, props, marks: restyledMarks(spot, props.styleRun ?? {}) }
+      ];
+    });
+    if (changed.length === 0) return false;
+    if (dispatch) dispatch(writeStyleChanges(state, changed).scrollIntoView());
+    return true;
+  };
+}
+function activeParagraphStyle(state) {
+  const ids = selectedParagraphs(state).map(
+    ({ node }) => styleIdOf(paragraphPPr(node))
+  );
+  if (ids.length === 0) return { kind: "none" };
+  const first = ids[0] ?? null;
+  return ids.every((id) => id === first) ? { kind: "shared", styleId: first } : { kind: "mixed" };
+}
+export {
+  activeParagraphAlign,
+  activeParagraphStyle,
+  canSetParagraphAlign,
+  setParagraphAlign,
+  setParagraphStyle
+};

package/dist/editor/commands/spacingCommands.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The line spacing of a paragraph.
+ *
+ * It is set to one of the presets the toolbar offers.
+ * All XML handling belongs to `docx/paraProps`; this file only decides which paragraphs to
+ * change and to what.
+ */
+import type { Command, EditorState } from "prosemirror-state";
+import { type LineSpacing } from "../../model/format";
+/** One line of text, which is what a paragraph nobody gave a line spacing is drawn with */
+export declare const SINGLE_LINE_SPACING: LineSpacing;
+/**
+ * Sets the line spacing of the selected paragraphs.
+ * A paragraph already drawn with that spacing is left untouched, so its original XML survives.
+ */
+export declare function setLineSpacing(spacing: LineSpacing): Command;
+/** The line spacing the selected paragraphs share. Null when several spacings are mixed or nothing is selected */
+export declare function activeLineSpacing(state: EditorState): LineSpacing | null;
+/**
+ * Whether the selection holds a paragraph to space out at all. The toolbar disables the menu when it
+ * holds none, a selection the lock leaves nothing of included (`editor/paragraphEdits`)
+ */
+export declare function canSetLineSpacing(state: EditorState): boolean;

package/dist/editor/commands/spacingCommands.js

@@ -0,0 +1,48 @@
+// src/editor/commands/spacingCommands.ts
+import { withLineSpacing } from "../../docx/paraProps.js";
+import {
+  toParagraphFormat
+} from "../../model/format.js";
+import { documentDefaults } from "../documentStyles.js";
+import {
+  editableParagraphs,
+  editParagraphs,
+  paragraphPPr,
+  selectedParagraphs
+} from "../paragraphEdits.js";
+var SINGLE_LINE_SPACING = { rule: "auto", lines: 1 };
+function lineSpacingOf(node, defaults) {
+  return toParagraphFormat(node.attrs.format)?.lineSpacing ?? defaults.lineSpacing ?? SINGLE_LINE_SPACING;
+}
+function sameLineSpacing(a, b) {
+  if (a.rule === "auto") return b.rule === "auto" && a.lines === b.lines;
+  return b.rule === a.rule && a.pt === b.pt;
+}
+function setLineSpacing(spacing) {
+  return (state, dispatch) => {
+    const defaults = documentDefaults(state);
+    return editParagraphs(
+      state,
+      dispatch,
+      (node, styles, defaultStyleId) => sameLineSpacing(lineSpacingOf(node, defaults), spacing) ? null : withLineSpacing(paragraphPPr(node), spacing, styles, defaultStyleId)
+    );
+  };
+}
+function activeLineSpacing(state) {
+  const defaults = documentDefaults(state);
+  const spacings = selectedParagraphs(state).map(
+    ({ node }) => lineSpacingOf(node, defaults)
+  );
+  const first = spacings[0];
+  if (!first) return null;
+  return spacings.every((spacing) => sameLineSpacing(spacing, first)) ? first : null;
+}
+function canSetLineSpacing(state) {
+  return editableParagraphs(state).length > 0;
+}
+export {
+  SINGLE_LINE_SPACING,
+  activeLineSpacing,
+  canSetLineSpacing,
+  setLineSpacing
+};

package/dist/editor/commands/tabCommands.d.ts

@@ -0,0 +1,5 @@
+import { type Command } from "prosemirror-state";
+/** Inserts an editable OOXML tab in an ordinary paragraph. */
+export declare const insertTab: Command;
+/** Moves one logical text position only when that position contains a tab. */
+export declare function moveAcrossTab(visualDirection: "left" | "right", extend: boolean): Command;

package/dist/editor/commands/tabCommands.js

@@ -0,0 +1,65 @@
+// src/editor/commands/tabCommands.ts
+import {
+  TextSelection
+} from "prosemirror-state";
+import { toParagraphFormat } from "../../model/format.js";
+import { docxSchema } from "../../schema/index.js";
+import { replacementShut } from "../../schema/locks.js";
+function isOrdinaryParagraph(state) {
+  const { $from } = state.selection;
+  if ($from.parent.type !== docxSchema.nodes.paragraph || toParagraphFormat($from.parent.attrs.format)?.numbering) {
+    return false;
+  }
+  for (let depth = $from.depth - 1; depth > 0; depth -= 1) {
+    if ($from.node(depth).type.spec.tableRole === "cell") return false;
+  }
+  return true;
+}
+var insertTab = (state, dispatch) => {
+  const { selection } = state;
+  if (!(selection instanceof TextSelection) || !selection.$from.sameParent(selection.$to) || !isOrdinaryParagraph(state) || replacementShut(selection, state.doc)) {
+    return false;
+  }
+  if (dispatch) {
+    const inherited = state.storedMarks ?? (selection.empty ? selection.$from.marks() : selection.$from.marksAcross(selection.$to) ?? []);
+    const marks = inherited.filter(
+      (mark) => mark.type !== docxSchema.marks.tab
+    );
+    const tab = docxSchema.text(
+      "	",
+      docxSchema.marks.tab.create().addToSet(marks)
+    );
+    dispatch(state.tr.replaceSelectionWith(tab, false).scrollIntoView());
+  }
+  return true;
+};
+function moveAcrossTab(visualDirection, extend) {
+  return (state, dispatch) => {
+    const { selection } = state;
+    if (!(selection instanceof TextSelection) || !extend && !selection.empty) {
+      return false;
+    }
+    const { $head } = selection;
+    if ($head.parent.type !== docxSchema.nodes.paragraph) return false;
+    const rtl = toParagraphFormat($head.parent.attrs.format)?.direction === "rtl";
+    const forward = visualDirection === "right" ? !rtl : rtl;
+    const delta = forward ? 1 : -1;
+    const nextOffset = $head.parentOffset + delta;
+    if (nextOffset < 0 || nextOffset > $head.parent.content.size) return false;
+    const from = delta > 0 ? $head.pos : $head.pos - 1;
+    if (state.doc.textBetween(from, from + 1, "", "") !== "	") return false;
+    if (dispatch) {
+      const anchor = extend ? selection.anchor : $head.pos + delta;
+      dispatch(
+        state.tr.setSelection(
+          TextSelection.create(state.doc, anchor, $head.pos + delta)
+        ).scrollIntoView()
+      );
+    }
+    return true;
+  };
+}
+export {
+  insertTab,
+  moveAcrossTab
+};

package/dist/editor/createEditor.d.ts

@@ -0,0 +1,59 @@
+/**
+ * This file knows nothing about zip or XML. All it knows is the document model and the screen.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { EditorState, type Plugin } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import { type ParagraphFormatLayer, type ParagraphStyleOption, type StyleTable } from "../docx/formatting";
+import { type PageGeometry } from "../docx/pageGeometry";
+import type { DocumentDefaults } from "../model/format";
+import { type Numbering } from "../numbering/parseNumbering";
+import { type FontFallbacks } from "../styles/fontStack";
+export interface EditorStateOptions {
+    numbering?: Numbering;
+    styles?: StyleTable;
+    defaults?: DocumentDefaults;
+    /** Paragraph properties from styles.xml docDefaults. */
+    paragraphDefaults?: ParagraphFormatLayer;
+    /**
+     * Whether the document has a place (numbering.xml) to write the definition of a new list.
+     * Callers that build a state without opening a document assume that place exists and behave
+     * as they do today.
+     */
+    canStartNewList?: boolean;
+    /** The plugins handed in from outside the package */
+    consumerPlugins?: readonly Plugin[];
+    /** The styles the document defines for the style picker to offer */
+    paragraphStyles?: ParagraphStyleOption[];
+    /**
+     * Whether the right click is the editor's own. Turned off, the browser's own menu is never
+     * taken away, which is what a consumer drawing menus of its own needs.
+     */
+    contextMenus?: boolean;
+    /** The paper the document names. A4 where a document names none */
+    geometry?: PageGeometry;
+    /** The interval between automatic tab stops, in points. */
+    defaultTabStopPt?: number;
+    /** Every id already present in the opened Comments part, including unreferenced entries. */
+    reservedCommentIds?: Iterable<string>;
+    /** Every paragraph id present in the opened comment parts, including orphan extension entries. */
+    reservedCommentParaIds?: Iterable<string>;
+}
+/**
+ * Creates a single editing state.
+ * The list definitions, the style table, and the document defaults are what the document
+ * wrote down, and commands and the toolbar read them through plugins.
+ */
+export declare function createEditorState(doc: PMNode, { numbering, styles, defaults, paragraphDefaults, canStartNewList, consumerPlugins, paragraphStyles, contextMenus, geometry, defaultTabStopPt, reservedCommentIds, reservedCommentParaIds, }?: EditorStateOptions): EditorState;
+export interface EditorOptions {
+    mount: HTMLElement;
+    state: EditorState;
+    defaults: DocumentDefaults;
+    /** The paper the document names. The sheet is drawn from it, A4 where a document names none */
+    geometry?: PageGeometry;
+    readOnly: boolean;
+    /** The fonts stood in for the ones the document declares. The built-in set when none is given */
+    fontFallbacks?: FontFallbacks;
+    onStateChange: (state: EditorState) => void;
+}
+export declare function createEditorView({ mount, state, defaults, geometry, readOnly, fontFallbacks, onStateChange, }: EditorOptions): EditorView;

package/dist/editor/createEditor.js

@@ -0,0 +1,160 @@
+// src/editor/createEditor.ts
+import { baseKeymap } from "prosemirror-commands";
+import { dropCursor } from "prosemirror-dropcursor";
+import { history } from "prosemirror-history";
+import { keymap } from "prosemirror-keymap";
+import { EditorState } from "prosemirror-state";
+import { tableEditing } from "prosemirror-tables";
+import { EditorView } from "prosemirror-view";
+import { DEFAULT_TAB_STOP_PT } from "../docx/documentSettings.js";
+import {
+  NO_DOCUMENT_DEFAULTS,
+  NO_STYLES
+} from "../docx/formatting.js";
+import { A4_PORTRAIT } from "../docx/pageGeometry.js";
+import { EMPTY_NUMBERING } from "../numbering/parseNumbering.js";
+import { pageDecorations } from "../page/pageDecorations.js";
+import { pageGeometryStyle, pagePixels } from "../page/pageLayout.js";
+import { editorClassNames } from "../styles/classNames.js";
+import {
+  DEFAULT_FONT_FALLBACKS
+} from "../styles/fontStack.js";
+import { documentDefaultsStyle } from "../styles/inlineStyle.js";
+import { gridBorders, withDerivedGridBorders } from "../table/gridBorders.js";
+import { documentDefaultTabStopPt, documentStyleTable } from "./documentStyles.js";
+import { externalClipboard } from "./externalClipboard.js";
+import { imageFiles } from "./imageFiles.js";
+import { bookmarkProtection } from "./plugins/bookmarkProtection.js";
+import { columnResize } from "./plugins/columnResize.js";
+import { commentDecorations } from "./plugins/commentDecorations.js";
+import { commentReservations } from "./plugins/commentReservations.js";
+import { imagePaste } from "./plugins/imagePaste.js";
+import { docxKeymap } from "./plugins/keymap.js";
+import { linkPanel } from "./plugins/linkPanel.js";
+import { listInputRules } from "./plugins/listInputRules.js";
+import { lockedContent } from "./plugins/lockedContent.js";
+import { noteProtection } from "./plugins/noteProtection.js";
+import { numberingMarkers } from "./plugins/numberingDecorations.js";
+import { rowResize } from "./plugins/rowResize.js";
+import { styledParagraphs } from "./plugins/styledParagraphs.js";
+import { tabCaret } from "./plugins/tabCaret.js";
+import { tabDecorations } from "./plugins/tabDecorations.js";
+import { tabLayout } from "./plugins/tabLayout.js";
+import { tableContextMenu } from "./plugins/tableContextMenu.js";
+import { tabPointer } from "./plugins/tabPointer.js";
+import { textContextMenu } from "./plugins/textContextMenu.js";
+import { ImageNodeView } from "./views/imageResize.js";
+import { runMarkView } from "./views/runMarkView.js";
+function createEditorState(doc, {
+  numbering = EMPTY_NUMBERING,
+  styles = NO_STYLES,
+  defaults = NO_DOCUMENT_DEFAULTS,
+  paragraphDefaults = {},
+  canStartNewList = true,
+  consumerPlugins = [],
+  paragraphStyles = [],
+  contextMenus = true,
+  geometry = A4_PORTRAIT,
+  defaultTabStopPt = DEFAULT_TAB_STOP_PT,
+  reservedCommentIds = [],
+  reservedCommentParaIds = []
+} = {}) {
+  return EditorState.create({
+    doc: withDerivedGridBorders(doc),
+    plugins: [
+      // Consumer plugins lead the array. ProseMirror walks the plugins in order and takes the
+      // first answer for a keypress, a paste, a drop or any other DOM event, so this is the
+      // only place from which a consumer handler can win over the built-in one.
+      ...consumerPlugins,
+      // Refuses every edit inside a locked content control, whoever asked for it. It is not
+      // optional: a document that locked a part of itself stays locked in every consumer.
+      lockedContent(),
+      // Bookmark ranges are preserved rather than edited, so neither half may disappear.
+      bookmarkProtection(),
+      // Note bodies are display-only, so their imported main-story references stay paired.
+      noteProtection(),
+      // An orphan Comments-part entry still owns its id and must not be replaced by a new comment.
+      commentReservations(reservedCommentIds, reservedCommentParaIds),
+      history(),
+      keymap(docxKeymap),
+      keymap(baseKeymap),
+      // Holds whether the link panel is open, which Cmd+K above and the toolbar button both set
+      linkPanel(),
+      // Turns a typed list prefix ("1. ", "- ") into a list. Backspace, bound in `docxKeymap`
+      // above, is what takes such a conversion back
+      listInputRules(),
+      dropCursor(),
+      // Clipboard priority is files, resolvable HTML images, then regular HTML or plain text.
+      imageFiles(),
+      imagePaste(),
+      externalClipboard(),
+      // A press that grabs a table edge must be intercepted before a cell-selection drag starts.
+      // For DOM events the plugin registered first wins, so both resizers precede `tableEditing`.
+      columnResize(),
+      rowResize(),
+      tableEditing(),
+      // Comment anchors live in the model; this paints their ranges without changing document XML.
+      commentDecorations(),
+      // Adjacent text tabs still need separate DOM ranges for layout and pointer selection.
+      tabDecorations(),
+      tabPointer(),
+      tabLayout(),
+      tabCaret(),
+      // Keeps table-cell lines aligned with OOXML precedence after an edit
+      gridBorders(),
+      // Reads the document's styles into the paragraphs an edit built from nothing
+      styledParagraphs(),
+      // Receiving a right-click means taking the browser's own menu away, so both of these stand
+      // or fall together with the menus the editor draws. The text menu stands ahead of the table
+      // menu, and hands a click with nothing selected inside a cell back to it
+      ...contextMenus ? [textContextMenu(), tableContextMenu()] : [],
+      numberingMarkers(numbering, canStartNewList),
+      // Values only go in when page display is turned on
+      pageDecorations(),
+      documentStyleTable(
+        styles,
+        defaults,
+        paragraphStyles,
+        geometry,
+        paragraphDefaults,
+        numbering,
+        defaultTabStopPt
+      )
+    ]
+  });
+}
+function createEditorView({
+  mount,
+  state,
+  defaults,
+  geometry = A4_PORTRAIT,
+  readOnly,
+  fontFallbacks = DEFAULT_FONT_FALLBACKS,
+  onStateChange
+}) {
+  const view = new EditorView(mount, {
+    state,
+    editable: () => !readOnly,
+    attributes: {
+      class: editorClassNames.sheet,
+      // The paper first, so a document that names one is drawn on it from the first frame
+      style: `${pageGeometryStyle(pagePixels(geometry))};${documentDefaultsStyle(defaults, fontFallbacks)};tab-size:${documentDefaultTabStopPt(state)}pt`
+    },
+    // The schema can only draw a run with the default fallback fonts, so this editor draws its own
+    markViews: { run: runMarkView(fontFallbacks) },
+    // An image is drawn by a view of its own, which is what carries the resize handles
+    nodeViews: {
+      image: (node, imageView, getPos) => new ImageNodeView(node, imageView, getPos)
+    },
+    dispatchTransaction(transaction) {
+      const next = view.state.apply(transaction);
+      view.updateState(next);
+      onStateChange(next);
+    }
+  });
+  return view;
+}
+export {
+  createEditorState,
+  createEditorView
+};

package/dist/editor/documentStyles.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Brings what the document laid down into the editor: what styles.xml told us, and the paper it
+ * is written on.
+ *
+ * Commands and the toolbar know nothing about the session, so this plugin holds all of it on
+ * their behalf: deriving the display values again after a formatting edit needs the values the
+ * style laid down, the toolbar needs the size a run is rendered at where nobody wrote a size
+ * down, and a new table is fitted to the width of the body the paper leaves.
+ * The values are fixed the moment the document is opened and do not change while editing.
+ */
+import { type EditorState, Plugin } from "prosemirror-state";
+import { type ParagraphFormatLayer, type ParagraphFormattingContext, type ParagraphStyleOption, type StyleTable } from "../docx/formatting";
+import { type PageGeometry } from "../docx/pageGeometry";
+import type { DocumentDefaults } from "../model/format";
+import { type Numbering } from "../numbering/parseNumbering";
+/** Values that apply to the whole document */
+interface DocumentInfo {
+    styles: StyleTable;
+    defaults: DocumentDefaults;
+    paragraphDefaults: ParagraphFormatLayer;
+    numbering: Numbering;
+    paragraphStyles: ParagraphStyleOption[];
+    /** The paper the document is written on, which decides the width a new table is fitted to */
+    geometry: PageGeometry;
+    /** The distance between automatic tab stops when no custom stop applies. */
+    defaultTabStopPt: number;
+}
+/** This document's style table. Empty when the editor does not know the table */
+export declare function documentStyles(state: EditorState): StyleTable;
+/** The default formatting this document wrote down. When the editor does not know it, it is the same as nothing being specified */
+export declare function documentDefaults(state: EditorState): DocumentDefaults;
+/** The values required to resolve the OOXML paragraph-property hierarchy. */
+export declare function documentParagraphFormatting(state: EditorState): ParagraphFormattingContext;
+/** The paragraph styles this document defines. Empty when the editor does not know them */
+export declare function documentParagraphStyles(state: EditorState): ParagraphStyleOption[];
+/**
+ * The style a paragraph pointing at none of its own wears (`w:default="1"`). Null when the
+ * document marks none.
+ *
+ * It is the style the list of them marks, of which `readParagraphStyles` leaves exactly one.
+ */
+export declare function defaultParagraphStyleId(state: EditorState): string | null;
+/**
+ * The paper the document is written on. A document the editor knows no paper for is drawn on
+ * the same A4 every document was drawn on before the geometry was read
+ */
+export declare function documentGeometry(state: EditorState): PageGeometry;
+/** The document-wide interval between automatic tab stops, in points. */
+export declare function documentDefaultTabStopPt(state: EditorState): number;
+/**
+ * The width one line of body text occupies on this document's paper, in pixels.
+ *
+ * It is the width an image wider than the page is shrunk to, so a caller inserting an image
+ * itself asks for it rather than taking the A4 width `fittedExtent` falls back to.
+ */
+export declare function documentBodyWidthPx(state: EditorState): number;
+/** The height one page of body content occupies, in pixels. */
+export declare function documentBodyHeightPx(state: EditorState): number;
+export declare function documentStyleTable(styles: StyleTable, defaults?: DocumentDefaults, paragraphStyles?: ParagraphStyleOption[], geometry?: PageGeometry, paragraphDefaults?: ParagraphFormatLayer, numbering?: Numbering, defaultTabStopPt?: number): Plugin<DocumentInfo>;
+export {};

package/dist/editor/documentStyles.js

@@ -0,0 +1,80 @@
+// src/editor/documentStyles.ts
+import { Plugin, PluginKey } from "prosemirror-state";
+import { DEFAULT_TAB_STOP_PT } from "../docx/documentSettings.js";
+import {
+  NO_DOCUMENT_DEFAULTS,
+  NO_PARAGRAPH_FORMATTING,
+  NO_STYLES
+} from "../docx/formatting.js";
+import {
+  A4_PORTRAIT,
+  bodyHeightTwips,
+  bodyWidth,
+  twipsToPx
+} from "../docx/pageGeometry.js";
+import { EMPTY_NUMBERING } from "../numbering/parseNumbering.js";
+var NO_PARAGRAPH_STYLES = [];
+var documentKey = new PluginKey("docxEditorDocument");
+function documentStyles(state) {
+  return documentKey.getState(state)?.styles ?? NO_STYLES;
+}
+function documentDefaults(state) {
+  return documentKey.getState(state)?.defaults ?? NO_DOCUMENT_DEFAULTS;
+}
+function documentParagraphFormatting(state) {
+  const info = documentKey.getState(state);
+  if (!info) return NO_PARAGRAPH_FORMATTING;
+  return {
+    styles: info.styles,
+    defaultStyleId: info.paragraphStyles.find((style) => style.isDefault)?.id ?? null,
+    defaults: info.paragraphDefaults,
+    numbering: info.numbering
+  };
+}
+function documentParagraphStyles(state) {
+  return documentKey.getState(state)?.paragraphStyles ?? NO_PARAGRAPH_STYLES;
+}
+function defaultParagraphStyleId(state) {
+  return documentParagraphStyles(state).find((style) => style.isDefault)?.id ?? null;
+}
+function documentGeometry(state) {
+  return documentKey.getState(state)?.geometry ?? A4_PORTRAIT;
+}
+function documentDefaultTabStopPt(state) {
+  return documentKey.getState(state)?.defaultTabStopPt ?? DEFAULT_TAB_STOP_PT;
+}
+function documentBodyWidthPx(state) {
+  return bodyWidth(documentGeometry(state)).px;
+}
+function documentBodyHeightPx(state) {
+  return twipsToPx(bodyHeightTwips(documentGeometry(state)));
+}
+function documentStyleTable(styles, defaults = NO_DOCUMENT_DEFAULTS, paragraphStyles = NO_PARAGRAPH_STYLES, geometry = A4_PORTRAIT, paragraphDefaults = {}, numbering = EMPTY_NUMBERING, defaultTabStopPt = DEFAULT_TAB_STOP_PT) {
+  return new Plugin({
+    key: documentKey,
+    state: {
+      init: () => ({
+        styles,
+        defaults,
+        paragraphDefaults,
+        numbering,
+        paragraphStyles,
+        geometry,
+        defaultTabStopPt
+      }),
+      apply: (_tr, current) => current
+    }
+  });
+}
+export {
+  defaultParagraphStyleId,
+  documentBodyHeightPx,
+  documentBodyWidthPx,
+  documentDefaultTabStopPt,
+  documentDefaults,
+  documentGeometry,
+  documentParagraphFormatting,
+  documentParagraphStyles,
+  documentStyleTable,
+  documentStyles
+};

package/dist/editor/externalClipboard.d.ts

@@ -0,0 +1,11 @@
+import { Slice } from "prosemirror-model";
+import { type EditorState, Plugin } from "prosemirror-state";
+import type { EditorView } from "prosemirror-view";
+import type { ImageToInsert } from "./insertImage";
+export declare function richHtmlSlice(state: EditorState, document: Document, source: string, images?: ReadonlyMap<string, ImageToInsert>): Slice | null;
+export declare function insertRichHtml(view: EditorView, source: string): boolean;
+export declare function insertClipboardData(view: EditorView, data: {
+    html?: string;
+    text?: string;
+}): void;
+export declare function externalClipboard(): Plugin;