@rhc-office/sdk 6.6.266 → 6.6.351

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,5 +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

@@ -0,0 +1,169 @@
+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: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.annotationEvents.push(callback as AnnotationEventCallback);
+      }
+    },
+  },
+  isInAnnotationMode: {
+    kind: 'stateGetter',
+    state: (state) => state.annotationEnabled,
+  },
+  getAnnotationMode: {
+    kind: 'stateGetter',
+    state: (state) => normalizeAnnotationMode(state.annotationMode),
+  },
+  getAnnotations: {
+    kind: 'stateGetter',
+    state: (state) => getPublishedAnnotations(state),
+  },
+  getAnnotationsCount: {
+    kind: 'stateGetter',
+    state: (state) => getPublishedAnnotations(state).length,
+  },
+  openAnnotationView: { kind: 'command' },
+  closeAnnotationView: { kind: 'command' },
+  saveAnnotations: { kind: 'callbackQuery' },
+  clearAnnotations: { kind: 'command', returnsResult: true },
+  undoAnnotation: { kind: 'command', returnsResult: true },
+  redoAnnotation: { kind: 'command', returnsResult: true },
+  canUndoAnnotation: { kind: 'query' },
+  canRedoAnnotation: { kind: 'query' },
+  selectAnnotationTool: { kind: 'command' },
+  selectAnnotationStamp: { kind: 'command' },
+  setAnnotationPenColor: { kind: 'command' },
+  setAnnotationPenWidth: { kind: 'command' },
+  setAnnotationPenStyle: { kind: 'command' },
+};
+
+export class AnnotationToolImpl implements AnnotationTool {
+  private readonly adapter: AnnotationTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<AnnotationTool>(
+      'annotation',
+      ANNOTATION_TOOL_DESCRIPTOR,
+      context,
+    );
+  }
+
+  openAnnotationView: AnnotationTool['openAnnotationView'] = (options) => {
+    return this.adapter.openAnnotationView(options);
+  };
+
+  closeAnnotationView: AnnotationTool['closeAnnotationView'] = () => {
+    return this.adapter.closeAnnotationView();
+  };
+
+  saveAnnotations: AnnotationTool['saveAnnotations'] = (saveCallback) => {
+    return this.adapter.saveAnnotations(saveCallback);
+  };
+
+  clearAnnotations: AnnotationTool['clearAnnotations'] = () => {
+    return this.adapter.clearAnnotations();
+  };
+
+  undoAnnotation: AnnotationTool['undoAnnotation'] = () => {
+    return this.adapter.undoAnnotation();
+  };
+
+  redoAnnotation: AnnotationTool['redoAnnotation'] = () => {
+    return this.adapter.redoAnnotation();
+  };
+
+  canUndoAnnotation: AnnotationTool['canUndoAnnotation'] = () => {
+    return this.adapter.canUndoAnnotation();
+  };
+
+  canRedoAnnotation: AnnotationTool['canRedoAnnotation'] = () => {
+    return this.adapter.canRedoAnnotation();
+  };
+
+  selectAnnotationTool: AnnotationTool['selectAnnotationTool'] = (tool, options) => {
+    return this.adapter.selectAnnotationTool(tool, options);
+  };
+
+  selectAnnotationStamp: AnnotationTool['selectAnnotationStamp'] = (stamp) => {
+    return this.adapter.selectAnnotationStamp(stamp);
+  };
+
+  setAnnotationPenColor: AnnotationTool['setAnnotationPenColor'] = (hexColor) => {
+    return this.adapter.setAnnotationPenColor(hexColor);
+  };
+
+  setAnnotationPenWidth: AnnotationTool['setAnnotationPenWidth'] = (penWidth) => {
+    return this.adapter.setAnnotationPenWidth(penWidth);
+  };
+
+  setAnnotationPenStyle: AnnotationTool['setAnnotationPenStyle'] = (options) => {
+    return this.adapter.setAnnotationPenStyle(options);
+  };
+
+  isInAnnotationMode: AnnotationTool['isInAnnotationMode'] = () => {
+    return this.adapter.isInAnnotationMode();
+  };
+
+  getAnnotationMode: AnnotationTool['getAnnotationMode'] = () => {
+    return this.adapter.getAnnotationMode();
+  };
+
+  getAnnotations: AnnotationTool['getAnnotations'] = () => {
+    return this.adapter.getAnnotations();
+  };
+
+  getAnnotationsCount: AnnotationTool['getAnnotationsCount'] = () => {
+    return this.adapter.getAnnotationsCount();
+  };
+
+  addAnnotationEventCallback: AnnotationTool['addAnnotationEventCallback'] = (callback) => {
+    return this.adapter.addAnnotationEventCallback(callback);
+  };
+}

package/src/tools/CryptoToolImpl.ts

@@ -0,0 +1,27 @@
+import type { CryptoTool } from '../api/crypto-tool';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const CRYPTO_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
+  configSecurityProvider: { kind: 'command' },
+  getSecurityProviders: { kind: 'query' },
+};
+
+export class CryptoToolImpl implements CryptoTool {
+  private readonly adapter: CryptoTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<CryptoTool>('crypto', CRYPTO_TOOL_DESCRIPTOR, context);
+  }
+
+  configSecurityProvider: CryptoTool['configSecurityProvider'] = (providers) => {
+    return this.adapter.configSecurityProvider(providers);
+  };
+
+  getSecurityProviders: CryptoTool['getSecurityProviders'] = () => {
+    return this.adapter.getSecurityProviders();
+  };
+}

package/src/tools/DigitalSignToolImpl.ts

@@ -0,0 +1,166 @@
+import type { DigitalSignatureRetrieveCallback, DigitalSignCallback } from '../api/callbacks';
+import type { DigitalSignTool } from '../api/sign-tool';
+import {
+  createBridgeToolAdapter,
+  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: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.digitalSignatureRetrieve.push(callback as DigitalSignatureRetrieveCallback);
+      }
+    },
+  },
+  addDigitalSignatureParseCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.digitalSignatureParse.push(callback as DigitalSignatureRetrieveCallback);
+      }
+    },
+  },
+  addDigitalSignCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.digitalSign.push(callback as DigitalSignCallback);
+      }
+    },
+  },
+  setCryptoProvider: { kind: 'command' },
+  setSealSource: { kind: 'command' },
+  setDefaultStampPassword: { kind: 'command' },
+  setDefaultSealPassword: { kind: 'command' },
+  setDefaultKeystorePassword: { kind: 'command' },
+  setDefaultUSBKeyPassword: { kind: 'command' },
+  setupExternalSealServer: { kind: 'command' },
+  setDigitalSignOptions: { kind: 'command' },
+  setExternalDigitalSignOptions: { kind: 'command' },
+  setPDFDigitalSignCaptionOptions: { kind: 'command' },
+  addDigitalSignature: { kind: 'callbackQuery' },
+  addDigitalSignatureBySelectedSearchHighlight: { kind: 'command' },
+  listDigitalSignatures: { kind: 'callbackQuery' },
+  getDigitalSignatures: {
+    kind: 'stateGetter',
+    state: (state) => getPublishedDigitalSignatures(state),
+  },
+  getDigitalSignaturesCount: {
+    kind: 'stateGetter',
+    state: (state) => getPublishedDigitalSignatures(state).length,
+  },
+  enableDigitalSignatureInfoView: { kind: 'command' },
+  enableDigitalSignatureRevocation: { kind: 'command' },
+};
+
+export class DigitalSignToolImpl implements DigitalSignTool {
+  private readonly adapter: DigitalSignTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<DigitalSignTool>(
+      'digitalSign',
+      DIGITAL_SIGN_TOOL_DESCRIPTOR,
+      context,
+    );
+  }
+
+  addDigitalSignatureRetrieveCallback: DigitalSignTool['addDigitalSignatureRetrieveCallback'] = (
+    callback,
+  ) => {
+    return this.adapter.addDigitalSignatureRetrieveCallback(callback);
+  };
+
+  addDigitalSignatureParseCallback: DigitalSignTool['addDigitalSignatureParseCallback'] = (
+    callback,
+  ) => {
+    return this.adapter.addDigitalSignatureParseCallback(callback);
+  };
+
+  setCryptoProvider: DigitalSignTool['setCryptoProvider'] = (usage, provider, configuration) => {
+    return this.adapter.setCryptoProvider(usage, provider, configuration);
+  };
+
+  setSealSource: DigitalSignTool['setSealSource'] = (source) => {
+    return this.adapter.setSealSource(source);
+  };
+
+  setDefaultStampPassword: DigitalSignTool['setDefaultStampPassword'] = (stampPassword) => {
+    return this.adapter.setDefaultStampPassword(stampPassword);
+  };
+
+  setDefaultSealPassword: DigitalSignTool['setDefaultSealPassword'] = (sealPassword) => {
+    return this.adapter.setDefaultSealPassword(sealPassword);
+  };
+
+  setDefaultKeystorePassword: DigitalSignTool['setDefaultKeystorePassword'] = (pkPassword) => {
+    return this.adapter.setDefaultKeystorePassword(pkPassword);
+  };
+
+  setDefaultUSBKeyPassword: DigitalSignTool['setDefaultUSBKeyPassword'] = (pkPassword) => {
+    return this.adapter.setDefaultUSBKeyPassword(pkPassword);
+  };
+
+  addDigitalSignCallback: DigitalSignTool['addDigitalSignCallback'] = (callback) => {
+    return this.adapter.addDigitalSignCallback(callback);
+  };
+
+  setupExternalSealServer: DigitalSignTool['setupExternalSealServer'] = (options) => {
+    return this.adapter.setupExternalSealServer(options);
+  };
+
+  setDigitalSignOptions: DigitalSignTool['setDigitalSignOptions'] = (options) => {
+    return this.adapter.setDigitalSignOptions(options);
+  };
+
+  setExternalDigitalSignOptions: DigitalSignTool['setExternalDigitalSignOptions'] = (options) => {
+    return this.adapter.setExternalDigitalSignOptions(options);
+  };
+
+  setPDFDigitalSignCaptionOptions: DigitalSignTool['setPDFDigitalSignCaptionOptions'] = (
+    options,
+  ) => {
+    return this.adapter.setPDFDigitalSignCaptionOptions(options);
+  };
+
+  addDigitalSignature: DigitalSignTool['addDigitalSignature'] = (options, callback) => {
+    return this.adapter.addDigitalSignature(options, callback);
+  };
+
+  addDigitalSignatureBySelectedSearchHighlight: DigitalSignTool['addDigitalSignatureBySelectedSearchHighlight'] =
+    (options) => {
+      return this.adapter.addDigitalSignatureBySelectedSearchHighlight(options);
+    };
+
+  listDigitalSignatures: DigitalSignTool['listDigitalSignatures'] = (callback) => {
+    return this.adapter.listDigitalSignatures(callback);
+  };
+
+  getDigitalSignatures: DigitalSignTool['getDigitalSignatures'] = () => {
+    return this.adapter.getDigitalSignatures();
+  };
+
+  getDigitalSignaturesCount: DigitalSignTool['getDigitalSignaturesCount'] = () => {
+    return this.adapter.getDigitalSignaturesCount();
+  };
+
+  enableDigitalSignatureInfoView: DigitalSignTool['enableDigitalSignatureInfoView'] = (enabled) => {
+    return this.adapter.enableDigitalSignatureInfoView(enabled);
+  };
+
+  enableDigitalSignatureRevocation: DigitalSignTool['enableDigitalSignatureRevocation'] = (
+    enabled,
+  ) => {
+    return this.adapter.enableDigitalSignatureRevocation(enabled);
+  };
+}

package/src/tools/DocumentToolImpl.ts

@@ -1,18 +1,28 @@
-import type { DocumentClosedCallback, DocumentSavedCallback } from '../api/callbacks';
-import type { DocumentTool } from '../api/document-tool';
+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 {
   createBridgeToolAdapter,
   type BridgeToolAdapterContext,
   type BridgeToolDescriptor,
 } from '../viewer/BridgeToolAdapter';
 
+type ReaderElementWithSaveAs = HTMLElement & {
+  saveAs?: (options?: IFileSaveOptions) => Promise<IFileSaveResult>;
+};
+
 const DOCUMENT_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
   addDocumentOpenedCallback: {
     kind: 'callbackRegister',
     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);
       }
     },
   },
@@ -48,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' },
@@ -68,7 +77,7 @@ const DOCUMENT_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
 export class DocumentToolImpl implements DocumentTool {
   private readonly adapter: DocumentTool;
 
-  constructor(context: BridgeToolAdapterContext) {
+  constructor(private readonly context: BridgeToolAdapterContext) {
     this.adapter = createBridgeToolAdapter<DocumentTool>(
       'document',
       DOCUMENT_TOOL_DESCRIPTOR,
@@ -129,6 +138,23 @@ export class DocumentToolImpl implements DocumentTool {
   };
 
   saveAs: DocumentTool['saveAs'] = (options) => {
+    const readerId = this.context.bridge.getReaderId();
+    if (!readerId) {
+      return Promise.resolve({
+        success: false,
+        action: 'save-as',
+        filename: options?.filename,
+        error: 'Reader is not mounted or does not expose saveAs.',
+      });
+    }
+
+    const readerElement = document.querySelector(
+      `[${RHC_OFFICE_READER_ID_ATTRIBUTE}="${readerId}"]`,
+    ) as ReaderElementWithSaveAs | null;
+    if (typeof readerElement?.saveAs === 'function') {
+      return readerElement.saveAs(options);
+    }
+
     return this.adapter.saveAs(options);
   };