@rhc-office/sdk 6.6.266 → 6.6.268

package/src/tools/DigitalSignToolImpl.ts

@@ -0,0 +1,155 @@
+import type { DigitalSignatureRetrieveCallback, DigitalSignCallback } from '../api/callbacks';
+import type { DigitalSignTool } from '../api/sign-tool';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+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: () => [] },
+  getDigitalSignaturesCount: { kind: 'stateGetter', state: () => 0 },
+  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,11 +1,16 @@
 import type { DocumentClosedCallback, DocumentSavedCallback } from '../api/callbacks';
-import type { DocumentTool } from '../api/document-tool';
+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',
@@ -68,7 +73,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 +134,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);
   };
 

package/src/tools/SignServerToolImpl.ts

@@ -0,0 +1,92 @@
+import type { SignServerAuthCallback, SignServerTool } from '../api/sign-server';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const SIGN_SERVER_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
+  setSignServer: { kind: 'command' },
+  addSignServerAuthCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.signServerAuth.push(callback as SignServerAuthCallback);
+      }
+    },
+  },
+  setSignServerDefaultLogin: { kind: 'command' },
+  setDefaultSignServerLogin: { kind: 'command' },
+  setSignServerDefaultPassword: { kind: 'command' },
+  setDefaultSignServerPassword: { kind: 'command' },
+  loginNTKOSignServer: { kind: 'command' },
+  loginSignServer: { kind: 'callbackQuery' },
+  signOutSignServer: { kind: 'command' },
+  isAuthenticatedOnSignServer: { kind: 'stateGetter', state: () => false },
+  setSignServerLoginFromUSBKey: { kind: 'command' },
+  setUserAuthSource: { kind: 'command' },
+};
+
+export class SignServerToolImpl implements SignServerTool {
+  private readonly adapter: SignServerTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<SignServerTool>(
+      'signServer',
+      SIGN_SERVER_TOOL_DESCRIPTOR,
+      context,
+    );
+  }
+
+  setSignServer: SignServerTool['setSignServer'] = (signServer) => {
+    return this.adapter.setSignServer(signServer);
+  };
+
+  addSignServerAuthCallback: SignServerTool['addSignServerAuthCallback'] = (callback) => {
+    return this.adapter.addSignServerAuthCallback(callback);
+  };
+
+  setSignServerDefaultLogin: SignServerTool['setSignServerDefaultLogin'] = (login) => {
+    return this.adapter.setSignServerDefaultLogin(login);
+  };
+
+  setDefaultSignServerLogin: SignServerTool['setDefaultSignServerLogin'] = (login) => {
+    return this.adapter.setDefaultSignServerLogin(login);
+  };
+
+  setSignServerDefaultPassword: SignServerTool['setSignServerDefaultPassword'] = (password) => {
+    return this.adapter.setSignServerDefaultPassword(password);
+  };
+
+  setDefaultSignServerPassword: SignServerTool['setDefaultSignServerPassword'] = (password) => {
+    return this.adapter.setDefaultSignServerPassword(password);
+  };
+
+  loginNTKOSignServer: SignServerTool['loginNTKOSignServer'] = (serverAddress, login, password) => {
+    return this.adapter.loginNTKOSignServer(serverAddress, login, password);
+  };
+
+  loginSignServer: SignServerTool['loginSignServer'] = (server, login, password, onSuccess) => {
+    return this.adapter.loginSignServer(server, login, password, onSuccess);
+  };
+
+  signOutSignServer: SignServerTool['signOutSignServer'] = () => {
+    return this.adapter.signOutSignServer();
+  };
+
+  isAuthenticatedOnSignServer: SignServerTool['isAuthenticatedOnSignServer'] = () => {
+    return this.adapter.isAuthenticatedOnSignServer();
+  };
+
+  setSignServerLoginFromUSBKey: SignServerTool['setSignServerLoginFromUSBKey'] = (
+    enabled,
+    options,
+  ) => {
+    return this.adapter.setSignServerLoginFromUSBKey(enabled, options);
+  };
+
+  setUserAuthSource: SignServerTool['setUserAuthSource'] = (source) => {
+    return this.adapter.setUserAuthSource(source);
+  };
+}

package/src/tools/SymbologyToolImpl.ts

@@ -0,0 +1,34 @@
+import type { SymbologyTool } from '../api/symbology-tool';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const SYMBOLOGY_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
+  createPDF417Barcode: { kind: 'command' },
+};
+
+export class SymbologyToolImpl implements SymbologyTool {
+  private readonly adapter: SymbologyTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<SymbologyTool>(
+      'symbology',
+      SYMBOLOGY_TOOL_DESCRIPTOR,
+      context,
+    );
+  }
+
+  createPDF417Barcode: SymbologyTool['createPDF417Barcode'] = (
+    content,
+    pageIndex,
+    x,
+    y,
+    width,
+    height,
+    margin,
+  ) => {
+    return this.adapter.createPDF417Barcode(content, pageIndex, x, y, width, height, margin);
+  };
+}

package/src/tools/TemplateSignToolImpl.ts

@@ -0,0 +1,51 @@
+import type { TemplateSignTool } from '../api/template-sign';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const TEMPLATE_SIGN_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
+  setup: { kind: 'command' },
+  create: { kind: 'command' },
+  getMarkups: { kind: 'callbackQuery' },
+  removeMarkup: { kind: 'command' },
+  removeAllMarkups: { kind: 'command' },
+  sign: { kind: 'callbackQuery' },
+};
+
+export class TemplateSignToolImpl implements TemplateSignTool {
+  private readonly adapter: TemplateSignTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<TemplateSignTool>(
+      'templateSign',
+      TEMPLATE_SIGN_TOOL_DESCRIPTOR,
+      context,
+    );
+  }
+
+  setup: TemplateSignTool['setup'] = (option) => {
+    return this.adapter.setup(option);
+  };
+
+  create: TemplateSignTool['create'] = (signType) => {
+    return this.adapter.create(signType);
+  };
+
+  getMarkups: TemplateSignTool['getMarkups'] = (callback) => {
+    return this.adapter.getMarkups(callback);
+  };
+
+  removeMarkup: TemplateSignTool['removeMarkup'] = (markupId, prompt) => {
+    return this.adapter.removeMarkup(markupId, prompt);
+  };
+
+  removeAllMarkups: TemplateSignTool['removeAllMarkups'] = (prompt) => {
+    return this.adapter.removeAllMarkups(prompt);
+  };
+
+  sign: TemplateSignTool['sign'] = (callback) => {
+    return this.adapter.sign(callback);
+  };
+}

package/src/tools/index.ts

@@ -1,3 +1,6 @@
+export * from './AnnotationToolImpl';
+export * from './CryptoToolImpl';
+export * from './DigitalSignToolImpl';
 export * from './DocumentToolImpl';
 export * from './FindToolImpl';
 export * from './NetworkingToolImpl';
@@ -5,4 +8,7 @@ export * from './PageToolImpl';
 export * from './PdfFormFillerImpl';
 export * from './Phase1ToolPlaceholder';
 export * from './SDKValueObjects';
+export * from './SignServerToolImpl';
+export * from './SymbologyToolImpl';
+export * from './TemplateSignToolImpl';
 export * from './UIToolImpl';

package/src/viewer/DocumentSDK.ts

@@ -1,11 +1,6 @@
 import type { AnnotationTool } from '../api/annotation-tool';
-import type { IDigitalAnnotationInfo } from '../api/annotation-tool';
 import type { CryptoTool } from '../api/crypto-tool';
-import type {
-  AnnotationEventCallback,
-  ReaderReadyCallback,
-  ReaderUnloadCallback,
-} from '../api/callbacks';
+import type { ReaderReadyCallback, ReaderUnloadCallback } from '../api/callbacks';
 import type { IDocumentSDK, IReaderEmbedOptions } from '../api/document-sdk';
 import type { DocumentTool } from '../api/document-tool';
 import type { FindTool } from '../api/find-tool';
@@ -17,12 +12,18 @@ import type { DigitalSignTool } from '../api/sign-tool';
 import type { SymbologyTool } from '../api/symbology-tool';
 import type { TemplateSignTool } from '../api/template-sign';
 import type { UITool } from '../api/ui-tool';
+import { AnnotationToolImpl } from '../tools/AnnotationToolImpl';
+import { CryptoToolImpl } from '../tools/CryptoToolImpl';
+import { DigitalSignToolImpl } from '../tools/DigitalSignToolImpl';
 import { DocumentToolImpl } from '../tools/DocumentToolImpl';
 import { FindToolImpl } from '../tools/FindToolImpl';
 import { NetworkingToolImpl } from '../tools/NetworkingToolImpl';
 import { PageToolImpl } from '../tools/PageToolImpl';
 import { PdfFormFillerImpl } from '../tools/PdfFormFillerImpl';
 import { DigitalSignOptions, KVField } from '../tools/SDKValueObjects';
+import { SignServerToolImpl } from '../tools/SignServerToolImpl';
+import { SymbologyToolImpl } from '../tools/SymbologyToolImpl';
+import { TemplateSignToolImpl } from '../tools/TemplateSignToolImpl';
 import { UIToolImpl } from '../tools/UIToolImpl';
 import type { NormalizedReaderEmbedOptions } from './ReaderConfiguration';
 import { normalizeAppUrl, normalizeReaderEmbedOptions } from './ReaderConfiguration';
@@ -36,7 +37,6 @@ import {
   RHC_OFFICE_READER_ID_ATTRIBUTE,
   type AdapterEvent,
 } from './AdapterProtocol';
-import { createBridgeToolAdapter, createNotImplementedBridgeTool } from './BridgeToolAdapter';
 import { ReaderBridgeClient } from './ReaderBridgeClient';
 import { ReaderStateStore } from './ReaderStateStore';
 import { SdkCallbackRegistry } from './SdkCallbackRegistry';
@@ -231,29 +231,14 @@ export class DocumentSDK implements IDocumentSDK {
   private readonly uiTool = new UIToolImpl(this.bridgeToolContext);
   private readonly pageTool = new PageToolImpl(this.bridgeToolContext);
   private readonly findTool = new FindToolImpl(this.bridgeToolContext);
-  private readonly signServerTool = createNotImplementedBridgeTool<SignServerTool>(
-    'signServer',
-    this.bridgeToolContext,
-  );
-  private readonly digitalSignTool = createNotImplementedBridgeTool<DigitalSignTool>(
-    'digitalSign',
-    this.bridgeToolContext,
-  );
-  private readonly symbologyTool = createNotImplementedBridgeTool<SymbologyTool>(
-    'symbology',
-    this.bridgeToolContext,
-  );
-  private readonly annotationTool = this.createAnnotationTool();
-  private readonly templateSignTool = createNotImplementedBridgeTool<TemplateSignTool>(
-    'templateSign',
-    this.bridgeToolContext,
-  );
+  private readonly signServerTool = new SignServerToolImpl(this.bridgeToolContext);
+  private readonly digitalSignTool = new DigitalSignToolImpl(this.bridgeToolContext);
+  private readonly symbologyTool = new SymbologyToolImpl(this.bridgeToolContext);
+  private readonly annotationTool = new AnnotationToolImpl(this.bridgeToolContext);
+  private readonly templateSignTool = new TemplateSignToolImpl(this.bridgeToolContext);
   private readonly pdfFormFiller = new PdfFormFillerImpl(this.bridgeToolContext);
   private readonly networkingTool = new NetworkingToolImpl(this.bridgeToolContext);
-  private readonly cryptoTool = createNotImplementedBridgeTool<CryptoTool>(
-    'crypto',
-    this.bridgeToolContext,
-  );
+  private readonly cryptoTool = new CryptoToolImpl(this.bridgeToolContext);
 
   private readonly readyCallbacks: ReaderReadyCallback[] = [];
   private readonly unloadCallbacks: ReaderUnloadCallback[] = [];
@@ -439,92 +424,6 @@ export class DocumentSDK implements IDocumentSDK {
     return new KVField(key, value, description);
   };
 
-  private createAnnotationTool(): AnnotationTool {
-    return createBridgeToolAdapter<AnnotationTool>(
-      'annotation',
-      {
-        addAnnotationEventCallback: {
-          kind: 'callbackRegister',
-          callback: (callbacks, args) => {
-            const callback = args[0];
-            if (typeof callback === 'function') {
-              callbacks.annotationEvents.push(callback as AnnotationEventCallback);
-            }
-          },
-        },
-        addAnnotationPersistCallback: {
-          kind: 'callbackRegister',
-          callback: (callbacks, args) => {
-            const callback = args[0];
-            if (typeof callback === 'function') {
-              callbacks.annotationPersist.push(callback as (event: unknown) => void);
-            }
-          },
-        },
-        addAnnotationRetrieveCallback: {
-          kind: 'callbackRegister',
-          callback: (callbacks, args) => {
-            const callback = args[0];
-            if (typeof callback === 'function') {
-              callbacks.annotationRetrieve.push(callback as (event: unknown) => void);
-            }
-          },
-        },
-        addDigitalAnnotationRetrieveCallback: {
-          kind: 'callbackRegister',
-          callback: (callbacks, args) => {
-            const callback = args[0];
-            if (typeof callback === 'function') {
-              callbacks.digitalAnnotationRetrieve.push(
-                callback as (annotations: IDigitalAnnotationInfo[]) => void,
-              );
-            }
-          },
-        },
-        isInAnnotationMode: {
-          kind: 'stateGetter',
-          state: (state) => state.annotationEnabled,
-        },
-        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' },
-        selectAnnotationTool: { kind: 'command' },
-        showAnnotationColorPicker: { kind: 'command' },
-        setAnnotationPenType: { kind: 'command' },
-        appendAnnotations: { kind: 'callbackQuery' },
-        batchAppendAnnotations: { kind: 'callbackQuery' },
-        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' },
-      },
-      this.bridgeToolContext,
-    );
-  }
-
   private readonly mountReader = async (
     hostContainer: HTMLDivElement,
     configuration: NormalizedReaderEmbedOptions,

package/src/viewer/SdkCallbackRegistry.ts

@@ -7,12 +7,14 @@ import type {
   PageModeChangeCallback,
 } from '../api/callbacks';
 import type { IDigitalAnnotationInfo } from '../api/annotation-tool';
+import type { ISignServerAuthorization, SignServerAuthCallback } from '../api/sign-server';
 
 export class SdkCallbackRegistry {
   readonly annotationEvents: AnnotationEventCallback[] = [];
   readonly annotationPersist: Array<(event: unknown) => void> = [];
   readonly annotationRetrieve: Array<(event: unknown) => void> = [];
   readonly digitalAnnotationRetrieve: Array<(annotations: IDigitalAnnotationInfo[]) => void> = [];
+  readonly digitalSign: Array<(response: unknown) => void> = [];
   readonly digitalSignatureParse: DigitalSignatureRetrieveCallback[] = [];
   readonly digitalSignatureRetrieve: DigitalSignatureRetrieveCallback[] = [];
   readonly documentClosed: DocumentClosedCallback[] = [];
@@ -20,6 +22,7 @@ export class SdkCallbackRegistry {
   readonly documentSaved: DocumentSavedCallback[] = [];
   readonly pageChange: PageChangeCallback[] = [];
   readonly pageModeChange: PageModeChangeCallback[] = [];
+  readonly signServerAuth: SignServerAuthCallback[] = [];
 
   emit(event: string, payload: unknown): void {
     switch (event) {
@@ -63,6 +66,9 @@ export class SdkCallbackRegistry {
           callback(Array.isArray(payload) ? (payload as IDigitalAnnotationInfo[]) : []),
         );
         return;
+      case 'digitalSign':
+        this.digitalSign.forEach((callback) => callback(payload));
+        return;
       case 'digitalSignatureRetrieve':
         this.digitalSignatureRetrieve.forEach((callback) =>
           callback(Array.isArray(payload) ? payload : []),
@@ -73,6 +79,9 @@ export class SdkCallbackRegistry {
           callback(Array.isArray(payload) ? payload : []),
         );
         return;
+      case 'signServerAuth':
+        this.signServerAuth.forEach((callback) => callback(payload as ISignServerAuthorization));
+        return;
       default:
         return;
     }