@beyondwork/docx-react-component 1.0.27 → 1.0.29

package/src/runtime/collab-review-sync.ts

@@ -1,254 +0,0 @@
-import * as Y from "yjs";
-
-import type { DocumentRuntime, DocumentRuntimeEvent, Unsubscribe } from "./document-runtime.ts";
-
-// ---------------------------------------------------------------------------
-// Serialised shapes stored inside the Y.Maps
-// ---------------------------------------------------------------------------
-
-interface YCommentThread {
-  commentId: string;
-  status: "open" | "resolved" | "detached";
-  anchor: { kind: string; [key: string]: unknown };
-  createdAt: string;
-  createdBy: string;
-  authorId: string;
-  body: string;
-  entries: Array<{
-    entryId: string;
-    authorId: string;
-    body: string;
-    createdAt: string;
-  }>;
-  resolvedAt?: string;
-  resolvedBy?: string;
-  warningIds: string[];
-  sourceClientId: number;
-}
-
-interface YRevisionAction {
-  changeId: string;
-  action: "accept" | "reject";
-  sourceClientId: number;
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-export interface CollabReviewSyncHandle {
-  destroy(): void;
-}
-
-export function createCollabReviewSync(
-  ydoc: Y.Doc,
-  runtime: DocumentRuntime,
-): CollabReviewSyncHandle {
-  const yComments = ydoc.getMap<YCommentThread>("comments");
-  const yRevisionActions = ydoc.getMap<YRevisionAction>("revisionActions");
-  const clientId = ydoc.clientID;
-
-  let suppressLocalEvents = false;
-
-  // --- Local → Yjs ---------------------------------------------------------
-
-  const unsubEvents: Unsubscribe = runtime.subscribeToEvents((event) => {
-    if (suppressLocalEvents) return;
-
-    switch (event.type) {
-      case "comment_added":
-        pushCommentToYjs(event.commentId);
-        break;
-      case "comment_resolved":
-        syncCommentFieldToYjs(event.commentId);
-        break;
-      case "change_accepted":
-        yRevisionActions.set(revisionActionKey(event.changeId, "accept"), {
-          changeId: event.changeId,
-          action: "accept",
-          sourceClientId: clientId,
-        });
-        break;
-      case "change_rejected":
-        yRevisionActions.set(revisionActionKey(event.changeId, "reject"), {
-          changeId: event.changeId,
-          action: "reject",
-          sourceClientId: clientId,
-        });
-        break;
-    }
-  });
-
-  function pushCommentToYjs(commentId: string): void {
-    const thread = runtime
-      .getRenderSnapshot()
-      .comments.threads.find((t) => t.commentId === commentId);
-    if (!thread) return;
-
-    yComments.set(commentId, {
-      commentId: thread.commentId,
-      status: thread.status,
-      anchor: thread.anchor,
-      createdAt: thread.createdAt,
-      createdBy: thread.createdBy,
-      authorId: thread.createdBy,
-      body: thread.entries[0]?.body ?? "",
-      entries: thread.entries.map((e) => ({
-        entryId: e.entryId,
-        authorId: e.authorId,
-        body: e.body,
-        createdAt: e.createdAt,
-      })),
-      resolvedAt: thread.resolvedAt,
-      resolvedBy: thread.resolvedBy,
-      warningIds: [],
-      sourceClientId: clientId,
-    });
-  }
-
-  function syncCommentFieldToYjs(commentId: string): void {
-    const existing = yComments.get(commentId);
-    const thread = runtime
-      .getRenderSnapshot()
-      .comments.threads.find((t) => t.commentId === commentId);
-    if (!existing || !thread) return;
-
-    yComments.set(commentId, {
-      ...existing,
-      status: thread.status,
-      entries: thread.entries.map((e) => ({
-        entryId: e.entryId,
-        authorId: e.authorId,
-        body: e.body,
-        createdAt: e.createdAt,
-      })),
-      resolvedAt: thread.resolvedAt,
-      resolvedBy: thread.resolvedBy,
-      sourceClientId: clientId,
-    });
-  }
-
-  // --- Yjs → Local ---------------------------------------------------------
-
-  function onCommentMapChange(event: Y.YMapEvent<YCommentThread>): void {
-    suppressLocalEvents = true;
-    try {
-      for (const [commentId, change] of event.changes.keys) {
-        const entry = yComments.get(commentId);
-        if (!entry || entry.sourceClientId === clientId) continue;
-
-        const existing = runtime
-          .getRenderSnapshot()
-          .comments.threads.find((t) => t.commentId === commentId);
-
-        if (change.action === "add" && !existing) {
-          runtime.dispatch({
-            type: "comment.add",
-            comment: {
-              commentId: entry.commentId,
-              status: entry.status,
-              anchor: entry.anchor as never,
-              createdAt: entry.createdAt,
-              createdBy: entry.createdBy,
-              authorId: entry.authorId,
-              body: entry.body,
-              entries: entry.entries,
-              warningIds: entry.warningIds,
-              isResolved: entry.status === "resolved",
-              metadata: { source: "runtime" },
-            },
-          });
-        } else if (change.action === "update" && existing) {
-          if (entry.status === "resolved" && existing.status !== "resolved") {
-            runtime.dispatch({
-              type: "comment.resolve",
-              commentId,
-              resolvedBy: entry.resolvedBy,
-            });
-          } else if (entry.status === "open" && existing.status === "resolved") {
-            runtime.dispatch({ type: "comment.reopen", commentId });
-          }
-
-          const localEntryCount = existing.entries.length;
-          if (entry.entries.length > localEntryCount) {
-            for (const newEntry of entry.entries.slice(localEntryCount)) {
-              runtime.dispatch({
-                type: "comment.add-reply",
-                commentId,
-                body: newEntry.body,
-                authorId: newEntry.authorId,
-              });
-            }
-          }
-        }
-      }
-    } finally {
-      suppressLocalEvents = false;
-    }
-  }
-
-  function onRevisionActionMapChange(event: Y.YMapEvent<YRevisionAction>): void {
-    suppressLocalEvents = true;
-    try {
-      for (const [, change] of event.changes.keys) {
-        if (change.action !== "add") continue;
-        const entries = [...yRevisionActions.entries()];
-        const latest = entries[entries.length - 1];
-        if (!latest) continue;
-        const entry = latest[1];
-        if (entry.sourceClientId === clientId) continue;
-
-        runtime.dispatch({
-          type: entry.action === "accept" ? "change.accept" : "change.reject",
-          changeId: entry.changeId,
-        });
-      }
-    } finally {
-      suppressLocalEvents = false;
-    }
-  }
-
-  yComments.observe(onCommentMapChange);
-  yRevisionActions.observe(onRevisionActionMapChange);
-
-  // --- Initial sync: push existing comments to Yjs if first client ----------
-
-  const snapshot = runtime.getRenderSnapshot();
-  if (yComments.size === 0 && snapshot.comments.threads.length > 0) {
-    ydoc.transact(() => {
-      for (const thread of snapshot.comments.threads) {
-        yComments.set(thread.commentId, {
-          commentId: thread.commentId,
-          status: thread.status,
-          anchor: thread.anchor,
-          createdAt: thread.createdAt,
-          createdBy: thread.createdBy,
-          authorId: thread.createdBy,
-          body: thread.entries[0]?.body ?? "",
-          entries: thread.entries.map((e) => ({
-            entryId: e.entryId,
-            authorId: e.authorId,
-            body: e.body,
-            createdAt: e.createdAt,
-          })),
-          resolvedAt: thread.resolvedAt,
-          resolvedBy: thread.resolvedBy,
-          warningIds: [],
-          sourceClientId: clientId,
-        });
-      }
-    });
-  }
-
-  return {
-    destroy() {
-      unsubEvents();
-      yComments.unobserve(onCommentMapChange);
-      yRevisionActions.unobserve(onRevisionActionMapChange);
-    },
-  };
-}
-
-function revisionActionKey(changeId: string, action: string): string {
-  return `${changeId}:${action}`;
-}

package/src/runtime/document-layout.ts

@@ -1,332 +0,0 @@
-import type {
-  EditorStoryTarget,
-  PageLayoutSnapshot,
-} from "../api/public-types";
-import { MAIN_STORY_TARGET } from "../core/selection/mapping.ts";
-import {
-  createSelectionSnapshot,
-  type CanonicalDocumentEnvelope,
-  type EditorState,
-} from "../core/state/editor-state.ts";
-import type {
-  FooterDocument,
-  HeaderDocument,
-  SectionProperties,
-  SubPartsCatalog,
-} from "../model/canonical-document.ts";
-import { createEditorSurfaceSnapshot } from "./surface-projection.ts";
-import {
-  resolveSectionVariants,
-  sectionSupportsStoryTarget,
-} from "./story-context.ts";
-import { storyTargetKey } from "./story-targeting.ts";
-
-export interface ResolvedDocumentSection {
-  index: number;
-  start: number;
-  end: number;
-  properties?: SectionProperties;
-}
-
-export function buildResolvedSections(
-  document: CanonicalDocumentEnvelope,
-): ResolvedDocumentSection[] {
-  const mainSurface = createEditorSurfaceSnapshot(
-    document,
-    createSelectionSnapshot(0, 0),
-    MAIN_STORY_TARGET,
-  );
-  const sections: ResolvedDocumentSection[] = [];
-  let sectionStart = 0;
-  let sectionIndex = 0;
-
-  for (const [index, block] of document.content.children.entries()) {
-    if (block.type !== "section_break") {
-      continue;
-    }
-
-    const surfaceBlock = mainSurface.blocks[index];
-    sections.push({
-      index: sectionIndex,
-      start: sectionStart,
-      end: surfaceBlock?.from ?? sectionStart,
-      properties: block.sectionProperties,
-    });
-    sectionStart = surfaceBlock?.to ?? sectionStart;
-    sectionIndex += 1;
-  }
-
-  sections.push({
-    index: sectionIndex,
-    start: sectionStart,
-    end: mainSurface.storySize,
-    properties: document.subParts?.finalSectionProperties,
-  });
-
-  return sections;
-}
-
-export function findSectionForPosition(
-  sections: ReadonlyArray<ResolvedDocumentSection>,
-  position: number,
-): ResolvedDocumentSection {
-  for (const section of sections) {
-    if (position < section.end) {
-      return section;
-    }
-  }
-
-  return sections[sections.length - 1] ?? {
-    index: 0,
-    start: 0,
-    end: 0,
-  };
-}
-
-export function buildPageLayoutSnapshot(
-  sectionIndex: number,
-  properties: SectionProperties | undefined,
-  subParts: SubPartsCatalog | undefined,
-): PageLayoutSnapshot {
-  const pageSize = properties?.pageSize ?? {
-    width: 12240,
-    height: 15840,
-    orientation: "portrait" as const,
-  };
-  const margins = properties?.pageMargins ?? {
-    top: 1440,
-    right: 1440,
-    bottom: 1440,
-    left: 1440,
-    header: 720,
-    footer: 720,
-    gutter: 0,
-  };
-  const columns = properties?.columns;
-  const explicitColumns = columns?.columns ?? [];
-  const differentOddEvenPages = Boolean(subParts?.settings?.evenAndOddHeaders);
-
-  return {
-    sectionIndex,
-    ...(properties?.sectionType ? { sectionType: properties.sectionType } : {}),
-    pageWidth: pageSize.width,
-    pageHeight: pageSize.height,
-    marginTop: margins.top,
-    marginBottom: margins.bottom,
-    marginLeft: margins.left,
-    marginRight: margins.right,
-    headerMargin: margins.header ?? 720,
-    footerMargin: margins.footer ?? 720,
-    gutter: margins.gutter ?? 0,
-    orientation: pageSize.orientation ?? "portrait",
-    columns:
-      explicitColumns.length > 0 ? explicitColumns.length : (columns?.count ?? 1),
-    differentFirstPage: Boolean(properties?.titlePage),
-    differentOddEvenPages,
-    ...(properties?.pageNumbering
-      ? {
-          pageNumbering: {
-            ...(properties.pageNumbering.format
-              ? { format: properties.pageNumbering.format }
-              : {}),
-            ...(properties.pageNumbering.start !== undefined
-              ? { start: properties.pageNumbering.start }
-              : {}),
-            ...(properties.pageNumbering.chapStyle
-              ? { chapterStyle: properties.pageNumbering.chapStyle }
-              : {}),
-            ...(properties.pageNumbering.chapSep
-              ? { chapterSeparator: properties.pageNumbering.chapSep }
-              : {}),
-          },
-        }
-      : {}),
-    ...(properties?.lineNumbering
-      ? {
-          lineNumbering: {
-            ...(properties.lineNumbering.countBy !== undefined
-              ? { countBy: properties.lineNumbering.countBy }
-              : {}),
-            ...(properties.lineNumbering.start !== undefined
-              ? { start: properties.lineNumbering.start }
-              : {}),
-            ...(properties.lineNumbering.distance !== undefined
-              ? { distance: properties.lineNumbering.distance }
-              : {}),
-            ...(properties.lineNumbering.restart
-              ? { restart: properties.lineNumbering.restart }
-              : {}),
-          },
-        }
-      : {}),
-    ...(properties?.pageBorders
-      ? {
-          pageBorders: {
-            ...(properties.pageBorders.top
-              ? { top: { ...properties.pageBorders.top } }
-              : {}),
-            ...(properties.pageBorders.left
-              ? { left: { ...properties.pageBorders.left } }
-              : {}),
-            ...(properties.pageBorders.bottom
-              ? { bottom: { ...properties.pageBorders.bottom } }
-              : {}),
-            ...(properties.pageBorders.right
-              ? { right: { ...properties.pageBorders.right } }
-              : {}),
-            ...(properties.pageBorders.offsetFrom
-              ? { offsetFrom: properties.pageBorders.offsetFrom }
-              : {}),
-            ...(properties.pageBorders.display
-              ? { display: properties.pageBorders.display }
-              : {}),
-            ...(properties.pageBorders.zOrder
-              ? { zOrder: properties.pageBorders.zOrder }
-              : {}),
-          },
-        }
-      : {}),
-    ...(properties?.documentGrid
-      ? {
-          documentGrid: {
-            ...(properties.documentGrid.type
-              ? { type: properties.documentGrid.type }
-              : {}),
-            ...(properties.documentGrid.linePitch !== undefined
-              ? { linePitch: properties.documentGrid.linePitch }
-              : {}),
-            ...(properties.documentGrid.charSpace !== undefined
-              ? { charSpace: properties.documentGrid.charSpace }
-              : {}),
-          },
-        }
-      : {}),
-    columnDefinitions: explicitColumns,
-    equalWidthColumns:
-      columns?.equalWidth ??
-      (explicitColumns.length === 0 || explicitColumns.length <= 1),
-    columnSeparator: Boolean(columns?.separator),
-    headerVariants: resolveSectionVariants(
-      "header",
-      sectionIndex,
-      properties?.headerReferences,
-      subParts?.headers ?? [],
-    ),
-    footerVariants: resolveSectionVariants(
-      "footer",
-      sectionIndex,
-      properties?.footerReferences,
-      subParts?.footers ?? [],
-    ),
-  };
-}
-
-export function resolveSectionForStoryTarget(
-  document: CanonicalDocumentEnvelope,
-  sections: ReadonlyArray<ResolvedDocumentSection>,
-  target: EditorStoryTarget,
-): ResolvedDocumentSection | undefined {
-  if (target.kind === "main" || sections.length === 0) {
-    return sections[0];
-  }
-
-  if (target.kind === "header") {
-    if (target.sectionIndex !== undefined) {
-      const section = sections.find((candidate) => candidate.index === target.sectionIndex);
-      return section &&
-        sectionSupportsStoryTarget(document, target.sectionIndex, target)
-        ? section
-        : undefined;
-    }
-    return (
-      findSectionByStoryReference(
-        document,
-        sections,
-        target,
-        "header",
-      ) ?? sections[0]
-    );
-  }
-
-  if (target.kind === "footer") {
-    if (target.sectionIndex !== undefined) {
-      const section = sections.find((candidate) => candidate.index === target.sectionIndex);
-      return section &&
-        sectionSupportsStoryTarget(document, target.sectionIndex, target)
-        ? section
-        : undefined;
-    }
-    return (
-      findSectionByStoryReference(
-        document,
-        sections,
-        target,
-        "footer",
-      ) ?? sections[0]
-    );
-  }
-
-  return undefined;
-}
-
-export function resolveActiveSection(
-  state: EditorState,
-  activeStory: EditorStoryTarget,
-  sections: ReadonlyArray<ResolvedDocumentSection>,
-  storySelections?: ReadonlyMap<string, EditorState["selection"]>,
-): ResolvedDocumentSection | undefined {
-  if (sections.length === 0) {
-    return undefined;
-  }
-
-  if (activeStory.kind === "main") {
-    return findSectionForPosition(sections, state.selection.head);
-  }
-
-  const referencedSection = resolveSectionForStoryTarget(
-    state.document,
-    sections,
-    activeStory,
-  );
-  if (referencedSection) {
-    return referencedSection;
-  }
-
-  const mainSelection =
-    storySelections?.get(storyTargetKey(MAIN_STORY_TARGET)) ?? state.selection;
-  return findSectionForPosition(sections, mainSelection.head);
-}
-
-function findSectionByStoryReference(
-  document: CanonicalDocumentEnvelope,
-  sections: ReadonlyArray<ResolvedDocumentSection>,
-  target:
-    | Extract<EditorStoryTarget, { kind: "header" }>
-    | Extract<EditorStoryTarget, { kind: "footer" }>,
-  kind: "header" | "footer",
-): ResolvedDocumentSection | undefined {
-  const propertyKey =
-    kind === "header" ? "headerReferences" : "footerReferences";
-  const documents =
-    kind === "header"
-      ? document.subParts?.headers ?? []
-      : document.subParts?.footers ?? [];
-
-  return (
-    sections.find((section) =>
-      section.properties?.[propertyKey]?.some(
-        (ref) =>
-          ref.relationshipId === target.relationshipId &&
-          ref.variant === target.variant,
-      ),
-    ) ??
-    sections.find((section) =>
-      documents.some(
-        (entry) =>
-          entry.relationshipId === target.relationshipId &&
-          entry.variant === target.variant &&
-          entry.sectionIndex === section.index,
-      ),
-    )
-  );
-}