ngx-clipboard/bundles/ngx-clipboard.umd.js

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/common'), require('@angular/core'), require('ngx-window-token'), require('rxjs')) :
    typeof define === 'function' && define.amd ? define('ngx-clipboard', ['exports', '@angular/common', '@angular/core', 'ngx-window-token', 'rxjs'], factory) :
    (global = global || self, factory(global['ngx-clipboard'] = {}, global.ng.common, global.ng.core, global.i2, global.rxjs));
}(this, (function (exports, i1, i0, i2, rxjs) { 'use strict';

    /**
     * The following code is heavily copied from https://github.com/zenorocha/clipboard.js
     */
    var ClipboardService = /** @class */ (function () {
        function ClipboardService(document, window) {
            this.document = document;
            this.window = window;
            this.copySubject = new rxjs.Subject();
            this.copyResponse$ = this.copySubject.asObservable();
            this.config = {};
        }
        ClipboardService.prototype.configure = function (config) {
            this.config = config;
        };
        ClipboardService.prototype.copy = function (content) {
            if (!this.isSupported || !content) {
                return this.pushCopyResponse({ isSuccess: false, content: content });
            }
            var copyResult = this.copyFromContent(content);
            if (copyResult) {
                return this.pushCopyResponse({ content: content, isSuccess: copyResult });
            }
            return this.pushCopyResponse({ isSuccess: false, content: content });
        };
        Object.defineProperty(ClipboardService.prototype, "isSupported", {
            get: function () {
                return !!this.document.queryCommandSupported && !!this.document.queryCommandSupported('copy') && !!this.window;
            },
            enumerable: false,
            configurable: true
        });
        ClipboardService.prototype.isTargetValid = function (element) {
            if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
                if (element.hasAttribute('disabled')) {
                    throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');
                }
                return true;
            }
            throw new Error('Target should be input or textarea');
        };
        /**
         * Attempts to copy from an input `targetElm`
         */
        ClipboardService.prototype.copyFromInputElement = function (targetElm, isFocus) {
            if (isFocus === void 0) { isFocus = true; }
            try {
                this.selectTarget(targetElm);
                var re = this.copyText();
                this.clearSelection(isFocus ? targetElm : undefined, this.window);
                return re && this.isCopySuccessInIE11();
            }
            catch (error) {
                return false;
            }
        };
        /**
         * This is a hack for IE11 to return `true` even if copy fails.
         */
        ClipboardService.prototype.isCopySuccessInIE11 = function () {
            var clipboardData = this.window['clipboardData'];
            if (clipboardData && clipboardData.getData) {
                if (!clipboardData.getData('Text')) {
                    return false;
                }
            }
            return true;
        };
        /**
         * Creates a fake textarea element, sets its value from `text` property,
         * and makes a selection on it.
         */
        ClipboardService.prototype.copyFromContent = function (content, container) {
            if (container === void 0) { container = this.document.body; }
            // check if the temp textarea still belongs to the current container.
            // In case we have multiple places using ngx-clipboard, one is in a modal using container but the other one is not.
            if (this.tempTextArea && !container.contains(this.tempTextArea)) {
                this.destroy(this.tempTextArea.parentElement || undefined);
            }
            if (!this.tempTextArea) {
                this.tempTextArea = this.createTempTextArea(this.document, this.window);
                try {
                    container.appendChild(this.tempTextArea);
                }
                catch (error) {
                    throw new Error('Container should be a Dom element');
                }
            }
            this.tempTextArea.value = content;
            var toReturn = this.copyFromInputElement(this.tempTextArea, false);
            if (this.config.cleanUpAfterCopy) {
                this.destroy(this.tempTextArea.parentElement || undefined);
            }
            return toReturn;
        };
        /**
         * Remove temporary textarea if any exists.
         */
        ClipboardService.prototype.destroy = function (container) {
            if (container === void 0) { container = this.document.body; }
            if (this.tempTextArea) {
                container.removeChild(this.tempTextArea);
                // removeChild doesn't remove the reference from memory
                this.tempTextArea = undefined;
            }
        };
        /**
         * Select the target html input element.
         */
        ClipboardService.prototype.selectTarget = function (inputElement) {
            inputElement.select();
            inputElement.setSelectionRange(0, inputElement.value.length);
            return inputElement.value.length;
        };
        ClipboardService.prototype.copyText = function () {
            return this.document.execCommand('copy');
        };
        /**
         * Moves focus away from `target` and back to the trigger, removes current selection.
         */
        ClipboardService.prototype.clearSelection = function (inputElement, window) {
            var _a;
            inputElement && inputElement.focus();
            (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.removeAllRanges();
        };
        /**
         * Creates a fake textarea for copy command.
         */
        ClipboardService.prototype.createTempTextArea = function (doc, window) {
            var isRTL = doc.documentElement.getAttribute('dir') === 'rtl';
            var ta;
            ta = doc.createElement('textarea');
            // Prevent zooming on iOS
            ta.style.fontSize = '12pt';
            // Reset box model
            ta.style.border = '0';
            ta.style.padding = '0';
            ta.style.margin = '0';
            // Move element out of screen horizontally
            ta.style.position = 'absolute';
            ta.style[isRTL ? 'right' : 'left'] = '-9999px';
            // Move element to the same position vertically
            var yPosition = window.pageYOffset || doc.documentElement.scrollTop;
            ta.style.top = yPosition + 'px';
            ta.setAttribute('readonly', '');
            return ta;
        };
        /**
         * Pushes copy operation response to copySubject, to provide global access
         * to the response.
         */
        ClipboardService.prototype.pushCopyResponse = function (response) {
            this.copySubject.next(response);
        };
        /**
         * @deprecated use pushCopyResponse instead.
         */
        ClipboardService.prototype.pushCopyReponse = function (response) {
            this.pushCopyResponse(response);
        };
        return ClipboardService;
    }());
    ClipboardService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ClipboardService_Factory() { return new ClipboardService(i0.ɵɵinject(i1.DOCUMENT), i0.ɵɵinject(i2.WINDOW, 8)); }, token: ClipboardService, providedIn: "root" });
    ClipboardService.decorators = [
        { type: i0.Injectable, args: [{ providedIn: 'root' },] }
    ];
    ClipboardService.ctorParameters = function () { return [
        { type: undefined, decorators: [{ type: i0.Inject, args: [i1.DOCUMENT,] }] },
        { type: undefined, decorators: [{ type: i0.Optional }, { type: i0.Inject, args: [i2.WINDOW,] }] }
    ]; };

    var ClipboardDirective = /** @class */ (function () {
        function ClipboardDirective(clipboardSrv) {
            this.clipboardSrv = clipboardSrv;
            this.cbOnSuccess = new i0.EventEmitter();
            this.cbOnError = new i0.EventEmitter();
        }
        // tslint:disable-next-line:no-empty
        ClipboardDirective.prototype.ngOnInit = function () { };
        ClipboardDirective.prototype.ngOnDestroy = function () {
            this.clipboardSrv.destroy(this.container);
        };
        ClipboardDirective.prototype.onClick = function (event) {
            if (!this.clipboardSrv.isSupported) {
                this.handleResult(false, undefined, event);
            }
            else if (this.targetElm && this.clipboardSrv.isTargetValid(this.targetElm)) {
                this.handleResult(this.clipboardSrv.copyFromInputElement(this.targetElm), this.targetElm.value, event);
            }
            else if (this.cbContent) {
                this.handleResult(this.clipboardSrv.copyFromContent(this.cbContent, this.container), this.cbContent, event);
            }
        };
        /**
         * Fires an event based on the copy operation result.
         * @param succeeded
         */
        ClipboardDirective.prototype.handleResult = function (succeeded, copiedContent, event) {
            var response = {
                isSuccess: succeeded,
                event: event
            };
            if (succeeded) {
                response = Object.assign(response, {
                    content: copiedContent,
                    successMessage: this.cbSuccessMsg
                });
                this.cbOnSuccess.emit(response);
            }
            else {
                this.cbOnError.emit(response);
            }
            this.clipboardSrv.pushCopyResponse(response);
        };
        return ClipboardDirective;
    }());
    ClipboardDirective.decorators = [
        { type: i0.Directive, args: [{
                    selector: '[ngxClipboard]'
                },] }
    ];
    ClipboardDirective.ctorParameters = function () { return [
        { type: ClipboardService }
    ]; };
    ClipboardDirective.propDecorators = {
        targetElm: [{ type: i0.Input, args: ['ngxClipboard',] }],
        container: [{ type: i0.Input }],
        cbContent: [{ type: i0.Input }],
        cbSuccessMsg: [{ type: i0.Input }],
        cbOnSuccess: [{ type: i0.Output }],
        cbOnError: [{ type: i0.Output }],
        onClick: [{ type: i0.HostListener, args: ['click', ['$event.target'],] }]
    };

    var ClipboardIfSupportedDirective = /** @class */ (function () {
        function ClipboardIfSupportedDirective(_clipboardService, _viewContainerRef, _templateRef) {
            this._clipboardService = _clipboardService;
            this._viewContainerRef = _viewContainerRef;
            this._templateRef = _templateRef;
        }
        ClipboardIfSupportedDirective.prototype.ngOnInit = function () {
            if (this._clipboardService.isSupported) {
                this._viewContainerRef.createEmbeddedView(this._templateRef);
            }
        };
        return ClipboardIfSupportedDirective;
    }());
    ClipboardIfSupportedDirective.decorators = [
        { type: i0.Directive, args: [{
                    selector: '[ngxClipboardIfSupported]'
                },] }
    ];
    ClipboardIfSupportedDirective.ctorParameters = function () { return [
        { type: ClipboardService },
        { type: i0.ViewContainerRef },
        { type: i0.TemplateRef }
    ]; };

    var ClipboardModule = /** @class */ (function () {
        function ClipboardModule() {
        }
        return ClipboardModule;
    }());
    ClipboardModule.decorators = [
        { type: i0.NgModule, args: [{
                    imports: [i1.CommonModule],
                    declarations: [ClipboardDirective, ClipboardIfSupportedDirective],
                    exports: [ClipboardDirective, ClipboardIfSupportedDirective]
                },] }
    ];

    /*
     * Public API Surface of ngx-clipboard
     */

    /**
     * Generated bundle index. Do not edit.
     */

    exports.ClipboardDirective = ClipboardDirective;
    exports.ClipboardIfSupportedDirective = ClipboardIfSupportedDirective;
    exports.ClipboardModule = ClipboardModule;
    exports.ClipboardService = ClipboardService;

    Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=ngx-clipboard.umd.js.map