@grapecity-software/gcdocs.pdfviewer 7.1.0

package/typings/vendor/js-viewer-core/api/PluginModel.d.ts

@@ -0,0 +1,246 @@
+/** @hidden */ /** */
+/// <reference path="../../../vendor/react/react.d.ts" />
+//@ts-ignore
+import { MouseEvent } from 'react';
+//@ts-ignore
+import { Icon } from '@grapecity/core-ui';
+import { CancellationToken, SessionState } from '../control';
+import { ReportViewerCmd, ReportViewerCommandStatus, DocumentMoniker } from './ReportViewerCmd';
+import { FindOptions, SearchResult } from '../features/search';
+import { PageDecoration } from '../components/DocumentViewer';
+export declare type ChangeHandler<TState> = (state: TState) => void;
+declare type UnsubscribeFn = () => void;
+/** Provides the read/write access to state store, similar to redux store */
+export interface IStore<TState, TMsg> {
+    dispatch(msg: TMsg): void;
+    readonly state: TState;
+    subscribe(onUpdate: ChangeHandler<TState>): UnsubscribeFn;
+}
+/**
+ * Interface to state binder component which purpose is to allow one UI control to handle several documents.
+ */
+export interface IStateBinder<TState> {
+    /** binds component to a new state */
+    bind(store: IStore<TState, any>): void;
+}
+export declare type PanelHandle = {
+    id: string;
+};
+/** Long running tasks API */
+export declare type TaskCallbacks = {
+    onProgress: (message: any) => void;
+    isCancelRequested: () => boolean;
+};
+export declare type TaskSettings = {
+    title?: string;
+    supportCancel?: boolean;
+};
+/** End of long running tasks API */
+/** Error reporting */
+export declare type ErrorSeverity = "error" | "warn" | "info" | "debug";
+export declare type ErrorMessage = {
+    severity: ErrorSeverity;
+    message: string;
+    details: string;
+};
+export declare type ErrorHandler = (error: ErrorMessage) => boolean;
+/** Defines a parameter for reportError method */
+export interface IErrorParams {
+    readonly severity?: ErrorSeverity;
+    readonly message: string;
+    readonly details?: string;
+}
+/** History API */
+export interface IViewerEvent {
+    readonly type: string;
+}
+export declare type ViewerEvent = IViewerEvent & {
+    type: "jumpedToPage";
+    fromPage: number | null;
+    to: {
+        pageIndex: number;
+        selector?: string;
+    };
+} | {
+    type: "drilledToDocument";
+    fromDoc: SessionState;
+    target: DocumentMoniker;
+};
+/** Action (for interactive documents) handler context */
+export declare type ActionContext<TEvent extends IViewerEvent> = {
+    readonly document: IDocument;
+    readonly view: IDocumentView | null;
+    processCommand(cmd: ReportViewerCmd): void;
+    processAction(action: ViewerAction): void;
+    pushEvent(event: TEvent): void;
+};
+/** Standard viewer actions */
+export declare type ViewerAction = {
+    Type: "goBookmark";
+    Target: {
+        pageNumber: number;
+        selector?: string;
+    };
+} | {
+    Type: "goHyperlink";
+    Target: string;
+} | {
+    Type: "drillDocument";
+    Target: DocumentMoniker;
+};
+/** end of History API */
+export interface IReportError {
+    /** Reports the error to user/UI. */
+    reportError(params: IErrorParams): void;
+}
+/** Defines the generic for processing error. */
+export declare class PluginError extends Error {
+    readonly text: string;
+    readonly details: string;
+    constructor(title: string, text: string, details: string);
+}
+/** Defines the document processing error. */
+export declare class DocumentError extends PluginError {
+    constructor(text: string, details: string);
+}
+export declare type PanelLocation = 'top' | 'bottom' | 'default';
+/** Main component API */
+export declare type PanelSettings = {
+    label: string;
+    icon: string | Icon;
+    description: string;
+    visible: boolean;
+    enabled: boolean;
+    /**Define this property to show this panel: 'top' - on top document view, 'bottom' - on bottom document view, 'default' -  in sidebar/menu
+    * This panel will be shown in sidebar/menu by default, if this property is undefined */
+    location?: PanelLocation;
+};
+/** Represents API to access main (host) viewer components. */
+export interface IViewerHost extends IReportError {
+    /** Creates a new UI panel
+     * @param render renders DOM for the panel UI to a specified container element. Must be instance of React.ReactChild
+     * @param binder instance of Binder that connects state to panel UI.
+     */
+    createPanel<T>(component: any, binder: IStateBinder<T>, key: string, settings: Partial<PanelSettings>): PanelHandle;
+    /** Shows or hides the panel button in sidebar. */
+    showPanel(panelKey: PanelHandle, visible?: boolean): void;
+    /** Updates sidebar panel status. */
+    updatePanel(panelKey: PanelHandle, settings: Partial<PanelSettings>): void;
+    /** Ensures the panel is visible to user. */
+    bringPanelToFront(panel: PanelHandle): void;
+    /** Binds panel to a new document/state. */
+    bindPanel<TState, TMsg>(panel: PanelHandle, store: IStore<TState, TMsg>): void;
+    /** Instructs viewer that after particular action (such as clicking link or button) it should close panel when in mobile mode. */
+    closePanelOnNarrowScreen(panel?: PanelHandle): void;
+    /** Allows plugin to send a command to viewer window */
+    processCommand(cmd: ReportViewerCmd): void;
+    /** Redirects action processing to plugin */
+    processAction(action: ViewerAction): void;
+    /** Gets commands status */
+    readonly commandStatus: ReportViewerCommandStatus;
+    /** Sets viewer background color, default value = 'transparent'.
+     * @obsolete Use backgroundColor property instead.
+     */
+    setBackgroundColor(backgroundColor?: string): void;
+    /** Gets or ets page decoration, default value = 'shadow'  */
+    pageDecoration: PageDecoration;
+    /** Gets or sets viewer background color, default value = 'transparent' */
+    backgroundColor: string;
+    /** Allows to show sidebar in fullscreen mode */
+    enableSidebarInFullscreen: boolean;
+}
+export declare enum TimeDirection {
+    Backward = "backward",
+    Forward = "forward"
+}
+/** Interface to plugin module to implement support for particular document types. */
+export interface IPluginModule<TEvent extends IViewerEvent, TAction> {
+    /** Gets unique plugin identifier */
+    readonly pluginKey: string;
+    /** Opens a new document by URI */
+    openDocument(location: DocumentMoniker, token?: CancellationToken): Promise<IDocument | null>;
+    /** Renders page to a page view */
+    renderPage(page: IPageData): PageView;
+    /** Renders the page with highlighted results */
+    renderHighlightPage?(page: IPageData, results: SearchResult[]): PageView;
+    /** Fires when user switches to a new document (opens a new report) */
+    onOpenDocument?(view: IDocument | null): void;
+    /** Fires when user switches to a new document view */
+    onOpenDocumentView(view: IDocumentView | null): void;
+    /** Given the mouse event attempts to resolve the action for the viewer/plugin. */
+    resolveAction(context: ActionContext<TEvent>, event: MouseEvent): TAction | ViewerAction | null;
+    /** Processes the action resolved on prior step */
+    processAction(context: ActionContext<TEvent>, action: TAction, processCommand: (cmd: ReportViewerCmd) => void): boolean;
+    /** Translates event to a viewer commands (provides implementation for the events) */
+    processEvent(context: ActionContext<TEvent>, event: TEvent, direction: TimeDirection): void;
+}
+export declare type PageCountResult = {
+    totalPageCount: number | null;
+    renderedSoFar: number;
+};
+/** Defines a progress message for IRunEventSink.progress() method. */
+export declare type ProgressMessage = {
+    phase: "starting";
+    message: string;
+} | {
+    phase: "run";
+    document?: IDocumentView;
+    count: PageCountResult;
+} | {
+    phase: "complete";
+    document?: IDocumentView;
+    pageCount: number;
+} | {
+    phase: "cancelled";
+};
+/** Interface for communicating viewer when document rendering is in progress. */
+export interface IRunEventsSink extends IReportError {
+    /** Changes current status and provides additional progress info. */
+    progress(message: ProgressMessage): Promise<void>;
+    /** Instruct viewer to reset cached page data for particular page or range of pages */
+    invalidatePage(index: number, count?: number): void;
+    /** Provides cancellation token for rendering routine. The latter should check cancellation status and cancel rendering as soon as possible. */
+    readonly cancel: CancellationToken;
+}
+/** Internal document representation */
+export interface IDocument {
+    /** Indicates whether the view can be created immediately after document is loaded. Primarily for AutoRun. */
+    canView(): boolean;
+    /** Creates a new document view (runs the reports or renders the document).
+     * @param baseView the view to inherit settings or parameters from. Consider "refresh" behavior in report viewer.
+     * @param sink the interface to communicate progress into to a viewer.
+     */
+    createView(baseView: IDocumentView | null, sink: IRunEventsSink): Promise<IDocumentView | undefined>;
+    /** Updates the document view without data retrieval. Usually is called when view settings are changed. */
+    updateView(view: IDocumentView, sink: IRunEventsSink): Promise<IDocumentView | undefined>;
+}
+/** Visual representation of the document. */
+export interface IDocumentView {
+    /** Gets the number of pages within a document. */
+    readonly pageCount: PageCountResult;
+    /** Gets the document page. */
+    awaitPage(index: number): Promise<IPageData | null>;
+    /** Override to provide fulltext search implementation */
+//@ts-ignore
+    search?(options: FindOptions, startFrom: SearchResult): AsyncIterableIterator<SearchResult>;
+}
+export declare type PageSize = {
+    /** Page width in html units. E.g. "13cm", "5in" */
+    width: string;
+    /** Page height. */
+    height: string;
+};
+/** Marker interface for page data */
+export interface IPageData {
+    /** Gets the page size */
+    readonly pageSize: PageSize;
+}
+/** Rendering friendly page representation. */
+export declare type PageView = {
+    kind: 'html';
+    html: string;
+} | {
+    kind: 'dom';
+    dom: Element;
+};
+export type { PageDecoration };

package/typings/vendor/js-viewer-core/api/ReportViewerCmd.d.ts

@@ -0,0 +1,72 @@
+export declare type HistoryDir = "Back" | "Fwd" | "Parent";
+export declare type GotoTarget = "first" | "prev" | "next" | "last";
+/** @hidden Pointer to a document with required settings/parameters */
+export interface DocumentMoniker {
+    readonly pluginKey: string;
+}
+/** @hidden */
+export declare type ReportViewerCmd = {
+    type: "Goto";
+    payload: {
+        target: GotoTarget;
+    };
+} | {
+    type: "GotoPage";
+    payload: {
+        pageIndex: number;
+        scrollTo?: string;
+    };
+} | {
+    type: "SetCurrentPage";
+    payload: {
+        pageIndex: number;
+    };
+} | {
+    type: "FetchPages";
+    payload: {
+        startPage: number;
+        pageCount: number;
+    };
+} | {
+    type: "Refresh";
+} | {
+    type: "Run";
+    payload?: {
+        dontCutHistory: boolean;
+        gotoPageIndex?: number;
+    };
+} | {
+    type: "Cancel";
+}
+/** Resets the pages navigation history. Clears document drill history if `hard` parameter is set to true */
+ | {
+    type: "ClearHistory";
+    payload: {
+        hard?: boolean;
+    };
+} | {
+    type: "GoHistory";
+    payload: {
+        direction: HistoryDir;
+    };
+} | {
+    type: "UpdateView";
+} | {
+    type: "OpenDocument";
+    payload: DocumentMoniker;
+};
+/** @hidden */
+export declare type ReportViewerCommandStatus = {
+    readonly canGoBack: boolean;
+    readonly canGoForward: boolean;
+    readonly canRefresh: boolean;
+    readonly canCancel: boolean;
+    readonly canGoHistoryBack: boolean;
+    readonly canGoBackToParent: boolean;
+    readonly canGoHistoryForward: boolean;
+    readonly canGoHistory: {
+        Back: boolean;
+        Fwd: boolean;
+        Parent: boolean;
+    };
+};

package/typings/vendor/js-viewer-core/api/index.d.ts

@@ -0,0 +1,3 @@
+import * as PluginModel from './PluginModel';
+export { ReportViewerCmd, ReportViewerCommandStatus, DocumentMoniker, HistoryDir, GotoTarget } from './ReportViewerCmd';
+export { PluginModel };

package/typings/vendor/js-viewer-core/components/DocumentViewer/ContinuousView.d.ts

@@ -0,0 +1,37 @@
+/** @hidden */ /** */
+/// <reference path="../../../../vendor/react/react.d.ts" />
+//@ts-ignore
+import { Component } from 'react';
+import { PageViewProps } from './types';
+declare type ContinuousViewState = {
+    viewportHeight: number;
+    viewportWidth: number;
+    scrollTopPosition: number;
+    scrollingToPage: boolean;
+    pagesOnScreen: number;
+};
+export declare class ContinuousView extends Component<PageViewProps, ContinuousViewState> {
+    static displayName: string;
+    private ref;
+    private _pageCoords;
+    private _lastScrollRequestNo;
+    private _moveHandler;
+    constructor(props: PageViewProps);
+    private checkMouseMode;
+    private onUnmount?;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: PageViewProps): void;
+    private getVisiblePageIndex;
+    private updateViewportSize;
+    private onScroll;
+    private getRange;
+    private fetchPagesIfNew;
+    private setCurrentPage;
+    private scrollToCurrentPage;
+    private onClick;
+    render(): JSX.Element;
+    private getPageSize;
+    private getPageViewportSize;
+}
+export {};

package/typings/vendor/js-viewer-core/components/DocumentViewer/Page.d.ts

@@ -0,0 +1,17 @@
+/** @hidden */ /** */
+/// <reference path="../../../../vendor/react/react.d.ts" />
+//@ts-ignore
+import { Component } from 'react';
+import { PageInfo, ZoomTarget } from './types';
+import { PluginModel } from '../../api';
+export declare type PageProps = {
+    pageIndex: number;
+    pageModel: PageInfo | null;
+    zoomFactor: number;
+    zoomTarget?: ZoomTarget;
+    defaultPageSize?: PluginModel.PageSize;
+};
+export declare class Page extends Component<PageProps> {
+    static displayName: string;
+    render(): JSX.Element;
+}

package/typings/vendor/js-viewer-core/components/DocumentViewer/SinglePageView.d.ts

@@ -0,0 +1,30 @@
+/** @hidden */ /** */
+/// <reference path="../../../../vendor/react/react.d.ts" />
+//@ts-ignore
+import { Component } from 'react';
+import { PageViewProps } from './types';
+declare type SinglePageViewState = {
+    zoomFactor: number;
+    viewportWidth: number;
+    viewportHeight: number;
+    shouldUpdateViewportSize: boolean;
+};
+export declare class SinglePageView extends Component<PageViewProps, SinglePageViewState> {
+    static displayName: string;
+    private zoomerRef;
+    private pageViewRef;
+    private _lastScrollRequestNo;
+    private _moveHandler;
+    state: SinglePageViewState;
+    private onClick;
+    private checkMouseMode;
+    private onUnmount?;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(): void;
+    render(): JSX.Element;
+    private updateViewportSize;
+    private getPageSize;
+    private getPageViewportSize;
+}
+export {};

package/typings/vendor/js-viewer-core/components/DocumentViewer/View.d.ts

@@ -0,0 +1,15 @@
+/** @hidden */ /** */
+/// <reference path="../../../../vendor/react/react.d.ts" />
+//@ts-ignore
+import { Component, MouseEventHandler } from 'react';
+import { Model } from "./types";
+import { ReportViewerCmd } from "../../api/ReportViewerCmd";
+export declare type DocumentViewerProps = {
+    dispatchViewerCmd: (cmd: ReportViewerCmd) => void;
+    onClick: MouseEventHandler;
+    resizeObserver: (handler: () => void) => (() => void);
+};
+export declare class View extends Component<DocumentViewerProps, Model> {
+    state: Model;
+    render(): JSX.Element;
+}

package/typings/vendor/js-viewer-core/components/DocumentViewer/Zoomer.d.ts

@@ -0,0 +1,12 @@
+/// <reference path="../../../../vendor/react/react.d.ts" />
+//@ts-ignore
+import React from "react";
+import { ZoomTarget } from "./types";
+export declare type ZoomerProps = {
+    zoomFactor: number;
+    zoomTarget: ZoomTarget;
+    shouldAddMargin: boolean;
+};
+export declare const Zoomer: React.ForwardRefExoticComponent<ZoomerProps & {
+    children?: React.ReactNode;
+} & React.RefAttributes<HTMLDivElement>>;

package/typings/vendor/js-viewer-core/components/DocumentViewer/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export { init, initDocView, initSettings, docViewReducer, settingsReducer } from "./state";
+export { View } from './View';

package/typings/vendor/js-viewer-core/components/DocumentViewer/moveTool.d.ts

@@ -0,0 +1,4 @@
+/** @hidden */ /** */
+export declare function createMoveHandler(pagesContainer: HTMLElement): {
+    dispose: () => void;
+};

package/typings/vendor/js-viewer-core/components/DocumentViewer/state.d.ts

@@ -0,0 +1,7 @@
+/** @hidden */ /** */
+import { DocViewMsg, DocViewModel, ViewSettings, SettingsMsg, Model } from "./types";
+export declare function init(): Model;
+export declare function initDocView(): DocViewModel;
+export declare function initSettings(): ViewSettings;
+export declare function docViewReducer(msg: DocViewMsg, model: DocViewModel): DocViewModel;
+export declare function settingsReducer(msg: SettingsMsg, model: ViewSettings): ViewSettings;

package/typings/vendor/js-viewer-core/components/DocumentViewer/types.d.ts

@@ -0,0 +1,214 @@
+/** @hidden */ /** */
+/// <reference path="../../../../vendor/react/react.d.ts" />
+//@ts-ignore
+import { MouseEventHandler } from 'react';
+import { PluginModel, ReportViewerCmd } from '../../api';
+export declare type PageInfo = {
+    size: PluginModel.PageSize | null;
+    data: PluginModel.PageView | null;
+    isLoading: boolean;
+    isInvalid: boolean;
+    reqIndex: number;
+};
+export declare enum ViewerStatus {
+    Empty = 0,
+    Loading = 1,
+    Cancelled = 2,
+    Ready = 3,
+    Failed = 4
+}
+export declare enum ZoomMode {
+    Value = 0,
+    PageWidth = 1,
+    WholePage = 2
+}
+export declare enum ViewMode {
+    SinglePage = 0,
+    Continuous = 1
+}
+export declare enum MouseMode {
+    Select = 0,
+    Move = 1
+}
+export declare type UISize = 'small' | 'medium' | 'large';
+/**
+ * Zoom settings.
+ **/
+export declare type ZoomSettings = {
+    /**
+     * Zoom mode - fit page width.
+     **/	
+    mode: ZoomMode.PageWidth;
+} | {
+    /**
+     * Zoom mode - fit whole page.
+     **/	
+    mode: ZoomMode.WholePage;
+} | {
+    /**
+     * Zoom mode - value. 
+     **/	
+    mode: ZoomMode.Value;
+    /**
+     * Zoom factor. 
+     **/	
+    factor: number;
+};
+export declare type ZoomTarget = 'viewport' | 'page';
+export declare type PageDecoration = 'none' | 'border' | 'shadow';
+export declare type ViewSettings = {
+    zoom: ZoomSettings;
+    zoomTarget: ZoomTarget;
+    mode: ViewMode;
+    mouseMode: MouseMode;
+    isFullscreen: boolean;
+    narrowScreen: boolean;
+    isToolbarVisible: boolean;
+    isSidebarVisible: boolean;
+    backgroundColor: string;
+    pageDecoration: PageDecoration;
+    enableSidebarInFullscreen: boolean;
+};
+export declare type DocViewModel = {
+    readonly status: ViewerStatus;
+    readonly pageCount: number;
+    readonly pageIndex: number;
+    /** Indicates last page was set by user and view should scroll to page */
+    readonly scrollRequestNo: number;
+    readonly scrollToSelector: string | null;
+    readonly progressMessage: string;
+    readonly pageBuffer: Array<PageInfo>;
+    readonly highlightPage: {
+        pageIndex: number;
+        pageView: PluginModel.PageView;
+    } | null;
+};
+export declare type SettingsMsg = {
+    type: "UpdateZoom";
+    payload: {
+        zoom: ZoomSettings;
+    };
+} | {
+    type: "UpdateZoomTarget";
+    payload: {
+        zoomTarget: ZoomTarget;
+    };
+} | {
+    type: "UpdateView";
+    payload: {
+        mode: ViewMode;
+    };
+} | {
+    type: "UpdateMouseMode";
+    payload: {
+        mode: MouseMode;
+    };
+} | {
+    type: "UpdateFullscreen";
+    payload: {
+        isFullscreen: boolean;
+    };
+} | {
+    type: "UpdateToolbarVisibility";
+    payload: {
+        isVisible: boolean;
+    };
+} | {
+    type: "UpdateSidebarVisibility";
+    payload: {
+        isVisible: boolean;
+    };
+} | {
+    type: "ToggleNarrowScreen";
+    payload: {
+        isNarrow?: boolean;
+    };
+} | {
+    type: 'UpdateBackgroundColor';
+    payload: {
+        backgroundColor: string;
+    };
+} | {
+    type: 'UpdatePageDecoration';
+    payload: {
+        pageDecoration: PageDecoration;
+    };
+} | {
+    type: 'EnableSidebarInFullscreen';
+    payload: {
+        enableSidebarInFullscreen: boolean;
+    };
+};
+export declare type DocViewMsg = {
+    type: "Reset";
+    payload: {};
+} | {
+    type: "UpdateStatus";
+    payload: {
+        isLoading: boolean;
+        pageCount?: number;
+        message: string;
+    };
+} | {
+    type: "Cancelled";
+    payload: {
+        message: string;
+    };
+} | {
+    type: "Failed";
+    payload: {
+        message: string;
+    };
+} | {
+    type: "SetCurrentPage";
+    payload: {
+        pageIndex: number;
+        doScroll?: boolean;
+        scrollTo?: string;
+    };
+} | {
+    type: "Fetching";
+    payload: {
+        pageIndex: number;
+        reqIndex: number;
+    };
+} | {
+    type: "Fetched";
+    payload: {
+        pageIndex: number;
+        reqIndex: number;
+        data: PluginModel.PageView;
+        size: PluginModel.PageSize;
+    };
+} | {
+    type: "RemoveHighlight";
+} | {
+    type: "HighlightPage";
+    payload: {
+        pageIndex: number;
+        pageView: PluginModel.PageView;
+    };
+} | {
+    type: "Invalidate";
+    payload: {
+        startPage: number;
+        pageCount: number;
+    };
+};
+export declare type PageViewProps = DocViewModel & {
+    settings: ViewSettings;
+    dispatchVwr: (cmd: ReportViewerCmd) => void;
+    onClick: MouseEventHandler;
+    resizeObserver: (handler: () => void) => (() => void);
+};
+export declare type Model = {
+    settings: ViewSettings;
+    session: DocViewModel;
+};
+export declare type Msg = {
+    type: 'settings';
+    payload: SettingsMsg;
+} | {
+    type: 'session';
+    payload: DocViewMsg;
+};