@rhc-office/sdk 6.6.266 → 6.6.351

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();
+  };
+}

package/src/tools/SecurityToolImpl.ts

@@ -0,0 +1,48 @@
+import type { SecurityTool } from '../api/security-tool';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const SECURITY_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
+  getSecuritySettings: { kind: 'query' },
+  isSecuritySettingsLocalEditable: { kind: 'query' },
+  setSecuritySettingsLocalEditable: { kind: 'query' },
+  setSecuritySettings: { kind: 'query' },
+  openSecuritySettingsDialog: { kind: 'command' },
+};
+
+export class SecurityToolImpl implements SecurityTool {
+  private readonly adapter: SecurityTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<SecurityTool>(
+      'security',
+      SECURITY_TOOL_DESCRIPTOR,
+      context,
+    );
+  }
+
+  getSecuritySettings: SecurityTool['getSecuritySettings'] = () => {
+    return this.adapter.getSecuritySettings();
+  };
+
+  setSecuritySettings: SecurityTool['setSecuritySettings'] = (update) => {
+    return this.adapter.setSecuritySettings(update);
+  };
+
+  isSecuritySettingsLocalEditable: SecurityTool['isSecuritySettingsLocalEditable'] = () => {
+    return this.adapter.isSecuritySettingsLocalEditable();
+  };
+
+  setSecuritySettingsLocalEditable: SecurityTool['setSecuritySettingsLocalEditable'] = (
+    editable,
+  ) => {
+    return this.adapter.setSecuritySettingsLocalEditable(editable);
+  };
+
+  openSecuritySettingsDialog: SecurityTool['openSecuritySettingsDialog'] = () => {
+    return this.adapter.openSecuritySettingsDialog();
+  };
+}

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/UIToolImpl.ts

@@ -22,10 +22,22 @@ const createUIToolDescriptor = (context: BridgeToolAdapterContext): BridgeToolDe
   hideRibbonMenuItem: { kind: 'command' },
   showRibbonTitleBar: { kind: 'command' },
   hideRibbonTitleBar: { kind: 'command' },
+  showRibbonTabs: { kind: 'command' },
+  hideRibbonTabs: { kind: 'command' },
   selectRibbonMenu: { kind: 'command' },
+  setupRibbonMenuTab: { kind: 'command' },
+  showRibbonMenuTab: { kind: 'command' },
+  hideRibbonMenuTab: { kind: 'command' },
+  enableRibbonMenuTab: { kind: 'command' },
+  disableRibbonMenuTab: { kind: 'command' },
+  setupRibbonMenuItemState: { kind: 'command' },
+  enableRibbonMenuItem: { kind: 'command' },
+  disableRibbonMenuItem: { kind: 'command' },
   setRibbonMenuButtonStyle: { kind: 'command' },
   setWatermark: { kind: 'command' },
   setCompactMode: { kind: 'command' },
+  setRulerVisible: { kind: 'command' },
+  toggleSidebar: { kind: 'command' },
   enterBookViewMode: {
     kind: 'callbackQuery',
     mapCallbackResult: () => [],
@@ -48,35 +60,53 @@ export class UIToolImpl implements UITool {
   }
 
   showToolbarMenu: UITool['showToolbarMenu'] = () => {
-    return this.adapter.showToolbarMenu();
+    this.warnLegacyRibbonMethod('showToolbarMenu', 'showRibbonMenu');
+    return this.showRibbonMenu();
   };
 
   hideToolbarMenu: UITool['hideToolbarMenu'] = () => {
-    return this.adapter.hideToolbarMenu();
+    this.warnLegacyRibbonMethod('hideToolbarMenu', 'hideRibbonMenu');
+    return this.hideRibbonMenu();
   };
 
   setupToolbarMenu: UITool['setupToolbarMenu'] = (opt) => {
-    return this.adapter.setupToolbarMenu(opt);
+    this.warnLegacyRibbonMethod(
+      'setupToolbarMenu',
+      'showRibbonMenu/hideRibbonMenu/setupRibbonMenuTab',
+    );
+    return this.setupRibbonMenu(opt);
   };
 
   showToolbarMenuItem: UITool['showToolbarMenuItem'] = (menuId) => {
-    return this.adapter.showToolbarMenuItem(menuId);
+    this.warnLegacyRibbonMethod('showToolbarMenuItem', 'showRibbonMenuItem');
+    return this.showRibbonMenuItem(menuId);
   };
 
   hideToolbarMenuItem: UITool['hideToolbarMenuItem'] = (menuId) => {
-    return this.adapter.hideToolbarMenuItem(menuId);
+    this.warnLegacyRibbonMethod('hideToolbarMenuItem', 'hideRibbonMenuItem');
+    return this.hideRibbonMenuItem(menuId);
   };
 
   setupRibbonMenu: UITool['setupRibbonMenu'] = (opt) => {
-    return this.adapter.setupRibbonMenu(opt);
+    this.warnLegacyRibbonMethod(
+      'setupRibbonMenu',
+      'showRibbonMenu/hideRibbonMenu/setupRibbonMenuTab',
+    );
+    if (typeof opt === 'boolean') {
+      return opt ? this.showRibbonMenu() : this.hideRibbonMenu();
+    }
+
+    return this.setupRibbonMenuTab(opt.menu, { visible: opt.visible });
   };
 
   setupRibbonMenuItem: UITool['setupRibbonMenuItem'] = (menuId, visible, config) => {
-    return this.adapter.setupRibbonMenuItem(menuId, visible, config);
+    this.warnLegacyRibbonMethod('setupRibbonMenuItem', 'setupRibbonMenuItemState');
+    return this.setupRibbonMenuItemState(menuId, { visible, config });
   };
 
   setupRibbonTitleBar: UITool['setupRibbonTitleBar'] = (visible) => {
-    return this.adapter.setupRibbonTitleBar(visible);
+    this.warnLegacyRibbonMethod('setupRibbonTitleBar', 'showRibbonTabs/hideRibbonTabs');
+    return visible ? this.showRibbonTabs() : this.hideRibbonTabs();
   };
 
   showRibbonMenu: UITool['showRibbonMenu'] = () => {
@@ -88,25 +118,69 @@ export class UIToolImpl implements UITool {
   };
 
   showRibbonMenuItem: UITool['showRibbonMenuItem'] = (menuId, config) => {
-    return this.adapter.showRibbonMenuItem(menuId, config);
+    this.warnLegacyRibbonMethod('showRibbonMenuItem', 'setupRibbonMenuItemState');
+    return this.setupRibbonMenuItemState(menuId, { visible: true, config });
   };
 
   hideRibbonMenuItem: UITool['hideRibbonMenuItem'] = (menuId, config) => {
-    return this.adapter.hideRibbonMenuItem(menuId, config);
+    this.warnLegacyRibbonMethod('hideRibbonMenuItem', 'setupRibbonMenuItemState');
+    return this.setupRibbonMenuItemState(menuId, { visible: false, config });
   };
 
   showRibbonTitleBar: UITool['showRibbonTitleBar'] = () => {
-    return this.adapter.showRibbonTitleBar();
+    this.warnLegacyRibbonMethod('showRibbonTitleBar', 'showRibbonTabs');
+    return this.showRibbonTabs();
   };
 
   hideRibbonTitleBar: UITool['hideRibbonTitleBar'] = () => {
-    return this.adapter.hideRibbonTitleBar();
+    this.warnLegacyRibbonMethod('hideRibbonTitleBar', 'hideRibbonTabs');
+    return this.hideRibbonTabs();
+  };
+
+  showRibbonTabs: UITool['showRibbonTabs'] = () => {
+    return this.adapter.showRibbonTabs();
+  };
+
+  hideRibbonTabs: UITool['hideRibbonTabs'] = () => {
+    return this.adapter.hideRibbonTabs();
   };
 
   selectRibbonMenu: UITool['selectRibbonMenu'] = (menuId) => {
     return this.adapter.selectRibbonMenu(menuId);
   };
 
+  setupRibbonMenuTab: UITool['setupRibbonMenuTab'] = (menuId, state) => {
+    return this.adapter.setupRibbonMenuTab(menuId, state);
+  };
+
+  showRibbonMenuTab: UITool['showRibbonMenuTab'] = (menuId) => {
+    return this.adapter.showRibbonMenuTab(menuId);
+  };
+
+  hideRibbonMenuTab: UITool['hideRibbonMenuTab'] = (menuId) => {
+    return this.adapter.hideRibbonMenuTab(menuId);
+  };
+
+  enableRibbonMenuTab: UITool['enableRibbonMenuTab'] = (menuId) => {
+    return this.adapter.enableRibbonMenuTab(menuId);
+  };
+
+  disableRibbonMenuTab: UITool['disableRibbonMenuTab'] = (menuId) => {
+    return this.adapter.disableRibbonMenuTab(menuId);
+  };
+
+  setupRibbonMenuItemState: UITool['setupRibbonMenuItemState'] = (menuId, state) => {
+    return this.adapter.setupRibbonMenuItemState(menuId, state);
+  };
+
+  enableRibbonMenuItem: UITool['enableRibbonMenuItem'] = (menuId, config) => {
+    return this.setupRibbonMenuItemState(menuId, { disabled: false, config });
+  };
+
+  disableRibbonMenuItem: UITool['disableRibbonMenuItem'] = (menuId, config) => {
+    return this.setupRibbonMenuItemState(menuId, { disabled: true, config });
+  };
+
   setRibbonMenuButtonStyle: UITool['setRibbonMenuButtonStyle'] = (buttonId, buttonStyle) => {
     return this.adapter.setRibbonMenuButtonStyle(buttonId, buttonStyle);
   };
@@ -119,6 +193,14 @@ export class UIToolImpl implements UITool {
     return this.adapter.setCompactMode(compact);
   };
 
+  setRulerVisible: UITool['setRulerVisible'] = (visible) => {
+    return this.adapter.setRulerVisible(visible);
+  };
+
+  toggleSidebar: UITool['toggleSidebar'] = () => {
+    return this.adapter.toggleSidebar();
+  };
+
   enterBookViewMode: UITool['enterBookViewMode'] = (callback) => {
     return this.adapter.enterBookViewMode(callback);
   };
@@ -142,4 +224,8 @@ export class UIToolImpl implements UITool {
   invalidateView: UITool['invalidateView'] = () => {
     return this.adapter.invalidateView();
   };
+
+  private warnLegacyRibbonMethod(methodName: string, replacement: string): void {
+    console.warn(`[RHC Office SDK] ui.${methodName} is deprecated. Use ui.${replacement} instead.`);
+  }
 }

package/src/tools/index.ts

@@ -1,8 +1,15 @@
+export * from './AnnotationToolImpl';
+export * from './CryptoToolImpl';
+export * from './DigitalSignToolImpl';
 export * from './DocumentToolImpl';
 export * from './FindToolImpl';
 export * from './NetworkingToolImpl';
+export * from './PageArrangeToolImpl';
 export * from './PageToolImpl';
 export * from './PdfFormFillerImpl';
-export * from './Phase1ToolPlaceholder';
 export * from './SDKValueObjects';
+export * from './SecurityToolImpl';
+export * from './SignServerToolImpl';
+export * from './SymbologyToolImpl';
+export * from './TemplateSignToolImpl';
 export * from './UIToolImpl';

package/src/viewer/AdapterProtocol.ts

@@ -8,9 +8,11 @@ export const RHC_OFFICE_READER_ID_ATTRIBUTE = 'data-rhc-office-reader-id';
 export type AdapterToolName =
   | 'document'
   | 'page'
+  | 'pageArrange'
   | 'ui'
   | 'find'
   | 'annotation'
+  | 'security'
   | 'digitalSign'
   | 'signServer'
   | 'review'
@@ -82,6 +84,8 @@ export interface AdapterStatePatch {
   documentType?: string;
   annotationMode?: string;
   annotationEnabled?: boolean;
+  annotations?: unknown[];
+  digitalSignatures?: unknown[];
   extensionState?: 'connected' | 'disconnected';
 }
 

package/src/viewer/BridgeToolAdapter.ts

@@ -15,6 +15,7 @@ export interface BridgeToolMethodDescriptor {
   callback?: (callbacks: SdkCallbackRegistry, args: unknown[]) => void;
   mapCallbackResult?: (result: unknown) => unknown[];
   kind: BridgeMethodKind;
+  returnsResult?: boolean;
   state?: (state: ReturnType<ReaderStateStore['snapshot']>, args: unknown[]) => unknown;
 }
 
@@ -100,9 +101,17 @@ export const createBridgeToolAdapter = <T extends object>(
             return undefined;
           }
 
-          void context.bridge
+          const commandRequest = context.bridge
             .request(tool, adapterMethod, normalizeParams(args))
-            .catch(context.onAsyncError);
+            .catch((error): undefined => {
+              context.onAsyncError(error);
+              return undefined;
+            });
+          if (methodDescriptor.returnsResult) {
+            return commandRequest;
+          }
+
+          void commandRequest;
           return undefined;
         };
       },