@theseam/ui-common 0.3.11 → 0.4.0-beta.0

package/esm2020/viewers/html-template-viewer/html-template-viewer.component.mjs

@@ -0,0 +1,219 @@
+import { __decorate } from "tslib";
+import { Component, Input, ViewChild } from '@angular/core';
+import { InputBoolean } from '@theseam/ui-common/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@theseam/ui-common/scrollbar";
+import * as i3 from "@theseam/ui-common/shared";
+var TemplateMessageType;
+(function (TemplateMessageType) {
+    TemplateMessageType["TplData"] = "theseam_tpl_data";
+    TemplateMessageType["TplResize"] = "theseam_tpl_resize";
+})(TemplateMessageType || (TemplateMessageType = {}));
+export class TheSeamHtmlTemplateViewerComponent {
+    constructor(_ngZone, _cdr, _elementRef) {
+        this._ngZone = _ngZone;
+        this._cdr = _cdr;
+        this._elementRef = _elementRef;
+        this._dataVersion = 0;
+        this._scrollHandleObserver = null;
+        this._scrollable = false;
+        this._scrollbarOptions = {
+            callbacks: {
+                onInitialized: () => this._initScrollHandleObserver(),
+                // Only scrollbar handles from OverlayScrollbars are currently observed,
+                // so we can just disable the observer for native scrollbars.
+                onInitializationWithdrawn: () => this._destroyScrollHandleObserver(),
+                onDestroyed: () => this._destroyScrollHandleObserver(),
+            }
+        };
+        this._mouseBlockActive = false;
+        this._mouseBlockWidth = '100%';
+        this._mouseBlockHeight = '100%';
+        this._onMessageFromTemplate = (e) => {
+            const type = e.data.type;
+            if (this._templateMessageHandlers[type]) {
+                this._ngZone.run(() => this._templateMessageHandlers[type](e.data.payload));
+            }
+        };
+        this._onResizeMessageFromTemplate = (payload) => {
+            const iframeNativeElement = this._getIFrameNativeElement();
+            if (iframeNativeElement) {
+                iframeNativeElement.style.height = `${payload.height}px`;
+            }
+        };
+        this._templateMessageHandlers = {
+            [TemplateMessageType.TplData]: () => { },
+            [TemplateMessageType.TplResize]: this._onResizeMessageFromTemplate
+        };
+    }
+    get src() { return this._src; }
+    set src(val) {
+        this._src = val;
+        this._updateSrc();
+    }
+    set dataVersion(value) {
+        const dv = value || 0;
+        const sendData = this._dataVersion !== dv;
+        this._dataVersion = dv;
+        if (sendData) {
+            this.postMessage(this._message);
+        }
+    }
+    set data(value) {
+        this.postMessage((value !== null && value !== undefined) ? JSON.stringify(value) : value);
+    }
+    set scrollable(value) {
+        this._scrollable = value;
+        if (this._scrollable) {
+            this._initScrollHandleObserver();
+        }
+        else {
+            this._destroyScrollHandleObserver();
+        }
+    }
+    set iframeElementRef(val) {
+        this._iframeElementRef = val;
+        const iframeNativeElement = this._getIFrameNativeElement();
+        if (iframeNativeElement) {
+            this._updateSrc();
+            iframeNativeElement.onload = () => this.postMessage(this._message);
+        }
+    }
+    ngOnInit() {
+        this._ngZone.runOutsideAngular(() => window.addEventListener('message', this._onMessageFromTemplate));
+    }
+    ngOnDestroy() {
+        window.removeEventListener('message', this._onMessageFromTemplate);
+        this._destroyScrollHandleObserver();
+    }
+    _updateSrc() {
+        const iframeNativeElement = this._getIFrameNativeElement();
+        if (iframeNativeElement) {
+            iframeNativeElement.src = this._src || '';
+        }
+    }
+    postMessage(msg) {
+        this._message = msg;
+        let _msg = msg;
+        const contentWindow = this._getIFrameContentWindow();
+        if (contentWindow && _msg) {
+            if (this._dataVersion === 2) {
+                const wrapper = { type: TemplateMessageType.TplData, payload: undefined };
+                try {
+                    wrapper.payload = JSON.parse(_msg);
+                }
+                catch {
+                    wrapper.payload = _msg;
+                }
+                _msg = JSON.stringify(wrapper);
+            }
+            contentWindow.postMessage(_msg, '*');
+        }
+    }
+    reload() {
+        this._updateSrc();
+    }
+    _onResized(event) {
+        // This ensures the iframe scales itself if it isn't listening to or misses
+        // the resize event.
+        this.reload();
+    }
+    _getIFrameNativeElement() {
+        return (this._iframeElementRef?.nativeElement) || null;
+    }
+    _getIFrameContentWindow() {
+        return (this._iframeElementRef?.nativeElement?.contentWindow) || null;
+    }
+    /**
+     * Initializes a MutationObserver to detect the 'active' class added to a
+     * scroll handle, because OverlayScrollbars does not seem to provide an event
+     * for scrollbar handle activation/deactivation.
+     *
+     * TODO: Do we need this to work for native scrollbars also?
+     */
+    _initScrollHandleObserver() {
+        if (this._scrollHandleObserver !== null) {
+            return;
+        }
+        this._ngZone.runOutsideAngular(() => {
+            const observer = new MutationObserver(() => {
+                this._ngZone.run(() => {
+                    if (this._isScrollbarHandleActive()) {
+                        this._enableMouseBlock();
+                    }
+                    else {
+                        this._disableMouseBlock();
+                    }
+                });
+            });
+            observer.observe(this._elementRef.nativeElement, {
+                attributes: true,
+                attributeFilter: ['class'],
+                childList: true,
+                subtree: true,
+                characterData: false,
+            });
+            this._scrollHandleObserver = observer;
+        });
+    }
+    _destroyScrollHandleObserver() {
+        if (this._scrollHandleObserver === null) {
+            return;
+        }
+        this._scrollHandleObserver.disconnect();
+        this._scrollHandleObserver = null;
+    }
+    /**
+     * Enables a transparent div to cover the iframe.
+     *
+     * When the mouse is over an iframe the browser stops letting the parent
+     * document receive mouse events. Anything actively tracking mouse movement or
+     * button pressed will think the mouse has left the page. So the scrollbar
+     * handle would deactivate, when the mouse hovers the iframe. This adds an
+     * element to cover the iframe, which prevents mouse events getting sent to
+     * the iframe.
+     */
+    _enableMouseBlock() {
+        this._mouseBlockActive = true;
+        const iframeElement = this._getIFrameNativeElement();
+        if (iframeElement) {
+            const rect = iframeElement.getBoundingClientRect();
+            this._mouseBlockWidth = `${rect.width}px`;
+            this._mouseBlockHeight = `${rect.height}px`;
+        }
+        else {
+            this._mouseBlockWidth = '100%';
+            this._mouseBlockHeight = '100%';
+        }
+        this._cdr.detectChanges();
+    }
+    _disableMouseBlock() {
+        this._mouseBlockActive = false;
+        this._cdr.detectChanges();
+    }
+    _isScrollbarHandleActive() {
+        return this._elementRef.nativeElement.querySelector('.os-scrollbar-handle.active') !== null;
+    }
+}
+TheSeamHtmlTemplateViewerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamHtmlTemplateViewerComponent, deps: [{ token: i0.NgZone }, { token: i0.ChangeDetectorRef }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+TheSeamHtmlTemplateViewerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.3", type: TheSeamHtmlTemplateViewerComponent, selector: "seam-html-template-viewer", inputs: { src: "src", dataVersion: "dataVersion", data: "data", scrollable: "scrollable" }, viewQueries: [{ propertyName: "iframeElementRef", first: true, predicate: ["iframeElement"], descendants: true, static: true }], ngImport: i0, template: "<div (seamElemResized)=\"_onResized($any($event))\">\n  <div class=\"embed-responsive embed-responsive-4by3\"\n    [seamOverlayScrollbar]=\"_scrollbarOptions\"\n    [overlayScrollbarEnabled]=\"_scrollable\">\n    <iframe #iframeElement class=\"embed-responsive-item\" allowfullscreen></iframe>\n    <div *ngIf=\"_mouseBlockActive\"\n      class=\"iframe-mouse-block\"\n      [style.width]=\"_mouseBlockWidth\"\n      [style.height]=\"_mouseBlockHeight\">\n    </div>\n  </div>\n</div>\n", styles: [":host{display:block}.iframe-mouse-block{position:absolute;top:0;right:0;height:100%;width:100%}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.OverlayScrollbarDirective, selector: "[seamOverlayScrollbar]", inputs: ["seamOverlayScrollbar", "overlayScrollbarEnabled"], exportAs: ["seamOverlayScrollbar"] }, { kind: "directive", type: i3.ElemResizedDirective, selector: "[seamElemResized]", outputs: ["seamElemResized"] }] });
+__decorate([
+    InputBoolean()
+], TheSeamHtmlTemplateViewerComponent.prototype, "scrollable", null);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamHtmlTemplateViewerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-html-template-viewer', template: "<div (seamElemResized)=\"_onResized($any($event))\">\n  <div class=\"embed-responsive embed-responsive-4by3\"\n    [seamOverlayScrollbar]=\"_scrollbarOptions\"\n    [overlayScrollbarEnabled]=\"_scrollable\">\n    <iframe #iframeElement class=\"embed-responsive-item\" allowfullscreen></iframe>\n    <div *ngIf=\"_mouseBlockActive\"\n      class=\"iframe-mouse-block\"\n      [style.width]=\"_mouseBlockWidth\"\n      [style.height]=\"_mouseBlockHeight\">\n    </div>\n  </div>\n</div>\n", styles: [":host{display:block}.iframe-mouse-block{position:absolute;top:0;right:0;height:100%;width:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: i0.ElementRef }]; }, propDecorators: { src: [{
+                type: Input
+            }], dataVersion: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], scrollable: [{
+                type: Input
+            }], iframeElementRef: [{
+                type: ViewChild,
+                args: ['iframeElement', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"html-template-viewer.component.js","sourceRoot":"","sources":["../../../../../projects/ui-common/viewers/html-template-viewer/html-template-viewer.component.ts","../../../../../projects/ui-common/viewers/html-template-viewer/html-template-viewer.component.html"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput } from '@angular/cdk/coercion'\nimport { ChangeDetectorRef, Component, ElementRef, Input, NgZone, OnDestroy, OnInit, ViewChild } from '@angular/core'\n\nimport { InputBoolean } from '@theseam/ui-common/core'\n\ninterface TemplateResizeMessagePayload {\n  width: number\n  height: number\n}\n\nenum TemplateMessageType {\n  TplData = 'theseam_tpl_data',\n  TplResize = 'theseam_tpl_resize',\n}\n\ninterface TemplateMessage<TType, TPayload> {\n  type: TType\n  payload: TPayload\n}\n\n@Component({\n  selector: 'seam-html-template-viewer',\n  templateUrl: './html-template-viewer.component.html',\n  styleUrls: ['./html-template-viewer.component.scss']\n})\nexport class TheSeamHtmlTemplateViewerComponent implements OnInit, OnDestroy {\n  static ngAcceptInputType_scrollable: BooleanInput\n\n  private readonly _templateMessageHandlers: { [key in TemplateMessageType]: (payload: any) => void }\n\n  private _message: string | undefined | null\n  private _dataVersion: number = 0\n  private _scrollHandleObserver: MutationObserver | null = null\n\n  @Input()\n  get src(): string | null | undefined { return this._src }\n  set src(val: string | null | undefined) {\n    this._src = val\n    this._updateSrc()\n  }\n  private _src: string | null | undefined\n\n  @Input()\n  set dataVersion(value: number | undefined | null) {\n    const dv = value || 0\n    const sendData = this._dataVersion !== dv\n    this._dataVersion = dv\n    if (sendData) {\n      this.postMessage(this._message)\n    }\n  }\n\n  @Input()\n  set data(value: any) {\n    this.postMessage((value !== null && value !== undefined) ? JSON.stringify(value) : value)\n  }\n\n  @Input() @InputBoolean()\n  set scrollable(value: boolean) {\n    this._scrollable = value\n    if (this._scrollable) {\n      this._initScrollHandleObserver()\n    } else {\n      this._destroyScrollHandleObserver()\n    }\n  }\n\n  _scrollable: boolean = false\n\n  @ViewChild('iframeElement', { static: true })\n  set iframeElementRef(val: ElementRef<HTMLIFrameElement>) {\n    this._iframeElementRef = val\n    const iframeNativeElement = this._getIFrameNativeElement()\n    if (iframeNativeElement) {\n      this._updateSrc()\n      iframeNativeElement.onload = () => this.postMessage(this._message)\n    }\n  }\n  private _iframeElementRef!: ElementRef<HTMLIFrameElement>\n\n  _scrollbarOptions = {\n    callbacks: {\n      onInitialized: () => this._initScrollHandleObserver(),\n      // Only scrollbar handles from OverlayScrollbars are currently observed,\n      // so we can just disable the observer for native scrollbars.\n      onInitializationWithdrawn: () => this._destroyScrollHandleObserver(),\n      onDestroyed: () => this._destroyScrollHandleObserver(),\n    }\n  }\n\n  _mouseBlockActive: boolean = false\n  _mouseBlockWidth: string = '100%'\n  _mouseBlockHeight: string = '100%'\n\n  constructor(\n    private readonly _ngZone: NgZone,\n    private readonly _cdr: ChangeDetectorRef,\n    private readonly _elementRef: ElementRef\n  ) {\n    this._templateMessageHandlers = {\n      [TemplateMessageType.TplData]: () => { }, // Not listening for message from template\n      [TemplateMessageType.TplResize]: this._onResizeMessageFromTemplate\n    }\n  }\n\n  ngOnInit(): void {\n    this._ngZone.runOutsideAngular(() => window.addEventListener('message', this._onMessageFromTemplate))\n  }\n\n  ngOnDestroy(): void {\n    window.removeEventListener('message', this._onMessageFromTemplate)\n    this._destroyScrollHandleObserver()\n  }\n\n  private _onMessageFromTemplate = (e: any) => {\n    const type = e.data.type as TemplateMessageType\n    if (this._templateMessageHandlers[type]) {\n      this._ngZone.run(() => this._templateMessageHandlers[type](e.data.payload))\n    }\n  }\n\n  private _onResizeMessageFromTemplate = (payload: TemplateResizeMessagePayload): void => {\n    const iframeNativeElement = this._getIFrameNativeElement()\n    if (iframeNativeElement) {\n      iframeNativeElement.style.height = `${payload.height}px`\n    }\n  }\n\n  private _updateSrc(): void {\n    const iframeNativeElement = this._getIFrameNativeElement()\n    if (iframeNativeElement) {\n      iframeNativeElement.src = this._src || ''\n    }\n  }\n\n  public postMessage(msg: string | undefined | null): void {\n    this._message = msg\n\n    let _msg = msg\n    const contentWindow = this._getIFrameContentWindow()\n    if (contentWindow && _msg) {\n      if (this._dataVersion === 2) {\n        const wrapper: TemplateMessage<TemplateMessageType, any> = { type: TemplateMessageType.TplData, payload: undefined }\n        try { wrapper.payload = JSON.parse(_msg) } catch { wrapper.payload = _msg }\n        _msg = JSON.stringify(wrapper)\n      }\n\n      contentWindow.postMessage(_msg, '*')\n    }\n  }\n\n  public reload(): void {\n    this._updateSrc()\n  }\n\n  _onResized(event: { width: number, height: number }) {\n    // This ensures the iframe scales itself if it isn't listening to or misses\n    // the resize event.\n    this.reload()\n  }\n\n  private _getIFrameNativeElement(): HTMLIFrameElement | null {\n    return (this._iframeElementRef?.nativeElement) || null\n  }\n\n  private _getIFrameContentWindow(): Window | null {\n    return (this._iframeElementRef?.nativeElement?.contentWindow) || null\n  }\n\n  /**\n   * Initializes a MutationObserver to detect the 'active' class added to a\n   * scroll handle, because OverlayScrollbars does not seem to provide an event\n   * for scrollbar handle activation/deactivation.\n   *\n   * TODO: Do we need this to work for native scrollbars also?\n   */\n  private _initScrollHandleObserver(): void {\n    if (this._scrollHandleObserver !== null) {\n      return\n    }\n\n    this._ngZone.runOutsideAngular(() => {\n      const observer = new MutationObserver(() => {\n        this._ngZone.run(() => {\n          if (this._isScrollbarHandleActive()) {\n            this._enableMouseBlock()\n          } else {\n            this._disableMouseBlock()\n          }\n        })\n      })\n\n      observer.observe(this._elementRef.nativeElement, {\n        attributes: true,\n        attributeFilter: [ 'class' ],\n        childList: true,\n        subtree: true,\n        characterData: false,\n      })\n\n      this._scrollHandleObserver = observer\n    })\n  }\n\n  private _destroyScrollHandleObserver(): void {\n    if (this._scrollHandleObserver === null) {\n      return\n    }\n\n    this._scrollHandleObserver.disconnect()\n    this._scrollHandleObserver = null\n  }\n\n  /**\n   * Enables a transparent div to cover the iframe.\n   *\n   * When the mouse is over an iframe the browser stops letting the parent\n   * document receive mouse events. Anything actively tracking mouse movement or\n   * button pressed will think the mouse has left the page. So the scrollbar\n   * handle would deactivate, when the mouse hovers the iframe. This adds an\n   * element to cover the iframe, which prevents mouse events getting sent to\n   * the iframe.\n   */\n  private _enableMouseBlock(): void {\n    this._mouseBlockActive = true\n\n    const iframeElement = this._getIFrameNativeElement()\n    if (iframeElement) {\n      const rect = iframeElement.getBoundingClientRect()\n      this._mouseBlockWidth = `${rect.width}px`\n      this._mouseBlockHeight = `${rect.height}px`\n    } else {\n      this._mouseBlockWidth = '100%'\n      this._mouseBlockHeight = '100%'\n    }\n\n    this._cdr.detectChanges()\n  }\n\n  private _disableMouseBlock(): void {\n    this._mouseBlockActive = false\n    this._cdr.detectChanges()\n  }\n\n  private _isScrollbarHandleActive(): boolean {\n    return this._elementRef.nativeElement.querySelector('.os-scrollbar-handle.active') !== null\n  }\n\n}\n","<div (seamElemResized)=\"_onResized($any($event))\">\n  <div class=\"embed-responsive embed-responsive-4by3\"\n    [seamOverlayScrollbar]=\"_scrollbarOptions\"\n    [overlayScrollbarEnabled]=\"_scrollable\">\n    <iframe #iframeElement class=\"embed-responsive-item\" allowfullscreen></iframe>\n    <div *ngIf=\"_mouseBlockActive\"\n      class=\"iframe-mouse-block\"\n      [style.width]=\"_mouseBlockWidth\"\n      [style.height]=\"_mouseBlockHeight\">\n    </div>\n  </div>\n</div>\n"]}

package/esm2020/viewers/html-template-viewer/html-template-viewer.module.mjs

@@ -0,0 +1,32 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { TheSeamScrollbarModule } from '@theseam/ui-common/scrollbar';
+import { TheSeamSharedModule } from '@theseam/ui-common/shared';
+import { TheSeamHtmlTemplateViewerComponent } from './html-template-viewer.component';
+import * as i0 from "@angular/core";
+export class TheSeamHtmlTemplateViewerModule {
+}
+TheSeamHtmlTemplateViewerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamHtmlTemplateViewerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TheSeamHtmlTemplateViewerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.3", ngImport: i0, type: TheSeamHtmlTemplateViewerModule, declarations: [TheSeamHtmlTemplateViewerComponent], imports: [CommonModule,
+        TheSeamScrollbarModule,
+        TheSeamSharedModule], exports: [TheSeamHtmlTemplateViewerComponent] });
+TheSeamHtmlTemplateViewerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamHtmlTemplateViewerModule, imports: [CommonModule,
+        TheSeamScrollbarModule,
+        TheSeamSharedModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamHtmlTemplateViewerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        TheSeamScrollbarModule,
+                        TheSeamSharedModule,
+                    ],
+                    declarations: [
+                        TheSeamHtmlTemplateViewerComponent,
+                    ],
+                    exports: [
+                        TheSeamHtmlTemplateViewerComponent,
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHRtbC10ZW1wbGF0ZS12aWV3ZXIubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWktY29tbW9uL3ZpZXdlcnMvaHRtbC10ZW1wbGF0ZS12aWV3ZXIvaHRtbC10ZW1wbGF0ZS12aWV3ZXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQTtBQUM5QyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBRXhDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLDhCQUE4QixDQUFBO0FBQ3JFLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDJCQUEyQixDQUFBO0FBRS9ELE9BQU8sRUFBRSxrQ0FBa0MsRUFBRSxNQUFNLGtDQUFrQyxDQUFBOztBQWVyRixNQUFNLE9BQU8sK0JBQStCOzs0SEFBL0IsK0JBQStCOzZIQUEvQiwrQkFBK0IsaUJBTnhDLGtDQUFrQyxhQUxsQyxZQUFZO1FBQ1osc0JBQXNCO1FBQ3RCLG1CQUFtQixhQU1uQixrQ0FBa0M7NkhBR3pCLCtCQUErQixZQVh4QyxZQUFZO1FBQ1osc0JBQXNCO1FBQ3RCLG1CQUFtQjsyRkFTViwrQkFBK0I7a0JBYjNDLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFO3dCQUNQLFlBQVk7d0JBQ1osc0JBQXNCO3dCQUN0QixtQkFBbUI7cUJBQ3BCO29CQUNELFlBQVksRUFBRTt3QkFDWixrQ0FBa0M7cUJBQ25DO29CQUNELE9BQU8sRUFBRTt3QkFDUCxrQ0FBa0M7cUJBQ25DO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJ1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5pbXBvcnQgeyBUaGVTZWFtU2Nyb2xsYmFyTW9kdWxlIH0gZnJvbSAnQHRoZXNlYW0vdWktY29tbW9uL3Njcm9sbGJhcidcbmltcG9ydCB7IFRoZVNlYW1TaGFyZWRNb2R1bGUgfSBmcm9tICdAdGhlc2VhbS91aS1jb21tb24vc2hhcmVkJ1xuXG5pbXBvcnQgeyBUaGVTZWFtSHRtbFRlbXBsYXRlVmlld2VyQ29tcG9uZW50IH0gZnJvbSAnLi9odG1sLXRlbXBsYXRlLXZpZXdlci5jb21wb25lbnQnXG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtcbiAgICBDb21tb25Nb2R1bGUsXG4gICAgVGhlU2VhbVNjcm9sbGJhck1vZHVsZSxcbiAgICBUaGVTZWFtU2hhcmVkTW9kdWxlLFxuICBdLFxuICBkZWNsYXJhdGlvbnM6IFtcbiAgICBUaGVTZWFtSHRtbFRlbXBsYXRlVmlld2VyQ29tcG9uZW50LFxuICBdLFxuICBleHBvcnRzOiBbXG4gICAgVGhlU2VhbUh0bWxUZW1wbGF0ZVZpZXdlckNvbXBvbmVudCxcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBUaGVTZWFtSHRtbFRlbXBsYXRlVmlld2VyTW9kdWxlIHsgfVxuIl19

package/esm2020/viewers/pdf-viewer/pdf-page/pdf-page.component.mjs

@@ -0,0 +1,142 @@
+import { __decorate } from "tslib";
+import { Component, HostBinding, Input, ViewChild } from '@angular/core';
+import { from, Subject } from 'rxjs';
+import { auditTime, switchMap, takeUntil } from 'rxjs/operators';
+import { InputBoolean } from '@theseam/ui-common/core';
+import { waitOnConditionAsync } from '@theseam/ui-common/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@theseam/ui-common/shared";
+export class TheSeamPdfPageComponent {
+    constructor() {
+        this._ngUnsubscribe = new Subject();
+        this.shadow = false;
+        /**
+         * Canvas will responsively scale and rerender if scaled more than
+         * `renderUpdateThreshold` pixels.
+         */
+        this.responsive = false;
+        /**
+         * The canvas will be rerendered if the canvas size changes by this many
+         * pixels from the last render.
+         *
+         * To make the canvas responsive using only the initial size for its render
+         * set the threshold to `-1`. You can still trigger a rerender by calling the
+         * `render()` method.
+         *
+         * NOTE: Only used when `responsive` is `true`.
+         */
+        this.renderUpdateThreshold = 100;
+        this.rendering = false;
+        this._renderRequestSubject = new Subject();
+        this._render$ = this._renderRequestSubject.pipe(takeUntil(this._ngUnsubscribe), auditTime(500), switchMap(_ => from(waitOnConditionAsync(() => this.rendering === false, 30 * 1000))), switchMap(_ => from(this._render())));
+    }
+    get page() { return this._page; }
+    set page(value) {
+        this._page = value;
+        setTimeout(() => { this.render(); });
+    }
+    get _shadow() { return this.shadow; }
+    ngOnDestroy() {
+        this._ngUnsubscribe.next(undefined);
+        this._ngUnsubscribe.complete();
+    }
+    ngAfterViewInit() {
+        this._render$.subscribe();
+        this.render();
+    }
+    render() {
+        this._renderRequestSubject.next();
+    }
+    async _render() {
+        if (!this.pdfContainer || !this.pdfCanvas) {
+            return;
+        }
+        try {
+            const w = this.pdfContainer.nativeElement.clientWidth;
+            const desiredWidth = w;
+            const viewport = this.page.getViewport({ scale: 1 });
+            const scale = desiredWidth / viewport.width;
+            const scaledViewport = this.page.getViewport({ scale });
+            // Prepare canvas using PDF page dimensions
+            const canvas = this.pdfCanvas.nativeElement;
+            const context = canvas.getContext('2d');
+            canvas.height = scaledViewport.height;
+            canvas.width = scaledViewport.width;
+            canvas.style.height = `${scaledViewport.height}px`;
+            canvas.style.width = `${scaledViewport.width}px`;
+            // Render PDF page into canvas context
+            const renderContext = {
+                canvasContext: context,
+                viewport: scaledViewport
+            };
+            const renderTask = await this.page.render(renderContext).promise;
+            // TODO: Allow canceling instead of only waiting
+            // await renderTask.cancel()
+            this.rendering = false;
+            if (this.responsive) {
+                canvas.style.width = '100%';
+                canvas.style.height = '100%';
+            }
+        }
+        catch (err) {
+            // PDF loading error
+            console.error(err);
+        }
+    }
+    onResized() {
+        if (!this.responsive || this.renderUpdateThreshold === -1) {
+            return;
+        }
+        if (!this.pdfContainer || !this.pdfCanvas) {
+            return;
+        }
+        const containerRect = this.pdfContainer.nativeElement.getBoundingClientRect();
+        const pdfWidth = this.pdfCanvas.nativeElement.width;
+        const pdfHeight = this.pdfCanvas.nativeElement.height;
+        const wDiff = Math.abs(containerRect.width - pdfWidth);
+        const hDiff = Math.abs(containerRect.height - pdfHeight);
+        if (wDiff > this.renderUpdateThreshold || hDiff > this.renderUpdateThreshold) {
+            this.render();
+        }
+    }
+}
+TheSeamPdfPageComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamPdfPageComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+TheSeamPdfPageComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.3", type: TheSeamPdfPageComponent, selector: "seam-pdf-page", inputs: { page: "page", shadow: "shadow", responsive: "responsive", renderUpdateThreshold: "renderUpdateThreshold" }, host: { properties: { "class.shadow": "this._shadow" } }, viewQueries: [{ propertyName: "pdfContainer", first: true, predicate: ["pdfContainer"], descendants: true, static: true }, { propertyName: "pdfCanvas", first: true, predicate: ["pdfCanvas"], descendants: true, static: true }], ngImport: i0, template: `
+  <div #pdfContainer
+    (seamElemResized)="onResized()">
+    <canvas #pdfCanvas></canvas>
+  </div>
+  `, isInline: true, styles: [":host{display:block}canvas{display:block}\n"], dependencies: [{ kind: "directive", type: i1.ElemResizedDirective, selector: "[seamElemResized]", outputs: ["seamElemResized"] }] });
+__decorate([
+    InputBoolean()
+], TheSeamPdfPageComponent.prototype, "shadow", void 0);
+__decorate([
+    InputBoolean()
+], TheSeamPdfPageComponent.prototype, "responsive", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamPdfPageComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-pdf-page', template: `
+  <div #pdfContainer
+    (seamElemResized)="onResized()">
+    <canvas #pdfCanvas></canvas>
+  </div>
+  `, styles: [":host{display:block}canvas{display:block}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { page: [{
+                type: Input
+            }], shadow: [{
+                type: Input
+            }], _shadow: [{
+                type: HostBinding,
+                args: ['class.shadow']
+            }], pdfContainer: [{
+                type: ViewChild,
+                args: ['pdfContainer', { static: true }]
+            }], pdfCanvas: [{
+                type: ViewChild,
+                args: ['pdfCanvas', { static: true }]
+            }], responsive: [{
+                type: Input
+            }], renderUpdateThreshold: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pdf-page.component.js","sourceRoot":"","sources":["../../../../../../projects/ui-common/viewers/pdf-viewer/pdf-page/pdf-page.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput } from '@angular/cdk/coercion'\nimport { AfterViewInit, Component, ElementRef, HostBinding, Input, OnDestroy, ViewChild } from '@angular/core'\nimport { from, Observable, Subject } from 'rxjs'\nimport { auditTime, switchMap, takeUntil } from 'rxjs/operators'\n\nimport { InputBoolean } from '@theseam/ui-common/core'\nimport { waitOnConditionAsync } from '@theseam/ui-common/utils'\n\n@Component({\n  selector: 'seam-pdf-page',\n  template: `\n  <div #pdfContainer\n    (seamElemResized)=\"onResized()\">\n    <canvas #pdfCanvas></canvas>\n  </div>\n  `,\n  styles: [`\n    :host { display: block; }\n    canvas { display: block; }\n  `]\n})\nexport class TheSeamPdfPageComponent implements OnDestroy, AfterViewInit {\n  static ngAcceptInputType_shadow: BooleanInput\n  static ngAcceptInputType_responsive: BooleanInput\n\n  private readonly _ngUnsubscribe = new Subject<void>()\n\n  @Input()\n  public get page() { return this._page }\n  public set page(value) {\n    this._page = value\n    setTimeout(() => { this.render() })\n  }\n  private _page: any\n\n  @Input() @InputBoolean() shadow: boolean = false\n\n  @HostBinding('class.shadow') get _shadow() { return this.shadow }\n\n  @ViewChild('pdfContainer', { static: true }) pdfContainer?: ElementRef<HTMLDivElement>\n  @ViewChild('pdfCanvas', { static: true }) pdfCanvas?: ElementRef<HTMLCanvasElement>\n\n  /**\n   * Canvas will responsively scale and rerender if scaled more than\n   * `renderUpdateThreshold` pixels.\n   */\n  @Input() @InputBoolean() responsive = false\n\n  /**\n   * The canvas will be rerendered if the canvas size changes by this many\n   * pixels from the last render.\n   *\n   * To make the canvas responsive using only the initial size for its render\n   * set the threshold to `-1`. You can still trigger a rerender by calling the\n   * `render()` method.\n   *\n   * NOTE: Only used when `responsive` is `true`.\n   */\n  @Input() renderUpdateThreshold = 100\n\n  public rendering = false\n\n  private _renderRequestSubject = new Subject<void>()\n\n  private _render$: Observable<void>\n\n  constructor() {\n    this._render$ = this._renderRequestSubject.pipe(\n      takeUntil(this._ngUnsubscribe),\n      auditTime(500),\n      switchMap(_ => from(waitOnConditionAsync(() => this.rendering === false, 30 * 1000))),\n      switchMap(_ => from(this._render()))\n    )\n  }\n\n  ngOnDestroy() {\n    this._ngUnsubscribe.next(undefined)\n    this._ngUnsubscribe.complete()\n  }\n\n  ngAfterViewInit() {\n    this._render$.subscribe()\n    this.render()\n  }\n\n  public render() {\n    this._renderRequestSubject.next()\n  }\n\n  private async _render() {\n    if (!this.pdfContainer || !this.pdfCanvas) {\n      return\n    }\n\n    try {\n      const w = this.pdfContainer.nativeElement.clientWidth\n      const desiredWidth = w\n      const viewport = this.page.getViewport({ scale: 1 })\n      const scale = desiredWidth / viewport.width\n      const scaledViewport = this.page.getViewport({ scale })\n\n      // Prepare canvas using PDF page dimensions\n      const canvas: HTMLCanvasElement = this.pdfCanvas.nativeElement\n      const context = canvas.getContext('2d')\n      canvas.height = scaledViewport.height\n      canvas.width = scaledViewport.width\n      canvas.style.height = `${scaledViewport.height}px`\n      canvas.style.width = `${scaledViewport.width}px`\n\n      // Render PDF page into canvas context\n      const renderContext = {\n        canvasContext: context,\n        viewport: scaledViewport\n      }\n\n      const renderTask = await this.page.render(renderContext).promise\n\n      // TODO: Allow canceling instead of only waiting\n      // await renderTask.cancel()\n      this.rendering = false\n      if (this.responsive) {\n        canvas.style.width = '100%'\n        canvas.style.height = '100%'\n      }\n    } catch (err) {\n      // PDF loading error\n      console.error(err)\n    }\n  }\n\n  onResized() {\n    if (!this.responsive || this.renderUpdateThreshold === -1) { return }\n\n    if (!this.pdfContainer || !this.pdfCanvas) {\n      return\n    }\n\n    const containerRect = this.pdfContainer.nativeElement.getBoundingClientRect()\n    const pdfWidth = this.pdfCanvas.nativeElement.width\n    const pdfHeight = this.pdfCanvas.nativeElement.height\n    const wDiff = Math.abs(containerRect.width - pdfWidth)\n    const hDiff = Math.abs(containerRect.height - pdfHeight)\n    if (wDiff > this.renderUpdateThreshold || hDiff > this.renderUpdateThreshold) {\n      this.render()\n    }\n\n  }\n\n}\n"]}

package/esm2020/viewers/pdf-viewer/pdf-renderer.service.mjs

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { from } from 'rxjs';
+import { shareReplay, switchMap, tap } from 'rxjs/operators';
+import { wrapIntoObservable } from '@theseam/ui-common/utils';
+import * as i0 from "@angular/core";
+export class PdfRendererService {
+    constructor() {
+        const pdfjsImport = wrapIntoObservable(import('pdfjs-dist/legacy/build/pdf'));
+        this._pdfjs$ = pdfjsImport.pipe(tap((pdfJs) => {
+            if (!pdfJs.GlobalWorkerOptions.workerSrc) {
+                // tslint:disable-next-line:max-line-length
+                pdfJs.GlobalWorkerOptions.workerSrc = `https://cdnjs.cloudflare.com/ajax/libs/pdf.js/${pdfJs.version}/pdf.worker.min.js`;
+            }
+        }), shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    getDocument(url) {
+        return from(fetch(url)).pipe(switchMap(v => this._pdfjs$.pipe(switchMap(pdfjs => pdfjs.getDocument(v).promise))));
+    }
+}
+PdfRendererService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: PdfRendererService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PdfRendererService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: PdfRendererService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: PdfRendererService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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