@rhc-office/sdk 6.6.268 → 6.6.363

package/src/api/annotation-tool.ts

@@ -1,199 +1,316 @@
-export type AnnotationSubject =
-  | 'InkAnnotation'
-  | 'HighlightAnnotation'
-  | 'UnderlineAnnotation'
-  | 'StrikeoutAnnotation'
-  | 'StampAnnotation'
-  | 'TextAnnotation'
-  | 'TemplateSignMarker'
-  | 'DigitalRedaction';
-
-export interface IDigitalAnnotationInfo {
-  author: string;
-  customData: string;
-  digest: string;
-  creationDate: Date;
-  pageIndex: number;
-  pageX: number;
-  pageY: number;
+export type AnnotationMode =
+  | 'none'
+  | 'select'
+  | 'pen'
+  | 'eraser'
+  | 'line'
+  | 'arrow'
+  | 'rectangle'
+  | 'circle'
+  | 'text-highlight'
+  | 'text-underline'
+  | 'text-strikethrough'
+  | 'text-squiggly'
+  | 'text-note'
+  | 'stamp';
+
+export type AnnotationViewPenType = AnnotationMode;
+
+export type AnnotationTextMarkupType = 'highlight' | 'underline' | 'strikethrough' | 'squiggly';
+
+export type AnnotationShapeType = 'line' | 'arrow' | 'rectangle' | 'ellipse';
+
+export type AnnotationPresetStampType =
+  | 'approved'
+  | 'rejected'
+  | 'pending'
+  | 'draft'
+  | 'final'
+  | 'completed'
+  | 'void'
+  | 'confidential'
+  | 'urgent'
+  | 'received'
+  | 'archived'
+  | 'copy';
+
+export type AnnotationStampSourceType = 'preset' | 'text' | 'image';
+
+export type AnnotationStampShape = 'rectangle' | 'rounded-rectangle' | 'ellipse' | 'circle';
+
+export interface AnnotationTextMarkupOptions {
+  type?: AnnotationTextMarkupType;
+  color?: string;
+  opacity?: number;
+  lineWidth?: number;
+  highlightStyle?: 'solid' | 'gradient' | 'translucent';
+  squigglyStyle?: 'wave' | 'zigzag' | 'sine' | 'sawtooth';
 }
 
-export interface IDigitalAnnotationOptions {
-  author: string;
-  penColor?: string;
-  penWidth?: number;
-  customData?: string;
+export interface AnnotationShapeOptions {
+  type?: AnnotationShapeType;
+  color?: string;
+  strokeWidth?: number;
+  opacity?: number;
+  fillColor?: string;
+  fillOpacity?: number;
+  fillEnabled?: boolean;
 }
 
-export interface ITextAnnotationInfo {
-  content: string;
-  pageIndex: number;
-  x: number;
-  y: number;
-  width: number;
-  height: number;
+export interface AnnotationPresetStampOptions {
+  sourceType: 'preset';
+  presetType: AnnotationPresetStampType;
+  customColor?: string;
+  customText?: string;
 }
 
-export interface AnnotationQueryParams {
-  batchId?: string;
-  batchIdSet?: string[];
-  author?: string;
-  authorNull?: 'undefined' | 'defined';
-  userName?: string;
-  userNameNull?: 'undefined' | 'defined';
-  userId?: string;
-  userIdNull?: 'undefined' | 'defined';
-  customData?: string;
-  customDataNull?: 'undefined' | 'defined';
-  pageIndex?: number;
-  pageRange?: number[];
-  subject?: AnnotationSubject;
-  locked?: boolean;
-  creationDateBefore?: Date;
-  creationDateAfter?: Date;
-  creationDateEquals?: Date;
-
-  parseSKQueryParams(query: string): void;
-
-  convertSKAnnotationTypeToSubject(skType: string): AnnotationSubject;
-
-  subjectEquals(subject: AnnotationSubject): AnnotationQueryParams;
-
-  batchIdEquals(batchId: string): AnnotationQueryParams;
-
-  batchIdInSet(batchIds: string[]): AnnotationQueryParams;
-
-  authorEquals(author: string): AnnotationQueryParams;
-
-  authorIsNull(): AnnotationQueryParams;
-
-  authorIsNotNull(): AnnotationQueryParams;
+export interface AnnotationTextStampOptions {
+  sourceType: 'text';
+  text: string;
+  fontFamily?: string;
+  fontSize?: number;
+  fontBold?: boolean;
+  textColor?: string;
+  backgroundColor?: string;
+  borderColor?: string;
+  borderWidth?: number;
+  shape?: AnnotationStampShape;
+  cornerRadius?: number;
+  padding?: number;
+}
 
-  userNameEquals(userName: string): AnnotationQueryParams;
+export interface AnnotationImageStampOptions {
+  height?: number;
+  sourceType: 'image';
+  imageData: string;
+  mimeType?: string;
+  naturalHeight?: number;
+  naturalWidth?: number;
+  preserveAspectRatio?: boolean;
+  width?: number;
+}
 
-  userNameIsNull(): AnnotationQueryParams;
+export type AnnotationStampOptions =
+  | AnnotationPresetStampOptions
+  | AnnotationTextStampOptions
+  | AnnotationImageStampOptions;
+
+export interface AnnotationCustomTextStampInput {
+  fontFamily?: string;
+  fontSize: number;
+  name?: string;
+  text: string;
+  textColor: string;
+}
 
-  userNameIsNotNull(): AnnotationQueryParams;
+export interface AnnotationCustomImageStampInput {
+  height?: number;
+  imageData: string;
+  mimeType?: string;
+  name?: string;
+  naturalHeight: number;
+  naturalWidth: number;
+  width?: number;
+}
 
-  userIdEquals(userId: string): AnnotationQueryParams;
+export interface AnnotationCustomStampRecord {
+  id: string;
+  name: string;
+  stamp: AnnotationStampOptions;
+  type: 'image' | 'text';
+}
 
-  userIdIsNull(): AnnotationQueryParams;
+export interface AnnotationTextBoxOptions {
+  text?: string;
+  fontFamily?: string;
+  fontSize?: number;
+  fontWeight?: 'normal' | 'bold';
+  fontStyle?: 'normal' | 'italic';
+  fontColor?: string;
+  backgroundColor?: string;
+  backgroundOpacity?: number;
+  borderColor?: string;
+  borderWidth?: number;
+  borderRadius?: number;
+  padding?: number;
+  lineHeight?: number;
+  letterSpacing?: number;
+  firstLineIndentEnabled?: boolean;
+  firstLineIndentChars?: number;
+  captionSeal?: string;
+  captionName?: string;
+  captionShowDate?: boolean;
+}
 
-  userIdIsNotNull(): AnnotationQueryParams;
+export type LegacyAnnotationPenType =
+  | AnnotationViewPenType
+  | 'draw'
+  | 'highlight'
+  | 'text'
+  | 'markup';
 
-  customDataEquals(customData: string): AnnotationQueryParams;
+export interface AnnotationViewOptions<TPenType extends string = AnnotationViewPenType> {
+  penType?: TPenType;
+  penColor?: string;
+  penWidth?: number;
+  textSize?: number;
+  textColor?: string;
+  textFont?: '仿宋' | '楷体' | '黑体' | string;
+  textMarkup?: AnnotationTextMarkupOptions;
+  shape?: AnnotationShapeOptions;
+  stamp?: AnnotationStampOptions;
+  textBox?: AnnotationTextBoxOptions;
+}
 
-  customDataIsNull(): AnnotationQueryParams;
+export interface LegacyAnnotationViewOptions extends AnnotationViewOptions<LegacyAnnotationPenType> {
+  penType?: LegacyAnnotationPenType;
+}
 
-  customDataIsNotNull(): AnnotationQueryParams;
+export interface AnnotationPenStyleOptions {
+  penTipStyle?: 'round' | 'tapered';
+  pressureSensitivity?: boolean;
+}
 
-  pageIndexEquals(pageIndex: number): AnnotationQueryParams;
+export interface AnnotationToolSelectOptions {
+  stamp?: AnnotationStampOptions;
+}
 
-  pageRangeEquals(fromPage: number, toPage: number): AnnotationQueryParams;
+export type AnnotationType =
+  | 'drawing'
+  | 'shape'
+  | 'text-markup'
+  | 'text-redaction'
+  | 'text-note'
+  | 'stamp';
 
-  isLocked(): AnnotationQueryParams;
+export type AnnotationState = 'creating' | 'created' | 'editing' | 'selected' | 'hidden';
 
-  isNotLocked(): AnnotationQueryParams;
+export type AnnotationGeometryUnit = 'mm' | 'pt';
 
-  creationDateIsBefore(before: Date): AnnotationQueryParams;
+export interface AnnotationAuthor {
+  id: string;
+  name: string;
+  avatar?: string;
+  color?: string;
+}
 
-  creationDateIsAfter(after: Date): AnnotationQueryParams;
+export interface AnnotationStyle {
+  strokeColor?: number;
+  strokeWidth?: number;
+  strokeOpacity?: number;
+  fillColor?: number;
+  fillOpacity?: number;
+  dashArray?: readonly [number, number];
+  lineCap?: 'butt' | 'round' | 'square';
+  lineJoin?: 'miter' | 'round' | 'bevel';
+  pressureSensitivity?: boolean;
+}
 
-  creationDateIsEquals(date: Date): AnnotationQueryParams;
+export interface AnnotationGeometry {
+  unit?: AnnotationGeometryUnit;
+  [property: string]: unknown;
 }
 
-export interface AnnotationRawData {
-  annotationData: Blob;
-  previews: {
-    imageBuffer: Blob;
-    boundary: {
-      x: number;
-      y: number;
-      width: number;
-      height: number;
-    };
-    pageIndex: number;
-  };
+export interface AnnotationRecord {
+  id: string;
+  type?: AnnotationType;
+  pageRange?: readonly [number, number];
+  createdAt?: number;
+  modifiedAt?: number;
+  author?: AnnotationAuthor;
+  state?: AnnotationState;
+  zIndex?: number;
+  visible?: boolean;
+  locked?: boolean;
+  persisted?: boolean;
+  customData?: Record<string, unknown>;
+  tool?: string;
+  style?: AnnotationStyle;
+  geometry?: AnnotationGeometry;
+  [property: string]: unknown;
 }
 
-export interface AnnotationTool {
-  setToolSource(source: 'stylus' | 'auto'): void;
+export interface AnnotationChangePayload {
+  annotationId?: string;
+  annotation?: AnnotationRecord;
+}
 
-  openAnnotationView(options?: any): void;
+export type AnnotationEventName =
+  | 'annotationAdded'
+  | 'annotationRemoved'
+  | 'annotationUpdated'
+  | 'annotationModeChange'
+  | 'annotationInputDeviceChange'
+  | 'annotationEvent';
 
-  closeAnnotationView(saveModifications: boolean): void;
+export type AnnotationEventPayload = AnnotationChangePayload | Record<string, unknown>;
 
-  openTextAnnotationView(): void;
+export type AnnotationEventCallback = (
+  event: AnnotationEventName | string,
+  payload?: AnnotationEventPayload,
+) => void;
 
-  setTextAnnotationFontColor(color: string): void;
+export interface IDigitalAnnotationInfo {
+  author: string;
+  customData: string;
+  digest: string;
+  creationDate: Date;
+  pageIndex: number;
+  pageX: number;
+  pageY: number;
+}
 
-  setTextAnnotationFontSize(size: number): void;
+export interface ITextAnnotationInfo {
+  content: string;
+  pageIndex: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
 
-  closeTextAnnotationView(saveModifications: boolean): void;
+export type AnnotationHistoryCommandResult = boolean | Promise<boolean>;
 
-  createTextAnnotation(options: any): void;
+export interface AnnotationTool {
+  openAnnotationView(options?: LegacyAnnotationViewOptions): void;
 
-  setPersistToDocument(persist?: boolean): void;
+  closeAnnotationView(): void;
 
   saveAnnotations(saveCallback?: () => void): void;
 
-  saveTextAnnotations(): void;
+  clearAnnotations(): AnnotationHistoryCommandResult;
 
-  clearAnnotations(): void;
+  undoAnnotation(): AnnotationHistoryCommandResult;
 
-  clearTextAnnotations(): void;
+  redoAnnotation(): AnnotationHistoryCommandResult;
 
-  undoAnnotation(): void;
+  canUndoAnnotation(): AnnotationHistoryCommandResult;
 
-  redoAnnotation(): void;
+  canRedoAnnotation(): AnnotationHistoryCommandResult;
 
-  selectAnnotationTool(tool: string): void;
+  selectAnnotationTool(tool: AnnotationMode, options?: AnnotationToolSelectOptions): void;
 
-  showAnnotationColorPicker(): void;
+  selectAnnotationStamp(stamp: AnnotationStampOptions): void;
 
-  setAnnotationPenType(penType: string): void;
+  getCustomStamps(): Promise<AnnotationCustomStampRecord[]>;
 
-  appendAnnotations(inkData: Blob, callback?: (event: { error: string } | 'ok') => void): void;
+  addCustomTextStamp(input: AnnotationCustomTextStampInput): Promise<AnnotationCustomStampRecord>;
 
-  batchAppendAnnotations(inkData: Blob[], callback?: (event: { error: string } | 'ok') => void): void;
+  addCustomImageStamp(input: AnnotationCustomImageStampInput): Promise<AnnotationCustomStampRecord>;
 
   setAnnotationPenColor(hexColor: string): void;
 
   setAnnotationPenWidth(penWidth: number): void;
 
-  setAnnotationPenThickness(thickness: number): void;
-
-  enableAnnotationsInfoView(enabled: boolean): void;
-
-  enableAnnotationsDeletion(enabled: boolean): void;
-
-  enableAnnotationsDeletionOnlyByAuthor(onlyByAuthor: boolean): void;
-
-  listDigitalStamps(): void;
+  setAnnotationPenStyle(options: AnnotationPenStyleOptions): void;
 
   isInAnnotationMode(): boolean;
 
-  listAnnotations(options?: any): void;
+  getAnnotationMode(): AnnotationMode;
 
-  getAnnotations(): any[];
+  getAnnotations(): AnnotationRecord[];
 
   getAnnotationsCount(): number;
 
-  queryAnnotationsBy(query?: AnnotationQueryParams): any[];
-
-  deleteAnnotationsBy(query?: AnnotationQueryParams, prompt?: boolean): void;
-
-  deleteAnnotationsById(annotationIds?: string[], prompt?: boolean): void;
-
-  addDigitalAnnotation(options: void | unknown): void;
-
-  addInkAnnotationCallback(callback: (event: any) => void): void;
-
-  addAnnotationEventCallback(callback: (event: string, payload: any) => void): void;
-
-  addAnnotationPersistCallback(callback: (event: any) => void): void;
-
-  addAnnotationRetrieveCallback(callback: (event: any) => void): void;
-
-  addDigitalAnnotationRetrieveCallback(callback: (annotations: IDigitalAnnotationInfo[]) => void): void;
+  addAnnotationEventCallback(callback: AnnotationEventCallback): void;
 }

package/src/api/callbacks.ts

@@ -1,20 +1,63 @@
-import { IDigitalAnnotationInfo, ITextAnnotationInfo } from './annotation-tool';
+import {
+  type AnnotationEventCallback,
+  type AnnotationEventName,
+  type AnnotationEventPayload,
+  IDigitalAnnotationInfo,
+  ITextAnnotationInfo,
+} from './annotation-tool';
+
+export type { AnnotationEventCallback, AnnotationEventName, AnnotationEventPayload };
 
 export type ReaderReadyCallback = () => void;
 export type ReaderUnloadCallback = () => void;
 
-export type DocumentOpenedCallback = (status: string, error?: any, docInfo?: any) => void;
+export interface DocumentReaderStatus {
+  currentPage?: number;
+  documentType?: string;
+  totalPages?: number;
+  zoomLevel?: number;
+}
 
-export type DocumentSavedCallback = (response?: any) => void;
+export interface DocumentOpenResult {
+  error?: string;
+  state?: DocumentReaderStatus;
+  status?: string;
+  success: boolean;
+}
 
-export type DocumentModifiedCallback = (documentInfo: any) => boolean;
+export interface DocumentSaveResult extends Record<string, unknown> {
+  error?: string;
+  savedContentType?: string;
+  success: boolean;
+}
+
+export interface DocumentContentResult {
+  fileBuffer?: ArrayBuffer;
+  fileCacheId?: string;
+}
+
+export interface DocumentCloseResult {
+  closed: boolean;
+  error?: string;
+  success: boolean;
+}
+
+export type DocumentOpenedCallback = (
+  status: string,
+  error?: string,
+  docInfo?: DocumentOpenResult,
+) => void;
+
+export type DocumentSavedCallback = (response?: DocumentSaveResult) => void;
+
+export type DocumentModifiedCallback = (documentInfo: DocumentOpenResult) => boolean;
 
 export interface IDocumentCloseEvent {
   docId: string;
   docTitle: string;
 }
 
-export type DocumentClosedCallback = (payload?: any) => void;
+export type DocumentClosedCallback = (payload?: DocumentCloseResult) => void;
 
 export type PageChangeCallback = (pageIndex: number, pageCount: number) => void;
 
@@ -26,8 +69,6 @@ export type PageModeChangeCallback = (pageMode: number) => void;
 
 export type AnnotationSaveCallback = () => void;
 
-export type AnnotationEventCallback = (event: string, payload: any) => void;
-
 export type DigitalSignCallback = (response: any) => void;
 
 export type DigitalAnnotationRetrieveCallback = (

package/src/api/document-sdk.ts

@@ -3,6 +3,7 @@ import { ReaderReadyCallback, ReaderUnloadCallback } from './callbacks';
 import { DocumentTool } from './document-tool';
 import { AnnotationTool } from './annotation-tool';
 import { UITool } from './ui-tool';
+import { PageArrangeTool } from './page-arrange-tool';
 import { PageTool } from './page-tool';
 import { FindTool } from './find-tool';
 import { DigitalSignTool } from './sign-tool';
@@ -12,6 +13,7 @@ import { SymbologyTool } from './symbology-tool';
 import { TemplateSignTool } from './template-sign';
 import { PdfFormFiller } from './pdf-formfiller';
 import { CryptoTool } from './crypto-tool';
+import { SecurityTool } from './security-tool';
 
 export interface IReaderEmbedOptions {
   debug?: boolean;
@@ -29,10 +31,6 @@ export interface IReaderEmbedOptions {
    * View: 阅读模式，Annotation: 批注模式，DigitalSign: 签章模式
    */
   viewMode: string;
-  /**
-   * 签章功能：Server: 服务器签章，Extension: 浏览器控件签章
-   */
-  signMode?: 'Extension' | 'Server';
   /**
    * 是否显示菜单
    */
@@ -69,12 +67,14 @@ export interface IReaderEmbedOptions {
   height?: string;
 }
 
+export type ReaderThemeMode = 'light' | 'dark' | 'high-contrast' | 'auto';
+
 export interface IDocumentSDK {
   enableDebug(debug: boolean): void;
 
   changeLanguage(lang: string): void;
 
-  setLicense(license: string, feature: string): void;
+  setThemeMode(theme: ReaderThemeMode): void;
 
   setSessionUser(
     userNameOrInfo:
@@ -115,6 +115,8 @@ export interface IDocumentSDK {
 
   getPageTool(): PageTool;
 
+  getPageArrangeTool(): PageArrangeTool;
+
   getFindTool(): FindTool;
 
   getSignServerTool(): SignServerTool;
@@ -133,6 +135,8 @@ export interface IDocumentSDK {
 
   getCryptoTool(): CryptoTool;
 
+  getSecurityTool(): SecurityTool;
+
   createDigitalSignOptions(): IDigitalSignOptions;
 
   createKVField(key: string, value: string, description?: string): IKVField;

package/src/api/document-tool.ts

@@ -1,4 +1,10 @@
-import { DocumentClosedCallback, DocumentSavedCallback } from './callbacks';
+import {
+  DocumentClosedCallback,
+  DocumentContentResult,
+  DocumentOpenedCallback,
+  DocumentOpenResult,
+  DocumentSavedCallback,
+} from './callbacks';
 
 export type IFileSaveFormat = 'pdf' | 'png' | 'jpeg' | 'jpg' | 'tiff';
 
@@ -22,6 +28,9 @@ export interface IFileOpenOptions {
     fontSize: number;
   };
   uploadUrl?: string;
+  headers?: Record<string, string>;
+  formData?: Record<string, string | number | boolean>;
+  fileFieldName?: string;
   readOnly?: boolean;
   fromCache?: boolean;
   viewMode?: 'view' | 'annotation' | 'digital-sign';
@@ -50,26 +59,34 @@ export interface IFileSaveResult {
   error?: string;
 }
 
+export interface DocumentCreatePreviewOptions extends Record<string, unknown> {
+  fileId?: string;
+}
+
+export type DocumentOpenCallback = (event: DocumentOpenResult) => void;
+
+export type DocumentContentCallback = (result: DocumentContentResult) => void;
+
 export interface DocumentTool {
-  addDocumentOpenedCallback(callback: (status: string, error: string) => void): void;
+  addDocumentOpenedCallback(callback: DocumentOpenedCallback): void;
 
   addDocumentSavedCallback(callback: DocumentSavedCallback): void;
 
   addDocumentClosedCallback(callback: DocumentClosedCallback): void;
 
-  openPDFDocument(options: IFileOpenOptions, onDocumentOpened?: (event: any) => void): void;
+  openPDFDocument(options: IFileOpenOptions, onDocumentOpened?: DocumentOpenCallback): void;
 
-  openPdfDocument(options: IFileOpenOptions, onDocumentOpened?: (event: any) => void): void;
+  openPdfDocument(options: IFileOpenOptions, onDocumentOpened?: DocumentOpenCallback): void;
 
-  openOFDDocument(options: IFileOpenOptions, onDocumentOpened?: (event: any) => void): void;
+  openOFDDocument(options: IFileOpenOptions, onDocumentOpened?: DocumentOpenCallback): void;
 
-  openOfdDocument(options: IFileOpenOptions, onDocumentOpened?: (event: any) => void): void;
+  openOfdDocument(options: IFileOpenOptions, onDocumentOpened?: DocumentOpenCallback): void;
 
-  openOfficeDocument(options: IFileOpenOptions, onDocumentOpened?: (event: any) => void): void;
+  openOfficeDocument(options: IFileOpenOptions, onDocumentOpened?: DocumentOpenCallback): void;
 
-  openImageDocument(options: IFileOpenOptions, onDocumentOpened?: (event: any) => void): void;
+  openImageDocument(options: IFileOpenOptions, onDocumentOpened?: DocumentOpenCallback): void;
 
-  openTextDocument(options: IFileOpenOptions, onDocumentOpened?: (event: any) => void): void;
+  openTextDocument(options: IFileOpenOptions, onDocumentOpened?: DocumentOpenCallback): void;
 
   openFromLocalStorage(): void;
 
@@ -83,9 +100,7 @@ export interface DocumentTool {
 
   saveAs(options?: IFileSaveOptions): Promise<IFileSaveResult>;
 
-  getDocumentContent(
-    onDocumentContent?: (fileCacheId?: string, fileBuffer?: ArrayBuffer) => void,
-  ): void;
+  getDocumentContent(onDocumentContent?: DocumentContentCallback): void;
 
   closeDocument(
     discardModify: boolean,
@@ -102,5 +117,5 @@ export interface DocumentTool {
 
   print(): void;
 
-  createPreview(serverUrl: string, options: any): void;
+  createPreview(serverUrl: string, options: DocumentCreatePreviewOptions): void;
 }