@pdftools/four-heights-pdf-web-viewer 4.3.6

package/es6/pdf-viewer-canvas/state/annotations.d.ts

@@ -0,0 +1,36 @@
+import { ActionsType } from './appState';
+import { Annotation, PdfItemsOnPage } from '../../pdf-viewer-api';
+/** internal */
+export interface AnnotationsState {
+    openPopupChanged: boolean;
+    annotationsChanged: boolean;
+    all: {
+        [id: number]: Annotation;
+    };
+    byPage: {
+        [page: number]: number[];
+    };
+    popupsByPage: {
+        [page: number]: number[];
+    };
+    openPopupsByPage: {
+        [page: number]: number[];
+    };
+}
+/** internal */
+export declare const state: AnnotationsState;
+/** internal */
+export interface AnnotationsActions {
+    setPageAnnotations(annotationsOnPage: PdfItemsOnPage): AnnotationsState;
+    addAnnotation(annotation: Annotation): AnnotationsState;
+    updateAnnotation(annotation: Annotation): AnnotationsState;
+    deleteAnnotation(id: number): AnnotationsState;
+}
+/** internal */
+export declare const annotationHasPopup: (annotation: Annotation) => boolean;
+/** internal */
+export declare const actions: ActionsType<AnnotationsState, AnnotationsActions>;
+/** internal */
+export declare const getPopups: ($state: AnnotationsState, startPage: number, endPage: number) => Annotation[];
+/** internal */
+export declare const getOpenPopups: ($state: AnnotationsState, startPage: number, endPage: number) => Annotation[];

package/es6/pdf-viewer-canvas/state/annotations.js

@@ -0,0 +1,157 @@
+import { PdfItemType, } from '../../pdf-viewer-api';
+/** internal */
+export const state = {
+    annotationsChanged: false,
+    openPopupChanged: false,
+    all: [],
+    byPage: [],
+    popupsByPage: [],
+    openPopupsByPage: [],
+};
+/** internal */
+export const annotationHasPopup = (annotation) => {
+    if (annotation.itemType === PdfItemType.TEXT) {
+        return true;
+    }
+    if (annotation.itemType === PdfItemType.FREE_TEXT) {
+        return false;
+    }
+    if (!annotation.behaviors) {
+        return false;
+    }
+    return (annotation.behaviors.canHavePopup &&
+        (annotation.popup.isOpen === true ||
+            (typeof annotation.content === 'string' && annotation.content !== '') ||
+            (typeof annotation.subject === 'string' && annotation.subject !== '')));
+};
+/** internal */
+export const actions = {
+    setPageAnnotations: (annotationsOnPage) => ($state) => {
+        const newState = Object.assign({}, $state);
+        const pageNumber = annotationsOnPage.page;
+        newState.byPage[pageNumber] = [];
+        annotationsOnPage.items.forEach((item) => {
+            const annotation = item;
+            newState.all[annotation.id] = annotation;
+            newState.byPage[pageNumber].push(annotation.id);
+            if (annotationHasPopup(annotation)) {
+                if (!newState.popupsByPage[pageNumber]) {
+                    newState.popupsByPage[pageNumber] = [];
+                }
+                newState.popupsByPage[pageNumber].push(annotation.id);
+                if (annotation.popup.isOpen) {
+                    if (!newState.openPopupsByPage[pageNumber]) {
+                        newState.openPopupsByPage[pageNumber] = [];
+                    }
+                    if (!newState.openPopupsByPage[pageNumber].find((id) => id === annotation.id)) {
+                        newState.openPopupsByPage[pageNumber].push(annotation.id);
+                        newState.openPopupChanged = true;
+                    }
+                }
+            }
+        });
+        newState.annotationsChanged = true;
+        return newState;
+    },
+    deleteAnnotation: (id) => ($state) => {
+        const newState = Object.assign({}, $state);
+        const annotation = $state.all[id];
+        const pageNumber = annotation.pdfRect.page;
+        delete newState.all[id];
+        newState.byPage[pageNumber] = newState.byPage[pageNumber].filter((i) => i !== id);
+        if (newState.popupsByPage[pageNumber]) {
+            newState.popupsByPage[pageNumber] = newState.popupsByPage[pageNumber].filter((i) => i !== id);
+        }
+        if (newState.openPopupsByPage[pageNumber]) {
+            newState.openPopupChanged = newState.openPopupsByPage[pageNumber].indexOf(id) > -1;
+            newState.openPopupsByPage[pageNumber] = newState.openPopupsByPage[pageNumber].filter((i) => i !== id);
+        }
+        newState.annotationsChanged = true;
+        return newState;
+    },
+    updateAnnotation: (annotation) => ($state) => {
+        const newState = Object.assign({}, $state);
+        const { behaviors } = annotation;
+        const id = annotation.id;
+        const pageNumber = annotation.pdfRect.page;
+        if (behaviors.canHavePopup) {
+            if (annotationHasPopup(annotation)) {
+                if (!newState.popupsByPage[pageNumber]) {
+                    newState.popupsByPage[pageNumber] = [];
+                }
+                const popupIndex = newState.popupsByPage[pageNumber].indexOf(id);
+                if (popupIndex < 0) {
+                    newState.popupsByPage[pageNumber].push(annotation.id);
+                }
+            }
+            else {
+                if (newState.popupsByPage[pageNumber]) {
+                    newState.popupsByPage[pageNumber] = newState.popupsByPage[pageNumber].filter((i) => i !== id);
+                }
+            }
+            if (annotation.popup.isOpen) {
+                if (!newState.openPopupsByPage[pageNumber]) {
+                    newState.openPopupsByPage[pageNumber] = [];
+                }
+                if (newState.openPopupsByPage[pageNumber].indexOf(id) < 0) {
+                    newState.openPopupsByPage[pageNumber].push(id);
+                }
+                newState.openPopupChanged = true;
+            }
+            else if (newState.openPopupsByPage[pageNumber]) {
+                newState.openPopupsByPage[pageNumber] = newState.openPopupsByPage[pageNumber].filter((i) => i !== id);
+                newState.openPopupChanged = true;
+            }
+        }
+        newState.all[annotation.id] = annotation;
+        newState.annotationsChanged = true;
+        return newState;
+    },
+    addAnnotation: (annotation) => ($state) => {
+        const newState = Object.assign({}, $state);
+        const pageNumber = annotation.pdfRect.page;
+        const id = annotation.id;
+        newState.all[id] = annotation;
+        if (!newState.byPage[pageNumber]) {
+            newState.byPage[pageNumber] = [];
+        }
+        newState.byPage[pageNumber].push(id);
+        if (annotationHasPopup(annotation)) {
+            if (!newState.popupsByPage[pageNumber]) {
+                newState.popupsByPage[pageNumber] = [];
+            }
+            newState.popupsByPage[pageNumber].push(id);
+            if (annotation.popup.isOpen) {
+                if (!newState.openPopupsByPage[pageNumber]) {
+                    newState.openPopupsByPage[pageNumber] = [];
+                }
+                newState.openPopupsByPage[pageNumber].push(id);
+                newState.openPopupChanged = true;
+            }
+        }
+        newState.annotationsChanged = true;
+        return newState;
+    },
+};
+/** internal */
+export const getPopups = ($state, startPage, endPage) => {
+    let popups = [];
+    for (let page = startPage; page <= endPage; page++) {
+        if ($state.popupsByPage[page]) {
+            popups = popups
+                .concat($state.popupsByPage[page].map((id) => $state.all[id]))
+                .filter((annot) => !annot.isHidden());
+        }
+    }
+    return popups;
+};
+/** internal */
+export const getOpenPopups = ($state, startPage, endPage) => {
+    let openPopups = [];
+    for (let page = startPage; page <= endPage; page++) {
+        if ($state.openPopupsByPage[page]) {
+            openPopups = openPopups.concat($state.openPopupsByPage[page].map((id) => $state.all[id]));
+        }
+    }
+    return openPopups;
+};

package/es6/pdf-viewer-canvas/state/appState.d.ts

@@ -0,0 +1,10 @@
+/** internal */
+export type ActionResult<State> = Partial<State> | Promise<any> | null | void;
+/** internal */
+export type ActionType<State, Actions> = (data?: any) => ((state: State, actions: Actions) => ActionResult<State>) | ActionResult<State>;
+/** internal */
+export type ActionsType<State, Actions> = {
+    [P in keyof Actions]: ActionType<State, Actions> | ActionsType<any, Actions[P]>;
+};
+/** internal */
+export declare const appState: <S, A>(state: S, actions: ActionsType<S, A>) => A;

package/es6/pdf-viewer-canvas/state/appState.js

@@ -0,0 +1,60 @@
+/** internal */
+export const appState = (state, actions) => {
+    const clone = (target, source) => {
+        const out = {};
+        for (const field of Object.keys(target)) {
+            out[field] = target[field];
+        }
+        if (source) {
+            for (const field of Object.keys(source)) {
+                out[field] = source[field];
+            }
+        }
+        return out;
+    };
+    const getPartialState = (path, source) => {
+        let i = 0;
+        while (i < path.length) {
+            source = source[path[i++]];
+        }
+        return source;
+    };
+    function setPartialState(path, value, source) {
+        const target = {};
+        if (path.length) {
+            target[path[0]] =
+                path.length > 1 ? setPartialState(path.slice(1), value, source[path[0]]) : value;
+            return clone(source, target);
+        }
+        return value;
+    }
+    const wireStateToActions = (path, wState, wActions) => {
+        for (const field of Object.keys(wActions)) {
+            if (typeof wActions[field] === 'function') {
+                ;
+                ((key, action) => {
+                    wActions[key] = (data) => {
+                        let result = action(data);
+                        if (typeof result === 'function') {
+                            result = result(getPartialState(path, globalState), wActions);
+                        }
+                        /* tslint:disable-next-line */
+                        if (result &&
+                            result !== (wState = getPartialState(path, globalState)) &&
+                            !result.then) {
+                            globalState = setPartialState(path, clone(wState, result), globalState);
+                        }
+                        return result;
+                    };
+                })(field, wActions[field]);
+            }
+            else {
+                wireStateToActions(path.concat(field), (wState[field] = clone(wState[field])), (wActions[field] = clone(wActions[field])));
+            }
+        }
+        return wActions;
+    };
+    let globalState = clone(state);
+    const wiredActions = wireStateToActions([], globalState, clone(actions));
+    return wiredActions;
+};

package/es6/pdf-viewer-canvas/state/canvas.d.ts

@@ -0,0 +1,31 @@
+import { ActionsType } from './appState';
+/** internal */
+export interface CanvasPixels {
+    devicePixels: number;
+    cssPixels: number;
+}
+/** internal */
+export interface CanvasState {
+    widthChanged: boolean;
+    heightChanged: boolean;
+    pixelRatioChanged: boolean;
+    canvasInvalidated: boolean;
+    width: CanvasPixels;
+    height: CanvasPixels;
+    pixelRatio: number;
+}
+/** internal */
+export declare const state: CanvasState;
+/** internal */
+export interface CanvasResizePayload {
+    cssWidth: number;
+    cssHeight: number;
+}
+/** internal */
+export interface CanvasActions {
+    resize(payload: CanvasResizePayload): CanvasState;
+    setPixelRatio(pixelRatio: number): CanvasState;
+    setCanvasInvalidated(canvasInvalidated: boolean): CanvasState;
+}
+/** internal */
+export declare const actions: ActionsType<CanvasState, CanvasActions>;

package/es6/pdf-viewer-canvas/state/canvas.js

@@ -0,0 +1,41 @@
+/** internal */
+export const state = {
+    widthChanged: true,
+    heightChanged: true,
+    pixelRatioChanged: true,
+    canvasInvalidated: true,
+    width: { devicePixels: 0, cssPixels: 0 },
+    height: { devicePixels: 0, cssPixels: 0 },
+    pixelRatio: 1,
+};
+/** internal */
+export const actions = {
+    resize: (payload) => ($state) => {
+        const pixelRatio = window.devicePixelRatio;
+        const newState = Object.assign({}, $state);
+        if ($state.pixelRatio !== pixelRatio) {
+            newState.pixelRatio = pixelRatio;
+            newState.pixelRatioChanged = true;
+        }
+        if ($state.width.cssPixels !== payload.cssWidth) {
+            newState.width.cssPixels = payload.cssWidth;
+            newState.width.devicePixels = payload.cssWidth * pixelRatio;
+            newState.widthChanged = true;
+        }
+        if ($state.height.cssPixels !== payload.cssHeight) {
+            newState.height.cssPixels = payload.cssHeight;
+            newState.height.devicePixels = payload.cssHeight * pixelRatio;
+            newState.heightChanged = true;
+        }
+        return newState;
+    },
+    setPixelRatio: (pixelRatio) => ($state) => {
+        const newState = Object.assign({}, $state);
+        if ($state.pixelRatio !== pixelRatio) {
+            newState.pixelRatio = pixelRatio;
+            newState.pixelRatioChanged = true;
+        }
+        return newState;
+    },
+    setCanvasInvalidated: (canvasInvalidated) => ($state) => (Object.assign(Object.assign({}, $state), { canvasInvalidated })),
+};

package/es6/pdf-viewer-canvas/state/document.d.ts

@@ -0,0 +1,50 @@
+import { ActionsType } from './appState';
+import { CanvasPixels } from './canvas';
+import { Rect, Point, PdfFitMode, PdfPageLayoutMode } from '../../pdf-viewer-api';
+/** internal */
+export interface DocumentState {
+    busyStateChanged: boolean;
+    heightChanged: boolean;
+    widthChanged: boolean;
+    zoomChanged: boolean;
+    rotationChanged: boolean;
+    busyState: boolean;
+    firstVisiblePageChanged: boolean;
+    lastVisiblePageChanged: boolean;
+    firstVisiblePage: number;
+    lastVisiblePage: number;
+    pageRects: {
+        [key: number]: Rect;
+    };
+    zoom: number;
+    fitMode: PdfFitMode;
+    pageLayoutMode: PdfPageLayoutMode;
+    rotation: number;
+    width: CanvasPixels;
+    height: CanvasPixels;
+}
+/** internal */
+export declare const state: DocumentState;
+/** internal */
+export interface DocumentResizedPayload {
+    zoom: number;
+    devicePixelsWidth: number;
+    devicePixelsHeight: number;
+}
+/** internal */
+export interface DocumentActions {
+    fistVisiblePageChanged(pageNumber: number): DocumentState;
+    lastVisiblePageChanged(pageNumber: number): DocumentState;
+    busyStateChanged(busyState: boolean): DocumentState;
+    resize(payload: DocumentResizedPayload): DocumentState;
+    rotationChanged(rotation: number): DocumentState;
+    updatePageRects(pageRects: {
+        [key: number]: Rect;
+    }): DocumentState;
+    fitModeChanged(fitMode: PdfFitMode): DocumentState;
+    pageLayoutModeChanged(pageLayoutMode: PdfPageLayoutMode): DocumentState;
+}
+/** internal */
+export declare const actions: ActionsType<DocumentState, DocumentActions>;
+/** internal */
+export declare const getRectFromSelection: ($state: DocumentState, startPoint: Point, endPoint: Point, page?: number, padding?: number) => Rect | null;

package/es6/pdf-viewer-canvas/state/document.js

@@ -0,0 +1,99 @@
+import { PdfFitMode, PdfPageLayoutMode } from '../../pdf-viewer-api';
+/** internal */
+export const state = {
+    busyStateChanged: true,
+    heightChanged: true,
+    widthChanged: true,
+    zoomChanged: true,
+    rotationChanged: true,
+    firstVisiblePageChanged: true,
+    lastVisiblePageChanged: true,
+    busyState: false,
+    firstVisiblePage: 0,
+    lastVisiblePage: 0,
+    pageRects: [],
+    zoom: 1,
+    fitMode: PdfFitMode.NONE,
+    pageLayoutMode: PdfPageLayoutMode.SINGLE_PAGE,
+    rotation: 0,
+    width: { devicePixels: 0, cssPixels: 0 },
+    height: { devicePixels: 0, cssPixels: 0 },
+};
+/** internal */
+export const actions = {
+    fistVisiblePageChanged: (pageNumber) => ($state) => (Object.assign(Object.assign({}, $state), { firstVisiblePage: pageNumber, firstVisiblePageChanged: true })),
+    lastVisiblePageChanged: (pageNumber) => ($state) => (Object.assign(Object.assign({}, $state), { lastVisiblePage: pageNumber, lastVisiblePageChanged: true })),
+    resize: (payload) => ($state) => {
+        const newState = Object.assign({}, $state);
+        const pixelRatio = window.devicePixelRatio;
+        if (newState.width.devicePixels !== payload.devicePixelsWidth) {
+            newState.width.cssPixels = payload.devicePixelsWidth / pixelRatio;
+            newState.width.devicePixels = payload.devicePixelsWidth;
+            newState.widthChanged = true;
+        }
+        if (newState.height.devicePixels !== payload.devicePixelsHeight) {
+            newState.height.cssPixels = payload.devicePixelsHeight / pixelRatio;
+            newState.height.devicePixels = payload.devicePixelsHeight;
+            newState.heightChanged = true;
+        }
+        if (newState.zoom !== payload.zoom) {
+            newState.zoom = payload.zoom;
+            newState.zoomChanged = true;
+        }
+        return newState;
+    },
+    rotationChanged: (rotation) => ($state) => (Object.assign(Object.assign({}, $state), { rotation, rotationChanged: true })),
+    updatePageRects: (pageRects) => ($state) => (Object.assign(Object.assign({}, $state), { pageRects })),
+    busyStateChanged: (busyState) => ($state) => (Object.assign(Object.assign({}, $state), { busyState, busyStateChanged: true })),
+    fitModeChanged: (fitMode) => ($state) => (Object.assign(Object.assign({}, $state), { fitMode })),
+    pageLayoutModeChanged: (pageLayoutMode) => ($state) => (Object.assign(Object.assign({}, $state), { pageLayoutMode })),
+};
+/** internal */
+const getSelectionRectFromPage = ($state, startPoint, endPoint, page, padding = 1) => {
+    let rect = null;
+    const pageRect = $state.pageRects[page];
+    const pX1 = pageRect.x + padding;
+    const pX2 = pageRect.x + (pageRect.w - 2 * padding);
+    const pY1 = pageRect.y + padding;
+    const pY2 = pageRect.y + (pageRect.h - 2 * padding);
+    if (startPoint.x >= pX1 && startPoint.x <= pX2 && startPoint.y >= pY1 && startPoint.y <= pY2) {
+        endPoint.x = endPoint.x < pX1 ? pX1 : endPoint.x > pX2 ? pX2 : endPoint.x;
+        endPoint.y = endPoint.y < pY1 ? pY1 : endPoint.y > pY2 ? pY2 : endPoint.y;
+        rect = { x: 0, y: 0, w: 0, h: 0 };
+        if (startPoint.x < endPoint.x) {
+            rect.x = startPoint.x;
+            rect.w = endPoint.x - startPoint.x;
+        }
+        else {
+            rect.x = endPoint.x;
+            rect.w = startPoint.x - endPoint.x;
+        }
+        if (startPoint.y < endPoint.y) {
+            rect.y = startPoint.y;
+            rect.h = endPoint.y - startPoint.y;
+        }
+        else {
+            rect.y = endPoint.y;
+            rect.h = startPoint.y - endPoint.y;
+        }
+        return rect;
+    }
+    return rect;
+};
+/** internal */
+export const getRectFromSelection = ($state, startPoint, endPoint, page, padding = 1) => {
+    if (page) {
+        return getSelectionRectFromPage($state, startPoint, endPoint, page);
+    }
+    else {
+        for (const pNr in $state.pageRects) {
+            if ($state.pageRects) {
+                const rect = getSelectionRectFromPage($state, startPoint, endPoint, parseInt(pNr, 10), padding);
+                if (rect) {
+                    return rect;
+                }
+            }
+        }
+    }
+    return null;
+};

package/es6/pdf-viewer-canvas/state/pointer.d.ts

@@ -0,0 +1,31 @@
+import { ActionsType } from './appState';
+import { CanvasPixels } from './canvas';
+/** internal */
+export type PointerAction = 'click' | 'dblclick' | 'longpress' | 'startdrag' | 'enddrag' | null;
+export type PointerType = 'mouse' | 'touch';
+/** internal */
+export interface PointerState {
+    positionChanged: boolean;
+    stateChanged: boolean;
+    isDown: boolean;
+    type: PointerType;
+    action: PointerAction;
+    x: CanvasPixels;
+    y: CanvasPixels;
+}
+/** internal */
+export declare const state: PointerState;
+/** internal */
+export interface UpdatePointerPayload {
+    cssX: number;
+    cssY: number;
+    isDown: boolean;
+    type: PointerType;
+}
+/** internal */
+export interface PointerActions {
+    update(payload: UpdatePointerPayload): PointerState;
+    setAction(action: PointerAction): PointerState;
+}
+/** internal */
+export declare const actions: ActionsType<PointerState, PointerActions>;

package/es6/pdf-viewer-canvas/state/pointer.js

@@ -0,0 +1,31 @@
+/** internal */
+export const state = {
+    positionChanged: true,
+    stateChanged: true,
+    isDown: false,
+    type: 'ontouchstart' in window ? 'touch' : 'mouse',
+    action: null,
+    x: { devicePixels: 0, cssPixels: 0 },
+    y: { devicePixels: 0, cssPixels: 0 },
+};
+/** internal */
+export const actions = {
+    setAction: (action) => ($state) => (Object.assign(Object.assign({}, $state), { action })),
+    update: (payload) => ($state) => {
+        const pixelRatio = window.devicePixelRatio;
+        const newState = Object.assign({}, $state);
+        newState.type = payload.type;
+        if ($state.x.cssPixels !== payload.cssY || $state.x.cssPixels !== payload.cssX) {
+            newState.x.cssPixels = payload.cssX;
+            newState.x.devicePixels = payload.cssX * pixelRatio;
+            newState.y.cssPixels = payload.cssY;
+            newState.y.devicePixels = payload.cssY * pixelRatio;
+            newState.positionChanged = true;
+        }
+        if ($state.isDown !== payload.isDown) {
+            newState.isDown = payload.isDown;
+            newState.stateChanged = true;
+        }
+        return newState;
+    },
+};

package/es6/pdf-viewer-canvas/state/scroll.d.ts

@@ -0,0 +1,22 @@
+import { ActionsType } from './appState';
+import { CanvasPixels } from './canvas';
+/** internal */
+export interface ScrollState {
+    topPositionChanged: boolean;
+    leftPositionChanged: boolean;
+    top: CanvasPixels;
+    left: CanvasPixels;
+}
+/** internal */
+export declare const state: ScrollState;
+/** internal */
+export interface ScrollChangedPayload {
+    cssTop: number;
+    cssLeft: number;
+}
+/** internal */
+export interface ScrollActions {
+    scrollChanged(payload: ScrollChangedPayload): ScrollState;
+}
+/** internal */
+export declare const actions: ActionsType<ScrollState, ScrollActions>;

package/es6/pdf-viewer-canvas/state/scroll.js

@@ -0,0 +1,25 @@
+/** internal */
+export const state = {
+    topPositionChanged: false,
+    leftPositionChanged: false,
+    top: { devicePixels: 0, cssPixels: 0 },
+    left: { devicePixels: 0, cssPixels: 0 },
+};
+/** internal */
+export const actions = {
+    scrollChanged: (payload) => ($state) => {
+        const newState = Object.assign({}, $state);
+        const pixelRatio = window.devicePixelRatio;
+        if ($state.top.devicePixels !== payload.cssTop) {
+            newState.top.cssPixels = payload.cssTop / pixelRatio;
+            newState.top.devicePixels = payload.cssTop;
+            newState.topPositionChanged = true;
+        }
+        if ($state.left.devicePixels !== payload.cssLeft) {
+            newState.left.cssPixels = payload.cssLeft / pixelRatio;
+            newState.left.devicePixels = payload.cssLeft;
+            newState.leftPositionChanged = true;
+        }
+        return newState;
+    },
+};

package/es6/pdf-viewer-canvas/state/search.d.ts

@@ -0,0 +1,36 @@
+import { ActionsType } from './appState';
+import { QuadrilateralOnPage } from '../../pdf-viewer-api';
+/** internal */
+export interface SearchState {
+    searchString: string;
+    caseSensitive: boolean;
+    wrapSearch: boolean;
+    useRegex: boolean;
+    page: number;
+    match: QuadrilateralOnPage[] | null;
+    painted: boolean;
+}
+/** internal */
+export declare const state: SearchState;
+/** internal */
+export interface StartSearchPayload {
+    searchString: string;
+    reverse: boolean;
+    caseSensitive: boolean;
+    wrapSearch: boolean;
+    useRegex: boolean;
+}
+/** internal */
+export interface UpdateSearchMatchPayload {
+    page: number;
+    match: QuadrilateralOnPage[];
+}
+/** internal */
+export interface SearchActions {
+    start(payload: StartSearchPayload): SearchState;
+    updateMatch(payload: UpdateSearchMatchPayload): SearchState;
+    matchPainted(): SearchState;
+    clear(): SearchState;
+}
+/** internal */
+export declare const actions: ActionsType<SearchState, SearchActions>;

package/es6/pdf-viewer-canvas/state/search.js

@@ -0,0 +1,27 @@
+/** internal */
+export const state = {
+    searchString: '',
+    caseSensitive: false,
+    wrapSearch: false,
+    useRegex: false,
+    page: 1,
+    match: null,
+    painted: false,
+};
+/** internal */
+export const actions = {
+    start: (payload) => ($state) => (Object.assign(Object.assign(Object.assign({}, $state), payload), { match: null, page: 1 })),
+    updateMatch: (payload) => ($state) => (Object.assign(Object.assign(Object.assign({}, $state), payload), { painted: false })),
+    matchPainted: () => ($state) => {
+        return Object.assign(Object.assign({}, $state), { painted: true });
+    },
+    clear: () => ($state) => ({
+        searchString: '',
+        caseSensitive: false,
+        wrapSearch: false,
+        useRegex: false,
+        page: 1,
+        match: null,
+        painted: false,
+    }),
+};