superdoc 2.7.0-next.1 → 2.7.0-next.10

package/dist/superdoc.es.js

@@ -3,7 +3,7 @@ import { t as blank_default } from "./chunks/blank-docx-DzQccOlW.es.js";
 import { t as import_eventemitter3 } from "./chunks/eventemitter3-CMOjDs74.es.js";
 import { t as v4 } from "./chunks/uuid-H0Xcmmhy.es.js";
 import { a as init_dist$1, i as global, n as init_dist$2, o as Buffer, r as process$1, s as init_dist, t as require_jszip_min } from "./chunks/jszip-VxCFV9YS.es.js";
-import { a as DOM_CLASS_NAMES, i as getV2TrackedChangeMutationImpact, t as createSuperDocUI } from "./chunks/create-super-doc-ui-DCjm-_Xo.es.js";
+import { a as DOM_CLASS_NAMES, i as getV2TrackedChangeMutationImpact, t as createSuperDocUI } from "./chunks/create-super-doc-ui-BTNVc3UD.es.js";
 import { t as _plugin_vue_export_helper_default } from "./chunks/_plugin-vue_export-helper-BOaGB7Aw.es.js";
 import { t as PDF_TO_CSS_UNITS } from "./chunks/constants-B6VBlmKp.es.js";
 import * as Vue from "vue";
@@ -18163,10 +18163,9 @@ function scrollToElement(targetElement, options = {
 */
 /**
 * Result of `doc.bookmarks.get()` as read here (Document API `BookmarkInfo`).
-* `range.from.blockId` is the bookmark's `w14:paraId`, used to find/reveal
-* the target paragraph. `address.story` is populated for non-body
-* bookmarks (omitted for body) — used to scope this fix to body targets,
-* since `revealBodyTarget`/`pageIndexForBodyTarget` are body-only.
+* `range.from.blockId` identifies the model paragraph sent to the viewport.
+* `address.story` is populated for non-body bookmarks (omitted for body),
+* which keeps anchor navigation scoped to body targets.
 * @typedef {Object} BookmarkGetResult
 * @property {{ story?: { kind?: string, storyType?: string } }} [address]
 * @property {{ from?: { blockId?: string } }} [range]
@@ -18185,15 +18184,6 @@ function scrollToElement(targetElement, options = {
 * @property {{ get?: (input: { target: { kind: 'entity', entityType: 'bookmark', name: string } }) => BookmarkGetResult | Promise<BookmarkGetResult | null | undefined> | null | undefined } | null} [bookmarks]
 */
 /**
-* Result of `activeEditor.pageMetrics.revealBodyTarget()` as read here
-* (`V2EditorHostRevealBodyTargetResult`). Only available in editing/
-* suggesting mode — the host rejects with `editing-not-mounted` in
-* viewing mode.
-* @typedef {Object} RevealBodyTargetResult
-* @property {'revealed' | 'rejected'} [status]
-* @property {string} [reason]
-*/
-/**
 * The `v2-link-click` payload the shell relays from the v2 host's
 * `onLinkClick` callback.
 * @typedef {Object} LinkClickPayload
@@ -18535,20 +18525,8 @@ function useLinkPopover({ getSurfaceManager, getActiveEditor, getUi, getResolver
 		handle.result?.then?.((outcome) => clearCurrentPopover(handle, outcome), () => clearCurrentPopover(handle));
 	}
 	/**
-	* Look up a real `<a name>` anchor, or a bookmark-marker span, in the
-	* currently mounted DOM. The marker span
-	* (`data-bookmark-marker`/`data-bookmark-name`) is a best-effort fast
-	* path only: layout-engine measuring drops those zero-width marker runs
-	* from paint whenever the wrapping paragraph has other visible content
-	* (the standard shape for a TOC bookmark wrapping heading text,
-	* `<w:bookmarkStart .../><w:r>Heading</w:r><w:bookmarkEnd/>`) — but it
-	* DOES survive for a standalone/empty bookmark paragraph (a supported v2
-	* shape, see `v2-layout-adapter/src/empty-paragraph.test.ts` and
-	* `isSyntheticStandaloneBookmarkParagraph` in
-	* `v2-host/src/compose-exact-complete-render.ts`), where it lets a
-	* mounted bookmark scroll immediately without a Document API round trip.
-	* `findPaintedParagraphByParaId` remains the reliable fallback for the
-	* common (marker-not-painted) case.
+	* Find a mounted named anchor for runtimes that do not expose the bookmark
+	* model. Model-backed runtimes never use DOM identity for navigation.
 	* @param {HTMLElement | null} container
 	* @param {string} escapedAnchorName
 	* @returns {HTMLElement | null}
@@ -18557,44 +18535,6 @@ function useLinkPopover({ getSurfaceManager, getActiveEditor, getUi, getResolver
 		return container?.querySelector?.(`a[name='${escapedAnchorName}'], [data-bookmark-marker='start'][data-bookmark-name='${escapedAnchorName}']`) ?? null;
 	}
 	/**
-	* Find the painted paragraph element for a `w14:paraId`, mirroring the
-	* attribute chain `paintedParaIdElement` uses in v2-host
-	* (`create-v2-editor-host.ts`) to confirm a paragraph is painted.
-	* @param {HTMLElement | null} container
-	* @param {string} paraId
-	* @returns {HTMLElement | null}
-	*/
-	function findPaintedParagraphByParaId(container, paraId) {
-		if (!container) return null;
-		const escaped = cssEscape(paraId);
-		return container.querySelector(`[data-source-node-id='${escaped}']`) ?? container.querySelector(`[data-layout-paraid='${escaped}']`) ?? container.querySelector(`[data-block-id$='/${escaped}']`) ?? container.querySelector(`[data-layout-block-ref$='/${escaped}']`) ?? null;
-	}
-	/**
-	* Poll for an element across a bounded number of animation frames. Used
-	* after `scrollToPage()` in review/viewing mode, where — unlike
-	* `revealBodyTarget` in editing mode — there is no promise that resolves
-	* once the deep-jumped page's geometry reconciles and paints.
-	* @param {() => HTMLElement | null} lookup
-	* @param {number} maxTicks
-	* @returns {Promise<HTMLElement | null>}
-	*/
-	function pollForElement(lookup, maxTicks = 30) {
-		return new Promise((resolve) => {
-			const raf = typeof window !== "undefined" ? window.requestAnimationFrame : null;
-			let ticks = 0;
-			const tick = () => {
-				const found = lookup();
-				if (found || ticks >= maxTicks || typeof raf !== "function") {
-					resolve(found ?? null);
-					return;
-				}
-				ticks += 1;
-				raf(tick);
-			};
-			tick();
-		});
-	}
-	/**
 	* Move the editable caret to the start of a resolved target paragraph after
 	* navigating to it. Mirrors V1's `goToAnchor`, whose final step places the
 	* caret at the bookmark position: without it a V2 TOC click only scrolls, so
@@ -18634,87 +18574,59 @@ function useLinkPopover({ getSurfaceManager, getActiveEditor, getUi, getResolver
 		} catch {}
 	}
 	/**
-	* Navigate to an internal `#anchor` link (TOC entries, bookmark links).
-	* Tries a real `<a name>` anchor in the currently mounted DOM first, then
-	* resolves the bookmark's target paragraph through the Document API and
-	* scrolls to that paragraph by its `paraId` — not to a bookmark-marker
-	* element, which layout-engine measuring may have excluded from paint.
-	*
-	* In editing/suggesting mode (`placeCaret`), also moves the caret to the
-	* start of the resolved target paragraph, matching V1's `goToAnchor`.
-	*
-	* If the paragraph isn't mounted (the v2 layout engine only mounts a
-	* sliding window of pages), asks the host to reveal it:
-	*  - In editing/suggesting mode, `pageMetrics.revealBodyTarget` deep-jumps
-	*    into unmounted pages and resolves once the target is painted. Any
-	*    rejection here OTHER than `editing-not-mounted` is a real failure of
-	*    this strong, paint-confirmed path and is left as a no-op rather than
-	*    silently degrading to the weaker path below.
-	*  - In viewing mode the host is mounted in "review" mode, where
-	*    `revealBodyTarget` always rejects with reason `editing-not-mounted`
-	*    (or is simply unpublished); only then falls back to
-	*    `pageIndexForBodyTarget` + `scrollToPage` (neither gated on mount
-	*    mode) and polls for paint, since neither returns a paint-complete
-	*    promise.
-	*
-	* Out of scope: bookmarks outside the body story (headers/footers/
-	* footnotes) — `revealBodyTarget`/`pageIndexForBodyTarget` are body-only.
+	* Navigate to a body bookmark through its model address. A mounted-anchor
+	* fallback is reserved for runtimes without a callable bookmark model.
 	* @param {string | null | undefined} anchorUrl
 	* @param {{ placeCaret?: boolean }} [options]
 	*/
 	async function navigateToAnchor(anchorUrl, { placeCaret = false } = {}) {
 		if (typeof anchorUrl !== "string" || !anchorUrl.startsWith("#")) return;
 		const anchorName = anchorUrl.slice(1);
-		const escapedAnchorName = cssEscape(anchorName);
-		const mountedAnchor = findMountedAnchor(getUi()?.viewport?.getHost?.() ?? null, escapedAnchorName);
-		if (mountedAnchor) {
-			scrollToElement(mountedAnchor);
-			return;
-		}
 		/** @type {LinkPopoverDocumentApi | null | undefined} */
 		const doc = getActiveEditor()?.doc;
+		const bookmarkGet = doc?.bookmarks?.get;
+		if (typeof bookmarkGet !== "function") {
+			const mountedAnchor = findMountedAnchor(getUi()?.viewport?.getHost?.() ?? null, cssEscape(anchorName));
+			if (mountedAnchor) scrollToElement(mountedAnchor, {
+				block: "start",
+				behavior: "instant"
+			});
+			return;
+		}
 		/** @type {BookmarkGetResult | null} */
 		let bookmark = null;
 		try {
-			bookmark = await Promise.resolve(doc?.bookmarks?.get?.({ target: {
+			bookmark = await Promise.resolve(bookmarkGet.call(doc.bookmarks, { target: {
 				kind: "entity",
 				entityType: "bookmark",
 				name: anchorName
 			} }));
 			bookmark ??= null;
 		} catch {
-			bookmark = null;
+			return;
 		}
 		const story = bookmark?.address?.story;
 		if (story && story.storyType !== "body") return;
 		const blockId = bookmark?.range?.from?.blockId;
 		if (typeof blockId !== "string") return;
 		if (placeCaret) await placeCaretAtHeadingStart(blockId);
-		const mountedParagraph = findPaintedParagraphByParaId(getUi()?.viewport?.getHost?.() ?? null, blockId);
-		if (mountedParagraph) {
-			scrollToElement(mountedParagraph);
-			return;
-		}
-		const pageMetrics = getActiveEditor()?.pageMetrics;
-		const revealBodyTarget = pageMetrics?.revealBodyTarget;
-		let revealResult;
+		const viewport = getUi()?.viewport;
+		const scrollIntoView = viewport?.scrollIntoView;
+		if (typeof scrollIntoView !== "function") return;
 		try {
-			revealResult = await revealBodyTarget?.({ paraId: blockId });
-		} catch {
-			revealResult = void 0;
-		}
-		if (revealResult?.status === "revealed") {
-			const revealedParagraph = findPaintedParagraphByParaId(getUi()?.viewport?.getHost?.() ?? null, blockId);
-			if (revealedParagraph) scrollToElement(revealedParagraph);
-			return;
-		}
-		if (revealBodyTarget && revealResult?.reason !== "editing-not-mounted") return;
-		const pageIndexForBodyTarget = pageMetrics?.pageIndexForBodyTarget;
-		const scrollToPage = pageMetrics?.scrollToPage;
-		const pageIndex = pageIndexForBodyTarget?.({ paraId: blockId });
-		if (typeof pageIndex !== "number" || !scrollToPage?.(pageIndex)) return;
-		const revealedByScroll = await pollForElement(() => findPaintedParagraphByParaId(getUi()?.viewport?.getHost?.() ?? null, blockId));
-		if (revealedByScroll) scrollToElement(revealedByScroll);
+			await Promise.resolve(scrollIntoView.call(viewport, {
+				target: {
+					kind: "text",
+					blockId,
+					range: {
+						start: 0,
+						end: 0
+					}
+				},
+				block: "start",
+				behavior: "instant"
+			}));
+		} catch {}
 	}
 	/**
 	* @param {LinkPopoverContext} ctx
@@ -43505,10 +43417,6 @@ var SuperDoc = class extends import_eventemitter3.default {
 		this.config.layoutEngineOptions = this.config.layoutEngineOptions || {};
 		const isWebLayout = this.config.viewOptions?.layout === "web";
 		const isSemanticFlow = this.config.layoutEngineOptions?.flowMode === "semantic";
-		if (isWebLayout && this.config.useLayoutEngine && !isSemanticFlow) {
-			console.warn("[SuperDoc] Web layout uses PM fallback unless layoutEngineOptions.flowMode is set to 'semantic'. Automatically disabling layout engine.");
-			this.config.useLayoutEngine = false;
-		}
 		if (!isWebLayout && isSemanticFlow) {
 			console.warn("[SuperDoc] flowMode 'semantic' is only valid with web layout. Coercing to 'paginated'.");
 			this.config.layoutEngineOptions.flowMode = "paginated";
@@ -43539,7 +43447,7 @@ var SuperDoc = class extends import_eventemitter3.default {
 		this.config.colors = shuffleArray(this.config.colors);
 		this.userColorMap = /* @__PURE__ */ new Map();
 		this.colorIndex = 0;
-		this.version = "2.7.0-next.1";
+		this.version = "2.7.0-next.10";
 		this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
 		this.superdocId = config.superdocId || v4();
 		this.colors = this.config.colors ?? [];

package/dist/word-layout/src/index.d.ts

@@ -7,6 +7,8 @@ export { createNumberingManager } from './numbering-manager.js';
 export type { NumberingManager, NumberingManagerSnapshot, NumberingCursor } from './numbering-manager.js';
 export { computeWordListMarker } from './list-marker.js';
 export type { ComputeWordListMarkerInput, ComputeWordListMarkerResult, WordListMarkerDefinition, } from './list-marker.js';
+export { createReviewAwareWordNumberingSequence, reviewAwareWordNumberingCounterScope, } from './review-aware-numbering.js';
+export type { ReviewAwareNumberingMembership, ReviewAwareNumberingStateMode, ReviewAwareWordMarkerFact, ReviewAwareWordNumberingDefinition, ReviewAwareWordNumberingResult, ReviewAwareWordNumberingSequence, ReviewAwareWordNumberingSnapshot, } from './review-aware-numbering.js';
 /**
  * Computes the complete layout properties for a Word paragraph, including indentation,
  * tabs, and optional list marker positioning.

package/dist/word-layout/src/list-marker.d.ts

@@ -19,6 +19,14 @@ export interface WordListMarkerDefinition {
     numFmt?: string;
     /** Custom format string when `numFmt === 'custom'`. */
     customFormat?: string;
+    /** True when the level carries Word's legal-numbering semantics. */
+    isLegal?: boolean;
+    /** Effective numbering formats for placeholders that reference each level. */
+    levelNumberingFormats?: Array<{
+        ilvl: number;
+        numFmt?: string;
+        customFormat?: string;
+    }>;
     /** `w:suff`. Defaults to `tab` when absent. */
     suffix?: string;
     /** `w:lvlJc`. Defaults to `left`. */

package/dist/word-layout/src/review-aware-numbering.d.ts

@@ -0,0 +1,41 @@
+import { ComputeWordListMarkerResult, WordListMarkerDefinition } from './list-marker.js';
+import { NumberingCursor, NumberingManager, NumberingManagerSnapshot } from './numbering-manager.js';
+export type ReviewAwareNumberingMembership = 'ordinary' | 'inserted' | 'deleted' | 'malformed';
+export type ReviewAwareNumberingStateMode = 'snapshot' | 'cursor';
+export interface ReviewAwareWordNumberingDefinition extends WordListMarkerDefinition {
+    restartNumberingAfterBreak?: boolean;
+}
+export type ReviewAwareWordMarkerFact = {
+    status: 'resolved';
+    result: ComputeWordListMarkerResult;
+} | {
+    status: 'unresolved';
+    reason: 'missingLvlText' | 'malformedMembership';
+};
+export interface ReviewAwareWordNumberingResult {
+    final: ReviewAwareWordMarkerFact | null;
+    original: ReviewAwareWordMarkerFact | null;
+    redline: ReviewAwareWordMarkerFact;
+}
+export interface ReviewAwareWordNumberingSnapshot {
+    live?: NumberingManagerSnapshot | NumberingCursor;
+    original?: NumberingManagerSnapshot | NumberingCursor;
+    liveSectionEpoch: number;
+    originalSectionEpoch: number;
+}
+export interface ReviewAwareWordNumberingSequence {
+    advance(input: {
+        definition: ReviewAwareWordNumberingDefinition;
+        paragraphOrdinal: number;
+        membership: ReviewAwareNumberingMembership;
+    }): ReviewAwareWordNumberingResult;
+    advanceSectionBreak(membership: ReviewAwareNumberingMembership): void;
+    captureSnapshot(): ReviewAwareWordNumberingSnapshot;
+    restoreSnapshot(snapshot: ReviewAwareWordNumberingSnapshot | null): void;
+    counterScope(definition: ReviewAwareWordNumberingDefinition, plane: 'live' | 'original'): string;
+    retainedState(): readonly [NumberingManager, NumberingManager];
+}
+export declare function createReviewAwareWordNumberingSequence(options?: {
+    stateMode?: ReviewAwareNumberingStateMode;
+}): ReviewAwareWordNumberingSequence;
+export declare function reviewAwareWordNumberingCounterScope(definition: ReviewAwareWordNumberingDefinition, plane: 'live' | 'original', epochs: Pick<ReviewAwareWordNumberingSnapshot, 'liveSectionEpoch' | 'originalSectionEpoch'>): string;