@rhc-office/sdk 6.6.256

package/src/viewer/ReaderBridgeClient.ts

@@ -0,0 +1,216 @@
+import {
+  RHC_OFFICE_ADAPTER_GLOBAL,
+  RHC_OFFICE_ADAPTER_PROTOCOL,
+  RHC_OFFICE_ADAPTER_READY_EVENT,
+  RHC_OFFICE_ADAPTER_VERSION,
+  type AdapterCapabilityManifest,
+  type AdapterGlobal,
+  type AdapterRequest,
+  type AdapterResponse,
+  type AdapterToolName,
+} from './AdapterProtocol';
+
+const DEFAULT_REQUEST_TIMEOUT_MS = 5000;
+const DEFAULT_READY_TIMEOUT_MS = 5000;
+
+type BrowserGlobal = typeof globalThis & {
+  [RHC_OFFICE_ADAPTER_GLOBAL]?: AdapterGlobal;
+};
+
+const createRequestId = (): string => {
+  const cryptoApi = globalThis.crypto;
+  if (typeof cryptoApi?.randomUUID === 'function') {
+    return cryptoApi.randomUUID();
+  }
+
+  return `adapter-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+};
+
+const getAdapterGlobal = (): AdapterGlobal | undefined => {
+  return (globalThis as BrowserGlobal)[RHC_OFFICE_ADAPTER_GLOBAL];
+};
+
+export class ReaderBridgeError extends Error {
+  readonly code: string;
+  readonly details?: unknown;
+
+  constructor(code: string, message: string, details?: unknown) {
+    super(message);
+    this.name = 'ReaderBridgeError';
+    this.code = code;
+    this.details = details;
+  }
+}
+
+export class ReaderBridgeClient {
+  private readerId: string | null = null;
+  private readyTimeoutMs: number;
+  private requestTimeoutMs: number;
+
+  constructor(options?: { readyTimeoutMs?: number; requestTimeoutMs?: number }) {
+    this.readyTimeoutMs = options?.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
+    this.requestTimeoutMs = options?.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  }
+
+  configureTimeouts(options?: { readyTimeoutMs?: number; requestTimeoutMs?: number }): void {
+    this.readyTimeoutMs = options?.readyTimeoutMs ?? this.readyTimeoutMs;
+    this.requestTimeoutMs = options?.requestTimeoutMs ?? this.requestTimeoutMs;
+  }
+
+  setReaderId(readerId: string | null): void {
+    this.readerId = readerId;
+  }
+
+  getReaderId(): string | null {
+    return this.readerId;
+  }
+
+  async request<TResult = unknown, TParams = unknown>(
+    tool: AdapterToolName,
+    method: string,
+    params?: TParams,
+    options?: {
+      timeoutMs?: number;
+    },
+  ): Promise<TResult> {
+    const response = await this.requestRaw<TResult, TParams>(tool, method, params, options);
+    if (response.ok) {
+      return response.result;
+    }
+
+    throw new ReaderBridgeError(
+      response.error.code,
+      response.error.message,
+      response.error.details,
+    );
+  }
+
+  async requestRaw<TResult = unknown, TParams = unknown>(
+    tool: AdapterToolName,
+    method: string,
+    params?: TParams,
+    options?: {
+      timeoutMs?: number;
+    },
+  ): Promise<AdapterResponse<TResult>> {
+    if (!this.readerId) {
+      return {
+        ok: false,
+        requestId: '',
+        error: {
+          code: 'READER_NOT_READY',
+          message: 'Reader is not mounted.',
+        },
+      };
+    }
+
+    const adapter = await this.waitForAdapter(this.readerId, options?.timeoutMs);
+    if (!adapter) {
+      return {
+        ok: false,
+        requestId: '',
+        error: {
+          code: 'ADAPTER_UNAVAILABLE',
+          message: 'Editor adapter is not available.',
+        },
+      };
+    }
+
+    const request: AdapterRequest<TParams> = {
+      protocol: RHC_OFFICE_ADAPTER_PROTOCOL,
+      version: RHC_OFFICE_ADAPTER_VERSION,
+      requestId: createRequestId(),
+      readerId: this.readerId,
+      tool,
+      method,
+      params,
+    };
+
+    return this.withTimeout(
+      adapter.request(request) as Promise<AdapterResponse<TResult>>,
+      request.requestId,
+      options?.timeoutMs ?? this.requestTimeoutMs,
+    );
+  }
+
+  getCapabilities(): AdapterCapabilityManifest | null {
+    if (!this.readerId) {
+      return null;
+    }
+
+    return getAdapterGlobal()?.getCapabilities(this.readerId) ?? null;
+  }
+
+  private async waitForAdapter(
+    readerId: string,
+    timeoutMs = this.readyTimeoutMs,
+  ): Promise<AdapterGlobal | null> {
+    const existingAdapter = getAdapterGlobal();
+    if (existingAdapter?.getCapabilities(readerId)) {
+      return existingAdapter;
+    }
+
+    return new Promise<AdapterGlobal | null>((resolve) => {
+      let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+      const cleanup = (): void => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        globalThis.removeEventListener(RHC_OFFICE_ADAPTER_READY_EVENT, onReady as EventListener);
+      };
+
+      const onReady = (event: Event): void => {
+        const detail = event instanceof CustomEvent ? event.detail : undefined;
+        if (detail?.readerId !== readerId) {
+          return;
+        }
+
+        const adapter = getAdapterGlobal();
+        cleanup();
+        resolve(adapter ?? null);
+      };
+
+      globalThis.addEventListener(RHC_OFFICE_ADAPTER_READY_EVENT, onReady as EventListener);
+      timeoutId = setTimeout(() => {
+        cleanup();
+        resolve(getAdapterGlobal()?.getCapabilities(readerId) ? getAdapterGlobal()! : null);
+      }, timeoutMs);
+    });
+  }
+
+  private async withTimeout<TResult>(
+    promise: Promise<AdapterResponse<TResult>>,
+    requestId: string,
+    timeoutMs: number,
+  ): Promise<AdapterResponse<TResult>> {
+    return new Promise<AdapterResponse<TResult>>((resolve) => {
+      const timeoutId = setTimeout(() => {
+        resolve({
+          ok: false,
+          requestId,
+          error: {
+            code: 'TIMEOUT',
+            message: `Editor adapter request timed out after ${timeoutMs}ms.`,
+          },
+        });
+      }, timeoutMs);
+
+      promise
+        .then((response) => resolve(response))
+        .catch((error: unknown) => {
+          resolve({
+            ok: false,
+            requestId,
+            error: {
+              code: 'EXECUTION_FAILED',
+              message: error instanceof Error ? error.message : String(error),
+            },
+          });
+        })
+        .finally(() => {
+          clearTimeout(timeoutId);
+        });
+    });
+  }
+}

package/src/viewer/ReaderConfiguration.ts

@@ -0,0 +1,59 @@
+import type { IReaderEmbedOptions } from '../api/document-sdk';
+
+export type SupportedReaderTheme = 'light' | 'dark' | 'high-contrast' | 'auto';
+
+export interface NormalizedReaderEmbedOptions extends IReaderEmbedOptions {
+  officeServer: string;
+  scrollIntoView: boolean;
+  theme?: SupportedReaderTheme;
+}
+
+const normalizeTheme = (theme?: string): SupportedReaderTheme | undefined => {
+  if (!theme) {
+    return undefined;
+  }
+
+  const normalizedTheme = theme.trim().toLowerCase();
+  if (normalizedTheme === 'application') {
+    return 'auto';
+  }
+
+  if (
+    normalizedTheme === 'light' ||
+    normalizedTheme === 'dark' ||
+    normalizedTheme === 'high-contrast' ||
+    normalizedTheme === 'auto'
+  ) {
+    return normalizedTheme;
+  }
+
+  return undefined;
+};
+
+export const normalizeAppUrl = (appUrl: string): string => {
+  const normalizedUrl = new URL(appUrl, globalThis.location?.href ?? 'http://localhost/');
+  normalizedUrl.hash = '';
+  if (!normalizedUrl.pathname.endsWith('/')) {
+    normalizedUrl.pathname = `${normalizedUrl.pathname}/`;
+  }
+
+  return normalizedUrl.toString();
+};
+
+export const createBootstrapUrl = (appUrl: string): string => {
+  return new URL('editors.bootstrap.js', appUrl).toString();
+};
+
+export const normalizeReaderEmbedOptions = (
+  appUrl: string,
+  configuration: IReaderEmbedOptions,
+): NormalizedReaderEmbedOptions => {
+  const normalizedAppUrl = normalizeAppUrl(appUrl);
+
+  return {
+    ...configuration,
+    officeServer: normalizedAppUrl,
+    scrollIntoView: configuration.scrollIntoView ?? true,
+    theme: normalizeTheme(configuration.theme),
+  };
+};

package/src/viewer/ReaderScriptLoader.ts

@@ -0,0 +1,130 @@
+import { createBootstrapUrl } from './ReaderConfiguration';
+
+export const READER_CUSTOM_ELEMENT_TAG = 'rhc-office-editor';
+
+const READER_LOADER_REGISTRY_KEY = '__RHC_OFFICE_SDK_READER_LOADER__';
+
+interface ReaderLoaderRegistry {
+  activeAppUrl: string | null;
+  loadPromises: Map<string, Promise<void>>;
+}
+
+type BrowserGlobal = typeof globalThis & {
+  [READER_LOADER_REGISTRY_KEY]?: ReaderLoaderRegistry;
+};
+
+const getReaderLoaderRegistry = (): ReaderLoaderRegistry => {
+  const browserGlobal = globalThis as BrowserGlobal;
+  if (!browserGlobal[READER_LOADER_REGISTRY_KEY]) {
+    browserGlobal[READER_LOADER_REGISTRY_KEY] = {
+      activeAppUrl: null,
+      loadPromises: new Map<string, Promise<void>>(),
+    };
+  }
+
+  return browserGlobal[READER_LOADER_REGISTRY_KEY];
+};
+
+const findScriptElementBySource = (source: string): HTMLScriptElement | null => {
+  return (
+    Array.from(document.querySelectorAll('script')).find((element) => element.src === source) ??
+    null
+  );
+};
+
+export class ReaderScriptLoadError extends Error {
+  constructor(bootstrapUrl: string) {
+    super(`Failed to load reader bootstrap script: ${bootstrapUrl}`);
+    this.name = 'ReaderScriptLoadError';
+  }
+}
+
+export class ReaderSourceConflictError extends Error {
+  constructor(activeAppUrl: string, requestedAppUrl: string) {
+    super(
+      `Reader Web Component "${READER_CUSTOM_ELEMENT_TAG}" is already bound to ${activeAppUrl} and cannot be reloaded from ${requestedAppUrl}.`,
+    );
+    this.name = 'ReaderSourceConflictError';
+  }
+}
+
+export const assertCompatibleReaderSource = (appUrl: string): void => {
+  const registry = getReaderLoaderRegistry();
+  if (registry.activeAppUrl && registry.activeAppUrl !== appUrl) {
+    throw new ReaderSourceConflictError(registry.activeAppUrl, appUrl);
+  }
+};
+
+export const ensureReaderScriptLoaded = (appUrl: string): Promise<void> => {
+  const registry = getReaderLoaderRegistry();
+  assertCompatibleReaderSource(appUrl);
+
+  const existingLoadPromise = registry.loadPromises.get(appUrl);
+  if (existingLoadPromise) {
+    return existingLoadPromise;
+  }
+
+  if (globalThis.customElements?.get(READER_CUSTOM_ELEMENT_TAG)) {
+    registry.activeAppUrl = appUrl;
+    const resolvedPromise = Promise.resolve();
+    registry.loadPromises.set(appUrl, resolvedPromise);
+    return resolvedPromise;
+  }
+
+  const bootstrapUrl = createBootstrapUrl(appUrl);
+  const existingScriptElement = findScriptElementBySource(bootstrapUrl);
+  registry.activeAppUrl = appUrl;
+
+  const loadPromise = new Promise<void>((resolve, reject) => {
+    const rejectScriptLoad = (scriptElement?: HTMLScriptElement): void => {
+      scriptElement?.remove();
+      reject(new ReaderScriptLoadError(bootstrapUrl));
+    };
+
+    const resolveWhenDefined = (): void => {
+      void globalThis.customElements
+        .whenDefined(READER_CUSTOM_ELEMENT_TAG)
+        .then(() => {
+          resolve();
+        })
+        .catch(reject);
+    };
+
+    if (existingScriptElement) {
+      if (globalThis.customElements?.get(READER_CUSTOM_ELEMENT_TAG)) {
+        resolve();
+        return;
+      }
+
+      existingScriptElement.addEventListener(
+        'error',
+        () => reject(new ReaderScriptLoadError(bootstrapUrl)),
+        {
+          once: true,
+        },
+      );
+      resolveWhenDefined();
+      return;
+    }
+
+    const scriptElement = document.createElement('script');
+    scriptElement.src = bootstrapUrl;
+    scriptElement.async = true;
+    scriptElement.dataset.rhcOfficeSdkReader = appUrl;
+    scriptElement.addEventListener('load', resolveWhenDefined, { once: true });
+    scriptElement.addEventListener('error', () => rejectScriptLoad(scriptElement), { once: true });
+    document.head.appendChild(scriptElement);
+  }).catch((error: unknown) => {
+    registry.loadPromises.delete(appUrl);
+    if (
+      !globalThis.customElements?.get(READER_CUSTOM_ELEMENT_TAG) &&
+      registry.activeAppUrl === appUrl
+    ) {
+      registry.activeAppUrl = null;
+    }
+    throw error;
+  });
+
+  registry.loadPromises.set(appUrl, loadPromise);
+  return loadPromise;
+};

package/src/viewer/ReaderStateStore.ts

@@ -0,0 +1,55 @@
+import type { AdapterStatePatch } from './AdapterProtocol';
+
+export interface ReaderStateSnapshot {
+  annotationEnabled: boolean;
+  annotationMode?: string;
+  documentModified: boolean;
+  documentOpened: boolean;
+  documentType?: string;
+  extensionState: 'connected' | 'disconnected';
+  pageCount: number;
+  pageIndex: number;
+  pageMode: number;
+  zoomLevel: number;
+}
+
+const DEFAULT_READER_STATE: ReaderStateSnapshot = {
+  annotationEnabled: false,
+  documentModified: false,
+  documentOpened: false,
+  extensionState: 'disconnected',
+  pageCount: 0,
+  pageIndex: 1,
+  pageMode: 0,
+  zoomLevel: 100,
+};
+
+export class ReaderStateStore {
+  private state: ReaderStateSnapshot = { ...DEFAULT_READER_STATE };
+
+  reset(): void {
+    this.state = { ...DEFAULT_READER_STATE };
+  }
+
+  update(patch?: AdapterStatePatch): void {
+    if (!patch) {
+      return;
+    }
+
+    this.state = {
+      ...this.state,
+      ...patch,
+    };
+  }
+
+  setDocumentOpened(opened: boolean): void {
+    this.state = {
+      ...this.state,
+      documentOpened: opened,
+    };
+  }
+
+  snapshot(): ReaderStateSnapshot {
+    return { ...this.state };
+  }
+}

package/src/viewer/SdkCallbackRegistry.ts

@@ -0,0 +1,89 @@
+import type {
+  AnnotationEventCallback,
+  DigitalSignatureRetrieveCallback,
+  DocumentClosedCallback,
+  DocumentSavedCallback,
+  ExtensionStateChangedCallback,
+  PageChangeCallback,
+  PageModeChangeCallback,
+} from '../api/callbacks';
+import type { IDigitalAnnotationInfo } from '../api/annotation-tool';
+
+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 digitalSignatureParse: DigitalSignatureRetrieveCallback[] = [];
+  readonly digitalSignatureRetrieve: DigitalSignatureRetrieveCallback[] = [];
+  readonly documentClosed: DocumentClosedCallback[] = [];
+  readonly documentOpened: Array<(status: string, error: string) => void> = [];
+  readonly documentSaved: DocumentSavedCallback[] = [];
+  readonly extensionStateChanged: ExtensionStateChangedCallback[] = [];
+  readonly pageChange: PageChangeCallback[] = [];
+  readonly pageModeChange: PageModeChangeCallback[] = [];
+
+  emit(event: string, payload: unknown): void {
+    switch (event) {
+      case 'documentOpened':
+      case 'documentLoaded':
+        this.documentOpened.forEach((callback) => callback('ok', ''));
+        return;
+      case 'documentSaved':
+        this.documentSaved.forEach((callback) => callback(payload));
+        return;
+      case 'documentClosed':
+        this.documentClosed.forEach((callback) => callback(payload));
+        return;
+      case 'pageChange': {
+        const pagePayload = payload as { pageIndex?: number; pageCount?: number };
+        this.pageChange.forEach((callback) =>
+          callback(pagePayload.pageIndex ?? 1, pagePayload.pageCount ?? 0),
+        );
+        return;
+      }
+      case 'pageModeChange': {
+        const pagePayload = payload as { pageMode?: number };
+        this.pageModeChange.forEach((callback) => callback(pagePayload.pageMode ?? 0));
+        return;
+      }
+      case 'annotationEvent': {
+        const annotationPayload = payload as { event?: string; payload?: unknown };
+        this.annotationEvents.forEach((callback) =>
+          callback(annotationPayload.event ?? 'annotationEvent', annotationPayload.payload),
+        );
+        return;
+      }
+      case 'annotationPersist':
+        this.annotationPersist.forEach((callback) => callback(payload));
+        return;
+      case 'annotationRetrieve':
+        this.annotationRetrieve.forEach((callback) => callback(payload));
+        return;
+      case 'digitalAnnotationRetrieve':
+        this.digitalAnnotationRetrieve.forEach((callback) =>
+          callback(Array.isArray(payload) ? (payload as IDigitalAnnotationInfo[]) : []),
+        );
+        return;
+      case 'digitalSignatureRetrieve':
+        this.digitalSignatureRetrieve.forEach((callback) =>
+          callback(Array.isArray(payload) ? payload : []),
+        );
+        return;
+      case 'digitalSignatureParse':
+        this.digitalSignatureParse.forEach((callback) =>
+          callback(Array.isArray(payload) ? payload : []),
+        );
+        return;
+      case 'extensionStateChanged': {
+        const extensionPayload = payload as { state?: 'connected' | 'disconnected' };
+        this.extensionStateChanged.forEach((callback) =>
+          callback(extensionPayload.state ?? 'disconnected'),
+        );
+        return;
+      }
+      default:
+        return;
+    }
+  }
+}

package/src/viewer/index.ts

@@ -0,0 +1 @@
+export * from './DocumentSDK';