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

package/es6/lib/hyperapp/index.d.ts

@@ -0,0 +1,108 @@
+export as namespace hyperapp
+
+/** @namespace [VDOM] */
+
+/** The VDOM representation of an Element.
+ *
+ * @memberOf [VDOM]
+ */
+export interface VNode<Attributes = {}> {
+  nodeName: string
+  attributes?: Attributes
+  children: Array<VNode | string>
+  key: string | number | null
+}
+
+/** A Component is a function that returns a custom VNode or View.
+ *
+ * @memberOf [VDOM]
+ */
+export interface Component<Attributes = {}> {
+  (attributes: Attributes, children: Array<VNode | string>): VNode<Attributes>
+}
+
+/** A Component is a function that returns a custom VNode or View.
+ *
+ * @memberOf [VDOM]
+ */
+export interface ViewComponent<Attributes = {}, State = {}, Actions = {}> {
+  (attributes: Attributes, children: Array<VNode | string>): any
+}
+
+/**
+ * Possibles children types
+ */
+export type Children = VNode | string | number | null
+
+/** The soft way to create a VNode.
+ * @param name      An element name or a Component function
+ * @param attributes     Any valid HTML atributes, events, styles, and meta data
+ * @param children  The children of the VNode
+ * @returns A VNode tree.
+ *
+ * @memberOf [VDOM]
+ */
+export function h<Attributes>(
+  nodeName: Component<Attributes> | string,
+  attributes?: Attributes,
+  ...children: Array<Children | Children[]>
+): VNode<Attributes>
+
+/** @namespace [App] */
+
+/** The result of an action.
+ *
+ * @memberOf [App]
+ */
+export type ActionResult<State> = Partial<State> | Promise<any> | null | void
+
+/** The interface for a single action implementation.
+ *
+ * @memberOf [App]
+ */
+export type ActionType<Data, State, Actions> = (
+  data?: Data
+) => ((state: State, actions: Actions) => ActionResult<State>) | ActionResult<State>
+
+/** The interface for the actions tree implementation.
+ *
+ * @memberOf [App]
+ */
+export type ActionsType<State, Actions> = {
+  [P in keyof Actions]: ActionType<any, State, Actions> | ActionsType<any, Actions[P]>
+}
+
+/** The view function describes the application UI as a tree of VNodes.
+ * @returns A VNode tree.
+ * @memberOf [App]
+ */
+export interface View<State, Actions> {
+  (state: State, actions: Actions): VNode<object> | null
+}
+
+/** The app() call creates and renders a new application.
+ *
+ * @param state The state object.
+ * @param actions The actions object implementation.
+ * @param view The view function.
+ * @param container The DOM element where the app will be rendered to.
+ * @returns The actions wired to the application.
+ * @memberOf [App]
+ */
+export function app<State, Actions>(
+  state: State,
+  actions: ActionsType<State, Actions>,
+  view: View<State, Actions>,
+  container: Element | null
+): Actions
+
+/** @namespace [JSX] */
+
+declare global {
+  namespace JSX {
+    interface Element extends VNode<any> {}
+    interface IntrinsicElements {
+      [elemName: string]: any
+    }
+  }
+}

package/es6/lib/hyperapp/index.js

@@ -0,0 +1,327 @@
+export function h(name, attributes) {
+    var rest = [];
+    var children = [];
+    var length = arguments.length;
+    while (length-- > 2)
+        rest.push(arguments[length]);
+    while (rest.length) {
+        var node = rest.pop();
+        if (node && node.pop) {
+            for (length = node.length; length--;) {
+                rest.push(node[length]);
+            }
+        }
+        else if (node != null && node !== true && node !== false) {
+            children.push(node);
+        }
+    }
+    return typeof name === "function"
+        ? name(attributes || {}, children)
+        : {
+            nodeName: name,
+            attributes: attributes || {},
+            children: children,
+            key: attributes && attributes.key
+        };
+}
+export function app(state, actions, view, container) {
+    var map = [].map;
+    var rootElement = (container && container.children[0]) || null;
+    var oldNode = rootElement && recycleElement(rootElement);
+    var lifecycle = [];
+    var skipRender;
+    var isRecycling = true;
+    var globalState = clone(state);
+    var wiredActions = wireStateToActions([], globalState, clone(actions));
+    scheduleRender();
+    return wiredActions;
+    function recycleElement(element) {
+        return {
+            nodeName: element.nodeName.toLowerCase(),
+            attributes: {},
+            children: map.call(element.childNodes, function (element) {
+                return element.nodeType === 3 // Node.TEXT_NODE
+                    ? element.nodeValue
+                    : recycleElement(element);
+            })
+        };
+    }
+    function resolveNode(node) {
+        return typeof node === "function"
+            ? resolveNode(node(globalState, wiredActions))
+            : node != null
+                ? node
+                : "";
+    }
+    function render() {
+        skipRender = !skipRender;
+        var node = resolveNode(view);
+        if (container && !skipRender) {
+            rootElement = patch(container, rootElement, oldNode, (oldNode = node));
+        }
+        isRecycling = false;
+        while (lifecycle.length)
+            lifecycle.pop()();
+    }
+    function scheduleRender() {
+        if (!skipRender) {
+            skipRender = true;
+            setTimeout(render);
+        }
+    }
+    function clone(target, source) {
+        var out = {};
+        for (var i in target)
+            out[i] = target[i];
+        for (var i in source)
+            out[i] = source[i];
+        return out;
+    }
+    function setPartialState(path, value, source) {
+        var 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;
+    }
+    function getPartialState(path, source) {
+        var i = 0;
+        while (i < path.length) {
+            source = source[path[i++]];
+        }
+        return source;
+    }
+    function wireStateToActions(path, state, actions) {
+        for (var key in actions) {
+            typeof actions[key] === "function"
+                ? (function (key, action) {
+                    actions[key] = function (data) {
+                        var result = action(data);
+                        if (typeof result === "function") {
+                            result = result(getPartialState(path, globalState), actions);
+                        }
+                        if (result &&
+                            result !== (state = getPartialState(path, globalState)) &&
+                            !result.then // !isPromise
+                        ) {
+                            scheduleRender((globalState = setPartialState(path, clone(state, result), globalState)));
+                        }
+                        return result;
+                    };
+                })(key, actions[key])
+                : wireStateToActions(path.concat(key), (state[key] = clone(state[key])), (actions[key] = clone(actions[key])));
+        }
+        return actions;
+    }
+    function getKey(node) {
+        return node ? node.key : null;
+    }
+    function eventListener(event) {
+        return event.currentTarget.events[event.type](event);
+    }
+    function updateAttribute(element, name, value, oldValue, isSvg) {
+        if (name === "key") {
+        }
+        else if (name === "style") {
+            if (typeof value === "string") {
+                element.style.cssText = value;
+            }
+            else {
+                if (typeof oldValue === "string")
+                    oldValue = element.style.cssText = "";
+                for (var i in clone(oldValue, value)) {
+                    var style = value == null || value[i] == null ? "" : value[i];
+                    if (i[0] === "-") {
+                        element.style.setProperty(i, style);
+                    }
+                    else {
+                        element.style[i] = style;
+                    }
+                }
+            }
+        }
+        else {
+            if (name[0] === "o" && name[1] === "n") {
+                name = name.slice(2);
+                if (element.events) {
+                    if (!oldValue)
+                        oldValue = element.events[name];
+                }
+                else {
+                    element.events = {};
+                }
+                element.events[name] = value;
+                if (value) {
+                    if (!oldValue) {
+                        element.addEventListener(name, eventListener);
+                    }
+                }
+                else {
+                    element.removeEventListener(name, eventListener);
+                }
+            }
+            else if (name in element &&
+                name !== "list" &&
+                name !== "type" &&
+                name !== "draggable" &&
+                name !== "spellcheck" &&
+                name !== "translate" &&
+                !isSvg) {
+                element[name] = value == null ? "" : value;
+            }
+            else if (value != null && value !== false) {
+                element.setAttribute(name, value);
+            }
+            if (value == null || value === false) {
+                element.removeAttribute(name);
+            }
+        }
+    }
+    function createElement(node, isSvg) {
+        var element = typeof node === "string" || typeof node === "number"
+            ? document.createTextNode(node)
+            : (isSvg = isSvg || node.nodeName === "svg")
+                ? document.createElementNS("http://www.w3.org/2000/svg", node.nodeName)
+                : document.createElement(node.nodeName);
+        var attributes = node.attributes;
+        if (attributes) {
+            if (attributes.oncreate) {
+                lifecycle.push(function () {
+                    attributes.oncreate(element);
+                });
+            }
+            for (var i = 0; i < node.children.length; i++) {
+                element.appendChild(createElement((node.children[i] = resolveNode(node.children[i])), isSvg));
+            }
+            for (var name in attributes) {
+                updateAttribute(element, name, attributes[name], null, isSvg);
+            }
+        }
+        return element;
+    }
+    function updateElement(element, oldAttributes, attributes, isSvg) {
+        for (var name in clone(oldAttributes, attributes)) {
+            if (attributes[name] !==
+                (name === "value" || name === "checked"
+                    ? element[name]
+                    : oldAttributes[name])) {
+                updateAttribute(element, name, attributes[name], oldAttributes[name], isSvg);
+            }
+        }
+        var cb = isRecycling ? attributes.oncreate : attributes.onupdate;
+        if (cb) {
+            lifecycle.push(function () {
+                cb(element, oldAttributes);
+            });
+        }
+    }
+    function removeChildren(element, node) {
+        var attributes = node.attributes;
+        if (attributes) {
+            for (var i = 0; i < node.children.length; i++) {
+                removeChildren(element.childNodes[i], node.children[i]);
+            }
+            if (attributes.ondestroy) {
+                attributes.ondestroy(element);
+            }
+        }
+        return element;
+    }
+    function removeElement(parent, element, node) {
+        function done() {
+            parent.removeChild(removeChildren(element, node));
+        }
+        var cb = node.attributes && node.attributes.onremove;
+        if (cb) {
+            cb(element, done);
+        }
+        else {
+            done();
+        }
+    }
+    function patch(parent, element, oldNode, node, isSvg) {
+        if (node === oldNode) {
+        }
+        else if (oldNode == null || oldNode.nodeName !== node.nodeName) {
+            var newElement = createElement(node, isSvg);
+            parent.insertBefore(newElement, element);
+            if (oldNode != null) {
+                removeElement(parent, element, oldNode);
+            }
+            element = newElement;
+        }
+        else if (oldNode.nodeName == null) {
+            element.nodeValue = node;
+        }
+        else {
+            updateElement(element, oldNode.attributes, node.attributes, (isSvg = isSvg || node.nodeName === "svg"));
+            var oldKeyed = {};
+            var newKeyed = {};
+            var oldElements = [];
+            var oldChildren = oldNode.children;
+            var children = node.children;
+            for (var i = 0; i < oldChildren.length; i++) {
+                oldElements[i] = element.childNodes[i];
+                var oldKey = getKey(oldChildren[i]);
+                if (oldKey != null) {
+                    oldKeyed[oldKey] = [oldElements[i], oldChildren[i]];
+                }
+            }
+            var i = 0;
+            var k = 0;
+            while (k < children.length) {
+                var oldKey = getKey(oldChildren[i]);
+                var newKey = getKey((children[k] = resolveNode(children[k])));
+                if (newKeyed[oldKey]) {
+                    i++;
+                    continue;
+                }
+                if (newKey != null && newKey === getKey(oldChildren[i + 1])) {
+                    if (oldKey == null) {
+                        removeElement(element, oldElements[i], oldChildren[i]);
+                    }
+                    i++;
+                    continue;
+                }
+                if (newKey == null || isRecycling) {
+                    if (oldKey == null) {
+                        patch(element, oldElements[i], oldChildren[i], children[k], isSvg);
+                        k++;
+                    }
+                    i++;
+                }
+                else {
+                    var keyedNode = oldKeyed[newKey] || [];
+                    if (oldKey === newKey) {
+                        patch(element, keyedNode[0], keyedNode[1], children[k], isSvg);
+                        i++;
+                    }
+                    else if (keyedNode[0]) {
+                        patch(element, element.insertBefore(keyedNode[0], oldElements[i]), keyedNode[1], children[k], isSvg);
+                    }
+                    else {
+                        patch(element, oldElements[i], null, children[k], isSvg);
+                    }
+                    newKeyed[newKey] = children[k];
+                    k++;
+                }
+            }
+            while (i < oldChildren.length) {
+                if (getKey(oldChildren[i]) == null) {
+                    removeElement(element, oldElements[i], oldChildren[i]);
+                }
+                i++;
+            }
+            for (var i in oldKeyed) {
+                if (!newKeyed[i]) {
+                    removeElement(element, oldKeyed[i][0], oldKeyed[i][1]);
+                }
+            }
+        }
+        return element;
+    }
+}

package/es6/modules/CanvasLayer.d.ts

@@ -0,0 +1,32 @@
+import { ViewerCanvasState, ViewerCanvasStore } from '../pdf-viewer-canvas/state/store';
+import { PdfViewerApi } from '../pdf-viewer-api';
+import { Annotation, PdfItem } from '../pdf-viewer-api/types';
+import { WebViewerOptions } from '../pdf-web-viewer/WebViewerOptions';
+import { PdfViewerCanvas } from '../pdf-viewer-canvas/PdfViewerCanvas';
+import { CanvasModule } from './CanvasModule';
+export interface CanvasLayerClass {
+    new (module: CanvasModule, name: string, containerElement: HTMLElement, store: ViewerCanvasStore, pdfApi: PdfViewerApi, pdfViewerCanvas: PdfViewerCanvas, options: WebViewerOptions): CanvasLayer;
+}
+export declare abstract class CanvasLayer {
+    protected containerElement: HTMLElement;
+    protected store: ViewerCanvasStore;
+    protected pdfApi: PdfViewerApi;
+    protected pdfViewerCanvas: PdfViewerCanvas;
+    protected options: WebViewerOptions;
+    protected module: CanvasModule;
+    private canvasContexts;
+    private htmlLayers;
+    private name;
+    constructor(module: CanvasModule, name: string, containerElement: HTMLElement, store: ViewerCanvasStore, pdfApi: PdfViewerApi, pdfViewerCanvas: PdfViewerCanvas, options: WebViewerOptions);
+    abstract onCreate(args?: any): void;
+    abstract onRemove(): void;
+    abstract render(timestamp: number, state: ViewerCanvasState): void;
+    abstract onSave(): Promise<void>;
+    resize(width: number, height: number): void;
+    protected remove(): void;
+    protected createHtmlLayer(): HTMLDivElement;
+    protected createCanvas(): CanvasRenderingContext2D;
+    protected removeHtmlElements(): void;
+    protected removeCanvasElements(): void;
+    protected onAnnotationCreated(annotation: Annotation): Promise<PdfItem>;
+}

package/es6/modules/CanvasLayer.js

@@ -0,0 +1,83 @@
+import { addHistoryEntry } from '../custom/history';
+export class CanvasLayer {
+    constructor(module, name, containerElement, store, pdfApi, pdfViewerCanvas, options) {
+        this.canvasContexts = [];
+        this.htmlLayers = [];
+        this.containerElement = containerElement;
+        this.store = store;
+        this.pdfApi = pdfApi;
+        this.pdfViewerCanvas = pdfViewerCanvas;
+        this.options = options;
+        this.module = module;
+        this.name = name;
+        this.remove = this.remove.bind(this);
+        this.onAnnotationCreated = this.onAnnotationCreated.bind(this);
+    }
+    resize(width, height) {
+        const tempCanvas = document.createElement('canvas');
+        tempCanvas.width = width * devicePixelRatio;
+        tempCanvas.height = height * devicePixelRatio;
+        const tempContext = tempCanvas.getContext('2d');
+        this.canvasContexts.forEach((ctx) => {
+            tempContext.drawImage(ctx.canvas, 0, 0);
+            ctx.canvas.style.width = width + 'px';
+            ctx.canvas.style.height = height + 'px';
+            ctx.canvas.width = width * devicePixelRatio;
+            ctx.canvas.height = height * devicePixelRatio;
+            ctx.drawImage(tempContext.canvas, 0, 0);
+        });
+    }
+    remove() {
+        this.module.removeCanvasLayer(this.name);
+    }
+    createHtmlLayer() {
+        const element = document.createElement('div');
+        this.htmlLayers.push(element);
+        if (this.containerElement) {
+            this.containerElement.appendChild(element);
+        }
+        return element;
+    }
+    createCanvas() {
+        const element = document.createElement('canvas');
+        element.style.position = 'absolute';
+        element.style.top = '0';
+        element.style.left = '0';
+        element.style.right = '0';
+        element.style.bottom = '0';
+        const context = element.getContext('2d');
+        this.canvasContexts.push(context);
+        if (this.containerElement) {
+            this.containerElement.appendChild(element);
+            const rect = this.containerElement.getBoundingClientRect();
+            context.canvas.width = rect.width * devicePixelRatio;
+            context.canvas.height = rect.height * devicePixelRatio;
+            context.canvas.style.width = rect.width + 'px';
+            context.canvas.style.height = rect.height + 'px';
+        }
+        return context;
+    }
+    removeHtmlElements() {
+        if (this.containerElement) {
+            for (let i = 0; i < this.htmlLayers.length; i++) {
+                this.containerElement.removeChild(this.htmlLayers[i]);
+            }
+            this.htmlLayers = [];
+        }
+    }
+    removeCanvasElements() {
+        if (this.containerElement) {
+            for (let i = 0; i < this.canvasContexts.length; i++) {
+                this.containerElement.removeChild(this.canvasContexts[i].canvas);
+            }
+            this.canvasContexts = [];
+        }
+    }
+    onAnnotationCreated(annotation) {
+        if (this.options.annotation.trackHistory) {
+            addHistoryEntry(annotation, 'create', this.options.viewer.general.user);
+            return this.pdfApi.updateItem(annotation);
+        }
+        return new Promise((resolve) => resolve(annotation));
+    }
+}

package/es6/modules/CanvasModule.d.ts

@@ -0,0 +1,59 @@
+import { ViewerCanvasStore, ViewerCanvasState } from '../pdf-viewer-canvas/state/store';
+import { PdfViewerApi, PdfItemType } from '../pdf-viewer-api';
+import { PdfViewerCanvas } from '../pdf-viewer-canvas/PdfViewerCanvas';
+import { CanvasLayer, CanvasLayerClass } from './CanvasLayer';
+import { WebViewerOptions } from '../pdf-web-viewer/WebViewerOptions';
+import { IconDefinition } from '../common/Icon';
+export declare enum CanvasModuleType {
+    Tool = 0,
+    Layer = 1
+}
+export interface CanvasModuleRegistration {
+    toolbar?: HTMLElement;
+    contextbar?: {
+        itemTypes: PdfItemType[];
+        icon: IconDefinition;
+        onCmd(args?: any): void;
+    };
+}
+export interface CanvasModuleInfo {
+    name: string;
+    moduleType: CanvasModuleType;
+    requiredFeatures: {
+        annotate: boolean;
+        fillFormFields: boolean;
+    };
+    translationKey?: string;
+    icon?: string;
+}
+export interface CanvasModuleClass {
+    new (): CanvasModule;
+    moduleInfo: CanvasModuleInfo;
+}
+export interface CanvasLayerList {
+    [name: string]: CanvasLayer;
+}
+export declare abstract class CanvasModule {
+    protected canvasLayers: CanvasLayerList;
+    protected store: ViewerCanvasStore | null;
+    protected pdfApi: PdfViewerApi | null;
+    protected pdfViewerCanvas: PdfViewerCanvas | null;
+    protected options: WebViewerOptions | null;
+    name: string | null;
+    private containerElement;
+    protected static moduleInfo: CanvasModuleInfo;
+    constructor();
+    register(containerElement: HTMLElement, store: ViewerCanvasStore, pdfApi: PdfViewerApi, pdfViewerCanvas: PdfViewerCanvas, options: WebViewerOptions): CanvasModuleRegistration;
+    abstract onRegister(): CanvasModuleRegistration;
+    abstract activate(args?: any): void;
+    render(timestamp: number, state: ViewerCanvasState): void;
+    deactivate(): void;
+    resize(width: number, height: number): void;
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    onSave(): Promise<void>;
+    createCanvasLayer(name: string, canvasLayer: CanvasLayerClass, args?: any): void;
+    removeCanvasLayer(name: string): void;
+}