@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/src/review/store/revision-store.ts

@@ -0,0 +1,323 @@
+import type { TransactionMapping } from "../../core/selection/mapping.ts";
+import {
+  describeRevisionKind,
+  getRevisionActionability,
+  isDetachedRevisionAnchor,
+  isRevisionActionable,
+  remapRevisionAnchor,
+  summarizeRevisionAnchor,
+  type RevisionActionability,
+  type RevisionKind,
+  type RevisionMetadataEnvelope,
+  type RevisionRecord,
+  type RevisionStatus,
+} from "./revision-types.ts";
+
+export type { RevisionRecord, RevisionKind, RevisionStatus } from "./revision-types.ts";
+
+export interface RevisionStore {
+  version: "revision-store/1";
+  revisions: Record<string, RevisionRecord>;
+}
+
+export interface CreateRevisionRecordParams {
+  revisionId: string;
+  kind: RevisionKind;
+  anchor: RevisionRecord["anchor"];
+  authorId: string;
+  createdAt: string;
+  status?: Exclude<RevisionStatus, "detached">;
+  warningIds?: string[];
+  metadata?: Partial<RevisionMetadataEnvelope>;
+}
+
+export interface RevisionSidebarEntry {
+  revisionId: string;
+  kind: RevisionKind;
+  label: string;
+  status: RevisionStatus;
+  actionability: RevisionActionability;
+  anchorLabel: string;
+  createdAt: string;
+  authorId: string;
+  warningCount: number;
+  canAccept: boolean;
+  canReject: boolean;
+  preserveOnlyReason?: string;
+  linkedMoveRevisionId?: string;
+  moveDirection?: "from" | "to";
+}
+
+export interface RevisionSidebarProjection {
+  totalCount: number;
+  activeRevisionIds: string[];
+  acceptedRevisionIds: string[];
+  rejectedRevisionIds: string[];
+  detachedRevisionIds: string[];
+  actionableRevisionIds: string[];
+  preserveOnlyRevisionIds: string[];
+  revisions: RevisionSidebarEntry[];
+}
+
+export function createRevisionStore(
+  revisions: Record<string, RevisionRecord> = {},
+): RevisionStore {
+  return {
+    version: "revision-store/1",
+    revisions,
+  };
+}
+
+export function createRevisionRecord(
+  params: CreateRevisionRecordParams,
+): RevisionRecord {
+  return normalizeRevisionRecord({
+    revisionId: params.revisionId,
+    kind: params.kind,
+    anchor: params.anchor,
+    authorId: params.authorId,
+    createdAt: params.createdAt,
+    status: params.status ?? "active",
+    warningIds: [...(params.warningIds ?? [])],
+    metadata: {
+      source: params.metadata?.source ?? "runtime",
+      storyTarget: params.metadata?.storyTarget,
+      preserveOnlyReason:
+        params.metadata?.preserveOnlyReason ??
+        (getRevisionActionability(params.kind) === "preserve-only"
+          ? "Imported preserve-only revision."
+          : undefined),
+      suggestionId: params.metadata?.suggestionId,
+      semanticKind: params.metadata?.semanticKind,
+      linkedRevisionIds: params.metadata?.linkedRevisionIds,
+      predecessorSuggestionId: params.metadata?.predecessorSuggestionId,
+      importedRevisionForm: params.metadata?.importedRevisionForm,
+      originalRevisionType: params.metadata?.originalRevisionType,
+      ooxmlRevisionId: params.metadata?.ooxmlRevisionId,
+      propertyChangeData: params.metadata?.propertyChangeData,
+      moveData: params.metadata?.moveData,
+    },
+  });
+}
+
+export function upsertRevisionRecord(
+  store: RevisionStore,
+  revision: RevisionRecord,
+): RevisionStore {
+  return {
+    ...store,
+    revisions: {
+      ...store.revisions,
+      [revision.revisionId]: normalizeRevisionRecord(revision),
+    },
+  };
+}
+
+export function setRevisionStatus(
+  store: RevisionStore,
+  revisionId: string,
+  status: Exclude<RevisionStatus, "detached">,
+): RevisionStore {
+  const existing = store.revisions[revisionId];
+  if (!existing) {
+    return store;
+  }
+
+  if (existing.status === "detached") {
+    return store;
+  }
+
+  if (
+    (status === "accepted" || status === "rejected") &&
+    getRevisionActionability(existing) !== "actionable"
+  ) {
+    return store;
+  }
+
+  return upsertRevisionRecord(store, {
+    ...existing,
+    status,
+  });
+}
+
+export function setRevisionWarnings(
+  store: RevisionStore,
+  revisionId: string,
+  warningIds: string[],
+): RevisionStore {
+  const existing = store.revisions[revisionId];
+  if (!existing) {
+    return store;
+  }
+
+  return upsertRevisionRecord(store, {
+    ...existing,
+    warningIds: [...warningIds],
+  });
+}
+
+export function remapRevisionStore(
+  store: RevisionStore,
+  mapping: TransactionMapping,
+): RevisionStore {
+  return createRevisionStore(
+    Object.fromEntries(
+      Object.entries(store.revisions).map(([revisionId, revision]) => {
+        const anchor = remapRevisionAnchor(revision.anchor, mapping);
+        const status =
+          anchor.kind === "detached"
+            ? "detached"
+            : revision.status === "accepted" || revision.status === "rejected"
+              ? revision.status
+              : "active";
+
+        return [
+          revisionId,
+          normalizeRevisionRecord({
+            ...revision,
+            anchor,
+            status,
+          }),
+        ];
+      }),
+    ),
+  );
+}
+
+export function createRevisionSidebarProjection(
+  store: RevisionStore,
+): RevisionSidebarProjection {
+  const revisions = Object.values(store.revisions)
+    .map(toSidebarEntry)
+    .sort(compareRevisionEntries);
+
+  return {
+    totalCount: revisions.length,
+    activeRevisionIds: revisions
+      .filter((revision) => revision.status === "active")
+      .map((revision) => revision.revisionId),
+    acceptedRevisionIds: revisions
+      .filter((revision) => revision.status === "accepted")
+      .map((revision) => revision.revisionId),
+    rejectedRevisionIds: revisions
+      .filter((revision) => revision.status === "rejected")
+      .map((revision) => revision.revisionId),
+    detachedRevisionIds: revisions
+      .filter((revision) => revision.status === "detached")
+      .map((revision) => revision.revisionId),
+    actionableRevisionIds: revisions
+      .filter((revision) => revision.actionability === "actionable")
+      .map((revision) => revision.revisionId),
+    preserveOnlyRevisionIds: revisions
+      .filter((revision) => revision.actionability === "preserve-only")
+      .map((revision) => revision.revisionId),
+    revisions,
+  };
+}
+
+function toSidebarEntry(revision: RevisionRecord): RevisionSidebarEntry {
+  const anchorSummary = summarizeRevisionAnchor(revision.anchor);
+  const actionability = getRevisionActionability(revision);
+
+  const moveData = revision.metadata.moveData;
+
+  return {
+    revisionId: revision.revisionId,
+    kind: revision.kind,
+    label:
+      revision.kind === "move"
+        ? moveData?.direction === "from"
+          ? "Move from"
+          : moveData?.direction === "to"
+            ? "Move to"
+            : describeRevisionKind(revision.kind)
+        : describeRevisionKind(revision.kind),
+    status: revision.status,
+    actionability,
+    anchorLabel:
+      anchorSummary.state === "detached"
+        ? `Detached ${anchorSummary.range.from}-${anchorSummary.range.to}`
+        : `Range ${anchorSummary.range.from}-${anchorSummary.range.to}`,
+    createdAt: revision.createdAt,
+    authorId: revision.authorId,
+    warningCount: revision.warningIds.length,
+    canAccept: isRevisionActionable(revision),
+    canReject: isRevisionActionable(revision),
+    preserveOnlyReason: revision.metadata.preserveOnlyReason,
+    linkedMoveRevisionId: moveData?.linkedRevisionId,
+    moveDirection: moveData?.direction,
+  };
+}
+
+function normalizeRevisionRecord(revision: RevisionRecord): RevisionRecord {
+  const actionability = getRevisionActionability(revision);
+
+  if (isDetachedRevisionAnchor(revision.anchor)) {
+    return {
+      ...revision,
+      status: "detached",
+      metadata: {
+        ...revision.metadata,
+        preserveOnlyReason:
+          revision.metadata.preserveOnlyReason ??
+          (actionability === "preserve-only"
+            ? "Imported preserve-only revision."
+            : undefined),
+      },
+    };
+  }
+
+  if (actionability === "preserve-only" && revision.status !== "detached") {
+    return {
+      ...revision,
+      status: revision.status === "accepted" || revision.status === "rejected" ? "active" : revision.status,
+      metadata: {
+        ...revision.metadata,
+        preserveOnlyReason:
+          revision.metadata.preserveOnlyReason ?? "Imported preserve-only revision.",
+      },
+    };
+  }
+
+  return revision;
+}
+
+function compareRevisionEntries(
+  left: RevisionSidebarEntry,
+  right: RevisionSidebarEntry,
+): number {
+  const statusDelta = priorityForStatus(left.status) - priorityForStatus(right.status);
+  if (statusDelta !== 0) {
+    return statusDelta;
+  }
+
+  const actionabilityDelta =
+    priorityForActionability(left.actionability) - priorityForActionability(right.actionability);
+  if (actionabilityDelta !== 0) {
+    return actionabilityDelta;
+  }
+
+  return left.createdAt.localeCompare(right.createdAt);
+}
+
+function priorityForStatus(status: RevisionStatus): number {
+  switch (status) {
+    case "active":
+      return 0;
+    case "detached":
+      return 1;
+    case "accepted":
+      return 2;
+    case "rejected":
+      return 3;
+  }
+}
+
+function priorityForActionability(actionability: RevisionActionability): number {
+  switch (actionability) {
+    case "actionable":
+      return 0;
+    case "preserve-only":
+      return 1;
+  }
+}

package/src/review/store/revision-types.ts

@@ -0,0 +1,182 @@
+import {
+  createNodeAnchor,
+  createRangeAnchor,
+  mapAnchor,
+  normalizeRange,
+  type Assoc,
+  type BoundaryAssoc,
+  type DocRange,
+  type EditorAnchorProjection,
+  type TransactionMapping,
+} from "../../core/selection/mapping.ts";
+import type { RevisionStoryTargetRecord } from "../../model/canonical-document.ts";
+
+export type RevisionAnchor = EditorAnchorProjection;
+
+export type SupportedRevisionKind = "insertion" | "deletion" | "property-change";
+export type PreserveOnlyRevisionKind = "formatting" | "move";
+export type RevisionKind = SupportedRevisionKind | PreserveOnlyRevisionKind;
+
+export type RevisionStatus = "active" | "accepted" | "rejected" | "detached";
+export type RevisionActionability = "actionable" | "preserve-only";
+export type RevisionAnchorState = "active" | "detached";
+
+export interface PropertyChangeData {
+  xmlTag: "pPrChange" | "sectPrChange" | "tblPrChange" | "rPrChange";
+  beforeXml: string;
+}
+
+export interface MoveData {
+  moveId: string;
+  direction: "from" | "to";
+  linkedRevisionId?: string;
+}
+
+export interface RevisionMetadataEnvelope {
+  source: "runtime" | "import";
+  storyTarget?: RevisionStoryTargetRecord;
+  preserveOnlyReason?: string;
+  suggestionId?: string;
+  semanticKind?:
+    | "insertion"
+    | "deletion"
+    | "replacement"
+    | "formatting-change"
+    | "paragraph-property-change"
+    | "structural-change"
+    | "object-change";
+  linkedRevisionIds?: string[];
+  predecessorSuggestionId?: string;
+  importedRevisionForm?:
+    | "run-insertion"
+    | "run-deletion"
+    | "paragraph-insertion"
+    | "paragraph-deletion";
+  originalRevisionType?: string;
+  ooxmlRevisionId?: string;
+  propertyChangeData?: PropertyChangeData;
+  moveData?: MoveData;
+}
+
+export type PropertyChangeRevision = RevisionRecord & {
+  kind: "property-change";
+  metadata: RevisionMetadataEnvelope & { propertyChangeData: PropertyChangeData };
+};
+
+export type MoveRevision = RevisionRecord & {
+  kind: "move";
+  metadata: RevisionMetadataEnvelope & { moveData: MoveData };
+};
+
+export interface RevisionRecord {
+  revisionId: string;
+  kind: RevisionKind;
+  anchor: RevisionAnchor;
+  authorId: string;
+  createdAt: string;
+  status: RevisionStatus;
+  warningIds: string[];
+  metadata: RevisionMetadataEnvelope;
+}
+
+export interface RevisionAnchorSummary {
+  anchor: RevisionAnchor;
+  state: RevisionAnchorState;
+  range: DocRange;
+}
+
+export function createRevisionRangeAnchor(
+  from: number,
+  to = from,
+  assoc?: BoundaryAssoc,
+): RevisionAnchor {
+  return createRangeAnchor(from, to, assoc);
+}
+
+export function createRevisionNodeAnchor(at: number, assoc?: Assoc): RevisionAnchor {
+  return createNodeAnchor(at, assoc);
+}
+
+export function remapRevisionAnchor(
+  anchor: RevisionAnchor,
+  mapping: TransactionMapping,
+): RevisionAnchor {
+  return mapAnchor(anchor, mapping);
+}
+
+export function isDetachedRevisionAnchor(anchor: RevisionAnchor): boolean {
+  return anchor.kind === "detached";
+}
+
+export function summarizeRevisionAnchor(anchor: RevisionAnchor): RevisionAnchorSummary {
+  if (anchor.kind === "range") {
+    return {
+      anchor,
+      state: "active",
+      range: normalizeRange(anchor.range),
+    };
+  }
+
+  if (anchor.kind === "node") {
+    return {
+      anchor,
+      state: "active",
+      range: {
+        from: anchor.at,
+        to: anchor.at,
+      },
+    };
+  }
+
+  return {
+    anchor,
+    state: "detached",
+    range: normalizeRange(anchor.lastKnownRange),
+  };
+}
+
+export function getRevisionActionability(
+  revision:
+    | RevisionKind
+    | Pick<RevisionRecord, "kind" | "metadata">,
+): RevisionActionability {
+  if (
+    typeof revision !== "string" &&
+    typeof revision.metadata.preserveOnlyReason === "string" &&
+    revision.metadata.preserveOnlyReason.length > 0
+  ) {
+    return "preserve-only";
+  }
+
+  const kind = typeof revision === "string" ? revision : revision.kind;
+  switch (kind) {
+    case "insertion":
+    case "deletion":
+    case "property-change":
+      return "actionable";
+    case "formatting":
+    case "move":
+      return "preserve-only";
+  }
+}
+
+export function isRevisionActionable(
+  record: Pick<RevisionRecord, "kind" | "metadata" | "status">,
+): boolean {
+  return getRevisionActionability(record) === "actionable" && record.status === "active";
+}
+
+export function describeRevisionKind(kind: RevisionKind): string {
+  switch (kind) {
+    case "insertion":
+      return "Insertion";
+    case "deletion":
+      return "Deletion";
+    case "formatting":
+      return "Formatting change";
+    case "move":
+      return "Move";
+    case "property-change":
+      return "Property change";
+  }
+}

package/src/review/store/runtime-comment-store.ts

@@ -0,0 +1,43 @@
+import {
+  normalizeCommentThreadRecord,
+  type CommentThreadRecord,
+} from "../../core/state/editor-state.ts";
+import {
+  createCommentStore,
+  type CommentStore,
+  type CommentThread,
+} from "./comment-store.ts";
+
+export function createCommentStoreFromRuntimeComments(
+  comments: Record<string, CommentThreadRecord>,
+): CommentStore {
+  const threads = Object.fromEntries(
+    Object.values(comments).map((comment) => [
+      comment.commentId,
+      toCommentThread(comment),
+    ]),
+  );
+
+  return createCommentStore(threads);
+}
+
+function toCommentThread(comment: CommentThreadRecord): CommentThread {
+  const normalized = normalizeCommentThreadRecord(comment);
+
+  return {
+    commentId: normalized.commentId,
+    anchor: normalized.anchor,
+    status:
+      normalized.anchor.kind === "detached"
+        ? "detached"
+        : normalized.status === "resolved"
+          ? "resolved"
+          : "open",
+    entries: normalized.entries ?? [],
+    createdBy: normalized.createdBy ?? normalized.authorId ?? "unknown",
+    createdAt: normalized.createdAt,
+    resolution: normalized.resolution,
+    warningIds: [...(normalized.warningIds ?? [])],
+    metadata: normalized.metadata,
+  };
+}

package/src/runtime/README.md

@@ -0,0 +1,3 @@
+# Runtime
+
+The document controller and coordination between canonical state, review state, UI state, preservation, validation, and IO belong here.