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

package/es6/common/Checkbox.d.ts

@@ -0,0 +1,9 @@
+import { Component } from '../lib/hyperapp';
+/** internal */
+export interface CheckboxProps {
+    label: string;
+    checked: boolean;
+    onClick?(): void;
+}
+/** internal */
+export declare const Checkbox: Component<CheckboxProps>;

package/es6/common/Checkbox.js

@@ -0,0 +1,8 @@
+import { h } from '../lib/hyperapp';
+import { classNames } from './classNames';
+/** internal */
+export const Checkbox = ({ label, checked, onClick }) => {
+    return (h("label", { onclick: onClick, class: classNames('', { '': checked }) },
+        h("span", null),
+        h("span", null, label)));
+};

package/es6/common/Color.d.ts

@@ -0,0 +1,23 @@
+/** internal */
+export declare class Color {
+    private pR;
+    private pG;
+    private pB;
+    private pA;
+    constructor(color: string);
+    isDark(): boolean;
+    get r(): number;
+    set r(r: number);
+    get g(): number;
+    set g(g: number);
+    get b(): number;
+    set b(b: number);
+    get a(): number;
+    darken(percent: number): void;
+    setOpacity(opacity: number): void;
+    toRgb(): string;
+    toRgba(): string;
+    toHexRgb(): string;
+    toHexRgba(): string;
+    private toHex;
+}

package/es6/common/Color.js

@@ -0,0 +1,118 @@
+/** internal */
+export class Color {
+    constructor(color) {
+        this.pR = 0;
+        this.pG = 0;
+        this.pB = 0;
+        this.pA = 0;
+        color = color.replace(/\s+/gi, '');
+        if (color === 'transparent') {
+            this.pR = 255;
+            this.pG = 255;
+            this.pB = 255;
+            this.pA = 0;
+        }
+        else if (color.indexOf('#') === 0) {
+            if (color.length === 4) {
+                this.pR = parseInt(color.substring(1, 2), 16);
+                this.pG = parseInt(color.substring(2, 3), 16);
+                this.pB = parseInt(color.substring(3, 4), 16);
+                this.pA = 255;
+            }
+            else if (color.length === 5) {
+                this.pR = parseInt(color.substring(1, 2), 16);
+                this.pG = parseInt(color.substring(2, 3), 16);
+                this.pB = parseInt(color.substring(3, 4), 16);
+                this.pA = parseInt(color.substring(4, 5), 16);
+            }
+            else if (color.length === 7) {
+                this.pR = parseInt(color.substring(1, 3), 16);
+                this.pG = parseInt(color.substring(3, 5), 16);
+                this.pB = parseInt(color.substring(5, 7), 16);
+                this.pA = 255;
+            }
+            else if (color.length === 9) {
+                this.pR = parseInt(color.substring(1, 3), 16);
+                this.pG = parseInt(color.substring(3, 5), 16);
+                this.pB = parseInt(color.substring(5, 7), 16);
+                this.pA = parseInt(color.substring(7, 9), 16);
+            }
+            else {
+                throw new Error('invalid color string: ' + color);
+            }
+        }
+        else if (color.indexOf('rgb') === 0) {
+            const values = color.substring(color.indexOf('(') + 1, color.indexOf(')')).split(',');
+            if (values.length < 3 || values.length > 4) {
+                throw new Error('invalid color string: ' + color);
+            }
+            this.pR = parseInt(values[0], 10);
+            this.pG = parseInt(values[1], 10);
+            this.pB = parseInt(values[2], 10);
+            if (values.length === 4) {
+                this.pA = Math.floor(parseFloat(values[3]) * 255);
+            }
+            else {
+                this.pA = 255;
+            }
+        }
+        else {
+            throw new Error('invalid color string: ' + color);
+        }
+    }
+    isDark() {
+        return this.pR * 0.3 + this.pG * 0.59 + this.pB * 0.11 < 127;
+    }
+    get r() {
+        return this.pR;
+    }
+    set r(r) {
+        this.pR = r;
+    }
+    get g() {
+        return this.pG;
+    }
+    set g(g) {
+        this.pG = g;
+    }
+    get b() {
+        return this.pB;
+    }
+    set b(b) {
+        this.pB = b;
+    }
+    get a() {
+        return Math.floor((this.pA / 255) * 1000) / 1000;
+    }
+    darken(percent) {
+        const f = 1 - Math.abs(percent / 100);
+        const r = Math.floor(this.pR * f);
+        const g = Math.floor(this.pG * f);
+        const b = Math.floor(this.pB * f);
+        this.pR = r > 255 ? 255 : r;
+        this.pG = g > 255 ? 255 : g;
+        this.pB = b > 255 ? 255 : b;
+    }
+    setOpacity(opacity) {
+        this.pA = Math.floor(opacity * 255);
+    }
+    toRgb() {
+        return `rgb(${this.pR},${this.pG},${this.pB})`;
+    }
+    toRgba() {
+        return `rgba(${this.pR},${this.pG},${this.pB},${this.a})`;
+    }
+    toHexRgb() {
+        return `#${this.toHex(this.pR)}${this.toHex(this.pG)}${this.toHex(this.pB)}`;
+    }
+    toHexRgba() {
+        return `#${this.toHex(this.pR)}${this.toHex(this.pG)}${this.toHex(this.pB)}${this.toHex(this.pA)}`;
+    }
+    toHex(value) {
+        let h = value.toString(16);
+        if (h.length === 1) {
+            h = '0' + h;
+        }
+        return h;
+    }
+}

package/es6/common/ColorPicker.d.ts

@@ -0,0 +1,15 @@
+import { Component } from '../lib/hyperapp';
+import { IconDefinition } from './Icon';
+/** internal */
+export interface ColorPickerProps {
+    icon: IconDefinition;
+    tooltip?: string;
+    disabled?: boolean;
+    colors: string[];
+    color: string;
+    mode?: 'dropdown' | 'buttons';
+    allowRgba?: boolean;
+    onChange?(color: string): void;
+}
+/** internal */
+export declare const ColorPicker: Component<ColorPickerProps>;

package/es6/common/ColorPicker.js

@@ -0,0 +1,46 @@
+import { h } from '../lib/hyperapp';
+import { classNames } from './classNames';
+import { Color } from '../common/Color';
+import { DropdownComponent } from './Dropdown';
+import { Icon } from './Icon';
+import { tooltipManager } from './TooltipManager';
+/** internal */
+export const ColorPicker = ({ icon, tooltip, disabled, colors, color, allowRgba = true, mode, onChange, }) => {
+    const items = allowRgba ? colors : colors.filter((c) => new Color(c).a >= 1);
+    if (mode === 'buttons' && window.innerWidth > 580) {
+        return h(ColorPickerButtons, { icon: icon, colors: items, color: color, onChange: onChange });
+    }
+    else {
+        return (h(ColorPickerDropdown, { icon: icon, tooltip: tooltip, disabled: disabled, colors: items, color: color, onChange: onChange }));
+    }
+};
+const ColorPickerDropdown = ({ icon, tooltip, disabled, colors, color, onChange, }) => {
+    if (disabled) {
+        return (h("div", { class: "pwv-ColorPicker pwv-Dropdown pwv-ToolbarItem pwv-disabled" },
+            h("button", Object.assign({}, tooltipManager.createTooltip(tooltip), { oncreate: DropdownComponent.create, onremove: DropdownComponent.remove }),
+                h(Icon, { icon: icon }),
+                h("div", { class: classNames('pwv-ColorPicker__selectedColor'), style: { backgroundColor: color } }))));
+    }
+    else {
+        return (h("div", { class: "pwv-ColorPicker pwv-Dropdown pwv-ToolbarItem" },
+            h("button", Object.assign({}, tooltipManager.createTooltip(tooltip), { oncreate: DropdownComponent.create, onremove: DropdownComponent.remove }),
+                h(Icon, { icon: icon }),
+                h("div", { class: classNames('pwv-ColorPicker__selectedColor'), style: { backgroundColor: color } })),
+            h("div", { class: classNames('pwv-DropdownPanel', {
+                    'pwv-DropdownPanel-wide': colors.length > 6,
+                }) }, colors.map((c) => (h("button", { disabled: c.toLowerCase() === color.toLowerCase(), class: classNames('pwv-ColorPicker__Button', {
+                    'pwv-selected': c.toLowerCase() === color.toLowerCase(),
+                }), onclick: (e) => {
+                    onChange && onChange(c);
+                } },
+                h("div", { style: { backgroundColor: c } })))))));
+    }
+};
+const ColorPickerButtons = ({ icon, colors, color, onChange }) => {
+    return (h("div", { class: "pwv-ColorPicker--buttons pwv-ToolbarItem" }, colors.map((c) => (h("button", { disabled: c.toLowerCase() === color.toLowerCase(), class: classNames('pwv-ColorPicker__Button', {
+            'pwv-selected': c.toLowerCase() === color.toLowerCase(),
+        }), onclick: (e) => {
+            onChange && onChange(c);
+        } },
+        h("div", { style: { backgroundColor: c } }))))));
+};

package/es6/common/Contextbar.d.ts

@@ -0,0 +1,6 @@
+import { Component } from '../lib/hyperapp';
+/** internal */
+export interface ContextbarProps {
+}
+/** internal */
+export declare const Contextbar: Component<ContextbarProps>;

package/es6/common/Contextbar.js

@@ -0,0 +1,19 @@
+import { h } from '../lib/hyperapp';
+const stopPropagation = (e) => {
+    e.stopPropagation();
+};
+/** internal */
+export const Contextbar = ({}, children) => {
+    return (h("div", { class: "pwv-contextbar", oncreate: (element) => {
+            element.addEventListener('click', (e) => {
+                e.preventDefault();
+            }, { passive: false });
+            element.addEventListener('mousedown', stopPropagation, false);
+            element.addEventListener('mousemove', stopPropagation, false);
+            element.addEventListener('mouseup', stopPropagation, false);
+            element.addEventListener('touchstart', stopPropagation, { passive: false });
+            element.addEventListener('touchmove', stopPropagation, { passive: true });
+            element.addEventListener('touchend', stopPropagation, { passive: true });
+        } },
+        h("div", { class: "pwv-contextbar-content" }, children)));
+};

package/es6/common/DragMoveHandler.d.ts

@@ -0,0 +1,51 @@
+/** internal */
+export interface DragMoveEvent {
+    clientX: number;
+    clientY: number;
+    movementX: number;
+    movementY: number;
+    element: HTMLElement;
+}
+/** internal */
+export interface DragMoveEndEvent extends DragMoveEvent {
+    moved: boolean;
+}
+type DragMoveEventHandler = (e: DragMoveEvent) => void;
+type DragMoveEndEventHandler = (e: DragMoveEndEvent) => void;
+export declare class DragMoveHandler {
+    private element;
+    private onDragStart;
+    private onDragMove;
+    private onDragEnd;
+    private onClick?;
+    private onDblClick?;
+    private disableCanvasEvents;
+    private lastPosX;
+    private lastPosY;
+    private startPosX;
+    private startPosY;
+    private isSuspended;
+    private dragging;
+    private clickTimer;
+    private dragStartTimer;
+    private readonly clickDuration;
+    private readonly dragStartDuration;
+    private dblClickTimer;
+    private readonly dblClickDuration;
+    constructor(element: HTMLElement, onDragStart: DragMoveEventHandler, onDragMove: DragMoveEventHandler, onDragEnd: DragMoveEndEventHandler, onClick?: DragMoveEventHandler, onDblClick?: DragMoveEventHandler);
+    suspend(): void;
+    resume(): void;
+    private clearClickTimer;
+    private clearDblClickTimer;
+    private clearDragStartTimer;
+    private onMouseDown;
+    private onTouchStart;
+    private start;
+    private onMouseMove;
+    private onTouchMove;
+    private move;
+    private onMouseUp;
+    private onTouchEnd;
+    private end;
+}
+export {};

package/es6/common/DragMoveHandler.js

@@ -0,0 +1,175 @@
+export class DragMoveHandler {
+    /* tslint:disable-next-line:max-line-length */
+    constructor(element, onDragStart, onDragMove, onDragEnd, onClick, onDblClick) {
+        this.lastPosX = 0;
+        this.lastPosY = 0;
+        this.startPosX = 0;
+        this.startPosY = 0;
+        this.isSuspended = false;
+        this.dragging = false;
+        this.clickTimer = null;
+        this.dragStartTimer = null;
+        this.clickDuration = 250;
+        this.dragStartDuration = 300;
+        this.dblClickTimer = null;
+        this.dblClickDuration = 250;
+        this.suspend = this.suspend.bind(this);
+        this.resume = this.resume.bind(this);
+        this.onMouseDown = this.onMouseDown.bind(this);
+        this.onTouchStart = this.onTouchStart.bind(this);
+        this.start = this.start.bind(this);
+        this.onMouseMove = this.onMouseMove.bind(this);
+        this.onTouchMove = this.onTouchMove.bind(this);
+        this.move = this.move.bind(this);
+        this.onMouseUp = this.onMouseUp.bind(this);
+        this.onTouchEnd = this.onTouchEnd.bind(this);
+        this.end = this.end.bind(this);
+        this.element = element;
+        this.onDragStart = onDragStart;
+        this.onDragMove = onDragMove;
+        this.onDragEnd = onDragEnd;
+        this.onClick = onClick;
+        this.onDblClick = onDblClick;
+        this.disableCanvasEvents = true;
+        this.element.addEventListener('mousedown', this.onMouseDown, { passive: true });
+        this.element.addEventListener('touchstart', this.onTouchStart, { passive: false });
+    }
+    suspend() {
+        window.removeEventListener('mousemove', this.onMouseMove);
+        window.removeEventListener('mouseup', this.onMouseUp);
+        window.removeEventListener('touchmove', this.onTouchMove);
+        window.removeEventListener('touchend', this.onTouchEnd);
+        this.element.removeEventListener('mousedown', this.onMouseDown);
+        this.element.removeEventListener('touchstart', this.onTouchStart);
+        this.isSuspended = true;
+    }
+    resume() {
+        if (this.isSuspended) {
+            this.element.addEventListener('mousedown', this.onMouseDown, { passive: true });
+            this.element.addEventListener('touchstart', this.onTouchStart, { passive: false });
+        }
+    }
+    clearClickTimer() {
+        if (this.clickTimer !== null) {
+            window.clearTimeout(this.clickTimer);
+            this.clickTimer = null;
+        }
+    }
+    clearDblClickTimer() {
+        if (this.dblClickTimer !== null) {
+            window.clearTimeout(this.dblClickTimer);
+            this.dblClickTimer = null;
+        }
+    }
+    clearDragStartTimer() {
+        if (this.dragStartTimer !== null) {
+            window.clearTimeout(this.dragStartTimer);
+            this.dragStartTimer = null;
+        }
+    }
+    onMouseDown(e) {
+        if (e.buttons === 1) {
+            this.start(e.clientX, e.clientY);
+            window.addEventListener('mousemove', this.onMouseMove, { passive: true });
+            window.addEventListener('mouseup', this.onMouseUp, { passive: true });
+        }
+    }
+    onTouchStart(e) {
+        if (e.touches.length === 1) {
+            this.start(e.touches[0].clientX, e.touches[0].clientY);
+            window.addEventListener('touchmove', this.onTouchMove, { passive: false });
+            window.addEventListener('touchend', this.onTouchEnd, { passive: false });
+        }
+    }
+    start(clientX, clientY) {
+        if (this.disableCanvasEvents) {
+            window.dispatchEvent(new Event('pdfwebviewer.DragMoveHandlerStart'));
+        }
+        this.startPosX = this.lastPosX = clientX;
+        this.startPosY = this.lastPosY = clientY;
+        this.dragging = false;
+        if (!this.dblClickTimer) {
+            this.clickTimer = window.setTimeout(() => {
+                this.clickTimer = null;
+            }, this.clickDuration);
+            this.dragStartTimer = window.setTimeout(() => {
+                this.dragging = true;
+                this.onDragStart({
+                    clientX: this.startPosX,
+                    clientY: this.startPosY,
+                    movementX: 0,
+                    movementY: 0,
+                    element: this.element,
+                });
+            }, this.dragStartDuration);
+        }
+    }
+    onMouseMove(e) {
+        this.move(e.clientX, e.clientY);
+    }
+    onTouchMove(e) {
+        this.move(e.touches[0].clientX, e.touches[0].clientY);
+    }
+    move(clientX, clientY) {
+        let movementX = clientX - this.lastPosX;
+        let movementY = clientY - this.lastPosY;
+        this.lastPosX = clientX;
+        this.lastPosY = clientY;
+        if (this.clickTimer || this.dragStartTimer) {
+            if (Math.abs(movementX) > 5 || Math.abs(movementY) > 5) {
+                this.clearClickTimer();
+                this.clearDragStartTimer();
+                this.dragging = true;
+                this.onDragStart({
+                    clientX: this.startPosX,
+                    clientY: this.startPosY,
+                    movementX: 0,
+                    movementY: 0,
+                    element: this.element,
+                });
+                movementX = clientX - this.startPosX;
+                movementY = clientY - this.startPosY;
+            }
+        }
+        if (this.dragging) {
+            this.onDragMove({ clientX, clientY, movementX, movementY, element: this.element });
+        }
+    }
+    onMouseUp(e) {
+        window.removeEventListener('mousemove', this.onMouseMove);
+        window.removeEventListener('mouseup', this.onMouseUp);
+        this.end();
+    }
+    onTouchEnd(e) {
+        window.removeEventListener('touchmove', this.onTouchMove);
+        window.removeEventListener('touchend', this.onTouchEnd);
+        this.end();
+    }
+    end() {
+        const moved = this.startPosX !== this.lastPosX || this.startPosY !== this.lastPosY;
+        const clientX = this.lastPosX;
+        const clientY = this.lastPosY;
+        if (this.disableCanvasEvents) {
+            window.dispatchEvent(new Event('pdfwebviewer.DragMoveHandlerEnd'));
+        }
+        if (this.dblClickTimer !== null) {
+            this.clearDblClickTimer();
+            if (this.onDblClick) {
+                this.onDblClick({ clientX, clientY, movementX: 0, movementY: 0, element: this.element });
+            }
+        }
+        else if (this.clickTimer !== null) {
+            if (this.onClick) {
+                this.onClick({ clientX, clientY, movementX: 0, movementY: 0, element: this.element });
+            }
+            this.dblClickTimer = window.setTimeout(() => {
+                this.dblClickTimer = null;
+            }, this.dblClickDuration);
+        }
+        if (this.dragging) {
+            this.onDragEnd({ clientX, clientY, movementX: 0, movementY: 0, moved, element: this.element });
+        }
+        this.clearClickTimer();
+        this.clearDragStartTimer();
+    }
+}

package/es6/common/Dropdown.d.ts

@@ -0,0 +1,36 @@
+import { Component } from '../lib/hyperapp';
+import { IconDefinition } from './Icon';
+/** internal */
+export interface DropdownItem {
+    icon?: IconDefinition;
+    text?: string;
+    value: string | number;
+    renderItem?(item: DropdownItem): any;
+}
+/** internal */
+export interface DropdownProps {
+    text?: string;
+    tooltip?: string;
+    icon?: IconDefinition;
+    name?: string;
+    value: string | number;
+    items: DropdownItem[];
+    disabled?: boolean;
+    width?: number;
+    align?: 'left' | 'right' | 'center';
+    className?: string;
+    hideCaret?: boolean;
+    renderButton?(value: string | number, text?: string): any;
+    onChange?(value: string | number): void;
+}
+export declare const Dropdown: Component<DropdownProps>;
+export declare class DropdownComponent {
+    static create(btnElement: HTMLElement): void;
+    static remove(btnElement: HTMLElement): void;
+    private element;
+    private button;
+    constructor(btnElement: HTMLElement);
+    unmount(): void;
+    private setMaxPanelHeight;
+    private handleOnClick;
+}

package/es6/common/Dropdown.js

@@ -0,0 +1,76 @@
+import { h } from '../lib/hyperapp';
+import { tooltipManager } from './TooltipManager';
+import { Icon, icons } from './Icon';
+import { classNames } from './classNames';
+export const Dropdown = ({ disabled, text, icon, name, value, tooltip, width, className, items, align, hideCaret, renderButton, onChange, }) => {
+    const selectedItem = items.find((item) => item.value === value);
+    if (!text && selectedItem) {
+        text = selectedItem.text;
+    }
+    const style = width
+        ? {
+            width: width + 'px',
+        }
+        : {};
+    return (h("div", { class: classNames('pwv-Dropdown', { 'pwv-disabled': disabled }, { 'pwv-Dropdown--alignLeft': !align || align === 'left' }, { 'pwv-Dropdown--alignRight': align === 'right' }, { 'pwv-Dropdown--alignCenter': align === 'center' }, className), style: style },
+        h("button", Object.assign({ name: name }, tooltipManager.createTooltip(tooltip), { oncreate: DropdownComponent.create, onremove: DropdownComponent.remove, disabled: disabled }),
+            renderButton ? (renderButton(value, text)) : (h("span", { class: "pwv-Dropdown-text" },
+                icon && h(Icon, { icon: icon }),
+                text)),
+            !hideCaret && (h("span", { class: "pwv-Dropdown-caret" },
+                h(Icon, { icon: icons.dropdownCaret })))),
+        !disabled && (h("div", { class: "pwv-DropdownPanel" },
+            h("ul", null, items.map((item) => (h("li", { class: "pwv-DropdownItem", onclick: () => onChange && onChange(item.value) }, item.renderItem ? (item.renderItem(item)) : (h("span", { class: "pwv-Dropdown-item-text" }, item.text))))))))));
+};
+export class DropdownComponent {
+    static create(btnElement) {
+        ;
+        btnElement.parentElement.dropdown = new DropdownComponent(btnElement);
+    }
+    static remove(btnElement) {
+        ;
+        btnElement.parentElement.dropdown.unmount();
+    }
+    constructor(btnElement) {
+        this.button = btnElement;
+        this.element = btnElement.parentElement;
+        this.handleOnClick = this.handleOnClick.bind(this);
+        this.setMaxPanelHeight = this.setMaxPanelHeight.bind(this);
+        this.button.addEventListener('click', this.handleOnClick, false);
+        tooltipManager.bindCssTooltip(this.button);
+        window.addEventListener('resize', this.setMaxPanelHeight);
+    }
+    unmount() {
+        this.button.removeEventListener('click', this.handleOnClick);
+        this.button.removeEventListener('resize', this.setMaxPanelHeight);
+    }
+    setMaxPanelHeight() {
+        const dropdownPanel = this.element.querySelector('.pwv-DropdownPanel');
+        if (dropdownPanel) {
+            const maxHeight = window.innerHeight - dropdownPanel.getBoundingClientRect().top;
+            if (dropdownPanel.scrollHeight > maxHeight) {
+                dropdownPanel.style.maxHeight = `${maxHeight - 10}px`;
+                dropdownPanel.classList.add('pwv-DropdownPanel--scroll');
+            }
+            else {
+                dropdownPanel.style.maxHeight = '';
+                dropdownPanel.classList.remove('pwv-DropdownPanel--scroll');
+            }
+        }
+    }
+    handleOnClick(e) {
+        if (!this.element.classList.contains('pwv-Dropdown--open')) {
+            this.element.classList.add('pwv-Dropdown--open');
+            this.setMaxPanelHeight();
+            const t = new Date().getTime();
+            e.openDropdown = t;
+            const closeDropdownPanel = (ev) => {
+                if (ev.openDropdown !== t) {
+                    window.removeEventListener('click', closeDropdownPanel);
+                    this.element.classList.remove('pwv-Dropdown--open');
+                }
+            };
+            window.addEventListener('click', closeDropdownPanel, false);
+        }
+    }
+}

package/es6/common/DropdownMenu.d.ts

@@ -0,0 +1,9 @@
+import { Component } from '../lib/hyperapp';
+import { IconDefinition } from './Icon';
+/** internal */
+export interface DropdownMenuProps {
+    icon?: IconDefinition;
+    className?: string;
+    tooltip?: string;
+}
+export declare const DropdownMenu: Component<DropdownMenuProps>;

package/es6/common/DropdownMenu.js

@@ -0,0 +1,10 @@
+import { h } from '../lib/hyperapp';
+import { tooltipManager } from './TooltipManager';
+import { Icon } from './Icon';
+import { classNames } from './classNames';
+import { DropdownComponent } from './Dropdown';
+export const DropdownMenu = ({ icon, className, tooltip }, children) => {
+    return (h("div", { class: classNames('pwv-Dropdown', className) },
+        h("button", Object.assign({ class: "pwv-ToolbarButton" }, tooltipManager.createTooltip(tooltip), { oncreate: DropdownComponent.create, onremove: DropdownComponent.remove }), icon && h(Icon, { icon: icon })),
+        h("div", { class: "pwv-DropdownPanel" }, children)));
+};

package/es6/common/DropdownSeparator.d.ts

@@ -0,0 +1,3 @@
+import { Component } from '../lib/hyperapp';
+/** internal */
+export declare const DropdownSeparator: Component<{}>;

package/es6/common/DropdownSeparator.js

@@ -0,0 +1,6 @@
+import { h } from '../lib/hyperapp';
+/** internal */
+export const DropdownSeparator = ({}) => {
+    return (h("div", { class: "pwv-DropdownSeparator" },
+        h("span", null)));
+};

package/es6/common/Icon.d.ts

@@ -0,0 +1,13 @@
+import { Component } from '../lib/hyperapp';
+import { IconDefinition } from './icons';
+export * from './icons';
+/** internal */
+export interface IconProps {
+    icon: IconDefinition;
+    className?: string;
+    fill?: string;
+    bg?: string;
+    title?: string;
+}
+/** internal */
+export declare const Icon: Component<IconProps>;

package/es6/common/Icon.js

@@ -0,0 +1,8 @@
+import { h } from '../lib/hyperapp';
+import { classNames } from './classNames';
+export * from './icons';
+/** internal */
+export const Icon = ({ icon, className, fill, bg, title }) => (h("span", { class: classNames('pwv-icon', className), title: title },
+    h("svg", { viewBox: `0 0 ${icon.width} ${icon.height}` },
+        icon.bg && bg && h("path", { d: icon.bg, fill: bg }),
+        h("path", { d: icon.path, fill: fill, "shape-rendering": "geometricPrecision", "stroke-width": "1px" }))));

package/es6/common/Loader.d.ts

@@ -0,0 +1,3 @@
+import { Component } from '../lib/hyperapp';
+/** internal */
+export declare const Loader: Component<{}>;

package/es6/common/Loader.js

@@ -0,0 +1,6 @@
+import { h } from '../lib/hyperapp';
+/** internal */
+export const Loader = ({}) => {
+    return (h("div", { class: "pwv-Loader" },
+        h("div", null)));
+};