@rhc-office/sdk 6.6.268 → 6.6.363

package/src/api/menu-visibility.ts

@@ -10,8 +10,17 @@ export interface RibbonMenuItemVisibility {
   [propName: string]: ViewVisibility;
 }
 
-export interface MenuActionButtonStyle {
+export interface RibbonMenuButtonContentStyle {
   type: 'Icon' | 'Label' | 'ToolTip';
   content: string;
   iconContentType?: 'application/svg' | 'url';
+  showLabel?: boolean;
 }
+
+export interface RibbonMenuButtonLabelVisibilityStyle {
+  showLabel: boolean;
+}
+
+export type MenuActionButtonStyle =
+  | RibbonMenuButtonContentStyle
+  | RibbonMenuButtonLabelVisibilityStyle;

package/src/api/page-arrange-tool.ts

@@ -0,0 +1,67 @@
+import type {
+  PageArrangeAction,
+  PageArrangeCommitResult,
+  PageArrangeDocumentFormat,
+  PageArrangeExtractResult,
+  PageArrangePageSize,
+  PageArrangeQuarterTurn,
+  PageArrangeTransactionSnapshot,
+} from '@rhc-office/schema';
+
+export interface PageArrangeNewPageOptions {
+  rotation?: PageArrangeQuarterTurn;
+  size?: PageArrangePageSize;
+}
+
+export interface PageArrangeImportDocumentOptions {
+  format: PageArrangeDocumentFormat;
+  insertIndex?: number;
+  pageIndices?: number[];
+}
+
+export type PageArrangeToolResult =
+  | PageArrangeTransactionSnapshot
+  | PageArrangeCommitResult
+  | PageArrangeExtractResult;
+
+export interface PageArrangeTool {
+  getSnapshot(): Promise<PageArrangeTransactionSnapshot>;
+
+  execute(action: PageArrangeAction): Promise<PageArrangeToolResult>;
+
+  newPage(
+    index?: number,
+    options?: PageArrangeNewPageOptions,
+  ): Promise<PageArrangeTransactionSnapshot>;
+
+  deletePages(pageIndices: number[]): Promise<PageArrangeTransactionSnapshot>;
+
+  duplicatePages(
+    pageIndices: number[],
+    insertIndex?: number,
+  ): Promise<PageArrangeTransactionSnapshot>;
+
+  rotateLeft(pageIndices: number[]): Promise<PageArrangeTransactionSnapshot>;
+
+  rotateRight(pageIndices: number[]): Promise<PageArrangeTransactionSnapshot>;
+
+  clearContent(pageIndices: number[]): Promise<PageArrangeTransactionSnapshot>;
+
+  moveBefore(pageIndices: number[], targetIndex: number): Promise<PageArrangeTransactionSnapshot>;
+
+  moveAfter(pageIndices: number[], targetIndex: number): Promise<PageArrangeTransactionSnapshot>;
+
+  importDocument(
+    data: Uint8Array | ArrayBuffer,
+    options: PageArrangeImportDocumentOptions,
+  ): Promise<PageArrangeTransactionSnapshot>;
+
+  extractPages(
+    pageIndices: number[],
+    suggestedFileName?: string,
+  ): Promise<PageArrangeExtractResult>;
+
+  undo(): Promise<PageArrangeTransactionSnapshot>;
+
+  commit(): Promise<PageArrangeCommitResult>;
+}

package/src/api/security-tool.ts

@@ -0,0 +1,32 @@
+export type DocumentSecurityPermissionId =
+  | 'print'
+  | 'documentAssembly'
+  | 'contentCopy'
+  | 'accessibilityExtraction'
+  | 'pageExtraction'
+  | 'annotation'
+  | 'formFill'
+  | 'signing'
+  | 'templatePage';
+
+export interface DocumentSecuritySettings {
+  print: boolean;
+  documentAssembly: boolean;
+  contentCopy: boolean;
+  accessibilityExtraction: boolean;
+  pageExtraction: boolean;
+  annotation: boolean;
+  formFill: boolean;
+  signing: boolean;
+  templatePage: boolean;
+}
+
+export type DocumentSecurityUpdate = Partial<DocumentSecuritySettings>;
+
+export interface SecurityTool {
+  getSecuritySettings(): Promise<DocumentSecuritySettings>;
+  setSecuritySettings(update: DocumentSecurityUpdate): Promise<DocumentSecuritySettings>;
+  isSecuritySettingsLocalEditable(): Promise<boolean>;
+  setSecuritySettingsLocalEditable(editable: boolean): Promise<boolean>;
+  openSecuritySettingsDialog(): void;
+}

package/src/api/ui-tool.ts

@@ -1,6 +1,15 @@
 import { RibbonMenuItemVisibility, MenuActionButtonStyle } from './menu-visibility';
 import { IWatermark } from './watermark';
 
+export interface RibbonMenuState {
+  visible?: boolean;
+  disabled?: boolean;
+}
+
+export interface RibbonMenuItemState extends RibbonMenuState {
+  config?: RibbonMenuItemVisibility;
+}
+
 export interface UITool {
   showToolbarMenu(): void;
 
@@ -44,14 +53,38 @@ export interface UITool {
 
   hideRibbonTitleBar(): void;
 
+  showRibbonTabs(): void;
+
+  hideRibbonTabs(): void;
+
   selectRibbonMenu(menuId: string): void;
 
+  setupRibbonMenuTab(menuId: string, state: RibbonMenuState): void;
+
+  showRibbonMenuTab(menuId: string): void;
+
+  hideRibbonMenuTab(menuId: string): void;
+
+  enableRibbonMenuTab(menuId: string): void;
+
+  disableRibbonMenuTab(menuId: string): void;
+
+  setupRibbonMenuItemState(menuId: string, state: RibbonMenuItemState): void;
+
+  enableRibbonMenuItem(menuId: string, config?: RibbonMenuItemVisibility): void;
+
+  disableRibbonMenuItem(menuId: string, config?: RibbonMenuItemVisibility): void;
+
   setRibbonMenuButtonStyle(buttonId: string, buttonStyle: MenuActionButtonStyle): void;
 
   setWatermark(fields: IWatermark | unknown): void;
 
   setCompactMode(compact: boolean): void;
 
+  setRulerVisible(visible: boolean): void;
+
+  toggleSidebar(): void;
+
   enterBookViewMode(callback?: () => void): void;
 
   exitBookViewMode(): void;

package/src/index.ts

@@ -6,6 +6,7 @@ export * from './api/document-tool';
 export * from './api/annotation-tool';
 export * from './api/ui-tool';
 export * from './api/page-tool';
+export * from './api/page-arrange-tool';
 export * from './api/find-tool';
 export * from './api/sign-tool';
 export * from './api/sign-server';
@@ -15,6 +16,7 @@ export * from './api/symbology-tool';
 export * from './api/template-sign';
 export * from './api/pdf-formfiller';
 export * from './api/crypto-tool';
+export * from './api/security-tool';
 export * from './api/document-sdk';
 export * from './tools';
 export * from './viewer';

package/src/tools/AnnotationToolImpl.ts

@@ -1,10 +1,47 @@
-import type { AnnotationTool, IDigitalAnnotationInfo } from '../api/annotation-tool';
-import type { AnnotationEventCallback } from '../api/callbacks';
+import type {
+  AnnotationEventCallback,
+  AnnotationMode,
+  AnnotationRecord,
+  AnnotationTool,
+} from '../api/annotation-tool';
 import {
   createBridgeToolAdapter,
   type BridgeToolAdapterContext,
   type BridgeToolDescriptor,
 } from '../viewer/BridgeToolAdapter';
+import type { ReaderStateSnapshot } from '../viewer/ReaderStateStore';
+
+const isAnnotationRecord = (value: unknown): value is AnnotationRecord => {
+  return typeof value === 'object' && value !== null && !Array.isArray(value) && 'id' in value;
+};
+
+const getPublishedAnnotations = (state: ReaderStateSnapshot): AnnotationRecord[] => {
+  return (
+    state.annotations?.filter(isAnnotationRecord).map((annotation) => ({ ...annotation })) ?? []
+  );
+};
+
+const normalizeAnnotationMode = (mode?: string): AnnotationMode => {
+  switch (mode) {
+    case 'select':
+    case 'pen':
+    case 'eraser':
+    case 'line':
+    case 'arrow':
+    case 'rectangle':
+    case 'circle':
+    case 'text-highlight':
+    case 'text-underline':
+    case 'text-strikethrough':
+    case 'text-squiggly':
+    case 'text-note':
+    case 'stamp':
+      return mode;
+    case 'none':
+    default:
+      return 'none';
+  }
+};
 
 const ANNOTATION_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
   addAnnotationEventCallback: {
@@ -16,74 +53,38 @@ const ANNOTATION_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
       }
     },
   },
-  addAnnotationPersistCallback: {
-    kind: 'callbackRegister',
-    callback: (callbacks, args) => {
-      const callback = args[0];
-      if (typeof callback === 'function') {
-        callbacks.annotationPersist.push(callback as (event: unknown) => void);
-      }
-    },
+  isInAnnotationMode: {
+    kind: 'stateGetter',
+    state: (state) => state.annotationEnabled,
   },
-  addAnnotationRetrieveCallback: {
-    kind: 'callbackRegister',
-    callback: (callbacks, args) => {
-      const callback = args[0];
-      if (typeof callback === 'function') {
-        callbacks.annotationRetrieve.push(callback as (event: unknown) => void);
-      }
-    },
+  getAnnotationMode: {
+    kind: 'stateGetter',
+    state: (state) => normalizeAnnotationMode(state.annotationMode),
   },
-  addDigitalAnnotationRetrieveCallback: {
-    kind: 'callbackRegister',
-    callback: (callbacks, args) => {
-      const callback = args[0];
-      if (typeof callback === 'function') {
-        callbacks.digitalAnnotationRetrieve.push(
-          callback as (annotations: IDigitalAnnotationInfo[]) => void,
-        );
-      }
-    },
+  getAnnotations: {
+    kind: 'stateGetter',
+    state: (state) => getPublishedAnnotations(state),
   },
-  isInAnnotationMode: {
+  getAnnotationsCount: {
     kind: 'stateGetter',
-    state: (state) => state.annotationEnabled,
+    state: (state) => getPublishedAnnotations(state).length,
   },
-  getAnnotations: { kind: 'stateGetter', state: () => [] },
-  getAnnotationsCount: { kind: 'stateGetter', state: () => 0 },
-  queryAnnotationsBy: { kind: 'stateGetter', state: () => [] },
-  setToolSource: { kind: 'command' },
   openAnnotationView: { kind: 'command' },
   closeAnnotationView: { kind: 'command' },
-  openTextAnnotationView: { kind: 'command' },
-  setTextAnnotationFontColor: { kind: 'command' },
-  setTextAnnotationFontSize: { kind: 'command' },
-  closeTextAnnotationView: { kind: 'command' },
-  createTextAnnotation: { kind: 'command' },
-  setPersistToDocument: { kind: 'command' },
   saveAnnotations: { kind: 'callbackQuery' },
-  saveTextAnnotations: { kind: 'command' },
-  clearAnnotations: { kind: 'command' },
-  clearTextAnnotations: { kind: 'command' },
-  undoAnnotation: { kind: 'command' },
-  redoAnnotation: { kind: 'command' },
+  clearAnnotations: { kind: 'command', returnsResult: true },
+  undoAnnotation: { kind: 'command', returnsResult: true },
+  redoAnnotation: { kind: 'command', returnsResult: true },
+  canUndoAnnotation: { kind: 'query' },
+  canRedoAnnotation: { kind: 'query' },
   selectAnnotationTool: { kind: 'command' },
-  showAnnotationColorPicker: { kind: 'command' },
-  setAnnotationPenType: { kind: 'command' },
-  appendAnnotations: { kind: 'callbackQuery' },
-  batchAppendAnnotations: { kind: 'callbackQuery' },
+  selectAnnotationStamp: { kind: 'command' },
+  getCustomStamps: { kind: 'query' },
+  addCustomTextStamp: { kind: 'query' },
+  addCustomImageStamp: { kind: 'query' },
   setAnnotationPenColor: { kind: 'command' },
   setAnnotationPenWidth: { kind: 'command' },
-  setAnnotationPenThickness: { kind: 'command' },
-  enableAnnotationsInfoView: { kind: 'command' },
-  enableAnnotationsDeletion: { kind: 'command' },
-  enableAnnotationsDeletionOnlyByAuthor: { kind: 'command' },
-  listDigitalStamps: { kind: 'command' },
-  listAnnotations: { kind: 'command' },
-  deleteAnnotationsBy: { kind: 'command' },
-  deleteAnnotationsById: { kind: 'command' },
-  addDigitalAnnotation: { kind: 'command' },
-  addInkAnnotationCallback: { kind: 'callbackRegister' },
+  setAnnotationPenStyle: { kind: 'command' },
 };
 
 export class AnnotationToolImpl implements AnnotationTool {
@@ -97,58 +98,22 @@ export class AnnotationToolImpl implements AnnotationTool {
     );
   }
 
-  setToolSource: AnnotationTool['setToolSource'] = (source) => {
-    return this.adapter.setToolSource(source);
-  };
-
   openAnnotationView: AnnotationTool['openAnnotationView'] = (options) => {
     return this.adapter.openAnnotationView(options);
   };
 
-  closeAnnotationView: AnnotationTool['closeAnnotationView'] = (saveModifications) => {
-    return this.adapter.closeAnnotationView(saveModifications);
-  };
-
-  openTextAnnotationView: AnnotationTool['openTextAnnotationView'] = () => {
-    return this.adapter.openTextAnnotationView();
-  };
-
-  setTextAnnotationFontColor: AnnotationTool['setTextAnnotationFontColor'] = (color) => {
-    return this.adapter.setTextAnnotationFontColor(color);
-  };
-
-  setTextAnnotationFontSize: AnnotationTool['setTextAnnotationFontSize'] = (size) => {
-    return this.adapter.setTextAnnotationFontSize(size);
-  };
-
-  closeTextAnnotationView: AnnotationTool['closeTextAnnotationView'] = (saveModifications) => {
-    return this.adapter.closeTextAnnotationView(saveModifications);
-  };
-
-  createTextAnnotation: AnnotationTool['createTextAnnotation'] = (options) => {
-    return this.adapter.createTextAnnotation(options);
-  };
-
-  setPersistToDocument: AnnotationTool['setPersistToDocument'] = (persist) => {
-    return this.adapter.setPersistToDocument(persist);
+  closeAnnotationView: AnnotationTool['closeAnnotationView'] = () => {
+    return this.adapter.closeAnnotationView();
   };
 
   saveAnnotations: AnnotationTool['saveAnnotations'] = (saveCallback) => {
     return this.adapter.saveAnnotations(saveCallback);
   };
 
-  saveTextAnnotations: AnnotationTool['saveTextAnnotations'] = () => {
-    return this.adapter.saveTextAnnotations();
-  };
-
   clearAnnotations: AnnotationTool['clearAnnotations'] = () => {
     return this.adapter.clearAnnotations();
   };
 
-  clearTextAnnotations: AnnotationTool['clearTextAnnotations'] = () => {
-    return this.adapter.clearTextAnnotations();
-  };
-
   undoAnnotation: AnnotationTool['undoAnnotation'] = () => {
     return this.adapter.undoAnnotation();
   };
@@ -157,62 +122,52 @@ export class AnnotationToolImpl implements AnnotationTool {
     return this.adapter.redoAnnotation();
   };
 
-  selectAnnotationTool: AnnotationTool['selectAnnotationTool'] = (tool) => {
-    return this.adapter.selectAnnotationTool(tool);
-  };
-
-  showAnnotationColorPicker: AnnotationTool['showAnnotationColorPicker'] = () => {
-    return this.adapter.showAnnotationColorPicker();
-  };
-
-  setAnnotationPenType: AnnotationTool['setAnnotationPenType'] = (penType) => {
-    return this.adapter.setAnnotationPenType(penType);
+  canUndoAnnotation: AnnotationTool['canUndoAnnotation'] = () => {
+    return this.adapter.canUndoAnnotation();
   };
 
-  appendAnnotations: AnnotationTool['appendAnnotations'] = (inkData, callback) => {
-    return this.adapter.appendAnnotations(inkData, callback);
+  canRedoAnnotation: AnnotationTool['canRedoAnnotation'] = () => {
+    return this.adapter.canRedoAnnotation();
   };
 
-  batchAppendAnnotations: AnnotationTool['batchAppendAnnotations'] = (inkData, callback) => {
-    return this.adapter.batchAppendAnnotations(inkData, callback);
+  selectAnnotationTool: AnnotationTool['selectAnnotationTool'] = (tool, options) => {
+    return this.adapter.selectAnnotationTool(tool, options);
   };
 
-  setAnnotationPenColor: AnnotationTool['setAnnotationPenColor'] = (hexColor) => {
-    return this.adapter.setAnnotationPenColor(hexColor);
+  selectAnnotationStamp: AnnotationTool['selectAnnotationStamp'] = (stamp) => {
+    return this.adapter.selectAnnotationStamp(stamp);
   };
 
-  setAnnotationPenWidth: AnnotationTool['setAnnotationPenWidth'] = (penWidth) => {
-    return this.adapter.setAnnotationPenWidth(penWidth);
+  getCustomStamps: AnnotationTool['getCustomStamps'] = () => {
+    return this.adapter.getCustomStamps();
   };
 
-  setAnnotationPenThickness: AnnotationTool['setAnnotationPenThickness'] = (thickness) => {
-    return this.adapter.setAnnotationPenThickness(thickness);
+  addCustomTextStamp: AnnotationTool['addCustomTextStamp'] = (input) => {
+    return this.adapter.addCustomTextStamp(input);
   };
 
-  enableAnnotationsInfoView: AnnotationTool['enableAnnotationsInfoView'] = (enabled) => {
-    return this.adapter.enableAnnotationsInfoView(enabled);
+  addCustomImageStamp: AnnotationTool['addCustomImageStamp'] = (input) => {
+    return this.adapter.addCustomImageStamp(input);
   };
 
-  enableAnnotationsDeletion: AnnotationTool['enableAnnotationsDeletion'] = (enabled) => {
-    return this.adapter.enableAnnotationsDeletion(enabled);
+  setAnnotationPenColor: AnnotationTool['setAnnotationPenColor'] = (hexColor) => {
+    return this.adapter.setAnnotationPenColor(hexColor);
   };
 
-  enableAnnotationsDeletionOnlyByAuthor: AnnotationTool['enableAnnotationsDeletionOnlyByAuthor'] = (
-    onlyByAuthor,
-  ) => {
-    return this.adapter.enableAnnotationsDeletionOnlyByAuthor(onlyByAuthor);
+  setAnnotationPenWidth: AnnotationTool['setAnnotationPenWidth'] = (penWidth) => {
+    return this.adapter.setAnnotationPenWidth(penWidth);
   };
 
-  listDigitalStamps: AnnotationTool['listDigitalStamps'] = () => {
-    return this.adapter.listDigitalStamps();
+  setAnnotationPenStyle: AnnotationTool['setAnnotationPenStyle'] = (options) => {
+    return this.adapter.setAnnotationPenStyle(options);
   };
 
   isInAnnotationMode: AnnotationTool['isInAnnotationMode'] = () => {
     return this.adapter.isInAnnotationMode();
   };
 
-  listAnnotations: AnnotationTool['listAnnotations'] = (options) => {
-    return this.adapter.listAnnotations(options);
+  getAnnotationMode: AnnotationTool['getAnnotationMode'] = () => {
+    return this.adapter.getAnnotationMode();
   };
 
   getAnnotations: AnnotationTool['getAnnotations'] = () => {
@@ -223,41 +178,7 @@ export class AnnotationToolImpl implements AnnotationTool {
     return this.adapter.getAnnotationsCount();
   };
 
-  queryAnnotationsBy: AnnotationTool['queryAnnotationsBy'] = (query) => {
-    return this.adapter.queryAnnotationsBy(query);
-  };
-
-  deleteAnnotationsBy: AnnotationTool['deleteAnnotationsBy'] = (query, prompt) => {
-    return this.adapter.deleteAnnotationsBy(query, prompt);
-  };
-
-  deleteAnnotationsById: AnnotationTool['deleteAnnotationsById'] = (annotationIds, prompt) => {
-    return this.adapter.deleteAnnotationsById(annotationIds, prompt);
-  };
-
-  addDigitalAnnotation: AnnotationTool['addDigitalAnnotation'] = (options) => {
-    return this.adapter.addDigitalAnnotation(options);
-  };
-
-  addInkAnnotationCallback: AnnotationTool['addInkAnnotationCallback'] = (callback) => {
-    return this.adapter.addInkAnnotationCallback(callback);
-  };
-
   addAnnotationEventCallback: AnnotationTool['addAnnotationEventCallback'] = (callback) => {
     return this.adapter.addAnnotationEventCallback(callback);
   };
-
-  addAnnotationPersistCallback: AnnotationTool['addAnnotationPersistCallback'] = (callback) => {
-    return this.adapter.addAnnotationPersistCallback(callback);
-  };
-
-  addAnnotationRetrieveCallback: AnnotationTool['addAnnotationRetrieveCallback'] = (callback) => {
-    return this.adapter.addAnnotationRetrieveCallback(callback);
-  };
-
-  addDigitalAnnotationRetrieveCallback: AnnotationTool['addDigitalAnnotationRetrieveCallback'] = (
-    callback,
-  ) => {
-    return this.adapter.addDigitalAnnotationRetrieveCallback(callback);
-  };
 }

package/src/tools/DigitalSignToolImpl.ts

@@ -5,6 +5,11 @@ import {
   type BridgeToolAdapterContext,
   type BridgeToolDescriptor,
 } from '../viewer/BridgeToolAdapter';
+import type { ReaderStateSnapshot } from '../viewer/ReaderStateStore';
+
+const getPublishedDigitalSignatures = (state: ReaderStateSnapshot): unknown[] => {
+  return state.digitalSignatures ? [...state.digitalSignatures] : [];
+};
 
 const DIGITAL_SIGN_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
   addDigitalSignatureRetrieveCallback: {
@@ -47,8 +52,14 @@ const DIGITAL_SIGN_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
   addDigitalSignature: { kind: 'callbackQuery' },
   addDigitalSignatureBySelectedSearchHighlight: { kind: 'command' },
   listDigitalSignatures: { kind: 'callbackQuery' },
-  getDigitalSignatures: { kind: 'stateGetter', state: () => [] },
-  getDigitalSignaturesCount: { kind: 'stateGetter', state: () => 0 },
+  getDigitalSignatures: {
+    kind: 'stateGetter',
+    state: (state) => getPublishedDigitalSignatures(state),
+  },
+  getDigitalSignaturesCount: {
+    kind: 'stateGetter',
+    state: (state) => getPublishedDigitalSignatures(state).length,
+  },
   enableDigitalSignatureInfoView: { kind: 'command' },
   enableDigitalSignatureRevocation: { kind: 'command' },
 };

package/src/tools/DocumentToolImpl.ts

@@ -1,4 +1,9 @@
-import type { DocumentClosedCallback, DocumentSavedCallback } from '../api/callbacks';
+import type {
+  DocumentClosedCallback,
+  DocumentContentResult,
+  DocumentOpenedCallback,
+  DocumentSavedCallback,
+} from '../api/callbacks';
 import type { DocumentTool, IFileSaveOptions, IFileSaveResult } from '../api/document-tool';
 import { RHC_OFFICE_READER_ID_ATTRIBUTE } from '../viewer/AdapterProtocol';
 import {
@@ -17,7 +22,7 @@ const DOCUMENT_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
     callback: (callbacks, args) => {
       const callback = args[0];
       if (typeof callback === 'function') {
-        callbacks.documentOpened.push(callback as (status: string, error: string) => void);
+        callbacks.documentOpened.push(callback as DocumentOpenedCallback);
       }
     },
   },
@@ -53,8 +58,7 @@ const DOCUMENT_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
   getDocumentContent: {
     kind: 'callbackQuery',
     mapCallbackResult: (result) => {
-      const content = result as { fileCacheId?: string; fileBuffer?: ArrayBuffer };
-      return [content?.fileCacheId, content?.fileBuffer];
+      return [result as DocumentContentResult];
     },
   },
   closeDocument: { kind: 'callbackQuery' },

package/src/tools/PageArrangeToolImpl.ts

@@ -0,0 +1,99 @@
+import type { PageArrangeTool } from '../api/page-arrange-tool';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const createPageArrangeToolDescriptor = (): BridgeToolDescriptor => ({
+  clearContent: { kind: 'command', returnsResult: true },
+  commit: { kind: 'command', returnsResult: true },
+  deletePages: { kind: 'command', returnsResult: true },
+  duplicatePages: { kind: 'command', returnsResult: true },
+  execute: { kind: 'command', returnsResult: true },
+  extractPages: { kind: 'command', returnsResult: true },
+  getSnapshot: { kind: 'query' },
+  importDocument: { kind: 'command', returnsResult: true },
+  moveAfter: { kind: 'command', returnsResult: true },
+  moveBefore: { kind: 'command', returnsResult: true },
+  newPage: { kind: 'command', returnsResult: true },
+  rotateLeft: { kind: 'command', returnsResult: true },
+  rotateRight: { kind: 'command', returnsResult: true },
+  undo: { kind: 'command', returnsResult: true },
+});
+
+const normalizePageArrangeBytes = (data: Uint8Array | ArrayBuffer): Uint8Array => {
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+
+  return new Uint8Array(data);
+};
+
+export class PageArrangeToolImpl implements PageArrangeTool {
+  private readonly adapter: PageArrangeTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<PageArrangeTool>(
+      'pageArrange',
+      createPageArrangeToolDescriptor(),
+      context,
+    );
+  }
+
+  getSnapshot: PageArrangeTool['getSnapshot'] = () => {
+    return this.adapter.getSnapshot();
+  };
+
+  execute: PageArrangeTool['execute'] = (action) => {
+    return this.adapter.execute(action);
+  };
+
+  newPage: PageArrangeTool['newPage'] = (index, options) => {
+    return this.adapter.newPage(index, options);
+  };
+
+  deletePages: PageArrangeTool['deletePages'] = (pageIndices) => {
+    return this.adapter.deletePages(pageIndices);
+  };
+
+  duplicatePages: PageArrangeTool['duplicatePages'] = (pageIndices, insertIndex) => {
+    return this.adapter.duplicatePages(pageIndices, insertIndex);
+  };
+
+  rotateLeft: PageArrangeTool['rotateLeft'] = (pageIndices) => {
+    return this.adapter.rotateLeft(pageIndices);
+  };
+
+  rotateRight: PageArrangeTool['rotateRight'] = (pageIndices) => {
+    return this.adapter.rotateRight(pageIndices);
+  };
+
+  clearContent: PageArrangeTool['clearContent'] = (pageIndices) => {
+    return this.adapter.clearContent(pageIndices);
+  };
+
+  moveBefore: PageArrangeTool['moveBefore'] = (pageIndices, targetIndex) => {
+    return this.adapter.moveBefore(pageIndices, targetIndex);
+  };
+
+  moveAfter: PageArrangeTool['moveAfter'] = (pageIndices, targetIndex) => {
+    return this.adapter.moveAfter(pageIndices, targetIndex);
+  };
+
+  importDocument: PageArrangeTool['importDocument'] = (data, options) => {
+    return this.adapter.importDocument(normalizePageArrangeBytes(data), options);
+  };
+
+  extractPages: PageArrangeTool['extractPages'] = (pageIndices, suggestedFileName) => {
+    return this.adapter.extractPages(pageIndices, suggestedFileName);
+  };
+
+  undo: PageArrangeTool['undo'] = () => {
+    return this.adapter.undo();
+  };
+
+  commit: PageArrangeTool['commit'] = () => {
+    return this.adapter.commit();
+  };
+}