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

package/es6/modules/stamp-annotation/AddStampAnnotationLayer.js

@@ -0,0 +1,257 @@
+import { CanvasLayer } from '../CanvasLayer';
+import { PdfItemType, StampAnnotationColor, } from '../../pdf-viewer-api';
+import { CursorStyle } from '../../pdf-viewer-canvas/state/viewer';
+import { getRectFromSelection } from '../../pdf-viewer-canvas/state/document';
+import { createAddStampAnnotationToolbar } from './AddStampAnnotationToolbar';
+import { translationManager } from '../../common/TranslationManager';
+import { imageDataUrlToUint8Array } from '../../common/Tools';
+const moduleLayerName = 'AddStampAnnotation';
+export class AddStampAnnotationLayer extends CanvasLayer {
+    constructor() {
+        super(...arguments);
+        this.context = null;
+        this.pointerDown = false;
+        this.startPoint = null;
+        this.stampRect = null;
+        this.page = 0;
+        this.screenPageRect = null;
+        this.aspectRatio = null;
+        this.stamps = [];
+    }
+    onCreate() {
+        this.setStamp = this.setStamp.bind(this);
+        this.close = this.close.bind(this);
+        this.context = this.createCanvas();
+        this.stamps = this.options.annotation.stamps;
+        /* tslint:disable-next-line:align */
+        const toolbarElement = this.module.toolbarElement;
+        this.setStamp(this.options.annotation.selectedStamp);
+        createAddStampAnnotationToolbar({
+            selectedStamp: this.options.annotation.selectedStamp,
+            stamps: this.stamps,
+            onStampChanged: this.setStamp,
+            onClose: this.close,
+        }, toolbarElement);
+        this.store.viewer.beginModule(moduleLayerName);
+    }
+    onSave() {
+        const promise = new Promise((resolve, reject) => {
+            resolve();
+        });
+        return promise;
+    }
+    onRemove() {
+        this.removeCanvasElements();
+        this.context = null;
+        /* tslint:disable-next-line:align */
+        const toolbarElement = this.module.toolbarElement;
+        toolbarElement.innerHTML = '';
+        this.store.viewer.setCursorStyle(CursorStyle.DEFAULT);
+        this.store.viewer.endModule(moduleLayerName);
+    }
+    render(timestamp, state) {
+        if (state.viewer.modeChanged && state.viewer.selectedModuleName !== moduleLayerName) {
+            this.remove();
+            return;
+        }
+        if (!this.aspectRatio) {
+            return;
+        }
+        if (this.context) {
+            const update = state.viewer.modeChanged ||
+                state.pointer.positionChanged ||
+                state.pointer.action ||
+                state.document.zoomChanged;
+            if (update) {
+                const ctx = this.context;
+                ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+                const pointerPos = { x: state.pointer.x.devicePixels, y: state.pointer.y.devicePixels };
+                const pointerPdfPos = this.pdfApi.transformScreenPointToPdfPoint(pointerPos);
+                if (pointerPdfPos.isOnPage) {
+                    this.store.viewer.setCursorStyle(CursorStyle.CROSSHAIR);
+                }
+                else {
+                    this.store.viewer.setCursorStyle(CursorStyle.NOT_ALLOWED);
+                }
+                if (state.pointer.isDown) {
+                    if (!this.pointerDown) {
+                        if (!pointerPdfPos.isOnPage) {
+                            return;
+                        }
+                        this.startPoint = pointerPos;
+                        this.page = pointerPdfPos.pdfPoint.page;
+                        this.pointerDown = true;
+                        this.screenPageRect = this.pdfApi.getPageScreenRect(this.page);
+                    }
+                    if (this.startPoint && this.screenPageRect) {
+                        this.stampRect = getRectFromSelection(state.document, {
+                            x: this.startPoint.x,
+                            y: this.startPoint.y,
+                        }, {
+                            x: pointerPos.x,
+                            y: pointerPos.y,
+                        });
+                        if (this.stampRect) {
+                            this.stampRect.h = this.stampRect.w / this.aspectRatio;
+                            const lineWidth = 2 * devicePixelRatio;
+                            ctx.save();
+                            ctx.strokeStyle = this.options.viewer.general.textSelectionColor;
+                            ctx.fillStyle = this.options.viewer.general.textSelectionColor;
+                            ctx.lineWidth = lineWidth;
+                            ctx.setLineDash([lineWidth, lineWidth]);
+                            if (this.startPoint.y > pointerPos.y) {
+                                this.stampRect.y = this.startPoint.y - this.stampRect.h;
+                                if (this.stampRect.y < this.screenPageRect.y) {
+                                    this.stampRect.y = this.screenPageRect.y;
+                                    this.stampRect.w = this.stampRect.h * this.aspectRatio;
+                                }
+                            }
+                            else {
+                                if (this.startPoint.y + this.stampRect.h >
+                                    this.screenPageRect.y + this.screenPageRect.h) {
+                                    this.stampRect.h =
+                                        this.screenPageRect.y + this.screenPageRect.h - this.startPoint.y;
+                                    this.stampRect.w = this.stampRect.h * this.aspectRatio;
+                                }
+                            }
+                            ctx.strokeRect(this.stampRect.x, this.stampRect.y, this.stampRect.w, this.stampRect.h);
+                            ctx.globalAlpha = 0.33;
+                            ctx.fillRect(this.stampRect.x, this.stampRect.y, this.stampRect.w, this.stampRect.h);
+                            ctx.restore();
+                        }
+                    }
+                }
+                else if (this.pointerDown && this.startPoint) {
+                    if (this.stampRect) {
+                        this.createStampAnnotation(this.stampRect);
+                        this.pointerDown = false;
+                        this.startPoint = null;
+                        this.stampRect = null;
+                        this.page = 0;
+                        this.aspectRatio = null;
+                        this.screenPageRect = null;
+                        this.remove();
+                        return;
+                    }
+                }
+            }
+        }
+    }
+    close() {
+        this.remove();
+    }
+    setStamp(stampIndex) {
+        if (this.stamps.length == 0) {
+            return;
+        }
+        if (stampIndex >= this.stamps.length) {
+            stampIndex = 0;
+        }
+        this.options.annotation.selectedStamp = stampIndex;
+        const stamp = this.stamps[stampIndex];
+        // todo: handle pdf stamps
+        if (stamp.aspectRatio) {
+            this.aspectRatio = stamp.aspectRatio;
+            return;
+        }
+        if (stamp.image) {
+            const img = new Image();
+            img.onload = () => {
+                this.aspectRatio = img.width / img.height;
+            };
+            img.src = stamp.image;
+            return;
+        }
+        this.pdfApi
+            .getTextStampAspectRatio(stamp.text ? stamp.text : translationManager.getText(stamp.translation_key))
+            .then((aspectRatio) => {
+            this.aspectRatio = aspectRatio;
+        });
+    }
+    createStampAnnotation(rect) {
+        const pdfRect = this.pdfApi.transformScreenRectToPdfRect(rect, this.page);
+        if (this.aspectRatio && (pdfRect.pdfW < 2 || pdfRect.pdfH < 2)) {
+            switch (this.pdfApi.getRotation()) {
+                case 0:
+                    pdfRect.pdfW = this.options.annotation.defaultStampWidth;
+                    pdfRect.pdfH = pdfRect.pdfW / this.aspectRatio;
+                    pdfRect.pdfY -= pdfRect.pdfH;
+                    break;
+                case 90:
+                    pdfRect.pdfH = this.options.annotation.defaultStampWidth;
+                    pdfRect.pdfW = pdfRect.pdfH / this.aspectRatio;
+                    break;
+                case 180:
+                    pdfRect.pdfW = this.options.annotation.defaultStampWidth;
+                    pdfRect.pdfH = pdfRect.pdfW / this.aspectRatio;
+                    pdfRect.pdfX -= pdfRect.pdfW;
+                    break;
+                case 270:
+                    pdfRect.pdfH = this.options.annotation.defaultStampWidth;
+                    pdfRect.pdfW = pdfRect.pdfH / this.aspectRatio;
+                    pdfRect.pdfX -= pdfRect.pdfW;
+                    pdfRect.pdfY -= pdfRect.pdfH;
+                    break;
+                default:
+                    break;
+            }
+        }
+        const stampSetting = this.stamps[this.options.annotation.selectedStamp];
+        if (stampSetting.pdfStampFileName) {
+            this.pdfApi
+                .registerPdfPage(stampSetting.pdfStampFileName, stampSetting.pageNumber)
+                .then((imageId) => {
+                const annotation = {
+                    itemType: PdfItemType.STAMP,
+                    imageId,
+                    page: pdfRect.page,
+                    color: this.options.annotation.colors.defaultHighlightColor,
+                    pdfRect,
+                    author: this.options.viewer.general.user,
+                };
+                this.pdfApi.createItem(annotation).then((annot) => {
+                    this.onAnnotationCreated(annot);
+                });
+            });
+        }
+        else if (stampSetting.image) {
+            const imgData = imageDataUrlToUint8Array(stampSetting.image);
+            this.pdfApi.registerStampImage(imgData).then((imageId) => {
+                const annotation = {
+                    itemType: PdfItemType.STAMP,
+                    imageId,
+                    page: pdfRect.page,
+                    color: this.options.annotation.colors.defaultHighlightColor,
+                    pdfRect,
+                    author: this.options.viewer.general.user,
+                };
+                this.pdfApi.createItem(annotation).then((annot) => {
+                    this.onAnnotationCreated(annot);
+                });
+            });
+        }
+        else {
+            let stampColor = null;
+            let stampName = null;
+            if (stampSetting) {
+                stampColor = stampSetting.color;
+                stampName = stampSetting.pdfStampName !== undefined ? stampSetting.pdfStampName : null;
+            }
+            const annotation = {
+                itemType: PdfItemType.STAMP,
+                color: this.options.annotation.colors.defaultHighlightColor,
+                author: this.options.viewer.general.user,
+                page: pdfRect.page,
+                pdfRect,
+                stampName,
+                stampText: stampSetting.text
+                    ? stampSetting.text
+                    : translationManager.getText(stampSetting.translation_key),
+                stampColor: stampColor != null ? stampColor : StampAnnotationColor.GREEN,
+            };
+            this.pdfApi.createItem(annotation).then((annot) => {
+                this.onAnnotationCreated(annot);
+            });
+        }
+    }
+}

package/es6/modules/stamp-annotation/AddStampAnnotationToolbar.d.ts

@@ -0,0 +1,17 @@
+import { DropdownItem } from '../../common/Dropdown';
+export interface AddStampAnnotationToolbarProps {
+    selectedStamp: number;
+    stamps: any[];
+    onStampChanged(stamp: number): void;
+    onClose(): void;
+}
+interface AddStampAnnotationToolbarState {
+    selectedStamp: number;
+    stamps: any[];
+    stampDropdownItems: DropdownItem[];
+}
+export interface AddStampAnnotationToolbarActions {
+    setStamp(stamp: number): AddStampAnnotationToolbarState;
+}
+export declare const createAddStampAnnotationToolbar: (props: AddStampAnnotationToolbarProps, element: HTMLElement) => AddStampAnnotationToolbarActions;
+export {};

package/es6/modules/stamp-annotation/AddStampAnnotationToolbar.js

@@ -0,0 +1,68 @@
+import { app, h } from '../../lib/hyperapp';
+import { translationManager } from '../../common/TranslationManager';
+import { Toolbar } from '../../common/Toolbar';
+import { ToolbarItemGroup } from '../../common/ToolbarItemGroup';
+import { ToolbarButton } from '../../common/ToolbarButton';
+import { icons } from '../../common/icons';
+import { ToolbarSeparator } from '../../common/ToolbarSeparator';
+import { Dropdown } from '../../common/Dropdown';
+export const createAddStampAnnotationToolbar = (props, element) => {
+    const state = {
+        stamps: props.stamps,
+        stampDropdownItems: [],
+        selectedStamp: props.selectedStamp,
+    };
+    const actions = {
+        setStamp: (stamp) => ($state) => {
+            props.onStampChanged(stamp);
+            return Object.assign(Object.assign({}, $state), { selectedStamp: stamp });
+        },
+    };
+    const DropdownStampItem = (item) => {
+        const stamp = state.stamps[item.value];
+        if (stamp.thumbnail) {
+            return (h("div", { title: stamp.title || '' },
+                h("img", { src: stamp.thumbnail })));
+        }
+        // todo: handle pdf stamps
+        if (stamp.name) {
+            return h("div", { title: stamp.title || '' }, stamp.name);
+        }
+        return (h("div", { title: stamp.title || '' }, stamp.image
+            ? stamp.name
+            : stamp.text
+                ? stamp.text
+                : translationManager.getText(stamp.translation_key)));
+    };
+    const DropdownButton = (value) => {
+        if (value === -1) {
+            return (h("div", { class: "pwv-Dropdown-text" }, translationManager.getText('annotStamp.chooseStamp')));
+        }
+        const stamp = state.stamps[value];
+        if (stamp.thumbnail) {
+            return (h("div", { class: "pwv-Dropdown-text" },
+                h("img", { src: stamp.thumbnail })));
+        }
+        // todo: handle pdf stamps
+        if (stamp.pdfStampFileName) {
+            return h("div", { class: "pwv-Dropdown-text" }, stamp.name);
+        }
+        return (h("div", { class: "pwv-Dropdown-text" }, stamp.image
+            ? stamp.name
+            : stamp.text
+                ? stamp.text
+                : translationManager.getText(stamp.translation_key)));
+    };
+    const App = () => h(AddStampAnnotationToolbar, null);
+    /* tslint:disable-next-line:max-line-length */
+    const AddStampAnnotationToolbar = ({}) => ($state, $actions) => (h(Toolbar, { allowWrap: true, alignCenter: true },
+        h(ToolbarItemGroup, null,
+            h(Dropdown, { className: "pwv-stampannotation-dropdown", value: $state.selectedStamp, items: $state.stamps.map((stamp, index) => ({
+                    value: index,
+                    renderItem: DropdownStampItem,
+                })), onChange: $actions.setStamp, renderButton: DropdownButton })),
+        h(ToolbarItemGroup, { pushRight: true },
+            h(ToolbarSeparator, null),
+            h(ToolbarButton, { icon: icons.close, onClick: props.onClose }))));
+    return app(state, actions, App, element);
+};

package/es6/modules/stamp-annotation/StampAnnotationModule.d.ts

@@ -0,0 +1,20 @@
+import { CanvasModule, CanvasModuleType } from '../CanvasModule';
+export declare class StampAnnotationModule extends CanvasModule {
+    annotationbarElement: HTMLElement | null;
+    toolbarElement: HTMLElement | null;
+    static moduleInfo: {
+        name: string;
+        moduleType: CanvasModuleType;
+        requiredFeatures: {
+            annotate: boolean;
+            fillFormFields: boolean;
+        };
+        translationKey: string;
+        icon: string;
+    };
+    constructor();
+    onRegister(): {
+        toolbar: HTMLElement;
+    };
+    activate(): void;
+}

package/es6/modules/stamp-annotation/StampAnnotationModule.js

@@ -0,0 +1,35 @@
+import { CanvasModule, CanvasModuleType } from '../CanvasModule';
+import { AddStampAnnotationLayer } from './AddStampAnnotationLayer';
+export class StampAnnotationModule extends CanvasModule {
+    constructor() {
+        super();
+        this.annotationbarElement = null;
+        this.toolbarElement = null;
+        this.name = StampAnnotationModule.moduleInfo.name;
+        this.activate = this.activate.bind(this);
+    }
+    onRegister() {
+        this.toolbarElement = document.createElement('div');
+        return {
+            toolbar: this.toolbarElement,
+        };
+    }
+    activate() {
+        if (!this.canvasLayers['add']) {
+            this.createCanvasLayer('add', AddStampAnnotationLayer);
+        }
+        else {
+            this.removeCanvasLayer('add');
+        }
+    }
+}
+StampAnnotationModule.moduleInfo = {
+    name: 'StampAnnotationModule',
+    moduleType: CanvasModuleType.Tool,
+    requiredFeatures: {
+        annotate: true,
+        fillFormFields: false,
+    },
+    translationKey: 'annotStamp.add',
+    icon: 'stamp',
+};

package/es6/modules/text-annotation/AddTextAnnotationLayer.d.ts

@@ -0,0 +1,14 @@
+import { CanvasLayer } from '../CanvasLayer';
+import { ViewerCanvasState } from '../../pdf-viewer-canvas/state/store';
+export declare class AddTextAnnotationLayer extends CanvasLayer {
+    private context;
+    private colors;
+    private selectedColor;
+    onCreate(): void;
+    onSave(): Promise<void>;
+    onRemove(): void;
+    render(timestamp: number, state: ViewerCanvasState): void;
+    private setColor;
+    private close;
+    private createTextAnnotation;
+}

package/es6/modules/text-annotation/AddTextAnnotationLayer.js

@@ -0,0 +1,132 @@
+import { CanvasLayer } from '../CanvasLayer';
+import { PdfItemType, } from '../../pdf-viewer-api';
+import { CursorStyle } from '../../pdf-viewer-canvas/state/viewer';
+import { renderStickyNote } from '../../pdf-viewer-canvas/view-layers/canvasShapes';
+import { createAddTextAnnotationToolbar } from './AddTextAnnotationToolbar';
+const moduleLayerName = 'AddTextAnnotation';
+export class AddTextAnnotationLayer extends CanvasLayer {
+    constructor() {
+        super(...arguments);
+        this.colors = [];
+        this.selectedColor = '';
+    }
+    onCreate() {
+        this.setColor = this.setColor.bind(this);
+        this.close = this.close.bind(this);
+        this.context = this.createCanvas();
+        this.colors = this.options.annotation.colors.highlightColors;
+        this.selectedColor = this.options.annotation.colors.stickyNoteColor;
+        /* tslint:disable-next-line:align */
+        const toolbarElement = this.module.toolbarElement;
+        createAddTextAnnotationToolbar({
+            colors: this.colors,
+            selectedColor: this.selectedColor,
+            onColorChanged: this.setColor,
+            onClose: this.close,
+        }, toolbarElement);
+        this.store.viewer.beginModule(moduleLayerName);
+    }
+    onSave() {
+        const promise = new Promise((resolve, reject) => {
+            resolve();
+        });
+        return promise;
+    }
+    onRemove() {
+        this.removeCanvasElements();
+        this.context = null;
+        /* tslint:disable-next-line:align */
+        const toolbarElement = this.module.toolbarElement;
+        toolbarElement.innerHTML = '';
+        this.store.viewer.endModule(moduleLayerName);
+    }
+    render(timestamp, state) {
+        if (state.viewer.modeChanged && state.viewer.selectedModuleName !== moduleLayerName) {
+            this.remove();
+            return;
+        }
+        if (this.context &&
+            (state.viewer.modeChanged ||
+                state.pointer.positionChanged ||
+                state.pointer.action ||
+                state.canvas.canvasInvalidated)) {
+            const ctx = this.context;
+            ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+            const scale = state.canvas.pixelRatio * state.document.zoom;
+            const s = 6 * scale;
+            const h = 22 * scale;
+            const rect = {
+                w: 26 * scale,
+                h,
+                x: state.pointer.x.devicePixels - s,
+                y: state.pointer.y.devicePixels - h,
+            };
+            let rectOnPage = false;
+            for (const k in state.document.pageRects) {
+                if (state.document.pageRects[k]) {
+                    const p = state.document.pageRects[k];
+                    const px2 = p.x + p.w;
+                    const rx2 = rect.x + rect.w;
+                    const py2 = p.y + p.h;
+                    const ry2 = rect.y + rect.h;
+                    if (rect.x >= p.x && rx2 <= px2 && rect.y >= p.y && ry2 <= py2) {
+                        rectOnPage = true;
+                        break;
+                    }
+                }
+            }
+            if (rectOnPage) {
+                if (state.pointer.type === 'mouse') {
+                    renderStickyNote(ctx, scale, rect, this.selectedColor, '#000000');
+                    this.store.viewer.setCursorStyle(CursorStyle.DEFAULT);
+                }
+                if (state.pointer.action === 'click') {
+                    rect.y = rect.y;
+                    this.createTextAnnotation(rect, this.selectedColor);
+                    this.remove();
+                    return;
+                }
+            }
+            else {
+                this.store.viewer.setCursorStyle(CursorStyle.NOT_ALLOWED);
+            }
+        }
+    }
+    setColor(color) {
+        this.selectedColor = color;
+        this.options.annotation.colors.stickyNoteColor = color;
+    }
+    close() {
+        this.remove();
+    }
+    createTextAnnotation(point, color) {
+        const pdfPoint = this.pdfApi.transformScreenPointToPdfPoint({
+            x: point.x,
+            y: point.y,
+        }).pdfPoint;
+        const annotation = {
+            itemType: PdfItemType.TEXT,
+            color,
+            author: this.options.viewer.general.user,
+            page: pdfPoint.page,
+            isOpen: true,
+            pdfRect: {
+                pdfX: pdfPoint.pdfX,
+                pdfY: pdfPoint.pdfY,
+                pdfW: 0,
+                pdfH: 0,
+                page: pdfPoint.page,
+            },
+        };
+        this.pdfApi.createItem(annotation).then((item) => {
+            const annot = item;
+            const annotation = this.pdfApi.getItem(annot.id);
+            if (annotation) {
+                annotation.popup.isOpen = true;
+                this.store.annotations.updateAnnotation(annotation);
+                this.store.viewer.selectPopup({ id: annot.id, focus: true });
+            }
+            this.onAnnotationCreated(annot);
+        });
+    }
+}

package/es6/modules/text-annotation/AddTextAnnotationToolbar.d.ts

@@ -0,0 +1,15 @@
+export interface AddTextAnnotationToolbarProps {
+    colors: string[];
+    selectedColor: string;
+    onColorChanged(color: string): void;
+    onClose(): void;
+}
+interface AddTextAnnotationToolbarState {
+    colors: string[];
+    selectedColor: string;
+}
+export interface AddTextAnnotationToolbarActions {
+    setColor(color: string): AddTextAnnotationToolbarState;
+}
+export declare const createAddTextAnnotationToolbar: (props: AddTextAnnotationToolbarProps, element: HTMLElement) => AddTextAnnotationToolbarActions;
+export {};

package/es6/modules/text-annotation/AddTextAnnotationToolbar.js

@@ -0,0 +1,27 @@
+import { app, h } from '../../lib/hyperapp';
+import { Toolbar } from '../../common/Toolbar';
+import { ToolbarItemGroup } from '../../common/ToolbarItemGroup';
+import { ToolbarButton } from '../../common/ToolbarButton';
+import { icons } from '../../common/icons';
+import { ToolbarSeparator } from '../../common/ToolbarSeparator';
+import { ColorPicker } from '../../common/ColorPicker';
+export const createAddTextAnnotationToolbar = (props, element) => {
+    const state = {
+        colors: props.colors,
+        selectedColor: props.selectedColor,
+    };
+    const actions = {
+        setColor: (color) => ($state) => {
+            props.onColorChanged(color);
+            return Object.assign(Object.assign({}, $state), { selectedColor: color });
+        },
+    };
+    const App = () => h(AddTextAnnotationToolbar, null);
+    const AddTextAnnotationToolbar = ({}) => ($state, $actions) => (h(Toolbar, { allowWrap: true, alignCenter: true },
+        h(ToolbarItemGroup, null,
+            h(ColorPicker, { colors: $state.colors, color: $state.selectedColor, icon: icons.fillColor, mode: "buttons", onChange: $actions.setColor })),
+        h(ToolbarItemGroup, { pushRight: true },
+            h(ToolbarSeparator, null),
+            h(ToolbarButton, { icon: icons.close, onClick: props.onClose }))));
+    return app(state, actions, App, element);
+};

package/es6/modules/text-annotation/TextAnnotationModule.d.ts

@@ -0,0 +1,19 @@
+import { CanvasModule, CanvasModuleType } from '../CanvasModule';
+export declare class TextAnnotationModule extends CanvasModule {
+    toolbarElement: HTMLElement | null;
+    static moduleInfo: {
+        name: string;
+        moduleType: CanvasModuleType;
+        requiredFeatures: {
+            annotate: boolean;
+            fillFormFields: boolean;
+        };
+        translationKey: string;
+        icon: string;
+    };
+    constructor();
+    onRegister(): {
+        toolbar: HTMLElement;
+    };
+    activate(): void;
+}

package/es6/modules/text-annotation/TextAnnotationModule.js

@@ -0,0 +1,34 @@
+import { CanvasModule, CanvasModuleType } from '../CanvasModule';
+import { AddTextAnnotationLayer } from './AddTextAnnotationLayer';
+export class TextAnnotationModule extends CanvasModule {
+    constructor() {
+        super();
+        this.toolbarElement = null;
+        this.name = TextAnnotationModule.moduleInfo.name;
+        this.activate = this.activate.bind(this);
+    }
+    onRegister() {
+        this.toolbarElement = document.createElement('div');
+        return {
+            toolbar: this.toolbarElement,
+        };
+    }
+    activate() {
+        if (!this.canvasLayers['add']) {
+            this.createCanvasLayer('add', AddTextAnnotationLayer);
+        }
+        else {
+            this.removeCanvasLayer('add');
+        }
+    }
+}
+TextAnnotationModule.moduleInfo = {
+    name: 'TextAnnotationModule',
+    moduleType: CanvasModuleType.Tool,
+    requiredFeatures: {
+        annotate: true,
+        fillFormFields: false,
+    },
+    translationKey: 'annotText.add',
+    icon: 'stickyNote',
+};

package/es6/pdf-viewer-api/ImageContainer.d.ts

@@ -0,0 +1,10 @@
+import { PdfViewing } from '@pdf-tools/four-heights-pdf-viewing';
+export declare class ImageContainer {
+    private _imageBitmap;
+    private _imageData;
+    private _htmlCanvas;
+    constructor(image: PdfViewing.Pdf.Content.Image);
+    get scaledImage(): HTMLCanvasElement | ImageBitmap | null;
+    get imageData(): ImageData | null;
+    destroy(): void;
+}