@rhc-office/sdk 6.6.256

package/src/tools/DocumentToolImpl.ts

@@ -0,0 +1,158 @@
+import type { DocumentClosedCallback, DocumentSavedCallback } from '../api/callbacks';
+import type { DocumentTool } from '../api/document-tool';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const DOCUMENT_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
+  addDocumentOpenedCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.documentOpened.push(callback as (status: string, error: string) => void);
+      }
+    },
+  },
+  addDocumentSavedCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.documentSaved.push(callback as DocumentSavedCallback);
+      }
+    },
+  },
+  addDocumentClosedCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.documentClosed.push(callback as DocumentClosedCallback);
+      }
+    },
+  },
+  openPDFDocument: { kind: 'callbackQuery', adapterMethod: 'open' },
+  openPdfDocument: { kind: 'callbackQuery', adapterMethod: 'open' },
+  openOFDDocument: { kind: 'callbackQuery', adapterMethod: 'open' },
+  openOfdDocument: { kind: 'callbackQuery', adapterMethod: 'open' },
+  openOfficeDocument: { kind: 'callbackQuery', adapterMethod: 'open' },
+  openImageDocument: { kind: 'callbackQuery', adapterMethod: 'open' },
+  openTextDocument: { kind: 'callbackQuery', adapterMethod: 'open' },
+  openFromLocalStorage: { kind: 'command' },
+  setUploadUrl: { kind: 'command' },
+  save: { kind: 'callbackQuery' },
+  saveAs: { kind: 'query' },
+  getDocumentContent: {
+    kind: 'callbackQuery',
+    mapCallbackResult: (result) => {
+      const content = result as { fileCacheId?: string; fileBuffer?: ArrayBuffer };
+      return [content?.fileCacheId, content?.fileBuffer];
+    },
+  },
+  closeDocument: { kind: 'callbackQuery' },
+  isDocumentOpened: {
+    kind: 'stateGetter',
+    state: (state) => state.documentOpened,
+  },
+  isDocumentModified: {
+    kind: 'stateGetter',
+    state: (state) => state.documentModified,
+  },
+  print: { kind: 'command' },
+  createPreview: { kind: 'command' },
+};
+
+export class DocumentToolImpl implements DocumentTool {
+  private readonly adapter: DocumentTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<DocumentTool>(
+      'document',
+      DOCUMENT_TOOL_DESCRIPTOR,
+      context,
+    );
+  }
+
+  addDocumentOpenedCallback: DocumentTool['addDocumentOpenedCallback'] = (callback) => {
+    return this.adapter.addDocumentOpenedCallback(callback);
+  };
+
+  addDocumentSavedCallback: DocumentTool['addDocumentSavedCallback'] = (callback) => {
+    return this.adapter.addDocumentSavedCallback(callback);
+  };
+
+  addDocumentClosedCallback: DocumentTool['addDocumentClosedCallback'] = (callback) => {
+    return this.adapter.addDocumentClosedCallback(callback);
+  };
+
+  openPDFDocument: DocumentTool['openPDFDocument'] = (options, onDocumentOpened) => {
+    return this.adapter.openPDFDocument(options, onDocumentOpened);
+  };
+
+  openPdfDocument: DocumentTool['openPdfDocument'] = (options, onDocumentOpened) => {
+    return this.adapter.openPdfDocument(options, onDocumentOpened);
+  };
+
+  openOFDDocument: DocumentTool['openOFDDocument'] = (options, onDocumentOpened) => {
+    return this.adapter.openOFDDocument(options, onDocumentOpened);
+  };
+
+  openOfdDocument: DocumentTool['openOfdDocument'] = (options, onDocumentOpened) => {
+    return this.adapter.openOfdDocument(options, onDocumentOpened);
+  };
+
+  openOfficeDocument: DocumentTool['openOfficeDocument'] = (options, onDocumentOpened) => {
+    return this.adapter.openOfficeDocument(options, onDocumentOpened);
+  };
+
+  openImageDocument: DocumentTool['openImageDocument'] = (options, onDocumentOpened) => {
+    return this.adapter.openImageDocument(options, onDocumentOpened);
+  };
+
+  openTextDocument: DocumentTool['openTextDocument'] = (options, onDocumentOpened) => {
+    return this.adapter.openTextDocument(options, onDocumentOpened);
+  };
+
+  openFromLocalStorage: DocumentTool['openFromLocalStorage'] = () => {
+    return this.adapter.openFromLocalStorage();
+  };
+
+  setUploadUrl: DocumentTool['setUploadUrl'] = (uploadUrl) => {
+    return this.adapter.setUploadUrl(uploadUrl);
+  };
+
+  save: DocumentTool['save'] = (uploadUrl, onSavedCallback, options) => {
+    return this.adapter.save(uploadUrl, onSavedCallback, options);
+  };
+
+  saveAs: DocumentTool['saveAs'] = (options) => {
+    return this.adapter.saveAs(options);
+  };
+
+  getDocumentContent: DocumentTool['getDocumentContent'] = (onDocumentContent) => {
+    return this.adapter.getDocumentContent(onDocumentContent);
+  };
+
+  closeDocument: DocumentTool['closeDocument'] = (discardModify, onClose, options) => {
+    return this.adapter.closeDocument(discardModify, onClose, options);
+  };
+
+  isDocumentOpened: DocumentTool['isDocumentOpened'] = () => {
+    return this.adapter.isDocumentOpened();
+  };
+
+  isDocumentModified: DocumentTool['isDocumentModified'] = () => {
+    return this.adapter.isDocumentModified();
+  };
+
+  print: DocumentTool['print'] = () => {
+    return this.adapter.print();
+  };
+
+  createPreview: DocumentTool['createPreview'] = (serverUrl, options) => {
+    return this.adapter.createPreview(serverUrl, options);
+  };
+}

package/src/tools/FindToolImpl.ts

@@ -0,0 +1,32 @@
+import type { FindTool } from '../api/find-tool';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const FIND_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
+  clearFind: { kind: 'command' },
+  findNext: { kind: 'command' },
+  findPrevious: { kind: 'command' },
+};
+
+export class FindToolImpl implements FindTool {
+  private readonly adapter: FindTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<FindTool>('find', FIND_TOOL_DESCRIPTOR, context);
+  }
+
+  clearFind: FindTool['clearFind'] = () => {
+    return this.adapter.clearFind();
+  };
+
+  findNext: FindTool['findNext'] = (queryText) => {
+    return this.adapter.findNext(queryText);
+  };
+
+  findPrevious: FindTool['findPrevious'] = (queryText) => {
+    return this.adapter.findPrevious(queryText);
+  };
+}

package/src/tools/NetworkingToolImpl.ts

@@ -0,0 +1,36 @@
+import type { NetworkingTool } from '../api/networking-tool';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const NETWORKING_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
+  configFileUpload: { kind: 'command' },
+  setHttpHeaders: { kind: 'command' },
+  setHttpFormFields: { kind: 'command' },
+};
+
+export class NetworkingToolImpl implements NetworkingTool {
+  private readonly adapter: NetworkingTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<NetworkingTool>(
+      'networking',
+      NETWORKING_TOOL_DESCRIPTOR,
+      context,
+    );
+  }
+
+  configFileUpload: NetworkingTool['configFileUpload'] = (options) => {
+    return this.adapter.configFileUpload(options);
+  };
+
+  setHttpHeaders: NetworkingTool['setHttpHeaders'] = (headers) => {
+    return this.adapter.setHttpHeaders(headers);
+  };
+
+  setHttpFormFields: NetworkingTool['setHttpFormFields'] = (fields) => {
+    return this.adapter.setHttpFormFields(fields);
+  };
+}

package/src/tools/PageToolImpl.ts

@@ -0,0 +1,181 @@
+import type {
+  PageChangeCallback,
+  PageCountCallback,
+  PageIndexGetCallback,
+  PageModeChangeCallback,
+} from '../api/callbacks';
+import type { PageTool } from '../api/page-tool';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const createPageToolDescriptor = (context: BridgeToolAdapterContext): BridgeToolDescriptor => ({
+  addPageChangeCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.pageChange.push(callback as PageChangeCallback);
+      }
+    },
+  },
+  addPageModeChangeCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.pageModeChange.push(callback as PageModeChangeCallback);
+      }
+    },
+  },
+  getPageCount: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      void callbacks;
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        (callback as PageCountCallback)(context.state.snapshot().pageCount);
+      }
+    },
+  },
+  getPageIndex: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      void callbacks;
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        (callback as PageIndexGetCallback)(context.state.snapshot().pageIndex);
+      }
+    },
+  },
+  setSinglePageViewMode: { kind: 'command' },
+  setTwoPagesViewMode: { kind: 'command' },
+  setPageScrollVertical: { kind: 'command' },
+  setPageScrollHorizontal: { kind: 'command' },
+  setPageCursorPanDrag: { kind: 'command' },
+  setPageCursorTextSelect: { kind: 'command' },
+  rotateCW: { kind: 'command' },
+  rotateCCW: { kind: 'command' },
+  autoFitPage: { kind: 'command' },
+  fitPageSize: { kind: 'command' },
+  fitPageWidth: { kind: 'command' },
+  fitPageHeight: { kind: 'command' },
+  increasePageScale: { kind: 'command' },
+  decreasePageScale: { kind: 'command' },
+  setPageScale: { kind: 'command' },
+  setPageBlendColor: { kind: 'command' },
+  gotoPage: { kind: 'command' },
+  gotoNextPage: { kind: 'command' },
+  gotoPreviousPage: { kind: 'command' },
+  rotatePage: { kind: 'command' },
+});
+
+export class PageToolImpl implements PageTool {
+  private readonly adapter: PageTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<PageTool>(
+      'page',
+      createPageToolDescriptor(context),
+      context,
+    );
+  }
+
+  addPageChangeCallback: PageTool['addPageChangeCallback'] = (callback) => {
+    return this.adapter.addPageChangeCallback(callback);
+  };
+
+  addPageModeChangeCallback: PageTool['addPageModeChangeCallback'] = (callback) => {
+    return this.adapter.addPageModeChangeCallback(callback);
+  };
+
+  getPageCount: PageTool['getPageCount'] = (callback) => {
+    return this.adapter.getPageCount(callback);
+  };
+
+  getPageIndex: PageTool['getPageIndex'] = (callback) => {
+    return this.adapter.getPageIndex(callback);
+  };
+
+  setSinglePageViewMode: PageTool['setSinglePageViewMode'] = () => {
+    return this.adapter.setSinglePageViewMode();
+  };
+
+  setTwoPagesViewMode: PageTool['setTwoPagesViewMode'] = () => {
+    return this.adapter.setTwoPagesViewMode();
+  };
+
+  setPageScrollVertical: PageTool['setPageScrollVertical'] = () => {
+    return this.adapter.setPageScrollVertical();
+  };
+
+  setPageScrollHorizontal: PageTool['setPageScrollHorizontal'] = () => {
+    return this.adapter.setPageScrollHorizontal();
+  };
+
+  setPageCursorPanDrag: PageTool['setPageCursorPanDrag'] = () => {
+    return this.adapter.setPageCursorPanDrag();
+  };
+
+  setPageCursorTextSelect: PageTool['setPageCursorTextSelect'] = () => {
+    return this.adapter.setPageCursorTextSelect();
+  };
+
+  rotateCW: PageTool['rotateCW'] = () => {
+    return this.adapter.rotateCW();
+  };
+
+  rotateCCW: PageTool['rotateCCW'] = () => {
+    return this.adapter.rotateCCW();
+  };
+
+  autoFitPage: PageTool['autoFitPage'] = () => {
+    return this.adapter.autoFitPage();
+  };
+
+  fitPageSize: PageTool['fitPageSize'] = () => {
+    return this.adapter.fitPageSize();
+  };
+
+  fitPageWidth: PageTool['fitPageWidth'] = () => {
+    return this.adapter.fitPageWidth();
+  };
+
+  fitPageHeight: PageTool['fitPageHeight'] = () => {
+    return this.adapter.fitPageHeight();
+  };
+
+  increasePageScale: PageTool['increasePageScale'] = () => {
+    return this.adapter.increasePageScale();
+  };
+
+  decreasePageScale: PageTool['decreasePageScale'] = () => {
+    return this.adapter.decreasePageScale();
+  };
+
+  setPageScale: PageTool['setPageScale'] = (scale) => {
+    return this.adapter.setPageScale(scale);
+  };
+
+  setPageBlendColor: PageTool['setPageBlendColor'] = (r, g, b, alpha) => {
+    return this.adapter.setPageBlendColor(r, g, b, alpha);
+  };
+
+  gotoPage: PageTool['gotoPage'] = (pageIndex, x, y) => {
+    return this.adapter.gotoPage(pageIndex, x, y);
+  };
+
+  gotoNextPage: PageTool['gotoNextPage'] = () => {
+    return this.adapter.gotoNextPage();
+  };
+
+  gotoPreviousPage: PageTool['gotoPreviousPage'] = () => {
+    return this.adapter.gotoPreviousPage();
+  };
+
+  rotatePage: PageTool['rotatePage'] = (rotation) => {
+    return this.adapter.rotatePage(rotation);
+  };
+}

package/src/tools/PdfFormFillerImpl.ts

@@ -0,0 +1,67 @@
+import type { PdfFormFiller } from '../api/pdf-formfiller';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+interface PdfFormKeyValueField {
+  key: string;
+  value: string;
+}
+
+const PDF_FORM_FILLER_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
+  open: { kind: 'command' },
+  setFormFieldValue: { kind: 'command' },
+  setFormFieldReadonly: { kind: 'command' },
+  commit: {
+    kind: 'callbackQuery',
+    mapCallbackResult: () => [],
+  },
+  clear: {
+    kind: 'callbackQuery',
+    mapCallbackResult: () => [],
+  },
+  toKeyValue: {
+    kind: 'callbackQuery',
+    mapCallbackResult: (result) => {
+      return [Array.isArray(result) ? (result as PdfFormKeyValueField[]) : []];
+    },
+  },
+};
+
+export class PdfFormFillerImpl implements PdfFormFiller {
+  private readonly adapter: PdfFormFiller;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<PdfFormFiller>(
+      'pdfFormFiller',
+      PDF_FORM_FILLER_TOOL_DESCRIPTOR,
+      context,
+    );
+  }
+
+  open: PdfFormFiller['open'] = () => {
+    return this.adapter.open();
+  };
+
+  setFormFieldValue: PdfFormFiller['setFormFieldValue'] = (filedName, value) => {
+    return this.adapter.setFormFieldValue(filedName, value);
+  };
+
+  setFormFieldReadonly: PdfFormFiller['setFormFieldReadonly'] = (filedName, readOnly) => {
+    return this.adapter.setFormFieldReadonly(filedName, readOnly);
+  };
+
+  commit: PdfFormFiller['commit'] = (callback) => {
+    return this.adapter.commit(callback);
+  };
+
+  clear: PdfFormFiller['clear'] = (callback) => {
+    return this.adapter.clear(callback);
+  };
+
+  toKeyValue: PdfFormFiller['toKeyValue'] = (callback) => {
+    return this.adapter.toKeyValue(callback);
+  };
+}

package/src/tools/Phase1ToolPlaceholder.ts

@@ -0,0 +1,35 @@
+export class SDKPhase1NotImplementedError extends Error {
+  constructor(toolName: string, methodName: string) {
+    super(`[Phase 1] ${toolName}.${methodName} is not implemented yet.`);
+    this.name = 'SDKPhase1NotImplementedError';
+  }
+}
+
+const createThrowingMethod = (toolName: string, methodName: string) => {
+  return (): never => {
+    throw new SDKPhase1NotImplementedError(toolName, methodName);
+  };
+};
+
+export const createPhase1ToolPlaceholder = <T extends object>(toolName: string): T => {
+  return new Proxy(
+    {},
+    {
+      get: (_target, property): unknown => {
+        if (property === 'then') {
+          return undefined;
+        }
+
+        if (typeof property === 'symbol') {
+          if (property === Symbol.toStringTag) {
+            return toolName;
+          }
+
+          return undefined;
+        }
+
+        return createThrowingMethod(toolName, property);
+      },
+    },
+  ) as T;
+};

package/src/tools/SDKValueObjects.ts

@@ -0,0 +1,172 @@
+import type {
+  DigitalSealPosition,
+  DigitalSignType,
+  IDigitalSignOptions,
+  IKVField,
+} from '../api/common';
+
+const PAGE_RANGE_SEPARATOR_PATTERN = /\s*,\s*/;
+const PAGE_BOUNDS_SEPARATOR_PATTERN = /\s*-\s*/;
+
+const normalizePageNumber = (value: string): number | null => {
+  const parsedValue = Number.parseInt(value.trim(), 10);
+  if (!Number.isFinite(parsedValue) || parsedValue <= 0) {
+    return null;
+  }
+
+  return parsedValue;
+};
+
+const expandPageRangeSegment = (segment: string): number[] => {
+  const bounds = segment.split(PAGE_BOUNDS_SEPARATOR_PATTERN);
+  if (bounds.length === 1) {
+    const pageNumber = normalizePageNumber(bounds[0] ?? '');
+    return pageNumber ? [pageNumber] : [];
+  }
+
+  const startPage = normalizePageNumber(bounds[0] ?? '');
+  const endPage = normalizePageNumber(bounds[1] ?? '');
+  if (!startPage || !endPage || endPage < startPage) {
+    return [];
+  }
+
+  return Array.from({ length: endPage - startPage + 1 }, (_, index) => startPage + index);
+};
+
+const parsePageRanges = (pageRange?: string): number[] => {
+  if (!pageRange) {
+    return [];
+  }
+
+  const pageNumbers = pageRange
+    .split(PAGE_RANGE_SEPARATOR_PATTERN)
+    .flatMap((segment) => expandPageRangeSegment(segment))
+    .filter((value, index, source) => source.indexOf(value) === index);
+
+  return pageNumbers;
+};
+
+export class KVField implements IKVField {
+  key?: string;
+  value?: string;
+  description?: string;
+
+  constructor(key: string, value: string, description?: string) {
+    this.key = key;
+    this.value = value;
+    this.description = description;
+  }
+
+  readonly setFieldName = (name: string): void => {
+    this.key = name;
+  };
+
+  readonly setFieldValue = (value: string): void => {
+    this.value = value;
+  };
+
+  readonly setDescription = (description?: string): void => {
+    this.description = description;
+  };
+}
+
+export class DigitalSignOptions implements IDigitalSignOptions {
+  pageRange?: string;
+  page?: number;
+  pageX?: number;
+  pageY?: number;
+  signReason?: string;
+  signLocation?: string;
+  signUserData?: string;
+  fields: IKVField[] = [];
+  defaultStampPassword?: string;
+  defaultKeystorePassword?: string;
+  keywordText?: string | undefined;
+  keywordTextFixedPositions:
+    | {
+        pageIndex?: number;
+        firstOccurrence?: boolean;
+        position?: number;
+      }[]
+    | undefined = undefined;
+  keywordOffsetX = 0;
+  keywordOffsetY = 0;
+  bookmarkName?: string | undefined;
+  bookmarkOffsetX = 0;
+  bookmarkOffsetY = 0;
+  printMargin?: number = 0;
+  grayscaleSealImage = false;
+
+  private signType: DigitalSignType = 0;
+  private sealPosition: DigitalSealPosition = 0;
+
+  readonly getSignType = (): DigitalSignType => {
+    return this.signType;
+  };
+
+  readonly setSignType = (signType: DigitalSignType): void => {
+    this.signType = signType;
+  };
+
+  readonly isCrossPageSideSign = (): boolean => {
+    return this.signType === 2 || this.signType === 3;
+  };
+
+  readonly getSealPosition = (): DigitalSealPosition => {
+    return this.sealPosition;
+  };
+
+  readonly setSignOnPageSides = (signType: number): void => {
+    if (signType >= 0 && signType <= 3) {
+      this.signType = signType as DigitalSignType;
+    }
+  };
+
+  readonly setSignPositionOnPageSides = (position: number): void => {
+    this.sealPosition = position;
+  };
+
+  readonly setPageRange = (text: string): void => {
+    this.pageRange = text;
+  };
+
+  readonly getPageRange = (): string | undefined => {
+    return this.pageRange;
+  };
+
+  readonly getPageRanges = (): number[] => {
+    return parsePageRanges(this.pageRange);
+  };
+
+  readonly setSignUserData = (signUserData: string): void => {
+    this.signUserData = signUserData;
+  };
+
+  readonly setPrintMargin = (margin: number): void => {
+    this.printMargin = margin;
+  };
+
+  readonly getPrintMargin = (): number => {
+    return this.printMargin ?? 0;
+  };
+
+  readonly setSignReason = (reason: string): void => {
+    this.signReason = reason;
+  };
+
+  readonly getSignReason = (): string | undefined => {
+    return this.signReason;
+  };
+
+  readonly setSignLocation = (location: string): void => {
+    this.signLocation = location;
+  };
+
+  readonly getSignLocation = (): string | undefined => {
+    return this.signLocation;
+  };
+
+  readonly setDefaultStampPassword = (password: string): void => {
+    this.defaultStampPassword = password;
+  };
+}