wordinweb 0.1.21 → 0.1.22

package/dist/index.d.ts

@@ -1281,6 +1281,10 @@ declare class DocxDocument {
         before: Paragraph;
         after: Paragraph;
     } | null;
+    /** Insert a new paragraph immediately before a retained body paragraph
+     * without rebuilding the complete document model. Used by Enter at the
+     * exact paragraph start, where the existing paragraph itself is unchanged. */
+    insertDirectBodyParagraphBefore(referenceSource: XmlElement, insertedSource: XmlElement): Paragraph | null;
     /** Reparse a body paragraph plus several new siblings created by
      * click-and-type without rebuilding the complete document model. */
     reparseDirectBodyParagraphSplits(beforeSource: XmlElement, afterSources: XmlElement[]): Paragraph[] | null;

package/dist/index.js

@@ -6364,6 +6364,45 @@ var DocxDocument = class _DocxDocument {
     const parsed = this.reparseDirectBodyParagraphSplits(beforeSource, [afterSource]);
     return parsed ? { before: parsed[0], after: parsed[1] } : null;
   }
+  /** Insert a new paragraph immediately before a retained body paragraph
+   * without rebuilding the complete document model. Used by Enter at the
+   * exact paragraph start, where the existing paragraph itself is unchanged. */
+  insertDirectBodyParagraphBefore(referenceSource, insertedSource) {
+    const parent = this.findParentOf(referenceSource);
+    if (!parent) return null;
+    const referenceIndex = parent.children.indexOf(referenceSource);
+    if (referenceIndex < 1 || parent.children[referenceIndex - 1] !== insertedSource) return null;
+    if (localName(referenceSource.name) !== "p" || localName(insertedSource.name) !== "p") return null;
+    const findBlockList = (blocks) => {
+      const index = blocks.findIndex((block) => block.type === "paragraph" && block.src === referenceSource);
+      if (index >= 0) return { blocks, index };
+      for (const block of blocks) {
+        if (block.type !== "table") continue;
+        for (const row of block.rows) {
+          for (const cell of row.cells) {
+            const found = findBlockList(cell.blocks);
+            if (found) return found;
+          }
+        }
+      }
+      return null;
+    };
+    let location = null;
+    for (const section of this.sections) {
+      location = findBlockList(section.blocks);
+      if (location) break;
+    }
+    if (!location || location.blocks.some((block) => block.src === insertedSource)) return null;
+    const paragraph = parseParagraph(insertedSource, {
+      ...this.ctxBase,
+      rels: this.documentRels,
+      readPart: (part) => this.readXmlOptional(part),
+      independentTextboxStories: true
+    });
+    if (paragraph.revisionHidden || paragraph.sectionBreak) return null;
+    location.blocks.splice(location.index, 0, paragraph);
+    return paragraph;
+  }
   /** Reparse a body paragraph plus several new siblings created by
    * click-and-type without rebuilding the complete document model. */
   reparseDirectBodyParagraphSplits(beforeSource, afterSources) {
@@ -6687,6 +6726,8 @@ var DocxDocument = class _DocxDocument {
   }
   markNumberingChanged() {
     this.numberingDirty = true;
+    this.numbering = parseNumbering(this.numberingRoot ?? void 0, this.ctxBase);
+    this._layoutGlobalSig = null;
   }
   /**
    * Retained footnotes tree. With create=true, a missing footnotes.xml part
@@ -11719,6 +11760,7 @@ var Engine = class {
     /** Per top-level block content signature, recorded during a captured layout
      * so the next incremental layout can find the first changed block. */
     this.incrSigs = null;
+    this.incrLastNumberingUse = null;
     /** Reuse points captured at clean page tops: the block index that starts the
      * page and a snapshot of engine state to resume from. */
     this.incrPoints = null;
@@ -11871,7 +11913,9 @@ var Engine = class {
   }
   startRun() {
     if (this.incrEligible()) {
-      this.incrSigs = this.doc.sections[0].blocks.map((b) => this.blockSig(b));
+      const blocks = this.doc.sections[0].blocks;
+      this.incrSigs = blocks.map((b) => this.blockSig(b));
+      this.incrLastNumberingUse = this.lastNumberingUse(blocks);
       this.incrPoints = [];
     }
     this.assignNoteNumbers();
@@ -11945,6 +11989,7 @@ var Engine = class {
       result._incr = {
         sigs: this.incrSigs,
         points: this.incrPoints,
+        lastNumberingUse: this.incrLastNumberingUse,
         pages: this.pages,
         bookmarks: this.bookmarkPages,
         bookmarkPageIndices: this.bookmarkPageIndices,
@@ -12055,6 +12100,43 @@ var Engine = class {
   blockSig(block) {
     return block.src ? hashXml(block.src) : "\0nosrc";
   }
+  blockNumberingKeys(block, keys) {
+    if (block.type === "paragraph") {
+      const numbering = this.doc.effectiveParaProps(block).numbering;
+      const instance = numbering ? this.doc.numberingInstance(numbering.numId) : void 0;
+      if (instance) keys.add(instance.abstractNumId);
+      return;
+    }
+    for (const row of block.rows) {
+      for (const cell of row.cells) {
+        for (const nested of cell.blocks) this.blockNumberingKeys(nested, keys);
+      }
+    }
+  }
+  lastNumberingUse(blocks) {
+    const lastUse = /* @__PURE__ */ new Map();
+    for (let index = 0; index < blocks.length; index++) {
+      const keys = /* @__PURE__ */ new Set();
+      this.blockNumberingKeys(blocks[index], keys);
+      for (const key of keys) lastUse.set(key, index);
+    }
+    return lastUse;
+  }
+  numberingCountersAffectLabels(abstractNumId) {
+    const abstract = this.doc.numbering.abstract.get(abstractNumId);
+    if (!abstract) return true;
+    for (const level of abstract.levels.values()) {
+      if (level.format !== "bullet" && level.format !== "none") return true;
+    }
+    for (const instance of this.doc.numbering.instances.values()) {
+      if (instance.abstractNumId !== abstractNumId) continue;
+      for (const override of instance.overrides.values()) {
+        const format = override.level?.format;
+        if (format && format !== "bullet" && format !== "none") return true;
+      }
+    }
+    return false;
+  }
   /** PAGEREF rewrite: replace stale cached field text with the bookmark's real
    * page. The right edge stays fixed so TOC right-tab page numbers keep align. */
   rewritePageRefs(pages) {
@@ -12122,7 +12204,7 @@ var Engine = class {
     if (this.incrPrevPoints && blockIdx > this.incrFirstDirty) {
       const pp = this.incrPrevPoints.get(blockIdx);
       const pageShift = pp ? globalPageIdx - pp.pageCount : 0;
-      if (pp && this.statesMatch(pp.state, pageShift)) {
+      if (pp && this.statesMatch(pp.state, pageShift, blockIdx)) {
         __incrStats.convergedBlock = blockIdx;
         __incrStats.convergedPage = globalPageIdx;
         __incrStats.pageShift = pageShift;
@@ -12152,17 +12234,27 @@ var Engine = class {
   /** True when the current engine state at a clean page top exactly matches a
    * prev-layout capture point — i.e. the relaid tail has re-converged and the
    * rest of the layout is guaranteed identical. */
-  statesMatch(s, pageShift = 0) {
+  statesMatch(s, pageShift = 0, blockIdx = 0) {
     const p = this.cur;
     if (this.col !== s.col || this.y !== s.y || this.sectionFirstPagePhys !== s.sectionFirstPagePhys || this.lastParaSpacingAfter !== s.lastParaSpacingAfter || this.lastParaAfterPad !== s.lastParaAfterPad || this.lastParaWasEmpty !== s.lastParaWasEmpty || this.trailingSectionBreakMarkGap !== s.trailingSectionBreakMarkGap || this.suppressNextSpaceBefore !== s.suppressNextSpaceBefore || this.docGridDropBefore !== s.docGridDropBefore || this.gridResyncPending !== s.gridResyncPending || this.verticalGridFlow !== s.verticalGridFlow || this.bannerSlotUsed !== s.bannerSlotUsed || p.physIndex !== s.page.physIndex + pageShift || p.displayNumber !== s.page.displayNumber + pageShift || p.bodyTop !== s.page.bodyTop || p.bodyBottom !== s.page.bodyBottom) {
       return false;
     }
-    if (this.seenNumIds.size !== s.seenNumIds.length) return false;
-    for (const id of s.seenNumIds) if (!this.seenNumIds.has(id)) return false;
-    if (this.counters.size !== s.counters.length) return false;
-    for (const [k, w] of s.counters) {
-      const v = this.counters.get(k);
-      if (!v || w.length !== v.length) return false;
+    const numberingActive = (abstractNumId) => this.numberingCountersAffectLabels(abstractNumId) && (!this.incrLastNumberingUse || (this.incrLastNumberingUse.get(abstractNumId) ?? -1) >= blockIdx);
+    const numIdActive = (numId) => {
+      const instance = this.doc.numberingInstance(numId);
+      return !instance || numberingActive(instance.abstractNumId);
+    };
+    const oldSeen = s.seenNumIds.filter(numIdActive);
+    const newSeen = [...this.seenNumIds].filter(numIdActive);
+    if (oldSeen.length !== newSeen.length) return false;
+    for (const id of oldSeen) if (!this.seenNumIds.has(id)) return false;
+    const oldCounters = new Map(s.counters);
+    const counterKeys = /* @__PURE__ */ new Set([...oldCounters.keys(), ...this.counters.keys()]);
+    for (const key of counterKeys) {
+      if (!numberingActive(key)) continue;
+      const w = oldCounters.get(key);
+      const v = this.counters.get(key);
+      if (!v || !w || w.length !== v.length) return false;
       for (let i = 0; i < v.length; i++) if (v[i] !== w[i]) return false;
     }
     return true;
@@ -12366,6 +12458,20 @@ var Engine = class {
       __incrStats.blocksHashed = blocks.length;
       __incrStats.firstDirty = firstDirty;
     }
+    this.incrLastNumberingUse = new Map(
+      [...inc.lastNumberingUse].map(([key, index]) => [
+        key,
+        index > this.incrBlockShiftAfter ? index + this.incrBlockDelta : index
+      ])
+    );
+    const changedEnd = Math.min(blocks.length - 1, firstDirty + Math.max(0, this.incrBlockDelta));
+    for (let index = firstDirty; index <= changedEnd; index++) {
+      const keys = /* @__PURE__ */ new Set();
+      this.blockNumberingKeys(blocks[index], keys);
+      for (const key of keys) {
+        this.incrLastNumberingUse.set(key, Math.max(index, this.incrLastNumberingUse.get(key) ?? -1));
+      }
+    }
     let rp;
     for (const pt of inc.points) {
       if (pt.blockIdx <= firstDirty) rp = pt;
@@ -12504,6 +12610,7 @@ var Engine = class {
       _incr: {
         sigs: newSigs,
         points,
+        lastNumberingUse: this.incrLastNumberingUse,
         pages: outInternal,
         bookmarks: mergedBookmarks,
         bookmarkPageIndices: mergedBookmarkPageIndices,
@@ -20957,13 +21064,7 @@ function listTypeAt(doc, target) {
   const lvl = doc.numberingLevel(id, parseInt(attr(ilvl ?? { name: "", attrs: {}, children: [], text: "" }, "val") ?? "0", 10) || 0);
   return lvl?.format === "bullet" ? "bullet" : "number";
 }
-function ensureListNum(doc, kind) {
-  for (const [numId2, inst] of doc.numbering.instances) {
-    const lvl = doc.numberingLevel(numId2, 0);
-    if (!lvl) continue;
-    if (kind === "bullet" ? lvl.format === "bullet" : lvl.format === "decimal") return numId2;
-    void inst;
-  }
+function createListNum(doc, kind) {
   const root = doc.numberingTree(true);
   if (!root) return null;
   const w = prefixOf6(root);
@@ -21037,7 +21138,7 @@ function setListType(doc, targets, kind) {
     if (p) paragraphs.add(p);
   }
   if (paragraphs.size === 0) return false;
-  const numId = kind === null ? null : ensureListNum(doc, kind);
+  const numId = kind === null ? null : createListNum(doc, kind);
   if (kind !== null && numId === null) return false;
   let touched = false;
   for (const pEl of paragraphs) {
@@ -21067,7 +21168,17 @@ function setListType(doc, targets, kind) {
     }
     touched = true;
   }
-  if (touched) doc.refresh();
+  if (touched) {
+    let reparsed = true;
+    for (const paragraph of paragraphs) {
+      if (!doc.reparseBodyParagraph(paragraph)) {
+        reparsed = false;
+        break;
+      }
+      invalidateParagraphSignature(paragraph);
+    }
+    if (!reparsed) doc.refresh();
+  }
   return touched;
 }
 
@@ -28554,11 +28665,39 @@ var _DocxEditor = class _DocxEditor {
     if (this.caret) {
       const paragraph = paragraphOf(this.host.doc, this.caret.t);
       if (paragraph && textElements(paragraph).every((text) => text.text.length === 0) && clearListParagraphFormatting(this.host.doc, paragraph)) {
-        this.commit();
+        const reparsed2 = this.host.doc.reparseBodyParagraph(paragraph);
+        if (reparsed2) {
+          for (const child4 of reparsed2.children) {
+            const runs = child4.type === "run" ? [child4] : child4.runs;
+            const run = runs.find(
+              (candidate) => candidate.content.some((content) => content.kind === "text" && content.srcT === this.caret.t)
+            );
+            if (run) {
+              this.caret.run = run;
+              break;
+            }
+          }
+          invalidateParagraphSignature(paragraph);
+        }
+        this.commit(false, "local", !!reparsed2);
         this.focusText();
         return;
       }
     }
+    const insertedBefore = this.insertBlankParagraphBeforeAtStart();
+    if (insertedBefore) {
+      const reparsed2 = this.host.doc.insertDirectBodyParagraphBefore(insertedBefore.reference, insertedBefore.blank);
+      if (reparsed2) {
+        const run = reparsed2.children.flatMap((child4) => child4.type === "run" ? [child4] : child4.runs).find(
+          (candidate) => candidate.content.some((content) => content.kind === "text" && content.srcT === insertedBefore.text)
+        );
+        if (run) this.caret = { t: insertedBefore.text, run, offset: 0 };
+        invalidateParagraphSignature(insertedBefore.blank);
+      }
+      this.commit(false, "local", !!reparsed2);
+      this.focusText();
+      return;
+    }
     const split = this.splitParagraphCore();
     const reparsed = split ? this.host.doc.reparseDirectBodyParagraphSplit(split.before, split.after) : null;
     if (reparsed && split && this.caret) {
@@ -28578,6 +28717,49 @@ var _DocxEditor = class _DocxEditor {
     this.commit(false, "local", !!reparsed);
     this.focusText();
   }
+  /** Enter at the exact paragraph start only needs a blank paragraph before
+   * the existing content. Retaining the original paragraph keeps its parsed
+   * model, fields, and bookmarks valid for incremental pagination. */
+  insertBlankParagraphBeforeAtStart() {
+    const caret = this.caret;
+    if (!caret || caret.offset !== 0) return null;
+    const rEl = this.host.doc.findParentOf(caret.t);
+    if (!rEl || localName(rEl.name) !== "r") return null;
+    let pEl = this.host.doc.findParentOf(rEl);
+    while (pEl && localName(pEl.name) !== "p") pEl = this.host.doc.findParentOf(pEl);
+    if (!pEl) return null;
+    const texts = textElements(pEl);
+    const textIndex = texts.indexOf(caret.t);
+    if (textIndex < 0 || texts.slice(0, textIndex).some((text) => text.text.length > 0)) return null;
+    const parent = this.host.doc.findParentOf(pEl);
+    if (!parent) return null;
+    const prefix = pEl.name.includes(":") ? pEl.name.slice(0, pEl.name.indexOf(":") + 1) : "";
+    const pPr = pEl.children.find((child4) => localName(child4.name) === "pPr");
+    const blankPPr = pPr ? cloneXml(pPr) : void 0;
+    if (blankPPr) blankPPr.children = blankPPr.children.filter((child4) => localName(child4.name) !== "sectPr");
+    const rPr = rEl.children.find((child4) => localName(child4.name) === "rPr");
+    const blankText = {
+      name: caret.t.name,
+      attrs: { ...caret.t.attrs, "xml:space": "preserve" },
+      text: "",
+      children: []
+    };
+    const blankRun = {
+      name: rEl.name,
+      attrs: { ...rEl.attrs },
+      text: "",
+      children: [...rPr ? [cloneXml(rPr)] : [], blankText]
+    };
+    const blank = {
+      name: prefix + "p",
+      attrs: {},
+      text: "",
+      children: [...blankPPr ? [blankPPr] : [], blankRun]
+    };
+    parent.children.splice(parent.children.indexOf(pEl), 0, blank);
+    if (this.suggesting) markParagraphGlyph(blank, "ins", this.revMeta());
+    return { blank, reference: pEl, text: blankText };
+  }
   /** Split the paragraph at the caret without history or commit — shared by
    * Enter and multi-line paste. */
   splitParagraphCore() {
@@ -35374,9 +35556,10 @@ function DocxView({
             const targets = segs.length > 0 ? segs.map((sg) => sg.t).filter((t) => !!t) : caret ? [caret.t] : [];
             if (targets.length === 0) return;
             const current = listTypeAt(doc, targets[0]);
+            const dirtyBlock = targets.length === 1 ? topLevelBlockOf(doc, targets[0]) ?? void 0 : void 0;
             history.checkpoint();
             if (setListType(doc, targets, current === kind ? null : kind)) {
-              pages = rerender(doc);
+              pages = rerender(doc, dirtyBlock);
               document.dispatchEvent(new CustomEvent("dxw-selection"));
             }
           },