@beyondwork/docx-react-component 1.0.0 → 1.0.1

package/src/ui-tailwind/tw-review-workspace.tsx

@@ -1,140 +0,0 @@
-import React, { type ReactNode, useState } from "react";
-
-import * as Tooltip from "@radix-ui/react-tooltip";
-
-import type {
-  CommentSidebarThreadSnapshot,
-  RuntimeRenderSnapshot,
-  TrackedChangeEntrySnapshot,
-} from "../api/public-types";
-import type { SessionCapabilities } from "../runtime/session-capabilities";
-import type { MarkupDisplay } from "../ui/headless/comment-decoration-model";
-import { TwAlertBanner } from "./chrome/tw-alert-banner";
-import { TwSelectionToolbar } from "./chrome/tw-selection-toolbar";
-import { TwReviewRail, type ReviewRailTab } from "./review/tw-review-rail";
-import { TwStatusBar } from "./status/tw-status-bar";
-import { TwToolbar, type ViewMode } from "./toolbar/tw-toolbar";
-
-export interface TwReviewWorkspaceProps {
-  snapshot: RuntimeRenderSnapshot;
-  currentUserId?: string;
-  capabilities?: SessionCapabilities;
-  reviewMode?: "editing" | "review";
-  document: ReactNode;
-  viewMode: ViewMode;
-  activeRailTab: ReviewRailTab;
-  activeCommentId?: string;
-  activeRevisionId?: string;
-  showTrackedChanges: boolean;
-  selectionPreview?: string | null;
-  onViewModeChange: (value: ViewMode) => void;
-  onActiveRailTabChange: (value: ReviewRailTab) => void;
-  onShowTrackedChangesChange: (show: boolean) => void;
-  onUndo: () => void;
-  onRedo: () => void;
-  onAddComment: () => void;
-  onExport: () => void;
-  onOpenComment: (thread: CommentSidebarThreadSnapshot) => void;
-  onResolveComment: (commentId: string) => void;
-  onReopenComment?: (commentId: string) => void;
-  onAddReply?: (commentId: string, body: string) => void;
-  onEditBody?: (commentId: string, body: string) => void;
-  onOpenRevision: (revision: TrackedChangeEntrySnapshot) => void;
-  onAcceptRevision: (revisionId: string) => void;
-  onRejectRevision: (revisionId: string) => void;
-  onAcceptAllChanges: () => void;
-  onRejectAllChanges: () => void;
-}
-
-export function TwReviewWorkspace(props: TwReviewWorkspaceProps) {
-  const { snapshot } = props;
-  const caps = props.capabilities;
-  const markupDisplay: MarkupDisplay = props.viewMode === "document" ? "all" : "clean";
-  const preserveOnlyCount = caps?.preserveOnlyCount ??
-    snapshot.compatibility.featureEntries.filter(
-      (entry) => entry.featureClass === "preserve-only",
-    ).length;
-  const showReviewRail = caps?.reviewRailVisible ?? true;
-
-  return (
-    <Tooltip.Provider delayDuration={400}>
-      <div className="flex h-full flex-col bg-canvas text-primary">
-        <TwToolbar
-          sourceLabel={snapshot.sourceLabel}
-          capabilities={caps}
-          compatibility={snapshot.compatibility}
-          warnings={snapshot.warnings}
-          viewMode={props.viewMode}
-          showTrackedChanges={props.showTrackedChanges}
-          onUndo={props.onUndo}
-          onRedo={props.onRedo}
-          onAddComment={props.onAddComment}
-          onExport={props.onExport}
-          onViewModeChange={props.onViewModeChange}
-          onShowTrackedChangesChange={props.onShowTrackedChangesChange}
-        />
-
-        <TwAlertBanner snapshot={snapshot} preserveOnlyCount={preserveOnlyCount} />
-
-        <div className="flex flex-1 min-h-0">
-          {/* Document column */}
-          <div className="flex flex-1 flex-col min-w-0">
-            <div className={`flex-1 overflow-y-auto ${props.viewMode === "document" ? "bg-surface" : "bg-canvas"}`}>
-              <div
-                className={`mx-auto min-h-full ${
-                  props.viewMode === "document"
-                    ? "max-w-[780px] my-8 rounded-xl ring-1 ring-border shadow-sm bg-canvas"
-                    : "bg-canvas"
-                }`}
-              >
-                {props.selectionPreview ? (
-                  <div className="flex justify-center pt-4 px-4">
-                    <TwSelectionToolbar
-                      selectionPreview={props.selectionPreview}
-                      readOnly={snapshot.readOnly}
-                      onAddComment={props.onAddComment}
-                    />
-                  </div>
-                ) : null}
-                {props.document}
-              </div>
-            </div>
-
-            <TwStatusBar
-              isDirty={snapshot.isDirty}
-              isExportBlocked={snapshot.compatibility.blockExport}
-              preserveOnlyCount={preserveOnlyCount}
-              commentCount={snapshot.comments.totalCount}
-              changeCount={snapshot.trackedChanges.totalCount}
-              sessionId={snapshot.sessionId}
-            />
-          </div>
-
-          {/* Review rail — hidden in editing mode unless toggled */}
-          {showReviewRail ? <TwReviewRail
-            activeTab={props.activeRailTab}
-            currentUserId={props.currentUserId}
-            comments={snapshot.comments}
-            trackedChanges={snapshot.trackedChanges}
-            compatibility={snapshot.compatibility}
-            warnings={snapshot.warnings}
-            markupDisplay={markupDisplay}
-            activeCommentId={props.activeCommentId}
-            activeRevisionId={props.activeRevisionId}
-            onActiveTabChange={props.onActiveRailTabChange}
-            onOpenComment={props.onOpenComment}
-            onResolveComment={props.onResolveComment}
-            onReopenComment={props.onReopenComment}
-            onAddReply={props.onAddReply}
-            onEditBody={props.onEditBody}
-            onOpenRevision={props.onOpenRevision}
-            onAcceptRevision={props.onAcceptRevision}
-            onRejectRevision={props.onRejectRevision}
-            onAcceptAllChanges={props.onAcceptAllChanges}
-            onRejectAllChanges={props.onRejectAllChanges}
-          /> : null}
-        </div>
-      </div>
-    </Tooltip.Provider>
-  );
-}

package/src/validation/README.md

@@ -1,3 +0,0 @@
-# Validation
-
-Compatibility checks, round-trip validation, support classification, and Word reopen evidence helpers belong here.

package/src/validation/compatibility-engine.ts

@@ -1,317 +0,0 @@
-import { createRangeAnchor } from "../core/selection/mapping.ts";
-import type {
-  CanonicalDocumentEnvelope,
-  CompatibilityFeatureEntry,
-  CompatibilityReport,
-  EditorError,
-  EditorWarning,
-} from "../core/state/editor-state.ts";
-import type {
-  DocumentRootNode,
-  InlineNode,
-  ParagraphNode,
-} from "../model/canonical-document.ts";
-import {
-  describeOpaqueFragment,
-  listOpaqueFragments,
-  listPreservedPackageParts,
-} from "../preservation/store.ts";
-
-export interface BuildCompatibilityReportInput {
-  document: CanonicalDocumentEnvelope;
-  warnings?: readonly EditorWarning[];
-  fatalError?: EditorError;
-  generatedAt: string;
-}
-
-export function buildCompatibilityReport(
-  input: BuildCompatibilityReportInput,
-): CompatibilityReport {
-  const content = normalizeDocumentRoot(input.document.content);
-  const contentFeatures = collectContentFeatures(content);
-  if (hasSupportedRuntimeComments(input.document.review.comments)) {
-    contentFeatures.push(
-      supportedEntry(
-        "comments-single-paragraph",
-        "Single-paragraph review comments stay mappable through runtime selections.",
-      ),
-    );
-  }
-  const featureEntries: CompatibilityFeatureEntry[] = [
-    ...contentFeatures,
-    ...collectPreservationFeatures(input.document),
-  ];
-  const warnings = dedupeWarnings([
-    ...(input.warnings ?? []),
-    ...collectDiagnosticWarnings(input.document),
-  ]);
-  const errors = dedupeErrors([
-    ...collectDiagnosticErrors(input.document),
-    ...(input.fatalError ? [input.fatalError] : []),
-  ]);
-
-  return {
-    reportVersion: "compatibility-report/1",
-    generatedAt: input.generatedAt,
-    blockExport:
-      featureEntries.some((entry) => entry.featureClass === "unsupported-fatal") ||
-      errors.some((error) => error.isFatal),
-    featureEntries,
-    warnings,
-    errors,
-  };
-}
-
-function hasSupportedRuntimeComments(
-  comments: CanonicalDocumentEnvelope["review"]["comments"],
-): boolean {
-  return Object.values(comments).some((comment) => comment.anchor.kind !== "detached");
-}
-
-function normalizeDocumentRoot(content: unknown): DocumentRootNode {
-  if (content && typeof content === "object" && (content as { type?: string }).type === "doc") {
-    return content as DocumentRootNode;
-  }
-
-  if (Array.isArray(content)) {
-    return {
-      type: "doc",
-      children: content.filter(
-        (value): value is DocumentRootNode["children"][number] =>
-          Boolean(value) &&
-          typeof value === "object" &&
-          ((value as { type?: string }).type === "paragraph" ||
-            (value as { type?: string }).type === "opaque_block"),
-      ),
-    };
-  }
-
-  return {
-    type: "doc",
-    children: [{ type: "paragraph", children: [] }],
-  };
-}
-
-function collectContentFeatures(
-  content: DocumentRootNode,
-): CompatibilityFeatureEntry[] {
-  const flags = {
-    paragraphs: false,
-    runs: false,
-    whitespace: false,
-    headings: false,
-    lists: false,
-    hyperlinks: false,
-    images: false,
-  };
-
-  for (let index = 0; index < content.children.length; index += 1) {
-    const block = content.children[index];
-    if (block.type !== "paragraph") {
-      continue;
-    }
-
-    flags.paragraphs = true;
-    if (block.styleId?.toLowerCase().startsWith("heading")) {
-      flags.headings = true;
-    }
-    if (block.numbering) {
-      flags.lists = true;
-    }
-
-    measureParagraph(block, flags);
-  }
-
-  const entries: CompatibilityFeatureEntry[] = [];
-  if (flags.paragraphs) {
-    entries.push(supportedEntry("paragraphs", "Paragraph structure is editable and round-trippable."));
-  }
-  if (flags.runs) {
-    entries.push(supportedEntry("runs", "Runs and inline text are editable through runtime commands."));
-  }
-  if (flags.whitespace) {
-    entries.push(supportedEntry("whitespace", "Whitespace-sensitive text units stay explicit in the runtime model."));
-  }
-  if (flags.headings) {
-    entries.push(supportedEntry("headings", "Heading styles remain attached to paragraph structure."));
-  }
-  if (flags.lists) {
-    entries.push(supportedEntry("lists", "Numbering metadata stays attached to paragraph blocks."));
-  }
-  if (flags.hyperlinks) {
-    entries.push(supportedEntry("hyperlinks", "Hyperlink relationships are preserved and re-serialized."));
-  }
-  if (flags.images) {
-    entries.push(supportedEntry("inline-images", "Inline image placements stay attached to preserved media parts."));
-  }
-  return entries;
-}
-
-function measureParagraph(
-  paragraph: ParagraphNode,
-  flags: {
-    runs: boolean;
-    whitespace: boolean;
-    hyperlinks: boolean;
-    images: boolean;
-  },
-): number {
-  let size = 0;
-  const children = Array.isArray(paragraph.children) ? paragraph.children : [];
-
-  for (const child of children) {
-    size += measureInlineNode(child, flags);
-  }
-
-  return size;
-}
-
-function measureInlineNode(
-  node: InlineNode,
-  flags: {
-    runs: boolean;
-    whitespace: boolean;
-    hyperlinks: boolean;
-    images: boolean;
-  },
-): number {
-  switch (node.type) {
-    case "text":
-      flags.runs = flags.runs || node.text.length > 0;
-      flags.whitespace =
-        flags.whitespace ||
-        /^\s/u.test(node.text) ||
-        /\s$/u.test(node.text) ||
-        node.text.includes("  ");
-      return Array.from(node.text).length;
-    case "tab":
-    case "hard_break":
-      flags.runs = true;
-      flags.whitespace = true;
-      return 1;
-    case "hyperlink":
-      flags.runs = true;
-      flags.hyperlinks = true;
-      return node.children.reduce((size, child) => size + measureInlineNode(child, flags), 0);
-    case "image":
-      flags.images = true;
-      flags.runs = true;
-      return 1;
-    case "opaque_inline":
-      flags.runs = true;
-      return 1;
-  }
-}
-
-function collectPreservationFeatures(
-  document: CanonicalDocumentEnvelope,
-): CompatibilityFeatureEntry[] {
-  const entries: CompatibilityFeatureEntry[] = [];
-
-  for (const fragment of listOpaqueFragments(document.preservation as never)) {
-    const descriptor = describeOpaqueFragment(fragment);
-    entries.push({
-      featureEntryId: `feature:${fragment.fragmentId}`,
-      featureKey: descriptor.featureKey,
-      featureClass: "preserve-only",
-      message: descriptor.label,
-      affectedAnchor: createRangeAnchor(
-        fragment.lastKnownRange.from,
-        fragment.lastKnownRange.to,
-      ),
-      details: {
-        fragmentId: fragment.fragmentId,
-        warningId: fragment.warningId,
-        detail: descriptor.detail,
-      },
-    });
-  }
-
-  for (const packagePart of listPreservedPackageParts(document.preservation as never)) {
-    entries.push({
-      featureEntryId: `feature:package:${packagePart.packagePartName}`,
-      featureKey: "unknown-package-parts",
-      featureClass: "preserve-only",
-      message: `Preserved package part ${packagePart.packagePartName}.`,
-      details: {
-        packagePartName: packagePart.packagePartName,
-        contentType: packagePart.contentType,
-        relationshipIds: packagePart.relationshipIds,
-      },
-    });
-  }
-
-  return entries;
-}
-
-function collectDiagnosticWarnings(
-  document: CanonicalDocumentEnvelope,
-): EditorWarning[] {
-  const diagnostics = Array.isArray(document.diagnostics?.warnings)
-    ? document.diagnostics.warnings
-    : [];
-
-  return diagnostics.map((warning) => ({
-    warningId: warning.warningId,
-    code:
-      warning.source === "validation" || warning.source === "export"
-        ? "export_roundtrip_risk"
-        : warning.source === "preservation"
-          ? "unsupported_ooxml_preserved"
-          : "import_normalized",
-    severity: "warning",
-    message: warning.message,
-    source: warning.source,
-  }));
-}
-
-function collectDiagnosticErrors(
-  document: CanonicalDocumentEnvelope,
-): EditorError[] {
-  const diagnostics = Array.isArray(document.diagnostics?.errors)
-    ? document.diagnostics.errors
-    : [];
-
-  return diagnostics.map((error) => ({
-    errorId: error.diagnosticId,
-    code:
-      error.code === "load_failed"
-        ? "import_failed"
-        : error.code,
-    message: error.message,
-    isFatal: error.isFatal,
-    source: error.source,
-  }));
-}
-
-function supportedEntry(
-  featureKey: CompatibilityFeatureEntry["featureKey"],
-  message: string,
-): CompatibilityFeatureEntry {
-  return {
-    featureEntryId: `feature:${featureKey}`,
-    featureKey,
-    featureClass: "supported-roundtrip",
-    message,
-  };
-}
-
-function dedupeWarnings(warnings: EditorWarning[]): EditorWarning[] {
-  const byId = new Map<string, EditorWarning>();
-
-  for (const warning of warnings) {
-    byId.set(warning.warningId, warning);
-  }
-
-  return [...byId.values()];
-}
-
-function dedupeErrors(errors: EditorError[]): EditorError[] {
-  const byId = new Map<string, EditorError>();
-
-  for (const error of errors) {
-    byId.set(error.errorId, error);
-  }
-
-  return [...byId.values()];
-}

package/src/validation/compatibility-report.ts

@@ -1,160 +0,0 @@
-import {
-  type CompatibilityDiagnostics,
-  type CompatibilityFeatureClass,
-  type CompatibilityFeatureEntry,
-  type EditorError,
-  type EditorWarning,
-  createDiagnostics,
-  diagnosticsBlockExport,
-  summarizeFeatureClasses,
-} from "./diagnostics.ts";
-
-export const COMPATIBILITY_REPORT_VERSION = "compatibility-report/1" as const;
-
-export const COMPATIBILITY_FEATURE_KEYS = [
-  "paragraphs",
-  "runs",
-  "whitespace",
-  "headings",
-  "lists",
-  "restart-numbering",
-  "tables",
-  "merged-cells",
-  "inline-images",
-  "hyperlinks",
-  "comments-single-paragraph",
-  "comment-threads",
-  "tracked-insertions",
-  "tracked-deletions",
-  "comments-multi-paragraph-ranges",
-  "tracked-moves",
-  "formatting-revisions",
-  "structural-revisions",
-  "sections",
-  "headers-footers",
-  "notes",
-  "fields",
-  "content-controls",
-  "custom-xml",
-  "alt-chunk",
-  "embedded-objects",
-  "floating-drawings",
-  "alternate-content",
-  "unknown-ooxml",
-  "unknown-package-parts",
-  "package-integrity",
-  "relationship-integrity",
-] as const;
-
-export type CompatibilityFeatureKey =
-  (typeof COMPATIBILITY_FEATURE_KEYS)[number];
-
-export interface CompatibilityReport<
-  FeatureKey extends string = CompatibilityFeatureKey,
-  FeatureClass extends CompatibilityFeatureClass = CompatibilityFeatureClass,
-> extends CompatibilityDiagnostics<FeatureKey, FeatureClass> {
-  reportVersion: typeof COMPATIBILITY_REPORT_VERSION;
-  generatedAt: string;
-  blockExport: boolean;
-}
-
-export interface CreateCompatibilityReportInput<
-  FeatureKey extends string = CompatibilityFeatureKey,
-  FeatureClass extends CompatibilityFeatureClass = CompatibilityFeatureClass,
-> extends Partial<CompatibilityDiagnostics<FeatureKey, FeatureClass>> {
-  generatedAt: string;
-  blockExport?: boolean;
-}
-
-export interface CompatibilityReportSummary {
-  generatedAt: string;
-  blockExport: boolean;
-  featureClassCounts: Record<CompatibilityFeatureClass, number>;
-  warningCount: number;
-  errorCount: number;
-}
-
-export function createCompatibilityReport<
-  FeatureKey extends string = CompatibilityFeatureKey,
-  FeatureClass extends CompatibilityFeatureClass = CompatibilityFeatureClass,
->(
-  input: CreateCompatibilityReportInput<FeatureKey, FeatureClass>,
-): CompatibilityReport<FeatureKey, FeatureClass> {
-  const diagnostics = createDiagnostics(input);
-
-  return Object.freeze({
-    reportVersion: COMPATIBILITY_REPORT_VERSION,
-    generatedAt: input.generatedAt,
-    blockExport: diagnosticsBlockExport(diagnostics, input.blockExport),
-    featureEntries: diagnostics.featureEntries,
-    warnings: diagnostics.warnings,
-    errors: diagnostics.errors,
-  });
-}
-
-export function mergeCompatibilityReports<
-  FeatureKey extends string = CompatibilityFeatureKey,
-  FeatureClass extends CompatibilityFeatureClass = CompatibilityFeatureClass,
->(
-  reports: readonly CompatibilityReport<FeatureKey, FeatureClass>[],
-  options: {
-    generatedAt: string;
-    blockExport?: boolean;
-  },
-): CompatibilityReport<FeatureKey, FeatureClass> {
-  return createCompatibilityReport({
-    generatedAt: options.generatedAt,
-    blockExport:
-      options.blockExport ?? reports.some((report) => report.blockExport),
-    featureEntries: flattenUnique(reports.flatMap((report) => report.featureEntries)),
-    warnings: flattenUnique(reports.flatMap((report) => report.warnings)),
-    errors: flattenUnique(reports.flatMap((report) => report.errors)),
-  });
-}
-
-export function summarizeCompatibilityReport<
-  FeatureKey extends string = CompatibilityFeatureKey,
-  FeatureClass extends CompatibilityFeatureClass = CompatibilityFeatureClass,
->(
-  report: CompatibilityReport<FeatureKey, FeatureClass>,
-): CompatibilityReportSummary {
-  return {
-    generatedAt: report.generatedAt,
-    blockExport: report.blockExport,
-    featureClassCounts: summarizeFeatureClasses(report.featureEntries),
-    warningCount: report.warnings.length,
-    errorCount: report.errors.length,
-  };
-}
-
-export function findFeatureEntry<
-  FeatureKey extends string = CompatibilityFeatureKey,
-  FeatureClass extends CompatibilityFeatureClass = CompatibilityFeatureClass,
->(
-  report: CompatibilityReport<FeatureKey, FeatureClass>,
-  featureEntryId: string,
-): CompatibilityFeatureEntry<FeatureKey, FeatureClass> | undefined {
-  return report.featureEntries.find(
-    (featureEntry) => featureEntry.featureEntryId === featureEntryId,
-  );
-}
-
-export type {
-  CompatibilityDiagnostics,
-  CompatibilityFeatureClass,
-  CompatibilityFeatureEntry,
-  EditorError,
-  EditorWarning,
-} from "./diagnostics.ts";
-
-function flattenUnique<Value extends { [key: string]: unknown }>(
-  items: readonly Value[],
-): readonly Value[] {
-  const deduped = new Map<string, Value>();
-
-  for (const item of items) {
-    deduped.set(JSON.stringify(item), item);
-  }
-
-  return Object.freeze([...deduped.values()]);
-}