@portone/docx-editor 0.2.1 → 0.4.0

package/dist/docx/comments/verifying.js

@@ -1,206 +0,0 @@
-// src/docx/comments/verifying.ts
-import {
-  attributeByLocalName,
-  elementChildren,
-  isElement,
-  parseXml,
-  serializeXml,
-  W_NS
-} from "../../ooxml/xml.js";
-import { W14_NS, W15_NS } from "./constants.js";
-import {
-  attributesWithin,
-  COMMENT_ATTRIBUTES,
-  lastBodyParagraph,
-  readStrictCommentBody,
-  recordedIdentity,
-  wellFormedCommentExtension,
-  wellFormedPerson
-} from "./grammar.js";
-import { commentReferencesIn } from "./model.js";
-import { commentAuthorId } from "./people.js";
-import { lastParagraphId } from "./reading.js";
-var COMMENT_IDENTITY = [
-  "id",
-  "author",
-  "date",
-  "initials"
-];
-function sameAttributes(entry, original, names) {
-  return names.every(
-    (name) => attributeByLocalName(entry, name) === attributeByLocalName(original, name)
-  );
-}
-function arrivedEntries(xml, localName, idAttr) {
-  const entries = /* @__PURE__ */ new Map();
-  if (xml === null) return entries;
-  for (const el of elementChildren(parseXml(xml).documentElement)) {
-    if (el.localName !== localName) continue;
-    const id = attributeByLocalName(el, idAttr);
-    if (id === null || entries.has(id)) continue;
-    entries.set(id, { el, xml: serializeXml(el) });
-  }
-  return entries;
-}
-function submittedEntries(xml, namespace, localName, idAttr) {
-  if (xml === null) return [];
-  const entries = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const el of elementChildren(parseXml(xml).documentElement)) {
-    if (el.namespaceURI !== namespace || el.localName !== localName)
-      return null;
-    const id = attributeByLocalName(el, idAttr);
-    if (id === null || seen.has(id)) return null;
-    seen.add(id);
-    entries.push({ id, el, xml: serializeXml(el) });
-  }
-  return entries;
-}
-function referencedCommentIds(doc) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const [id, comment] of commentReferencesIn(doc)) {
-    ids.add(id);
-    for (const reply of comment.replies) ids.add(reply.id);
-  }
-  return ids;
-}
-function wellFormedEntry(entry) {
-  if (entry.namespaceURI === W_NS && entry.localName === "comment") {
-    return attributesWithin(entry, COMMENT_ATTRIBUTES) && readStrictCommentBody(entry) !== null;
-  }
-  if (entry.namespaceURI === W15_NS && entry.localName === "commentEx") {
-    return wellFormedCommentExtension(entry);
-  }
-  if (entry.namespaceURI === W15_NS && entry.localName === "person") {
-    return wellFormedPerson(entry);
-  }
-  return false;
-}
-function withoutThreadKey(entry) {
-  const copy = entry.cloneNode(true);
-  if (!isElement(copy)) return serializeXml(entry);
-  const last = lastBodyParagraph(copy);
-  last?.removeAttributeNS(W14_NS, "paraId");
-  return serializeXml(copy);
-}
-function threadKeyAlone(entry, original) {
-  const before = lastParagraphId(original);
-  const after = lastParagraphId(entry);
-  const kept = before === null || after === before;
-  return kept && withoutThreadKey(entry) === withoutThreadKey(original);
-}
-function entryAllowed(entry, original, authorId, editableComments, people) {
-  if (entry.namespaceURI === W_NS && entry.localName === "comment") {
-    const author = attributeByLocalName(entry, "author");
-    const recorded = author === null ? null : commentAuthorId(people, author);
-    if (original === null) return recorded === authorId;
-    const paraId = lastParagraphId(original);
-    if (!sameAttributes(entry, original, COMMENT_IDENTITY) || paraId !== null && lastParagraphId(entry) !== paraId) {
-      return false;
-    }
-    return editableComments === "all" || recorded === null || recorded === authorId;
-  }
-  if (entry.namespaceURI === W15_NS && entry.localName === "commentEx") {
-    if (original === null) return true;
-    return sameAttributes(entry, original, ["paraId", "paraIdParent"]);
-  }
-  if (entry.namespaceURI === W15_NS && entry.localName === "person") {
-    return original === null && recordedIdentity(entry) === authorId;
-  }
-  return false;
-}
-function commentEntries(story) {
-  return Array.from(
-    arrivedEntries(story.session.comments.xml, "comment", "id").values(),
-    (entry) => entry.el
-  );
-}
-var COMMENT_PARTS = [
-  {
-    namespace: W_NS,
-    localName: "comment",
-    idAttr: "id",
-    xmlOf: (story) => story.session.comments.xml,
-    pathOf: (story) => story.session.comments.partPath,
-    referents: (story) => referencedCommentIds(story.doc)
-  },
-  {
-    namespace: W15_NS,
-    localName: "commentEx",
-    idAttr: "paraId",
-    xmlOf: (story) => story.session.comments.extendedXml,
-    pathOf: (story) => story.session.comments.extendedPartPath,
-    // Thread state stands for a comment, and it is keyed by the comment's own thread key
-    referents: (story) => new Set(
-      commentEntries(story).flatMap((el) => {
-        const key = lastParagraphId(el);
-        return key === null ? [] : [key];
-      })
-    )
-  },
-  {
-    namespace: W15_NS,
-    localName: "person",
-    idAttr: "author",
-    xmlOf: (story) => story.session.comments.people.xml,
-    pathOf: (story) => story.session.comments.people.partPath,
-    // An identity stands for a name somebody writes comments under
-    referents: (story) => new Set(
-      commentEntries(story).flatMap((el) => {
-        const author = attributeByLocalName(el, "author");
-        return author === null ? [] : [author];
-      })
-    )
-  }
-];
-function partKept(kind, before, after, authorId, editableComments) {
-  const arrived = arrivedEntries(
-    kind.xmlOf(before),
-    kind.localName,
-    kind.idAttr
-  );
-  const submitted = submittedEntries(
-    kind.xmlOf(after),
-    kind.namespace,
-    kind.localName,
-    kind.idAttr
-  );
-  if (submitted === null) return false;
-  const stoodBehindNow = kind.referents(after);
-  const people = after.session.comments.people;
-  for (const entry of submitted) {
-    const original = arrived.get(entry.id);
-    if (original && original.xml === entry.xml) continue;
-    if (!stoodBehindNow.has(entry.id)) return false;
-    if (original && threadKeyAlone(entry.el, original.el)) continue;
-    if (!wellFormedEntry(entry.el) || !entryAllowed(
-      entry.el,
-      original?.el ?? null,
-      authorId,
-      editableComments,
-      people
-    )) {
-      return false;
-    }
-  }
-  const held = new Set(submitted.map((entry) => entry.id));
-  const stoodBehindBefore = kind.referents(before);
-  return Array.from(arrived.keys()).every(
-    (id) => stoodBehindBefore.has(id) || held.has(id)
-  );
-}
-function commentPartsKept(before, after, authorId, editableComments) {
-  for (const kind of COMMENT_PARTS) {
-    const path = kind.pathOf(after) ?? kind.pathOf(before);
-    if (path === null) continue;
-    if (!partKept(kind, before, after, authorId, editableComments)) {
-      return { ok: false, reason: "part-changed", part: path };
-    }
-  }
-  return { ok: true };
-}
-export {
-  commentPartsKept,
-  entryAllowed,
-  wellFormedEntry
-};

package/dist/docx/formatting/effectiveParagraph.d.ts

@@ -1,15 +0,0 @@
-import { type ParagraphFormat } from "../../model/format";
-import { type Numbering } from "../../numbering/parseNumbering";
-import { type StyleFormat, type StyleTable } from "./styles";
-import { type ParagraphFormatLayer } from "./tabStops";
-export interface ParagraphFormattingContext {
-    styles: StyleTable;
-    defaultStyleId: string | null;
-    defaults: ParagraphFormatLayer;
-    numbering: Numbering;
-}
-export declare const NO_PARAGRAPH_FORMATTING: ParagraphFormattingContext;
-/** Resolves the effective OOXML paragraph-property hierarchy for display. */
-export declare function effectiveParagraphFormat(pPr: unknown, context: ParagraphFormattingContext): ParagraphFormat | null;
-/** Resolves the run properties supplied by the paragraph style. */
-export declare function effectiveParagraphStyle(pPr: unknown, context: ParagraphFormattingContext): StyleFormat | undefined;

package/dist/docx/formatting/effectiveParagraph.js

@@ -1,81 +0,0 @@
-// src/docx/formatting/effectiveParagraph.ts
-import { toParagraphFormat } from "../../model/format.js";
-import { mergeTabStops } from "../../model/tabStops.js";
-import {
-  EMPTY_NUMBERING,
-  levelIndentPt
-} from "../../numbering/parseNumbering.js";
-import { parsePropsXml } from "../propsXml.js";
-import { readParagraphFormat } from "./direct.js";
-import {
-  paragraphStyleFormat
-} from "./styles.js";
-import { layerParagraphValues } from "./tabStops.js";
-var NO_PARAGRAPH_FORMATTING = {
-  styles: /* @__PURE__ */ new Map(),
-  defaultStyleId: null,
-  defaults: {},
-  numbering: EMPTY_NUMBERING
-};
-function numberingRef(defaults, style, direct) {
-  let value = defaults.numbering;
-  if (style.numbering !== void 0) value = style.numbering;
-  if (direct.numbering !== void 0) value = direct.numbering;
-  return value;
-}
-function numberingLayer(ref, numbering) {
-  if (!ref) return {};
-  const level = numbering.lists.get(ref.numId)?.levels.get(ref.ilvl);
-  if (!level) return {};
-  const indent = levelIndentPt(level.indent);
-  const leadingIndentPt = indent.startPt;
-  const implicitHangingStop = leadingIndentPt !== null && indent.textIndentPt !== null && indent.textIndentPt < 0 ? [{ positionPt: leadingIndentPt, align: "start" }] : [];
-  return {
-    tabStops: [...implicitHangingStop, ...level.tabStops ?? []]
-  };
-}
-function withImplicitHangingStop(format) {
-  const leadingIndentPt = format?.indentStartPt ?? format?.indentLeftPt;
-  if (format?.textIndentPt === void 0 || format.textIndentPt >= 0 || leadingIndentPt === void 0) {
-    return format;
-  }
-  const implicit = {
-    positionPt: leadingIndentPt,
-    align: "start"
-  };
-  return {
-    ...format,
-    tabStops: mergeTabStops([implicit], format.tabStops ?? [])
-  };
-}
-function directLayer(pPr) {
-  if (typeof pPr !== "string") return {};
-  return readParagraphFormat(parsePropsXml(pPr)) ?? {};
-}
-function styleFor(pPr, context) {
-  return paragraphStyleFormat(pPr, context.styles, context.defaultStyleId);
-}
-function effectiveParagraphFormat(pPr, context) {
-  const direct = directLayer(pPr);
-  const style = styleFor(pPr, context)?.paragraph ?? {};
-  const level = numberingLayer(
-    numberingRef(context.defaults, style, direct),
-    context.numbering
-  );
-  const layered = [level, style, direct].reduce(
-    layerParagraphValues,
-    context.defaults
-  );
-  const format = toParagraphFormat(layered);
-  return withImplicitHangingStop(
-    format !== null && Object.keys(format).length === 0 ? null : format
-  );
-}
-function effectiveParagraphStyle(pPr, context) {
-  return styleFor(pPr, context);
-}
-export {
-  NO_PARAGRAPH_FORMATTING,
-  effectiveParagraphFormat,
-  effectiveParagraphStyle
-};

package/dist/docx/propsXml.d.ts

@@ -1,67 +0,0 @@
-/**
- * Handles the XML fragments that carry formatting, such as `<w:rPr>`, `<w:pPr>`, and `<w:tcPr>`.
- *
- * A fragment is never rebuilt: only the one child a job names is sliced out and swapped, so the
- * rest (borders, shading, margins) stays as the original text wrote it. OOXML lays down the order
- * of the children, so the spot to insert a child that was not there is found by that same order.
- */
-export interface PropsChild {
-    /** The name with its namespace prefix stripped off (e.g. `gridSpan`) */
-    name: string;
-    /** This child's original XML fragment exactly as it was */
-    xml: string;
-    /**
-     * Whatever stood between the child before this one and this one: line breaks a producer laid
-     * out, comments, anything that is not an element. Carried so that rewriting one child does not
-     * quietly drop the rest of what the fragment said. Absent rather than empty when nothing did.
-     */
-    before?: string;
-}
-export interface Props {
-    /** The opening tag name exactly as written (e.g. `w:tcPr`) */
-    tag: string;
-    attrs: string | null;
-    children: PropsChild[];
-    /** The same, for what stood between the last child and the closing tag */
-    tail?: string;
-}
-/** The order the children are laid out in under `w:rPr` (CT_RPr) */
-export declare const RUN_PR_ORDER: readonly string[];
-/** The order the children are laid out in under `w:pPr` (CT_PPr) */
-export declare const P_PR_ORDER: readonly string[];
-/** The order the children are laid out in under `w:tcPr` (CT_TcPr) */
-export declare const TC_PR_ORDER: readonly string[];
-/** The conventional order of children under `w:trPr` (CT_TrPr). */
-export declare const TR_PR_ORDER: readonly string[];
-/** The order the children are laid out in under `w:tblPr` (CT_TblPr) */
-export declare const TBL_PR_ORDER: readonly string[];
-/**
- * What stood inside a single element, and "" for one that stood empty or cannot be made out.
- *
- * The opening tag is read rather than scanned for, so a `>` inside an attribute value does not
- * pass for the end of it.
- */
-export declare function innerXml(xml: string): string;
-/**
- * Splits a formatting fragment into its opening tag and its list of children.
- * null if its shape cannot be made out (in which case leaving the original untouched is the safe move).
- */
-export declare function parseProps(xml: string): Props | null;
-/**
- * With nothing to say, the formatting fragment itself is not written. A fragment holding only
- * whitespace says nothing; one holding a comment does, so it is written back.
- */
-export declare function renderProps(props: Props): string;
-/**
- * Replaces a single child with new XML.
- * A null `xml` removes that child. A child that was not there goes into the spot the order calls for.
- */
-export declare function setPropsChild(props: Props, name: string, xml: string | null, order: readonly string[]): Props;
-export declare function propsChild(children: PropsChild[], name: string): PropsChild | undefined;
-/**
- * Reads a single formatting fragment into an element.
- *
- * A fragment carries no namespace declarations, so they are put back on as it is wrapped.
- * null if its shape cannot be made out, in which case the caller leaves the display values alone.
- */
-export declare function parsePropsXml(xml: string): Element | null;

package/dist/docx/uniqueControls.d.ts

@@ -1,14 +0,0 @@
-/**
- * Keeping one content control from going out twice under the same name.
- *
- * A control cannot cross a paragraph, so splitting a paragraph in the middle of one leaves that
- * same control standing in two, and dropping unmarked text into the middle of one breaks it in
- * two within the paragraph. Each piece then writes a `w:sdt` of its own (see `docx/sdt` for what
- * a copy must not carry along).
- *
- * A document nobody broke apart comes back node for node as it was, which is what keeps an
- * unedited block going out as its original XML.
- */
-import { type Node as PMNode } from "prosemirror-model";
-/** The document with every copy of a control opening under a name of its own */
-export declare function withUniqueControls(doc: PMNode): PMNode;

package/dist/docx/uniqueControls.js

@@ -1,62 +0,0 @@
-// src/docx/uniqueControls.ts
-import { Fragment } from "prosemirror-model";
-import { docxSchema } from "../schema/index.js";
-import { copiedControlPrefix, newControlId } from "./sdt.js";
-function sdtMarkOf(node) {
-  return node.marks.find((mark) => mark.type === docxSchema.marks.sdt) ?? null;
-}
-function controlName(mark) {
-  const key = mark.attrs.sdtKey;
-  const prefix = mark.attrs.sdtPrefix;
-  return `${typeof key === "number" ? key : 0} ${typeof prefix === "string" ? prefix : ""}`;
-}
-function copiedMark(mark) {
-  const prefix = mark.attrs.sdtPrefix;
-  if (typeof prefix !== "string") return mark;
-  return mark.type.create({
-    ...mark.attrs,
-    sdtPrefix: copiedControlPrefix(prefix, newControlId())
-  });
-}
-function claim(mark, written) {
-  const name = controlName(mark);
-  const copy = written.has(name) ? copiedMark(mark) : null;
-  written.add(name);
-  return { mark, copy };
-}
-function rewriteParagraph(paragraph, written) {
-  const inline = [];
-  let running = null;
-  let renamed = false;
-  paragraph.forEach((child) => {
-    const mark = sdtMarkOf(child);
-    if (!mark) {
-      running = null;
-      inline.push(child);
-      return;
-    }
-    const control = running?.mark.eq(mark) ? running : claim(mark, written);
-    running = control;
-    if (!control.copy) {
-      inline.push(child);
-      return;
-    }
-    renamed = true;
-    inline.push(
-      child.mark(control.copy.addToSet(mark.removeFromSet(child.marks)))
-    );
-  });
-  return renamed ? paragraph.copy(Fragment.fromArray(inline)) : paragraph;
-}
-function rewriteBlock(node, written) {
-  if (node.type.name === "paragraph") return rewriteParagraph(node, written);
-  if (node.childCount === 0) return node;
-  const children = node.children.map((child) => rewriteBlock(child, written));
-  return children.every((child, index) => child === node.child(index)) ? node : node.copy(Fragment.fromArray(children));
-}
-function withUniqueControls(doc) {
-  return rewriteBlock(doc, /* @__PURE__ */ new Set());
-}
-export {
-  withUniqueControls
-};

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

@@ -1,5 +0,0 @@
-/** Keeps identifiers from the opened Comments parts reserved for the lifetime of the editor state. */
-import { type EditorState, Plugin } from "prosemirror-state";
-export declare function commentReservations(ids: Iterable<string>, paraIds: Iterable<string>): Plugin;
-export declare function reservedCommentIds(state: EditorState): ReadonlySet<string>;
-export declare function reservedCommentParaIds(state: EditorState): ReadonlySet<string>;

package/dist/editor/plugins/commentReservations.js

@@ -1,26 +0,0 @@
-// src/editor/plugins/commentReservations.ts
-import { Plugin, PluginKey } from "prosemirror-state";
-var commentReservationsKey = new PluginKey(
-  "docxCommentReservations"
-);
-function commentReservations(ids, paraIds) {
-  const reserved = { ids: new Set(ids), paraIds: new Set(paraIds) };
-  return new Plugin({
-    key: commentReservationsKey,
-    state: {
-      init: () => reserved,
-      apply: (_transaction, value) => value
-    }
-  });
-}
-function reservedCommentIds(state) {
-  return commentReservationsKey.getState(state)?.ids ?? /* @__PURE__ */ new Set();
-}
-function reservedCommentParaIds(state) {
-  return commentReservationsKey.getState(state)?.paraIds ?? /* @__PURE__ */ new Set();
-}
-export {
-  commentReservations,
-  reservedCommentIds,
-  reservedCommentParaIds
-};

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

@@ -1,15 +0,0 @@
-/**
- * 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

@@ -1,65 +0,0 @@
-// 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/page/tableMeasurements.d.ts

@@ -1,18 +0,0 @@
-/** Measures safe row boundaries without treating pagination decorations as document content. */
-import type { Node as PMNode } from "prosemirror-model";
-import type { EditorView } from "prosemirror-view";
-import type { BreakCandidate } from "./blockKinds";
-export interface TableMeasure {
-    /** Every row that may start the continued part of the table */
-    candidates: readonly BreakCandidate[];
-    /** The smallest useful first piece: headers followed by one body row group */
-    minFirstPiece: number;
-    /** Height already added by the previous pagination pass */
-    appliedHeight: number;
-    /** Document positions of the contiguous header rows at the start of the table */
-    headerRows: readonly number[];
-    /** Changes when any projected header content or formatting changes */
-    headerSignature: string;
-    columns: number;
-}
-export declare function measureTable(view: EditorView, tableNode: PMNode, tablePos: number, tableDom: HTMLElement, scale?: number): TableMeasure | null;