superdoc 2.29.0 → 2.30.0-next.19

package/dist/superdoc/src/stores/helpers/comment-grouping.d.ts

@@ -23,7 +23,7 @@ type CommittedReviewPresentation = {
         resolved: readonly CommentId[];
     };
 };
-type CommittedReviewPresentations = Readonly<Record<string, CommittedReviewPresentation>>;
+type CommittedReviewPresentations = Readonly<Record<string, CommittedReviewPresentation | undefined>>;
 export declare const groupComments: <Comment extends GroupableComment>(source: readonly Comment[], isVisible: (comment: Comment) => boolean) => GroupedComments<Comment>;
 export declare const groupCommittedComments: <Comment extends GroupableComment>(comments: readonly Comment[], presentations: CommittedReviewPresentations, isVisible: (comment: Comment) => boolean) => GroupedComments<Comment>;
 export declare const hasOpenTrackedChange: ({ parentComments }: GroupedComments<GroupableComment>) => boolean;

package/dist/superdoc/src/stores/helpers/comment-identity.d.ts

@@ -23,18 +23,18 @@ type PositionMatch = {
     key: null;
     entry: null;
 };
-type CommentIdentitySources = {
-    getComments: () => CommentIdentityRow[];
-    getReviewDirectory: () => CommentIdentityRow[];
+type CommentIdentitySources<Row extends CommentIdentityRow> = {
+    getComments: () => Row[];
+    getReviewDirectory: () => Row[];
     getPositions: () => CommentPositions | null | undefined;
 };
-type CommentReference = CommentIdentityRow | string | number | null | undefined;
+type CommentReference<Row extends CommentIdentityRow> = Row | string | number | null | undefined;
 export declare const trackedChangeThreadParentIdForComment: (comment: CommentIdentityRow | null | undefined) => unknown;
-export declare const createCommentIdentity: ({ getComments, getReviewDirectory, getPositions }: CommentIdentitySources) => {
-    getComment: (id: unknown) => CommentIdentityRow | null;
-    getThreadParent: (comment: CommentIdentityRow | null | undefined) => CommentIdentityRow | null | undefined;
-    getCommentPositionKey: (commentOrId: CommentIdentityRow | string | null | undefined) => unknown;
-    getCommentAliasIds: (commentOrId: CommentReference) => string[];
-    resolveCommentPositionEntry: (commentOrId: CommentReference, preferredId?: unknown) => PositionMatch;
+export declare const createCommentIdentity: <Row extends CommentIdentityRow>({ getComments, getReviewDirectory, getPositions, }: CommentIdentitySources<Row>) => {
+    getComment: (id: unknown) => Row | null;
+    getThreadParent: (comment: Row | null | undefined) => Row | null | undefined;
+    getCommentPositionKey: (commentOrId: Row | string | null | undefined) => unknown;
+    getCommentAliasIds: (commentOrId: CommentReference<Row>) => string[];
+    resolveCommentPositionEntry: (commentOrId: CommentReference<Row>, preferredId?: unknown) => PositionMatch;
 };
 export {};

package/dist/superdoc/src/stores/helpers/pending-selection-snapshot.d.ts

@@ -1,11 +1,11 @@
-export type PendingSelectionHost = {
+export type PendingSelectionHost<Snapshot = unknown> = {
     activeEditor?: {
         options?: {
             documentId?: unknown;
         } | null;
         doc?: {
             selection?: {
-                current?: () => unknown;
+                current?: () => Snapshot | PromiseLike<Snapshot>;
             } | null;
         } | null;
     } | null;
@@ -14,4 +14,4 @@ export type PendingActiveSelection = {
     source?: unknown;
     documentId?: unknown;
 } | null | undefined;
-export declare const getPendingSelectionSnapshot: (superdoc: PendingSelectionHost, activeSelection: PendingActiveSelection) => unknown;
+export declare const getPendingSelectionSnapshot: <Snapshot>(superdoc: PendingSelectionHost<Snapshot>, activeSelection: PendingActiveSelection) => Snapshot | Promise<Snapshot | null> | null;

package/dist/superdoc/src/stores/helpers/review-presentation.d.ts

@@ -0,0 +1,91 @@
+type CommentId = string | number;
+export type ReviewCoordinate = {
+    documentEpoch: string;
+    mountId: string;
+    commitSequence: number;
+    reviewVersion: number;
+};
+export type ReviewPositionEntry = {
+    pageIndex?: number | null;
+    bounds?: {
+        top?: number;
+        bottom?: number;
+    } | null;
+};
+export type ReviewInstance = {
+    id: string;
+    rowId: string;
+    threadId: string;
+    pageIndex: number | null;
+    positionKey: string | null;
+    positionEntry: ReviewPositionEntry | null;
+    anchorTop: number;
+    anchorBottom: number;
+    top: number;
+    height: number;
+    provisional?: boolean;
+    isPrimary: boolean;
+    isOffscreenReviewCard: boolean;
+    mount: boolean;
+};
+export type DecisionContinuityRequest = ReviewCoordinate & {
+    removedInstanceId: string;
+    removedRowVersion: number;
+    targetInstanceId: string;
+    targetRowVersion: number;
+    top: number;
+};
+export type ViewportRange = {
+    top: number;
+    bottom: number;
+};
+export type ReviewViewport = ViewportRange & {
+    width: number;
+    scale: number;
+    stageOffsetX: number;
+    stageOffsetY: number;
+};
+export type ReviewContextInput = {
+    decisionContinuity: DecisionContinuityRequest | null;
+    activeThreadId: string | null;
+    activeInstanceId: string | null;
+    editingRowId: string | null;
+    retainedThreadIds: string[];
+    visibility: {
+        comments: boolean;
+        trackedChanges: boolean;
+    };
+    viewport: ReviewViewport;
+    pending: {
+        anchorTop: number | null;
+        height: number;
+    } | null;
+    measurements: {
+        instanceId: string;
+        rowVersion: number;
+        height: number;
+        fontRevision?: number;
+    }[];
+};
+export type CommittedReviewPresentation = {
+    catalogVersion?: number;
+    epoch: string;
+    baseVersion: number;
+    version: number;
+    unchanged: boolean;
+    fontRevision?: number;
+    coordinate: ReviewCoordinate;
+    instances: ReviewInstance[];
+    rowVersions: Record<string, number | undefined>;
+    groupOrder: {
+        open: readonly CommentId[];
+        resolved: readonly CommentId[];
+    };
+    readPaintOrigin?: () => {
+        left: number;
+        top: number;
+    } | null;
+    readFontRevision?: () => number;
+    updateContext: (input: ReviewContextInput, readViewport?: () => ReviewViewport | null) => void;
+};
+export {};

package/dist/superdoc/src/stores/helpers/tracked-change-identity.d.ts

@@ -1,9 +1,11 @@
-import { BodyStoryLocator } from '../../../../document-api/src/index.js';
 type TrackedChangeAnchorParts = {
     storyKey: string;
     rawId: string;
 };
-export declare const BODY_TRACKED_CHANGE_STORY: BodyStoryLocator;
+export declare const BODY_TRACKED_CHANGE_STORY: {
+    kind: "story";
+    storyType: "body";
+};
 export declare const normalizeCommentId: (id: unknown) => string | null;
 export declare const makeTrackedChangeAnchorKey: ({ storyKey, rawId }: TrackedChangeAnchorParts) => string;
 export declare const isBodyTrackedChangeComment: (comment: unknown) => boolean;

package/dist/superdoc/src/stores/helpers/tracked-change-row-values.d.ts

@@ -1,16 +1,9 @@
 import { TrackChangeCustomAttribute } from '../../../../document-api/src/index.js';
+import { TrackedChangeRowImagePreview } from '../../components/CommentsLayer/comment-params.js';
 type TrackedChangeDetailLine = {
     excerpt: string;
     label: string;
 };
-type TrackedChangeRowImagePreview = {
-    src: string;
-    contentType?: string;
-    role?: string;
-    width?: number;
-    height?: number;
-    alt: string;
-};
 export declare const shallowEqual: (a: unknown, b: unknown) => boolean;
 export declare const normalizeTrackedChangeDetailLines: (lines: unknown) => TrackedChangeDetailLine[] | null;
 export declare const trackedChangeDetailLinesEqual: (a: unknown, b: unknown) => boolean;

package/dist/superdoc/src/stores/helpers/tracked-change-thread-index.d.ts

@@ -20,6 +20,6 @@ export declare const trackedChangeRowSideGroup: (comment: {
     semanticColorKey?: string | null;
 }) => TrackedChangeSideGroup | null;
 export declare const buildTrackedChangeThreadOwnerIndex: <Comment extends TrackedChangeThreadOwnerFields>(allComments: ReadonlyArray<Comment>) => Map<Comment, Comment>;
-export declare const buildTrackedChangeThreadIndex: <Comment extends TrackedChangeThreadFields>(allComments: ReadonlyArray<Comment>, previous?: ReadonlyMap<CommentId, ReadonlyArray<Comment>>) => Map<CommentId, ReadonlyArray<Comment>>;
+export declare const buildTrackedChangeThreadIndex: <Comment extends TrackedChangeThreadFields>(allComments: ReadonlyArray<Comment>, previous?: ReadonlyMap<Comment["commentId"], ReadonlyArray<Comment>>) => Map<Comment["commentId"], ReadonlyArray<Comment>>;
 export declare const buildTrackedChangeDecisionLinkIndex: <Comment extends TrackedChangeLinkFields>(allComments: ReadonlyArray<Comment>, previous?: ReadonlyMap<string, ReadonlyArray<Comment>>) => Map<string, ReadonlyArray<Comment>>;
 export {};

package/dist/superdoc/src/stores/helpers/v2-review-adapters.d.ts

@@ -0,0 +1,148 @@
+import { SelectionInfo } from '../../../../document-api/src/index.js';
+import { CommentInputParams } from '../../components/CommentsLayer/comment-params.js';
+import { StoryLocator } from '../../core/types/index.js';
+import { TrackedChangeDecisionOutcome } from './tracked-change-decision.js';
+export type V2CommentMention = {
+    id?: string | null;
+    name?: string | null;
+    email?: string | null;
+};
+export type V2CommentMutationOutcome = {
+    ok: boolean;
+    items?: unknown[];
+    reason?: string;
+    code?: string;
+    detail?: unknown;
+    committed?: boolean;
+    complete?: boolean;
+    visibleWindowSource?: string;
+    threadLifecycle?: {
+        commentId: string;
+        status: 'open' | 'resolved';
+    };
+    removedCommentIds?: string[];
+    createdCommentId?: string;
+    mutationPath?: string;
+};
+export type V2CommentsCapabilityState = {
+    canWrite?: boolean;
+    reason?: string | null;
+};
+export type V2CommentSelectionCapture = {
+    ok: boolean;
+    target?: unknown;
+    reason?: string;
+    detail?: unknown;
+};
+export type V2ReviewCatalogSeedResult = {
+    ok: boolean;
+    reason?: string;
+};
+export type V2VisibleReviewComments = {
+    ok: boolean;
+    items?: unknown[];
+    unresolvedIds?: string[];
+    reason?: string;
+};
+export type V2ReviewAdapterDocumentId = string | number | null;
+export type V2CommentInputOptions = {
+    fileId: V2ReviewAdapterDocumentId;
+    fileType: string | null;
+};
+export interface V2CommentsAdapter {
+    documentId?: V2ReviewAdapterDocumentId;
+    setActiveComment(commentId: string | null): Promise<V2CommentMutationOutcome>;
+    commitPendingComment(input: {
+        text: string;
+        target?: unknown;
+        mentions?: readonly V2CommentMention[];
+    }): Promise<V2CommentMutationOutcome>;
+    reply(input: {
+        parentCommentId: string;
+        text: string;
+        mentions?: readonly V2CommentMention[];
+    }): Promise<V2CommentMutationOutcome>;
+    edit(input: {
+        commentId: string;
+        text: string;
+    }): Promise<V2CommentMutationOutcome>;
+    resolve(input: {
+        commentId: string;
+    }): Promise<V2CommentMutationOutcome>;
+    reopen(input: {
+        commentId: string;
+    }): Promise<V2CommentMutationOutcome>;
+    delete(input: {
+        commentId: string;
+    }): Promise<V2CommentMutationOutcome>;
+    mapV2CommentToUseCommentInput(item: unknown, options: V2CommentInputOptions): CommentInputParams | null;
+    getCapabilityState?(command?: string | null): V2CommentsCapabilityState | null | undefined;
+    captureCurrentSelection?(options?: {
+        beforeReady?: (snapshot: SelectionInfo) => void | Promise<void>;
+    }): Promise<V2CommentSelectionCapture>;
+    isPendingCommentCreation?(commentId: string | undefined): boolean;
+    seedReviewCatalog?(items: unknown[], metadata?: {
+        sourceCoverageRevision?: string;
+        evaluatedRevision?: string;
+    }): V2ReviewCatalogSeedResult;
+    selectVisibleReviewComments?(): V2VisibleReviewComments | PromiseLike<V2VisibleReviewComments>;
+}
+export type V2TrackedChangeDecisionResult = TrackedChangeDecisionOutcome & {
+    ok: boolean;
+    reason?: string;
+    detail?: unknown;
+    documentId?: string | null;
+};
+export type V2TrackedChangeCommentParams = {
+    event?: string | null;
+    changeId?: string | number | null;
+    documentId?: V2ReviewAdapterDocumentId;
+    trackedChangeText?: string | null;
+    trackedChangeType?: string | null;
+    trackedChangeDisplayType?: string | null;
+    semanticColorKey?: string | null;
+    semanticColor?: string | null;
+    deletedText?: string | null;
+    trackedChangeLabel?: string | null;
+    trackedChangeDetailLines?: unknown;
+    trackedChangeImagePreview?: unknown;
+    customAttributes?: unknown;
+    authorId?: string | null;
+    authorEmail?: string | null;
+    authorImage?: string | null;
+    author?: string | null;
+    date?: number;
+    importedAuthor?: CommentInputParams['importedAuthor'];
+    importedId?: string | number | null;
+    coords?: NonNullable<CommentInputParams['selection']>['selectionBounds'];
+    trackedChangeStory?: StoryLocator | null;
+    trackedChangeStoryKind?: string | null;
+    trackedChangeStoryLabel?: string;
+    trackedChangeAnchorKey?: string | null;
+    trackedChangeCanonicalId?: string | null;
+    trackedChangePositionAliases?: unknown;
+    resolvedById?: string | null;
+    resolvedByEmail?: string | null;
+    resolvedByName?: string | null;
+    decision?: 'accept' | 'reject' | null;
+    reason?: string;
+};
+export interface V2TrackedChangesAdapter {
+    documentId?: V2ReviewAdapterDocumentId;
+    accept(target: unknown): Promise<V2TrackedChangeDecisionResult>;
+    reject(target: unknown): Promise<V2TrackedChangeDecisionResult>;
+    mapV2TrackedChangeToCommentParams(item: unknown): V2TrackedChangeCommentParams | null;
+    clearActiveTrackedChangeTargetIfMatches?(decidedId: string): unknown;
+}
+type MethodKeys<Adapter> = Exclude<keyof Adapter, 'documentId'>;
+export type RequiredMethodKeys<Adapter> = {
+    [Member in MethodKeys<Adapter>]-?: undefined extends Adapter[Member] ? never : Member;
+}[MethodKeys<Adapter>];
+export type OptionalMethodKeys<Adapter> = Exclude<MethodKeys<Adapter>, RequiredMethodKeys<Adapter>>;
+export declare const COMMENTS_ADAPTER_METHODS: readonly ["setActiveComment", "commitPendingComment", "reply", "edit", "resolve", "reopen", "delete", "mapV2CommentToUseCommentInput"];
+export declare const COMMENTS_ADAPTER_OPTIONAL_METHODS: readonly ["getCapabilityState", "captureCurrentSelection", "isPendingCommentCreation", "seedReviewCatalog", "selectVisibleReviewComments"];
+export declare const TRACKED_CHANGES_ADAPTER_METHODS: readonly ["accept", "reject", "mapV2TrackedChangeToCommentParams"];
+export declare const TRACKED_CHANGES_ADAPTER_OPTIONAL_METHODS: readonly ["clearActiveTrackedChangeTargetIfMatches"];
+export declare function isV2CommentsAdapter(value: unknown): value is V2CommentsAdapter;
+export declare function isV2TrackedChangesAdapter(value: unknown): value is V2TrackedChangesAdapter;
+export {};