@portone/docx-editor 0.1.0

package/dist/editor/commands/formatting/reading.js

@@ -0,0 +1,82 @@
+// src/editor/commands/formatting/reading.ts
+import { fontNamesOf } from "../../../docx/formatting.js";
+import {
+  NO_FILL,
+  toRunFormat
+} from "../../../model/format.js";
+import {
+  DEFAULT_FONT_FALLBACKS
+} from "../../../styles/fontStack.js";
+import {
+  FALLBACK_FONT_SIZE_PT,
+  HIGHLIGHT_COLORS
+} from "../../../styles/inlineStyle.js";
+import { documentDefaults } from "../../documentStyles.js";
+import { activePieces, runMarkOf } from "./shared.js";
+function sharedValue(values) {
+  if (values.length === 0) return null;
+  const [first, ...rest] = values;
+  return rest.every((value) => value === first) ? first : null;
+}
+function defaultFontSizePt(state) {
+  return documentDefaults(state).fontSizePt ?? FALLBACK_FONT_SIZE_PT;
+}
+function activeFontSize(state) {
+  const sizes = activePieces(state).map(
+    (target) => target.format?.fontSizePt ?? null
+  );
+  const first = sizes[0] ?? null;
+  if (sizes.some((pt) => pt !== first)) return { kind: "mixed" };
+  if (first !== null) return { kind: "size", pt: first };
+  return { kind: "default", pt: defaultFontSizePt(state) };
+}
+function fontNameOf(format) {
+  return fontNamesOf(format?.fontFamily)[0] ?? null;
+}
+function defaultFontName(state, fontFallbacks) {
+  const defaults = documentDefaults(state);
+  return fontNamesOf(defaults.fontFamily)[0] ?? fontFallbacks.defaultFontName;
+}
+function activeFontFamily(state, fontFallbacks = DEFAULT_FONT_FALLBACKS) {
+  const names = activePieces(state).map((target) => fontNameOf(target.format));
+  const first = names[0] ?? null;
+  if (names.some((name) => name !== first)) return { kind: "mixed" };
+  if (first !== null) return { kind: "font", name: first };
+  return { kind: "default", name: defaultFontName(state, fontFallbacks) };
+}
+function documentFontNames(doc, defaults) {
+  const names = new Set(fontNamesOf(defaults.fontFamily));
+  doc.descendants((node) => {
+    const mark = runMarkOf(node.marks);
+    for (const name of fontNamesOf(
+      toRunFormat(mark?.attrs.format)?.fontFamily
+    )) {
+      names.add(name);
+    }
+    return true;
+  });
+  return Array.from(names).sort((a, b) => a.localeCompare(b));
+}
+function activeTextColor(state) {
+  return sharedValue(
+    activePieces(state).map((target) => target.format?.color ?? null)
+  );
+}
+function backgroundOf(format) {
+  const highlight = format?.highlight;
+  if (highlight !== void 0) return HIGHLIGHT_COLORS[highlight] ?? null;
+  const background = format?.background ?? null;
+  return background === NO_FILL ? null : background;
+}
+function activeTextBackground(state) {
+  return sharedValue(
+    activePieces(state).map((target) => backgroundOf(target.format ?? null))
+  );
+}
+export {
+  activeFontFamily,
+  activeFontSize,
+  activeTextBackground,
+  activeTextColor,
+  documentFontNames
+};

package/dist/editor/commands/formatting/shared.d.ts

@@ -0,0 +1,32 @@
+/** Shared text-piece discovery for formatting reads and edits. */
+import type { Mark } from "prosemirror-model";
+import type { EditorState } from "prosemirror-state";
+import { type RunFormat } from "../../../model/format";
+/** One piece of text whose formatting is to be edited */
+export interface TextPiece {
+    from: number;
+    to: number;
+    /** The run mark this text carries. Null for text with no formatting */
+    mark: Mark | null;
+    /** The formatting XML of the paragraph the text sits in. Used to check for style inheritance */
+    pPr: string | null;
+    /** The effective formatting visible on screen */
+    format: RunFormat | null;
+}
+export declare function text(value: unknown): string | null;
+export declare function runMarkOf(marks: readonly Mark[]): Mark | null;
+/**
+ * The text pieces inside the selection.
+ * Non-text content is skipped. A tab is text in the model and shares its OOXML run properties,
+ * so character formatting reaches it along with the visible characters around it.
+ * Selections with several ranges, such as a table cell selection, go down the same path.
+ */
+export declare function textPieces(state: EditorState): TextPiece[];
+/** When the selection is collapsed, the formatting that text typed next will follow */
+export declare function caretPiece(state: EditorState): TextPiece;
+/**
+ * The places formatting currently applies to: a single caret, or the text pieces of the selection
+ * a lock leaves open. It has to leave out what `applyToSelection` leaves out, or a toggle reads off
+ * for text that is already on and can never turn it off.
+ */
+export declare function activePieces(state: EditorState): TextPiece[];

package/dist/editor/commands/formatting/shared.js

@@ -0,0 +1,53 @@
+// src/editor/commands/formatting/shared.ts
+import { toRunFormat } from "../../../model/format.js";
+import { docxSchema } from "../../../schema/index.js";
+import { rangeTouchesLocked } from "../../../schema/locks.js";
+function text(value) {
+  return typeof value === "string" ? value : null;
+}
+function runMarkOf(marks) {
+  return marks.find((mark) => mark.type === docxSchema.marks.run) ?? null;
+}
+function piece(from, to, marks, parent) {
+  const mark = runMarkOf(marks);
+  return {
+    from,
+    to,
+    mark,
+    pPr: text(parent?.attrs.pPr),
+    format: toRunFormat(mark?.attrs.format)
+  };
+}
+function textPieces(state) {
+  const pieces = [];
+  for (const range of state.selection.ranges) {
+    const from = range.$from.pos;
+    const to = range.$to.pos;
+    state.doc.nodesBetween(from, to, (node, pos, parent) => {
+      if (!node.isText) return true;
+      const start = Math.max(pos, from);
+      const end = Math.min(pos + node.nodeSize, to);
+      if (start < end) pieces.push(piece(start, end, node.marks, parent));
+      return false;
+    });
+  }
+  return pieces;
+}
+function caretPiece(state) {
+  const $from = state.selection.$from;
+  const marks = state.storedMarks ?? $from.marks();
+  return piece($from.pos, $from.pos, marks, $from.parent);
+}
+function activePieces(state) {
+  if (state.selection.empty) return [caretPiece(state)];
+  return textPieces(state).filter(
+    (target) => !rangeTouchesLocked(state.doc, target.from, target.to)
+  );
+}
+export {
+  activePieces,
+  caretPiece,
+  runMarkOf,
+  text,
+  textPieces
+};

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

@@ -0,0 +1,2 @@
+export * from "./formatting/editing";
+export * from "./formatting/reading";

package/dist/editor/commands/formattingCommands.js

@@ -0,0 +1,3 @@
+// src/editor/commands/formattingCommands.ts
+export * from "./formatting/editing.js";
+export * from "./formatting/reading.js";

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

@@ -0,0 +1,11 @@
+/**
+ * Undo and redo, each carrying the pass that takes a replayed lock through the lock guard
+ * (`historyReplay` in `schema/locks`).
+ *
+ * These are the two the keymap, the toolbar and `./commands` use. A raw prosemirror-history command
+ * is refused the moment the history reaches a lock, and that refusal leaves everything behind it in
+ * the history out of reach.
+ */
+import type { Command } from "prosemirror-state";
+export declare const undo: Command;
+export declare const redo: Command;

package/dist/editor/commands/historyCommands.js

@@ -0,0 +1,16 @@
+// src/editor/commands/historyCommands.ts
+import { redo as historyRedo, undo as historyUndo } from "prosemirror-history";
+import { historyReplay } from "../../schema/locks.js";
+function replaying(command) {
+  return (state, dispatch, view) => command(
+    state,
+    dispatch && ((tr) => dispatch(tr.setMeta(historyReplay, true))),
+    view
+  );
+}
+var undo = replaying(historyUndo);
+var redo = replaying(historyRedo);
+export {
+  redo,
+  undo
+};

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

@@ -0,0 +1,15 @@
+/**
+ * The indent commands, which work on any paragraph.
+ *
+ * In any paragraph but a list they move that paragraph's own left indent one step, the same as
+ * Word, which is what sets them apart from `increaseListLevel` and `decreaseListLevel`.
+ * In a list paragraph they move the item one level instead, exactly what Tab and Shift+Tab do.
+ * A selection holding both kinds gets each paragraph treated by its own rule.
+ */
+import type { Command, EditorState } from "prosemirror-state";
+export declare const increaseIndent: Command;
+export declare const decreaseIndent: Command;
+/** Whether anything in the selection can still move right. The toolbar disables the button when nothing can */
+export declare function canIncreaseIndent(state: EditorState): boolean;
+/** Whether anything in the selection can still move left. A paragraph with no indent left to give up cannot */
+export declare function canDecreaseIndent(state: EditorState): boolean;

package/dist/editor/commands/indentCommands.js

@@ -0,0 +1,44 @@
+// src/editor/commands/indentCommands.ts
+import { withLeftIndent, withListNumbering } from "../../docx/paraProps.js";
+import { toParagraphFormat } from "../../model/format.js";
+import { editParagraphs, paragraphPPr } from "../paragraphEdits.js";
+import { documentNumbering } from "../plugins/numberingDecorations.js";
+import { listLevelChange, listRefOf } from "./listCommands.js";
+var STEP_TWIPS = 720;
+function leftIndentTwips(node) {
+  const format = toParagraphFormat(node.attrs.format);
+  const pt = format?.indentStartPt ?? format?.indentLeftPt ?? 0;
+  return Math.round(pt * 20);
+}
+function steppedLeftTwips(node, delta) {
+  const left = leftIndentTwips(node);
+  if (delta === -1 && left <= 0) return null;
+  return Math.max(0, left + delta * STEP_TWIPS);
+}
+function indentStep(delta) {
+  return (state, dispatch) => {
+    const numbering = documentNumbering(state);
+    return editParagraphs(state, dispatch, (node, styles, defaultStyleId) => {
+      if (listRefOf(node)) {
+        const change = listLevelChange(numbering, node, delta);
+        return change && withListNumbering(paragraphPPr(node), change, styles, defaultStyleId);
+      }
+      const left = steppedLeftTwips(node, delta);
+      return left === null ? null : withLeftIndent(paragraphPPr(node), left, styles, defaultStyleId);
+    });
+  };
+}
+var increaseIndent = indentStep(1);
+var decreaseIndent = indentStep(-1);
+function canIncreaseIndent(state) {
+  return increaseIndent(state);
+}
+function canDecreaseIndent(state) {
+  return decreaseIndent(state);
+}
+export {
+  canDecreaseIndent,
+  canIncreaseIndent,
+  decreaseIndent,
+  increaseIndent
+};

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

@@ -0,0 +1,82 @@
+/**
+ * The public surface for character formatting and list editing.
+ *
+ * Everything the built-in toolbar and the right click menu run is exported, so a consumer can
+ * build controls of its own design or drive the same editing from a plugin. Following the
+ * ProseMirror convention, calling a command without `dispatch` only reports whether it is
+ * applicable right now, and `is*Active`, `can*` and `active*` are used to render button state.
+ */
+import type { Command } from "prosemirror-state";
+export type EditorCommand = Command;
+/** The paragraph styles the document defines, which the style picker offers */
+export type { ParagraphStyleOption } from "../../docx/formatting";
+export type { RunToggle } from "../../docx/runProps";
+export type { LineSpacing, ParagraphAlign } from "../../model/format";
+export type { ListKind } from "../../numbering/listTemplate";
+/** The size an image is shown at, which the insert command asks for */
+export type { ImageExtent } from "../../ooxml/image";
+/** The fonts to draw with where a document names one the machine does not have, which the font queries read */
+export type { FontFallbacks } from "../../styles/fontStack";
+/**
+ * The document's own default formatting, which `documentFontNames` needs, and the width of one
+ * line of body text on the paper the document names, which is what an image wider than the page
+ * is shrunk to
+ */
+export { documentBodyWidthPx, documentDefaults, documentParagraphStyles, } from "../documentStyles";
+/**
+ * The way an image file goes from outside into the document, which is what an image button of
+ * your own stands on. `insertImageFiles` is all of it in one call, and is what the built-in
+ * button runs; `readImageFile` and `fittedExtent` are for a caller that puts the image in itself,
+ * the second being the rule by which an image wider than the body is shrunk to the body width.
+ * Both take that width, which `documentBodyWidthPx` reads off the open document; left out, it is
+ * A4's.
+ */
+export { fittedExtent, IMAGE_FILE_ACCEPT, imageFilesIn, insertImageFiles, readImageFile, } from "../imageFiles";
+export type { ImageToInsert } from "../insertImage";
+export { canInsertImage, insertImage } from "../insertImage";
+export type { TableSize } from "../insertTable";
+export { canInsertTable, insertTable } from "../insertTable";
+/**
+ * The two breaks, which are what the keymap binds to Shift+Enter and Mod+Enter
+ * (`editor/plugins/keymap`), so a control of your own can put in either.
+ */
+export { insertLineBreak, insertPageBreak } from "./breakCommands";
+/**
+ * Whether a command this package does not own would go through right now, the lock guard included.
+ * The commands here need no such wrapper: each of them asks the guard before it answers. What does
+ * is a command of a consumer's own, or one out of `prosemirror-commands`, since the predicates the
+ * question takes are not exported anywhere.
+ */
+export { canRunCommand } from "./canRunCommand";
+export type { CommentAuthor, DocumentComment, DocumentCommentReply, NewComment, } from "./commentCommands";
+export { addComment, addCommentReply, canAddComment, documentComments, removeComment, removeCommentReply, selectComment, setCommentResolved, updateComment, updateCommentReply, } from "./commentCommands";
+export type { ActiveFontFamily, ActiveFontSize, } from "./formattingCommands";
+export { activeFontFamily, activeFontSize, activeTextBackground, activeTextColor, canFormatText, documentFontNames, isBoldActive, isItalicActive, isStrikeActive, isUnderlineActive, setFontFamily, setFontSize, setTextBackground, setTextColor, toggleBold, toggleItalic, toggleStrike, toggleUnderline, } from "./formattingCommands";
+/**
+ * Undo and redo are the editor's own rather than prosemirror-history's, because a replayed lock
+ * only passes the lock guard with the pass these two carry (`./historyCommands`). They also find
+ * the history this editor keeps, which an import of the consumer's own copy of prosemirror-history
+ * would not.
+ */
+export { redo, undo } from "./historyCommands";
+export { canDecreaseIndent, canIncreaseIndent, decreaseIndent, increaseIndent, } from "./indentCommands";
+export type { ActiveLinkSpan } from "./linkCommands";
+/**
+ * The link commands, which the Cmd+K panel and the toolbar button are drawn from
+ * (`ui/LinkPanel`). `activeLink` is the address to show, `canSetLink` whether a link may go on at
+ * all - it is asked before an address has been typed - and `removeLink` reporting false is how a
+ * control knows there is no link to take away.
+ * `activeLinkSpan` is the one link the selection sits inside, stretch and address, which is what a
+ * card standing by a link is placed and drawn from (`ui/LinkCard`).
+ */
+export { activeLink, activeLinkSpan, canSetLink, removeLink, setLink, } from "./linkCommands";
+export { activeListKind, decreaseListLevel, increaseListLevel, isInList, toggleBulletList, toggleNumberedList, } from "./listCommands";
+export type { SelectionLock } from "./lockCommands";
+export { documentHasLocked, lockSelection, selectionLock, selectionTouchesLocked, unlockSelection, } from "./lockCommands";
+export type { DocumentNote } from "./noteQueries";
+export { documentNotes } from "./noteQueries";
+export type { ActiveParagraphAlign, ActiveParagraphStyle, } from "./paragraphCommands";
+export { activeParagraphAlign, activeParagraphStyle, canSetParagraphAlign, setParagraphAlign, setParagraphStyle, } from "./paragraphCommands";
+export { activeLineSpacing, canSetLineSpacing, SINGLE_LINE_SPACING, setLineSpacing, } from "./spacingCommands";
+/** Inserts the same editable DOCX tab as the built-in Tab binding. */
+export { insertTab } from "./tabCommands";

package/dist/editor/commands/index.js

@@ -0,0 +1,171 @@
+// src/editor/commands/index.ts
+import {
+  documentBodyWidthPx,
+  documentDefaults,
+  documentParagraphStyles
+} from "../documentStyles.js";
+import {
+  fittedExtent,
+  IMAGE_FILE_ACCEPT,
+  imageFilesIn,
+  insertImageFiles,
+  readImageFile
+} from "../imageFiles.js";
+import { canInsertImage, insertImage } from "../insertImage.js";
+import { canInsertTable, insertTable } from "../insertTable.js";
+import { insertLineBreak, insertPageBreak } from "./breakCommands.js";
+import { canRunCommand } from "./canRunCommand.js";
+import {
+  addComment,
+  addCommentReply,
+  canAddComment,
+  documentComments,
+  removeComment,
+  removeCommentReply,
+  selectComment,
+  setCommentResolved,
+  updateComment,
+  updateCommentReply
+} from "./commentCommands.js";
+import {
+  activeFontFamily,
+  activeFontSize,
+  activeTextBackground,
+  activeTextColor,
+  canFormatText,
+  documentFontNames,
+  isBoldActive,
+  isItalicActive,
+  isStrikeActive,
+  isUnderlineActive,
+  setFontFamily,
+  setFontSize,
+  setTextBackground,
+  setTextColor,
+  toggleBold,
+  toggleItalic,
+  toggleStrike,
+  toggleUnderline
+} from "./formattingCommands.js";
+import { redo, undo } from "./historyCommands.js";
+import {
+  canDecreaseIndent,
+  canIncreaseIndent,
+  decreaseIndent,
+  increaseIndent
+} from "./indentCommands.js";
+import {
+  activeLink,
+  activeLinkSpan,
+  canSetLink,
+  removeLink,
+  setLink
+} from "./linkCommands.js";
+import {
+  activeListKind,
+  decreaseListLevel,
+  increaseListLevel,
+  isInList,
+  toggleBulletList,
+  toggleNumberedList
+} from "./listCommands.js";
+import {
+  documentHasLocked,
+  lockSelection,
+  selectionLock,
+  selectionTouchesLocked,
+  unlockSelection
+} from "./lockCommands.js";
+import { documentNotes } from "./noteQueries.js";
+import {
+  activeParagraphAlign,
+  activeParagraphStyle,
+  canSetParagraphAlign,
+  setParagraphAlign,
+  setParagraphStyle
+} from "./paragraphCommands.js";
+import {
+  activeLineSpacing,
+  canSetLineSpacing,
+  SINGLE_LINE_SPACING,
+  setLineSpacing
+} from "./spacingCommands.js";
+import { insertTab } from "./tabCommands.js";
+export {
+  IMAGE_FILE_ACCEPT,
+  SINGLE_LINE_SPACING,
+  activeFontFamily,
+  activeFontSize,
+  activeLineSpacing,
+  activeLink,
+  activeLinkSpan,
+  activeListKind,
+  activeParagraphAlign,
+  activeParagraphStyle,
+  activeTextBackground,
+  activeTextColor,
+  addComment,
+  addCommentReply,
+  canAddComment,
+  canDecreaseIndent,
+  canFormatText,
+  canIncreaseIndent,
+  canInsertImage,
+  canInsertTable,
+  canRunCommand,
+  canSetLineSpacing,
+  canSetLink,
+  canSetParagraphAlign,
+  decreaseIndent,
+  decreaseListLevel,
+  documentBodyWidthPx,
+  documentComments,
+  documentDefaults,
+  documentFontNames,
+  documentHasLocked,
+  documentNotes,
+  documentParagraphStyles,
+  fittedExtent,
+  imageFilesIn,
+  increaseIndent,
+  increaseListLevel,
+  insertImage,
+  insertImageFiles,
+  insertLineBreak,
+  insertPageBreak,
+  insertTab,
+  insertTable,
+  isBoldActive,
+  isInList,
+  isItalicActive,
+  isStrikeActive,
+  isUnderlineActive,
+  lockSelection,
+  readImageFile,
+  redo,
+  removeComment,
+  removeCommentReply,
+  removeLink,
+  selectComment,
+  selectionLock,
+  selectionTouchesLocked,
+  setCommentResolved,
+  setFontFamily,
+  setFontSize,
+  setLineSpacing,
+  setLink,
+  setParagraphAlign,
+  setParagraphStyle,
+  setTextBackground,
+  setTextColor,
+  toggleBold,
+  toggleBulletList,
+  toggleItalic,
+  toggleNumberedList,
+  toggleStrike,
+  toggleUnderline,
+  undo,
+  unlockSelection,
+  updateComment,
+  updateCommentReply
+};

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

@@ -0,0 +1,56 @@
+/**
+ * Creates, removes, and inspects link spans. Existing links are edited as whole objects, while
+ * unlocked plain-text pieces can be linked independently; non-inclusive edges remain outside.
+ */
+import type { Command, EditorState } from "prosemirror-state";
+/**
+ * Puts a link at this address on the text the selection covers, and changes where every link it
+ * touches points, each of them whole.
+ *
+ * A piece already pointing there is left untouched, so the wrapper it came in with is not rewritten
+ * for nothing. A host typed with no scheme is written with one (`settled`).
+ */
+export declare function setLink(url: string): Command;
+/**
+ * Takes off every link the selection touches, each of them whole, however little of it the
+ * selection covers.
+ * The text and its formatting stay where they are; only the wrapper goes.
+ */
+export declare const removeLink: Command;
+/**
+ * Whether a link can go on where the selection stands, which is what a control offering one is
+ * drawn from.
+ *
+ * It is asked before an address has been typed, which is why it is a query of its own rather than
+ * `setLink(url)` with no dispatch.
+ */
+export declare function canSetLink(state: EditorState): boolean;
+/**
+ * The address at the selection. null where the selection is in no link, where the link it is in
+ * names a bookmark rather than an address, and where several addresses are mixed.
+ *
+ * The three answer as one, unlike `activeFontSize`, because the one thing drawn from this is the
+ * address field of the link panel and all three leave it empty. It reads the same pieces the
+ * commands edit, so the address shown is the address `setLink` would change.
+ */
+export declare function activeLink(state: EditorState): string | null;
+/** The stretch one link covers, and where it points */
+export interface ActiveLinkSpan {
+    from: number;
+    to: number;
+    /** The address. null for a link that names a bookmark rather than an address */
+    href: string | null;
+}
+/**
+ * The one link the selection sits inside, as the stretch it covers and the address it points at.
+ * null where the selection is in no link, where it runs past the edge of one, and where it covers
+ * several.
+ *
+ * This is what the card that says where a link points is drawn from (`ui/LinkCard`), so it answers
+ * about the link rather than about the address: a link naming a bookmark is here with a null `href`,
+ * where `activeLink` and it are one answer.
+ *
+ * The locks are the one thing it does not read. A link inside a settled part of the document still
+ * has an address worth reading, and what may be done to it is `canSetLink` and `removeLink`.
+ */
+export declare function activeLinkSpan(state: EditorState): ActiveLinkSpan | null;