@rhc-office/sdk 6.6.256

package/src/tools/UIToolImpl.ts

@@ -0,0 +1,145 @@
+import type { UITool } from '../api/ui-tool';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const BOOK_VIEW_PAGE_MODES = new Set([2, 5]);
+
+const createUIToolDescriptor = (context: BridgeToolAdapterContext): BridgeToolDescriptor => ({
+  showToolbarMenu: { kind: 'command' },
+  hideToolbarMenu: { kind: 'command' },
+  setupToolbarMenu: { kind: 'command' },
+  showToolbarMenuItem: { kind: 'command' },
+  hideToolbarMenuItem: { kind: 'command' },
+  setupRibbonMenu: { kind: 'command' },
+  setupRibbonMenuItem: { kind: 'command' },
+  setupRibbonTitleBar: { kind: 'command' },
+  showRibbonMenu: { kind: 'command' },
+  hideRibbonMenu: { kind: 'command' },
+  showRibbonMenuItem: { kind: 'command' },
+  hideRibbonMenuItem: { kind: 'command' },
+  showRibbonTitleBar: { kind: 'command' },
+  hideRibbonTitleBar: { kind: 'command' },
+  selectRibbonMenu: { kind: 'command' },
+  setRibbonMenuButtonStyle: { kind: 'command' },
+  setWatermark: { kind: 'command' },
+  setCompactMode: { kind: 'command' },
+  enterBookViewMode: {
+    kind: 'callbackQuery',
+    mapCallbackResult: () => [],
+  },
+  exitBookViewMode: { kind: 'command' },
+  isBookViewActivated: {
+    kind: 'stateGetter',
+    state: () => BOOK_VIEW_PAGE_MODES.has(context.state.snapshot().pageMode),
+  },
+  requestFullScreen: { kind: 'command' },
+  exitFullScreen: { kind: 'command' },
+  invalidateView: { kind: 'command' },
+});
+
+export class UIToolImpl implements UITool {
+  private readonly adapter: UITool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<UITool>('ui', createUIToolDescriptor(context), context);
+  }
+
+  showToolbarMenu: UITool['showToolbarMenu'] = () => {
+    return this.adapter.showToolbarMenu();
+  };
+
+  hideToolbarMenu: UITool['hideToolbarMenu'] = () => {
+    return this.adapter.hideToolbarMenu();
+  };
+
+  setupToolbarMenu: UITool['setupToolbarMenu'] = (opt) => {
+    return this.adapter.setupToolbarMenu(opt);
+  };
+
+  showToolbarMenuItem: UITool['showToolbarMenuItem'] = (menuId) => {
+    return this.adapter.showToolbarMenuItem(menuId);
+  };
+
+  hideToolbarMenuItem: UITool['hideToolbarMenuItem'] = (menuId) => {
+    return this.adapter.hideToolbarMenuItem(menuId);
+  };
+
+  setupRibbonMenu: UITool['setupRibbonMenu'] = (opt) => {
+    return this.adapter.setupRibbonMenu(opt);
+  };
+
+  setupRibbonMenuItem: UITool['setupRibbonMenuItem'] = (menuId, visible, config) => {
+    return this.adapter.setupRibbonMenuItem(menuId, visible, config);
+  };
+
+  setupRibbonTitleBar: UITool['setupRibbonTitleBar'] = (visible) => {
+    return this.adapter.setupRibbonTitleBar(visible);
+  };
+
+  showRibbonMenu: UITool['showRibbonMenu'] = () => {
+    return this.adapter.showRibbonMenu();
+  };
+
+  hideRibbonMenu: UITool['hideRibbonMenu'] = () => {
+    return this.adapter.hideRibbonMenu();
+  };
+
+  showRibbonMenuItem: UITool['showRibbonMenuItem'] = (menuId, config) => {
+    return this.adapter.showRibbonMenuItem(menuId, config);
+  };
+
+  hideRibbonMenuItem: UITool['hideRibbonMenuItem'] = (menuId, config) => {
+    return this.adapter.hideRibbonMenuItem(menuId, config);
+  };
+
+  showRibbonTitleBar: UITool['showRibbonTitleBar'] = () => {
+    return this.adapter.showRibbonTitleBar();
+  };
+
+  hideRibbonTitleBar: UITool['hideRibbonTitleBar'] = () => {
+    return this.adapter.hideRibbonTitleBar();
+  };
+
+  selectRibbonMenu: UITool['selectRibbonMenu'] = (menuId) => {
+    return this.adapter.selectRibbonMenu(menuId);
+  };
+
+  setRibbonMenuButtonStyle: UITool['setRibbonMenuButtonStyle'] = (buttonId, buttonStyle) => {
+    return this.adapter.setRibbonMenuButtonStyle(buttonId, buttonStyle);
+  };
+
+  setWatermark: UITool['setWatermark'] = (fields) => {
+    return this.adapter.setWatermark(fields);
+  };
+
+  setCompactMode: UITool['setCompactMode'] = (compact) => {
+    return this.adapter.setCompactMode(compact);
+  };
+
+  enterBookViewMode: UITool['enterBookViewMode'] = (callback) => {
+    return this.adapter.enterBookViewMode(callback);
+  };
+
+  exitBookViewMode: UITool['exitBookViewMode'] = () => {
+    return this.adapter.exitBookViewMode();
+  };
+
+  isBookViewActivated: UITool['isBookViewActivated'] = () => {
+    return this.adapter.isBookViewActivated();
+  };
+
+  requestFullScreen: UITool['requestFullScreen'] = () => {
+    return this.adapter.requestFullScreen();
+  };
+
+  exitFullScreen: UITool['exitFullScreen'] = () => {
+    return this.adapter.exitFullScreen();
+  };
+
+  invalidateView: UITool['invalidateView'] = () => {
+    return this.adapter.invalidateView();
+  };
+}

package/src/tools/index.ts

@@ -0,0 +1,8 @@
+export * from './DocumentToolImpl';
+export * from './FindToolImpl';
+export * from './NetworkingToolImpl';
+export * from './PageToolImpl';
+export * from './PdfFormFillerImpl';
+export * from './Phase1ToolPlaceholder';
+export * from './SDKValueObjects';
+export * from './UIToolImpl';

package/src/viewer/AdapterProtocol.ts

@@ -0,0 +1,114 @@
+export const RHC_OFFICE_ADAPTER_PROTOCOL = 'rhc-office.editor-adapter';
+export const RHC_OFFICE_ADAPTER_VERSION = 1;
+export const RHC_OFFICE_ADAPTER_GLOBAL = '__RHC_OFFICE_EDITOR_ADAPTER__';
+export const RHC_OFFICE_ADAPTER_READY_EVENT = 'rhcOfficeAdapterReady';
+export const RHC_OFFICE_ADAPTER_EVENT = 'rhcOfficeAdapterEvent';
+export const RHC_OFFICE_READER_ID_ATTRIBUTE = 'data-rhc-office-reader-id';
+
+export type AdapterToolName =
+  | 'document'
+  | 'page'
+  | 'ui'
+  | 'find'
+  | 'annotation'
+  | 'digitalSign'
+  | 'signServer'
+  | 'review'
+  | 'ekey'
+  | 'symbology'
+  | 'templateSign'
+  | 'pdfFormFiller'
+  | 'extension'
+  | 'networking'
+  | 'crypto';
+
+export type AdapterErrorCode =
+  | 'ADAPTER_UNAVAILABLE'
+  | 'READER_NOT_READY'
+  | 'READER_NOT_FOUND'
+  | 'COMMAND_NOT_FOUND'
+  | 'NOT_IMPLEMENTED'
+  | 'INVALID_PARAMS'
+  | 'EXECUTION_FAILED'
+  | 'TIMEOUT';
+
+export interface AdapterError {
+  code: AdapterErrorCode;
+  message: string;
+  details?: unknown;
+}
+
+export interface AdapterRequest<TParams = unknown> {
+  protocol: typeof RHC_OFFICE_ADAPTER_PROTOCOL;
+  version: typeof RHC_OFFICE_ADAPTER_VERSION;
+  requestId: string;
+  readerId: string;
+  tool: AdapterToolName;
+  method: string;
+  params?: TParams;
+}
+
+export type AdapterResponse<TResult = unknown> =
+  | {
+      ok: true;
+      requestId: string;
+      result: TResult;
+    }
+  | {
+      ok: false;
+      requestId: string;
+      error: AdapterError;
+    };
+
+export interface AdapterCommandCapability {
+  implemented: boolean;
+  method: string;
+  tool: AdapterToolName;
+}
+
+export interface AdapterCapabilityManifest {
+  version: typeof RHC_OFFICE_ADAPTER_VERSION;
+  tools: AdapterToolName[];
+  commands: AdapterCommandCapability[];
+}
+
+export interface AdapterStatePatch {
+  documentOpened?: boolean;
+  documentModified?: boolean;
+  pageCount?: number;
+  pageIndex?: number;
+  pageMode?: number;
+  zoomLevel?: number;
+  documentType?: string;
+  annotationMode?: string;
+  annotationEnabled?: boolean;
+  extensionState?: 'connected' | 'disconnected';
+}
+
+export interface AdapterEvent<TPayload = unknown> {
+  protocol: typeof RHC_OFFICE_ADAPTER_PROTOCOL;
+  version: typeof RHC_OFFICE_ADAPTER_VERSION;
+  readerId: string;
+  event: string;
+  payload?: TPayload;
+  statePatch?: AdapterStatePatch;
+}
+
+export interface AdapterReadyEventDetail {
+  protocol: typeof RHC_OFFICE_ADAPTER_PROTOCOL;
+  version: typeof RHC_OFFICE_ADAPTER_VERSION;
+  readerId: string;
+}
+
+export interface AdapterReaderSession {
+  readerId: string;
+  capabilities: AdapterCapabilityManifest;
+  request(request: AdapterRequest): Promise<AdapterResponse>;
+}
+
+export interface AdapterGlobal {
+  registerReader(session: AdapterReaderSession): void;
+  unregisterReader(readerId: string): void;
+  request(request: AdapterRequest): Promise<AdapterResponse>;
+  getCapabilities(readerId: string): AdapterCapabilityManifest | null;
+}

package/src/viewer/BridgeToolAdapter.ts

@@ -0,0 +1,137 @@
+import type { AdapterToolName } from './AdapterProtocol';
+import type { ReaderBridgeClient } from './ReaderBridgeClient';
+import type { SdkCallbackRegistry } from './SdkCallbackRegistry';
+import type { ReaderStateStore } from './ReaderStateStore';
+
+export type BridgeMethodKind =
+  | 'callbackQuery'
+  | 'callbackRegister'
+  | 'command'
+  | 'query'
+  | 'stateGetter';
+
+export interface BridgeToolMethodDescriptor {
+  adapterMethod?: string;
+  callback?: (callbacks: SdkCallbackRegistry, args: unknown[]) => void;
+  mapCallbackResult?: (result: unknown) => unknown[];
+  kind: BridgeMethodKind;
+  state?: (state: ReturnType<ReaderStateStore['snapshot']>, args: unknown[]) => unknown;
+}
+
+export type BridgeToolDescriptor = Record<string, BridgeToolMethodDescriptor>;
+
+export interface BridgeToolAdapterContext {
+  bridge: ReaderBridgeClient;
+  callbacks: SdkCallbackRegistry;
+  debug: () => boolean;
+  onAsyncError: (error: unknown) => void;
+  state: ReaderStateStore;
+}
+
+const normalizeParams = (args: unknown[]): unknown => {
+  if (args.length === 0) {
+    return undefined;
+  }
+
+  if (args.length === 1) {
+    return args[0];
+  }
+
+  return args;
+};
+
+export const createBridgeToolAdapter = <T extends object>(
+  tool: AdapterToolName,
+  descriptor: BridgeToolDescriptor,
+  context: BridgeToolAdapterContext,
+): T => {
+  return new Proxy(
+    {},
+    {
+      get: (_target, property): unknown => {
+        if (property === 'then') {
+          return undefined;
+        }
+
+        if (typeof property === 'symbol') {
+          if (property === Symbol.toStringTag) {
+            return tool;
+          }
+
+          return undefined;
+        }
+
+        const methodDescriptor = descriptor[property];
+        if (!methodDescriptor) {
+          return (..._args: unknown[]) => {
+            const error = new Error(`${tool}.${property} is not implemented by the SDK adapter.`);
+            context.onAsyncError(error);
+          };
+        }
+
+        return (...args: unknown[]) => {
+          if (methodDescriptor.kind === 'callbackRegister') {
+            methodDescriptor.callback?.(context.callbacks, args);
+            return undefined;
+          }
+
+          if (methodDescriptor.kind === 'stateGetter') {
+            return methodDescriptor.state?.(context.state.snapshot(), args);
+          }
+
+          const adapterMethod = methodDescriptor.adapterMethod ?? property;
+
+          if (methodDescriptor.kind === 'query') {
+            return context.bridge.request(tool, adapterMethod, normalizeParams(args));
+          }
+
+          if (methodDescriptor.kind === 'callbackQuery') {
+            const callback = args.find((arg) => typeof arg === 'function') as
+              | ((...values: unknown[]) => void)
+              | undefined;
+            const params = args.filter((arg) => typeof arg !== 'function');
+            void context.bridge
+              .request(tool, adapterMethod, normalizeParams(params))
+              .then((result) => {
+                const callbackArgs = methodDescriptor.mapCallbackResult?.(result) ?? [result];
+                callback?.(...callbackArgs);
+              })
+              .catch(context.onAsyncError);
+            return undefined;
+          }
+
+          void context.bridge
+            .request(tool, adapterMethod, normalizeParams(args))
+            .catch(context.onAsyncError);
+          return undefined;
+        };
+      },
+    },
+  ) as T;
+};
+
+export const createNotImplementedBridgeTool = <T extends object>(
+  tool: AdapterToolName,
+  context: BridgeToolAdapterContext,
+): T => {
+  return new Proxy(
+    {},
+    {
+      get: (_target, property): unknown => {
+        if (property === 'then') {
+          return undefined;
+        }
+
+        if (typeof property === 'symbol') {
+          return undefined;
+        }
+
+        return (..._args: unknown[]) => {
+          const message = `${tool}.${property} is not implemented by the SDK adapter.`;
+          context.onAsyncError(new Error(message));
+          return undefined;
+        };
+      },
+    },
+  ) as T;
+};