@rhc-office/sdk 6.6.256

package/src/viewer/DocumentSDK.ts

@@ -0,0 +1,688 @@
+import type { AnnotationTool } from '../api/annotation-tool';
+import type { IDigitalAnnotationInfo } from '../api/annotation-tool';
+import type { CryptoTool } from '../api/crypto-tool';
+import type {
+  AnnotationEventCallback,
+  ExtensionStateChangedCallback,
+  ReaderReadyCallback,
+  ReaderUnloadCallback,
+} from '../api/callbacks';
+import type { IDocumentSDK, IReaderEmbedOptions } from '../api/document-sdk';
+import type { DocumentTool } from '../api/document-tool';
+import type { EkeyTool } from '../api/ekey-tool';
+import type { ExtensionTool } from '../api/extension-tool';
+import type { FindTool } from '../api/find-tool';
+import type { NetworkingTool } from '../api/networking-tool';
+import type { PageTool } from '../api/page-tool';
+import type { PdfFormFiller } from '../api/pdf-formfiller';
+import type { ReviewTool } from '../api/review-tool';
+import type { SignServerTool } from '../api/sign-server';
+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 { 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 { UIToolImpl } from '../tools/UIToolImpl';
+import type { NormalizedReaderEmbedOptions } from './ReaderConfiguration';
+import { normalizeAppUrl, normalizeReaderEmbedOptions } from './ReaderConfiguration';
+import {
+  assertCompatibleReaderSource,
+  ensureReaderScriptLoaded,
+  READER_CUSTOM_ELEMENT_TAG,
+} from './ReaderScriptLoader';
+import {
+  RHC_OFFICE_ADAPTER_EVENT,
+  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';
+
+type ReaderEventListener = Parameters<IDocumentSDK['setReaderEventListener']>[0];
+type ReaderEventPayload = Parameters<NonNullable<ReaderEventListener>>[1];
+
+interface DocumentSDKRuntimeOptions {
+  adapterReadyTimeoutMs?: number;
+  adapterRequestTimeoutMs?: number;
+}
+
+type NativeReaderEventName = 'documentLoaded' | 'documentStateChange' | 'documentError';
+type ReaderThemeCleanup = () => void;
+type CompatibleMediaQueryList = MediaQueryList & {
+  addListener?: (listener: (event: MediaQueryListEvent) => void) => void;
+  removeListener?: (listener: (event: MediaQueryListEvent) => void) => void;
+};
+
+const NATIVE_READER_EVENT_NAMES: NativeReaderEventName[] = [
+  'documentLoaded',
+  'documentStateChange',
+  'documentError',
+];
+
+const READER_READY_EVENT_NAME = 'readerReady';
+const READER_UNLOAD_EVENT_NAME = 'readerUnload';
+const READER_ERROR_EVENT_NAME = 'readerError';
+
+const createReaderId = (): string => {
+  if (typeof globalThis.crypto?.randomUUID === 'function') {
+    return globalThis.crypto.randomUUID();
+  }
+
+  return `rhc-reader-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+};
+
+const createReaderPayload = (
+  readerElement: HTMLElement | null,
+  configuration: NormalizedReaderEmbedOptions | null,
+): Record<string, unknown> => {
+  return {
+    appUrl: configuration?.officeServer ?? null,
+    configuration,
+    element: readerElement,
+  };
+};
+
+const resolveContainerElement = (container: string | HTMLDivElement): HTMLDivElement => {
+  if (typeof container === 'string') {
+    const element = document.getElementById(container);
+    if (!element) {
+      throw new Error(`Reader container "${container}" was not found.`);
+    }
+
+    if (!(element instanceof HTMLDivElement)) {
+      throw new Error(`Reader container "${container}" must be a div element.`);
+    }
+
+    return element;
+  }
+
+  if (!(container instanceof HTMLDivElement)) {
+    throw new Error('Reader container must be a div element.');
+  }
+
+  return container;
+};
+
+const resolveSystemReaderTheme = (): 'light' | 'dark' | 'high-contrast' => {
+  const supportsMatchMedia = typeof globalThis.matchMedia === 'function';
+  const prefersHighContrast = supportsMatchMedia
+    ? globalThis.matchMedia('(prefers-contrast: more)').matches
+    : false;
+  if (prefersHighContrast) {
+    return 'high-contrast';
+  }
+
+  const prefersDark = supportsMatchMedia
+    ? globalThis.matchMedia('(prefers-color-scheme: dark)').matches
+    : false;
+  return prefersDark ? 'dark' : 'light';
+};
+
+const addMediaQueryListener = (
+  mediaQuery: MediaQueryList,
+  listener: (event: MediaQueryListEvent) => void,
+): void => {
+  const compatibleMediaQuery = mediaQuery as CompatibleMediaQueryList;
+  if (typeof compatibleMediaQuery.addEventListener === 'function') {
+    compatibleMediaQuery.addEventListener('change', listener);
+    return;
+  }
+
+  if (typeof compatibleMediaQuery.addListener === 'function') {
+    compatibleMediaQuery.addListener(listener);
+  }
+};
+
+const removeMediaQueryListener = (
+  mediaQuery: MediaQueryList,
+  listener: (event: MediaQueryListEvent) => void,
+): void => {
+  const compatibleMediaQuery = mediaQuery as CompatibleMediaQueryList;
+  if (typeof compatibleMediaQuery.removeEventListener === 'function') {
+    compatibleMediaQuery.removeEventListener('change', listener);
+    return;
+  }
+
+  if (typeof compatibleMediaQuery.removeListener === 'function') {
+    compatibleMediaQuery.removeListener(listener);
+  }
+};
+
+const applyReaderElementLayout = (
+  readerElement: HTMLElement,
+  configuration: NormalizedReaderEmbedOptions,
+): void => {
+  if (configuration.style) {
+    readerElement.style.cssText = configuration.style;
+  }
+
+  if (!readerElement.style.display) {
+    readerElement.style.display = 'block';
+  }
+
+  if (!readerElement.style.width) {
+    readerElement.style.width = configuration.width ?? '100%';
+  } else if (configuration.width) {
+    readerElement.style.width = configuration.width;
+  }
+
+  if (!readerElement.style.height) {
+    readerElement.style.height = configuration.height ?? '100%';
+  } else if (configuration.height) {
+    readerElement.style.height = configuration.height;
+  }
+};
+
+const bindReaderElementTheme = (
+  readerElement: HTMLElement,
+  configuration: NormalizedReaderEmbedOptions,
+): ReaderThemeCleanup | null => {
+  const configuredTheme = configuration.theme;
+  if (!configuredTheme) {
+    readerElement.removeAttribute('theme');
+    return null;
+  }
+
+  if (configuredTheme !== 'auto') {
+    readerElement.setAttribute('theme', configuredTheme);
+    return null;
+  }
+
+  const applySystemTheme = (): void => {
+    readerElement.setAttribute('theme', resolveSystemReaderTheme());
+  };
+
+  applySystemTheme();
+
+  if (typeof globalThis.matchMedia !== 'function') {
+    return null;
+  }
+
+  const colorSchemeMediaQuery = globalThis.matchMedia('(prefers-color-scheme: dark)');
+  const contrastMediaQuery = globalThis.matchMedia('(prefers-contrast: more)');
+  const handleThemeChange = (): void => {
+    applySystemTheme();
+  };
+
+  addMediaQueryListener(colorSchemeMediaQuery, handleThemeChange);
+  addMediaQueryListener(contrastMediaQuery, handleThemeChange);
+
+  return () => {
+    removeMediaQueryListener(colorSchemeMediaQuery, handleThemeChange);
+    removeMediaQueryListener(contrastMediaQuery, handleThemeChange);
+  };
+};
+
+export class DocumentSDK implements IDocumentSDK {
+  private readonly bridge = new ReaderBridgeClient();
+  private readonly callbacks = new SdkCallbackRegistry();
+  private readonly readerState = new ReaderStateStore();
+  private readonly bridgeToolContext = {
+    bridge: this.bridge,
+    callbacks: this.callbacks,
+    debug: () => this.debugEnabled,
+    onAsyncError: (error: unknown) => this.reportAdapterError(error),
+    state: this.readerState,
+  };
+  private readonly documentTool = new DocumentToolImpl(this.bridgeToolContext);
+  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 reviewTool = createNotImplementedBridgeTool<ReviewTool>(
+    'review',
+    this.bridgeToolContext,
+  );
+  private readonly ekeyTool = createNotImplementedBridgeTool<EkeyTool>(
+    'ekey',
+    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 pdfFormFiller = new PdfFormFillerImpl(this.bridgeToolContext);
+  private readonly extensionTool = this.createExtensionTool();
+  private readonly networkingTool = new NetworkingToolImpl(this.bridgeToolContext);
+  private readonly cryptoTool = createNotImplementedBridgeTool<CryptoTool>(
+    'crypto',
+    this.bridgeToolContext,
+  );
+
+  private readonly readyCallbacks: ReaderReadyCallback[] = [];
+  private readonly unloadCallbacks: ReaderUnloadCallback[] = [];
+
+  private debugEnabled = false;
+  private isReady = false;
+  private removed = false;
+  private mountToken = 0;
+
+  private readerEventListener?: ReaderEventListener;
+  private hostContainer: HTMLDivElement | null = null;
+  private readerElement: HTMLElement | null = null;
+  private readerId: string | null = null;
+  private normalizedConfiguration: NormalizedReaderEmbedOptions | null = null;
+  private sessionUser?: Parameters<IDocumentSDK['setSessionUser']>[0];
+  private sessionData?: string;
+  private license?: { license: string; feature: string };
+  private readonly nativeEventCleanupCallbacks: Array<() => void> = [];
+  private themeCleanup: ReaderThemeCleanup | null = null;
+
+  constructor(options?: DocumentSDKRuntimeOptions) {
+    this.bridge.configureTimeouts({
+      readyTimeoutMs: options?.adapterReadyTimeoutMs,
+      requestTimeoutMs: options?.adapterRequestTimeoutMs,
+    });
+  }
+
+  readonly enableDebug: IDocumentSDK['enableDebug'] = (debug): void => {
+    this.debugEnabled = debug;
+  };
+
+  readonly changeLanguage: IDocumentSDK['changeLanguage'] = (): void => {
+    // Phase 1: reserved for future reader language bridging.
+  };
+
+  readonly setLicense: IDocumentSDK['setLicense'] = (license, feature): void => {
+    this.license = { license, feature };
+  };
+
+  readonly setSessionUser: IDocumentSDK['setSessionUser'] = (userNameOrInfo): void => {
+    this.sessionUser = userNameOrInfo;
+  };
+
+  readonly setSessionUserId: IDocumentSDK['setSessionUserId'] = (userId): void => {
+    if (typeof this.sessionUser === 'string' || !this.sessionUser) {
+      this.sessionUser = {
+        userName: typeof this.sessionUser === 'string' ? this.sessionUser : '',
+        userId,
+      };
+      return;
+    }
+
+    this.sessionUser = {
+      ...this.sessionUser,
+      userId,
+    };
+  };
+
+  readonly setSessionData: IDocumentSDK['setSessionData'] = (sessionData): void => {
+    this.sessionData = sessionData;
+  };
+
+  readonly isReaderReady: IDocumentSDK['isReaderReady'] = (): boolean => {
+    return this.isReady;
+  };
+
+  readonly isReaderDestroyed: IDocumentSDK['isReaderDestroyed'] = (): boolean => {
+    return this.removed && !this.isReady;
+  };
+
+  readonly addReaderReadyCallback: IDocumentSDK['addReaderReadyCallback'] = (callback): void => {
+    this.readyCallbacks.push(callback);
+  };
+
+  readonly addReaderUnloadCallback: IDocumentSDK['addReaderUnloadCallback'] = (callback): void => {
+    this.unloadCallbacks.push(callback);
+  };
+
+  readonly setReaderEventListener: IDocumentSDK['setReaderEventListener'] = (callback): void => {
+    this.readerEventListener = callback;
+  };
+
+  readonly embedReader: IDocumentSDK['embedReader'] = (container, appUrl, configuration): void => {
+    const hostContainer = resolveContainerElement(container);
+    const normalizedAppUrl = normalizeAppUrl(appUrl);
+    assertCompatibleReaderSource(normalizedAppUrl);
+
+    const normalizedConfiguration = normalizeReaderEmbedOptions(normalizedAppUrl, configuration);
+    const mountToken = this.mountToken + 1;
+
+    this.removeReader();
+
+    this.mountToken = mountToken;
+    this.removed = false;
+    this.hostContainer = hostContainer;
+    this.normalizedConfiguration = normalizedConfiguration;
+
+    void this.mountReader(hostContainer, normalizedConfiguration, mountToken);
+  };
+
+  readonly removeReader: IDocumentSDK['removeReader'] = (): void => {
+    const hadMountedReader = Boolean(this.readerElement || this.hostContainer);
+
+    this.mountToken += 1;
+    this.cleanupNativeEventForwarders();
+    this.cleanupThemeBinding();
+
+    if (this.readerElement?.parentNode) {
+      this.readerElement.parentNode.removeChild(this.readerElement);
+    }
+
+    this.readerElement = null;
+    this.readerId = null;
+    this.bridge.setReaderId(null);
+    this.readerState.reset();
+    this.hostContainer = null;
+    this.normalizedConfiguration = null;
+    this.isReady = false;
+    this.removed = true;
+
+    if (!hadMountedReader) {
+      return;
+    }
+
+    const payload = createReaderPayload(null, null);
+    this.emitReaderEvent(READER_UNLOAD_EVENT_NAME, payload);
+    this.unloadCallbacks.forEach((callback) => callback());
+  };
+
+  readonly getDocumentTool: IDocumentSDK['getDocumentTool'] = (): DocumentTool => {
+    return this.documentTool;
+  };
+
+  readonly getUITool: IDocumentSDK['getUITool'] = (): UITool => {
+    return this.uiTool;
+  };
+
+  readonly getPageTool: IDocumentSDK['getPageTool'] = (): PageTool => {
+    return this.pageTool;
+  };
+
+  readonly getFindTool: IDocumentSDK['getFindTool'] = (): FindTool => {
+    return this.findTool;
+  };
+
+  readonly getSignServerTool: IDocumentSDK['getSignServerTool'] = (): SignServerTool => {
+    return this.signServerTool;
+  };
+
+  readonly getDigitalSignTool: IDocumentSDK['getDigitalSignTool'] = (): DigitalSignTool => {
+    return this.digitalSignTool;
+  };
+
+  readonly getReviewTool: IDocumentSDK['getReviewTool'] = (): ReviewTool => {
+    return this.reviewTool;
+  };
+
+  readonly getEkeyTool: IDocumentSDK['getEkeyTool'] = (): EkeyTool => {
+    return this.ekeyTool;
+  };
+
+  readonly getSymbologyTool: IDocumentSDK['getSymbologyTool'] = (): SymbologyTool => {
+    return this.symbologyTool;
+  };
+
+  readonly getAnnotationTool: IDocumentSDK['getAnnotationTool'] = (): AnnotationTool => {
+    return this.annotationTool;
+  };
+
+  readonly getTemplateSignTool: IDocumentSDK['getTemplateSignTool'] = (): TemplateSignTool => {
+    return this.templateSignTool;
+  };
+
+  readonly getPdfFormFiller: IDocumentSDK['getPdfFormFiller'] = (): PdfFormFiller => {
+    return this.pdfFormFiller;
+  };
+
+  readonly getExtensionTool: IDocumentSDK['getExtensionTool'] = (): ExtensionTool => {
+    return this.extensionTool;
+  };
+
+  readonly getNetworkingTool: IDocumentSDK['getNetworkingTool'] = (): NetworkingTool => {
+    return this.networkingTool;
+  };
+
+  readonly getCryptoTool: IDocumentSDK['getCryptoTool'] = (): CryptoTool => {
+    return this.cryptoTool;
+  };
+
+  readonly createDigitalSignOptions: IDocumentSDK['createDigitalSignOptions'] = () => {
+    return new DigitalSignOptions();
+  };
+
+  readonly createKVField: IDocumentSDK['createKVField'] = (key, value, description) => {
+    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 createExtensionTool(): ExtensionTool {
+    return createBridgeToolAdapter<ExtensionTool>(
+      'extension',
+      {
+        addExtensionStateChangedCallback: {
+          kind: 'callbackRegister',
+          callback: (callbacks, args) => {
+            const callback = args[0];
+            if (typeof callback === 'function') {
+              callbacks.extensionStateChanged.push(callback as ExtensionStateChangedCallback);
+            }
+          },
+        },
+      },
+      this.bridgeToolContext,
+    );
+  }
+
+  private readonly mountReader = async (
+    hostContainer: HTMLDivElement,
+    configuration: NormalizedReaderEmbedOptions,
+    mountToken: number,
+  ): Promise<void> => {
+    try {
+      await ensureReaderScriptLoaded(configuration.officeServer);
+      if (this.mountToken !== mountToken) {
+        return;
+      }
+
+      const readerElement = document.createElement(READER_CUSTOM_ELEMENT_TAG);
+      const readerId = createReaderId();
+      readerElement.setAttribute(RHC_OFFICE_READER_ID_ATTRIBUTE, readerId);
+      this.readerId = readerId;
+      this.bridge.setReaderId(readerId);
+      applyReaderElementLayout(readerElement, configuration);
+      this.themeCleanup = bindReaderElementTheme(readerElement, configuration);
+      this.bindNativeReaderEvents(readerElement);
+
+      hostContainer.replaceChildren(readerElement);
+      this.readerElement = readerElement;
+      await Promise.resolve();
+      if (this.mountToken !== mountToken) {
+        return;
+      }
+
+      if (configuration.scrollIntoView && typeof hostContainer.scrollIntoView === 'function') {
+        hostContainer.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+      }
+
+      this.isReady = true;
+      const payload = createReaderPayload(readerElement, configuration);
+      this.emitReaderEvent(READER_READY_EVENT_NAME, payload);
+      this.readyCallbacks.forEach((callback) => callback());
+    } catch (error: unknown) {
+      if (this.mountToken !== mountToken) {
+        return;
+      }
+
+      this.reportReaderError(error);
+    }
+  };
+
+  private readonly bindNativeReaderEvents = (readerElement: HTMLElement): void => {
+    this.cleanupNativeEventForwarders();
+
+    const adapterEventListener = (event: Event): void => {
+      const detail = event instanceof CustomEvent ? (event.detail as AdapterEvent) : null;
+      if (!detail || detail.readerId !== this.readerId) {
+        return;
+      }
+
+      this.readerState.update(detail.statePatch);
+      this.callbacks.emit(detail.event, detail.payload);
+      this.emitReaderEvent(detail.event, detail.payload as ReaderEventPayload);
+    };
+    readerElement.addEventListener(RHC_OFFICE_ADAPTER_EVENT, adapterEventListener as EventListener);
+    this.nativeEventCleanupCallbacks.push(() => {
+      readerElement.removeEventListener(
+        RHC_OFFICE_ADAPTER_EVENT,
+        adapterEventListener as EventListener,
+      );
+    });
+
+    NATIVE_READER_EVENT_NAMES.forEach((eventName) => {
+      const listener = (event: Event): void => {
+        const payload = event instanceof CustomEvent ? event.detail : event;
+        if (eventName === 'documentLoaded') {
+          this.readerState.setDocumentOpened(true);
+        }
+        this.emitReaderEvent(eventName, payload);
+        if (eventName === 'documentError') {
+          this.emitReaderEvent(READER_ERROR_EVENT_NAME, payload);
+        }
+      };
+
+      readerElement.addEventListener(eventName, listener as EventListener);
+      this.nativeEventCleanupCallbacks.push(() => {
+        readerElement.removeEventListener(eventName, listener as EventListener);
+      });
+    });
+  };
+
+  private readonly cleanupNativeEventForwarders = (): void => {
+    this.nativeEventCleanupCallbacks.splice(0).forEach((callback) => callback());
+  };
+
+  private readonly cleanupThemeBinding = (): void => {
+    this.themeCleanup?.();
+    this.themeCleanup = null;
+  };
+
+  private readonly emitReaderEvent = (eventName: string, payload: unknown): void => {
+    this.readerEventListener?.(eventName, payload as ReaderEventPayload);
+  };
+
+  private readonly reportReaderError = (error: unknown): void => {
+    this.isReady = false;
+    if (this.debugEnabled) {
+      console.error('[RHC Office SDK] Reader mount failed', error);
+    }
+
+    this.emitReaderEvent(READER_ERROR_EVENT_NAME, error);
+  };
+
+  private readonly reportAdapterError = (error: unknown): void => {
+    if (this.debugEnabled) {
+      console.error('[RHC Office SDK] Adapter command failed', error);
+    }
+
+    this.emitReaderEvent(READER_ERROR_EVENT_NAME, error);
+  };
+}
+
+export const createNewDocumentSdk = (options?: DocumentSDKRuntimeOptions): IDocumentSDK => {
+  return new DocumentSDK(options);
+};