@bravobit/bb-foundation 0.15.5 → 0.16.2

package/fesm2020/bravobit-bb-foundation.mjs

@@ -0,0 +1,892 @@
+import * as i0 from '@angular/core';
+import { PLATFORM_ID, Injectable, Inject, InjectionToken, Optional, inject } from '@angular/core';
+import { isPlatformBrowser, DOCUMENT, formatDate } from '@angular/common';
+import { mapTo, map, distinctUntilChanged, shareReplay, debounceTime, startWith } from 'rxjs/operators';
+import { of, fromEvent, Observable, merge, Subscription } from 'rxjs';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+
+let hasV8BreakIterator;
+try {
+    hasV8BreakIterator = (typeof Intl !== 'undefined' && Intl.v8BreakIterator);
+}
+catch {
+    hasV8BreakIterator = false;
+}
+class Platform {
+    constructor(_platformId) {
+        this._platformId = _platformId;
+        // Browser check.
+        this.isBrowser = this._platformId
+            ? isPlatformBrowser(this._platformId)
+            : typeof document === 'object' && !!document;
+        // Is checks.
+        this.isEdge = this.isBrowser && /(edge)/i.test(navigator.userAgent);
+        this.isTrident = this.isBrowser && /(msie|trident)/i.test(navigator.userAgent);
+        this.isBlink = this.isBrowser && (!!(window.chrome || hasV8BreakIterator) && typeof CSS !== 'undefined' && !this.isEdge && !this.isTrident);
+        this.isWebkit = this.isBrowser && /AppleWebKit/i.test(navigator.userAgent) && !this.isBlink && !this.isEdge && !this.isTrident;
+        this.isChrome = this.isBrowser && /Google Inc./.test(navigator.vendor);
+        this.isFirefox = this.isBrowser && /(firefox|minefield)/i.test(navigator.userAgent);
+        this.isSafari = this.isBrowser && /safari/i.test(navigator.userAgent) && this.isWebkit;
+        this.isAndroid = this.isBrowser && /android/i.test(navigator.userAgent) && !this.isTrident;
+        this.isIos = this.isBrowser && /iPad|iPhone|iPod/.test(navigator.userAgent) && !('MSStream' in window);
+        this.isDesktop = this.isBrowser && !(/(iPhone|iPod|iPad|Android|BlackBerry|IEMobile)/.test(navigator.userAgent));
+    }
+}
+Platform.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Platform, deps: [{ token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable });
+Platform.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Platform, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Platform, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; } });
+
+class FileLoader {
+    constructor() {
+        this.isFile = (input) => {
+            return 'File' in window && input instanceof File;
+        };
+        this.isBlob = (input) => {
+            return 'Blob' in window && input instanceof Blob;
+        };
+        this.blobToFile = (blob, fileName) => {
+            const anyBlob = blob;
+            anyBlob.lastModifiedDate = new Date();
+            anyBlob.name = fileName;
+            return anyBlob;
+        };
+    }
+    fromDataUrl(value, name = 'file') {
+        if (!value) {
+            return null;
+        }
+        try {
+            // Convert base64 to raw binary data held in a string.
+            const byteString = window.atob(value.split(',')[1]);
+            // Separate out the mime component.
+            const mimeString = value
+                .split(',')[0]
+                .split(':')[1]
+                .split(';')[0];
+            // Write the bytes of the string to an ArrayBuffer.
+            const arrayBuffer = new ArrayBuffer(byteString.length);
+            const uint8Array = new Uint8Array(arrayBuffer);
+            for (let index = 0; index < byteString.length; index++) {
+                uint8Array[index] = byteString.charCodeAt(index);
+            }
+            const dataView = new DataView(arrayBuffer);
+            const blob = new Blob([dataView.buffer], { type: mimeString });
+            return this.createFile(blob, name);
+        }
+        catch {
+            return null;
+        }
+    }
+    asDataUrl(file) {
+        return this.read(file, 'dataurl');
+    }
+    asArrayBuffer(file) {
+        return this.read(file, 'arraybuffer');
+    }
+    async read(file, type) {
+        return new Promise((resolve, reject) => {
+            const isFileLike = this.isFile(file) || this.isBlob(file);
+            if (!file || !isFileLike) {
+                return reject('Invalid file');
+            }
+            const reader = new FileReader();
+            reader.onerror = () => reject('Error file read');
+            reader.onabort = () => reject('Abort file read');
+            reader.onload = () => {
+                const result = reader.result;
+                return resolve(result);
+            };
+            if (type === 'dataurl') {
+                reader.readAsDataURL(file);
+            }
+            else if (type === 'arraybuffer') {
+                reader.readAsArrayBuffer(file);
+            }
+        });
+    }
+    createFile(blob, name) {
+        if (!navigator['msSaveBlob']) {
+            return new File([blob], name, { lastModified: Date.now(), type: blob?.type });
+        }
+        const blobFile = new Blob([blob], { type: blob?.type });
+        return this.blobToFile(blobFile, name);
+    }
+}
+FileLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: FileLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FileLoader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: FileLoader, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: FileLoader, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class Exif {
+    constructor(_platform, _fileLoader) {
+        this._platform = _platform;
+        this._fileLoader = _fileLoader;
+        this.transformImage = (image, type, orientation, quality = 100) => {
+            // Create the canvas and context.
+            const canvas = document.createElement('canvas');
+            const context = canvas.getContext('2d');
+            // Validate the context exists.
+            if (!context) {
+                return null;
+            }
+            // Set the canvas size based on the image.
+            const { width, height } = image;
+            canvas.width = width;
+            canvas.height = height;
+            // Validate the orientation is correct
+            // else flip the canvas sizes.
+            if (4 < orientation && orientation < 9) {
+                canvas.width = height;
+                canvas.height = width;
+            }
+            // Transform the context based on the orientation.
+            switch (orientation) {
+                case 2:
+                    context.transform(-1, 0, 0, 1, width, 0);
+                    break;
+                case 3:
+                    context.transform(-1, 0, 0, -1, width, height);
+                    break;
+                case 4:
+                    context.transform(1, 0, 0, -1, 0, height);
+                    break;
+                case 5:
+                    context.transform(0, 1, 1, 0, 0, 0);
+                    break;
+                case 6:
+                    context.transform(0, 1, -1, 0, height, 0);
+                    break;
+                case 7:
+                    context.transform(0, -1, -1, 0, height, width);
+                    break;
+                case 8:
+                    context.transform(0, -1, 1, 0, 0, width);
+                    break;
+                default:
+                    break;
+            }
+            // Draw the image on the context and return the data URL.
+            context.drawImage(image, 0, 0, width, height);
+            return canvas.toDataURL(type, quality / 100);
+        };
+        this.getSupportedCanvasType = (fileType) => {
+            switch (fileType) {
+                case 'image/jpeg':
+                case 'image/jpg':
+                    return 'image/jpeg';
+                case 'image/x-windows-bmp':
+                case 'image/bmp':
+                    return 'image/bmp';
+                default:
+                    return 'image/png';
+            }
+        };
+        this.getOrientation = (buffer) => {
+            // Create a new data view.
+            const view = new DataView(buffer);
+            if (view.getUint16(0, false) !== 0xFFD8) {
+                return -2;
+            }
+            const length = view.byteLength;
+            let offset = 2;
+            while (offset < length) {
+                if (view.getUint16(offset + 2, false) <= 8) {
+                    return -1;
+                }
+                const marker = view.getUint16(offset, false);
+                offset += 2;
+                if (marker === 0xFFE1) {
+                    if (view.getUint32(offset += 2, false) !== 0x45786966) {
+                        return -1;
+                    }
+                    const little = view.getUint16(offset += 6, false) === 0x4949;
+                    offset += view.getUint32(offset + 4, little);
+                    const tags = view.getUint16(offset, little);
+                    offset += 2;
+                    for (let index = 0; index < tags; index++) {
+                        if (view.getUint16(offset + index * 12, little) === 0x0112) {
+                            return view.getUint16(offset + index * 12 + 8, little);
+                        }
+                    }
+                }
+                else if ((marker & 0xFF00) !== 0xFF00) {
+                    break;
+                }
+                else {
+                    offset += view.getUint16(offset, false);
+                }
+            }
+            return -1;
+        };
+    }
+    async strip(file, quality = 100) {
+        // Validate we are on a browser.
+        if (!this._platform.isBrowser) {
+            return file;
+        }
+        // Validate the file exists and is
+        // an instance of a File object.
+        if (!file || !(file instanceof File)) {
+            return file;
+        }
+        // Only jpeg images need correction.
+        if (!['image/jpeg'].includes(file.type)) {
+            return file;
+        }
+        try {
+            // Read the file as an array buffer and data url.
+            const arrayBuffer = await this._fileLoader.asArrayBuffer(file);
+            const dataUrl = await this._fileLoader.asDataUrl(file);
+            // Create an image element.
+            const imageElement = await this.createImageElement(dataUrl);
+            // Get the orientation by using the buffer.
+            const orientation = this.getOrientation(arrayBuffer);
+            // Transform the image to remove the orientation.
+            const canvasType = this.getSupportedCanvasType(file.type);
+            const imageUrl = this.transformImage(imageElement, canvasType, orientation, quality);
+            // Validate the image url exists.
+            if (!imageUrl) {
+                return file;
+            }
+            // Transform the image url to a file.
+            return this._fileLoader.fromDataUrl(imageUrl, file.name);
+        }
+        catch {
+            // When something goes wrong we
+            // just return the default file.
+            return file;
+        }
+    }
+    async createImageElement(dataUrl) {
+        return new Promise((resolve, reject) => {
+            const image = new Image();
+            image.src = dataUrl;
+            image.onerror = () => reject('Error image create');
+            image.onabort = () => reject('Abort image create');
+            image.onload = () => resolve(image);
+        });
+    }
+}
+Exif.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Exif, deps: [{ token: Platform }, { token: FileLoader }], target: i0.ɵɵFactoryTarget.Injectable });
+Exif.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Exif, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Exif, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: Platform }, { type: FileLoader }]; } });
+
+class ImageConverter {
+    constructor(_exif, _platform, _fileLoader) {
+        this._exif = _exif;
+        this._platform = _platform;
+        this._fileLoader = _fileLoader;
+        // Data.
+        this._types = ['image/png', 'image/jpeg'];
+        this.calculateOffsetAndDimensions = (image, canvasWidth, canvasHeight) => {
+            const originalWidth = image.width;
+            const originalHeight = image.height;
+            const widthRatio = canvasWidth / originalWidth;
+            const heightRatio = canvasHeight / originalHeight;
+            let width;
+            let height;
+            if (originalWidth > originalHeight) {
+                height = originalHeight * heightRatio;
+                width = (originalWidth / originalHeight) * height;
+            }
+            else {
+                width = originalWidth * widthRatio;
+                height = (originalHeight / originalWidth) * width;
+            }
+            let xOffset = 0;
+            let yOffset = 0;
+            if (canvasHeight === height) {
+                xOffset = -((width - canvasWidth) / 2);
+            }
+            else if (canvasWidth === width) {
+                yOffset = -((height - canvasHeight) / 2);
+            }
+            return { xOffset, yOffset, width, height };
+        };
+    }
+    async toDataUri(contents, options = null) {
+        // Check if the current platform is a browser.
+        if (!this._platform.isBrowser) {
+            return null;
+        }
+        // Get the image.
+        const image = await this.getImage(contents);
+        // Get the canvas width and height.
+        const canvasWidth = options?.width || image?.width;
+        const canvasHeight = options?.height || image?.height;
+        // Get the canvas and context.
+        const canvas = document.createElement('canvas');
+        const context = canvas.getContext('2d');
+        // Validate the context exists.
+        if (!context) {
+            return null;
+        }
+        // Set the width and height.
+        canvas.width = canvasWidth;
+        canvas.height = canvasHeight;
+        // When the canvas sizes are 0 we have failed.
+        if (canvas?.width === 0 && canvas?.height === 0) {
+            return null;
+        }
+        // Check if dimensions where supplied, else create the image.
+        if (!options) {
+            // Draw the image.
+            context.drawImage(image, 0, 0);
+            // Convert the canvas to a data url.
+            return canvas.toDataURL(this._types[0]);
+        }
+        // Get the dimensions and offsets.
+        const { width, height, xOffset, yOffset } = this.calculateOffsetAndDimensions(image, canvasWidth, canvasHeight);
+        // Draw the image.
+        context.drawImage(image, 0, 0, image.width, image.height, xOffset, yOffset, width, height);
+        // Convert the canvas to a data url.
+        return canvas.toDataURL(this._types[0]);
+    }
+    async fileToImage(file, types = this._types) {
+        // Check if the file matches an image.
+        if (!types.includes(file.type)) {
+            throw new Error('The selected file does not meet the required format.');
+        }
+        let stripped = null;
+        try {
+            stripped = await this._exif.strip(file, 90);
+        }
+        catch {
+            // Do nothing.
+        }
+        // Ge the data uri.
+        const dataUri = await this._fileLoader.asDataUrl(stripped ?? file);
+        // Convert the data URI to a image element.
+        return await this.stringToImage(dataUri);
+    }
+    stringToImage(src) {
+        return new Promise((resolve, reject) => {
+            const image = new Image();
+            image.src = src;
+            image.onload = () => resolve(image);
+            image.onerror = error => reject(error);
+        });
+    }
+    async getImage(contents) {
+        // If the contents is already an HTML image element just return it.
+        if (contents instanceof HTMLImageElement) {
+            return contents;
+        }
+        // If the contents is a file convert it to an HTML image element.
+        if (contents instanceof File) {
+            return this.fileToImage(contents);
+        }
+        // If the contents is a string convert it to an HTML image element.
+        return this.stringToImage(contents);
+    }
+}
+ImageConverter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: ImageConverter, deps: [{ token: Exif }, { token: Platform }, { token: FileLoader }], target: i0.ɵɵFactoryTarget.Injectable });
+ImageConverter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: ImageConverter, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: ImageConverter, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: Exif }, { type: Platform }, { type: FileLoader }]; } });
+
+const ACCEPT_LANGUAGE = new InjectionToken('AcceptLanguage');
+
+class Languages {
+    constructor(_acceptLanguage) {
+        this._acceptLanguage = _acceptLanguage;
+        // Data.
+        this._data = [];
+        this.getLanguages = () => {
+            // If defined we must be in a server environment.
+            if (this._acceptLanguage) {
+                return this._acceptLanguage;
+            }
+            // Try to get the languages from the navigator.
+            if (typeof navigator !== 'object') {
+                return null;
+            }
+            let t = 'anguage';
+            let n = navigator;
+            let f = n['l' + t + 's'];
+            const data = f && f.length ? f : (t = n['l' + t] ||
+                n['browserL' + t] ||
+                n['userL' + t]) ? [t] : t;
+            return typeof data === 'string'
+                ? data
+                : data.join(';');
+        };
+        this._data = this.initialize();
+    }
+    get all() {
+        return this._data;
+    }
+    initialize() {
+        // Get the languages.
+        const data = this.getLanguages();
+        // Parse all languages by using a regex.
+        const strings = (data || '')
+            .match(/((([a-zA-Z]+(-[a-zA-Z0-9]+){0,2})|\*)(;q=[0-1](\.[0-9]+)?)?)*/g);
+        // Get the content by parsing the strings.
+        const content = strings.map(item => {
+            if (!item) {
+                return null;
+            }
+            const bits = item.split(';');
+            const ietf = bits[0].split('-');
+            const hasScript = ietf.length === 3;
+            return {
+                code: ietf[0],
+                script: hasScript ? ietf[1] : null,
+                region: hasScript ? ietf[2] : ietf[1],
+                quality: bits[1] ? parseFloat(bits[1].split('=')[1]) : 1.0
+            };
+        });
+        // Filter out all the empty items
+        // and sort them by the quality.
+        return content
+            .filter(item => !!item)
+            .sort((a, b) => b.quality - a.quality);
+    }
+}
+Languages.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Languages, deps: [{ token: ACCEPT_LANGUAGE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+Languages.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Languages, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Languages, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ACCEPT_LANGUAGE]
+                }] }]; } });
+
+const WINDOW = new InjectionToken('An abstraction over global window object', {
+    factory: () => {
+        const { defaultView } = inject(DOCUMENT);
+        if (!defaultView) {
+            throw new Error('Window is not available');
+        }
+        return defaultView;
+    }
+});
+
+const NAVIGATOR = new InjectionToken('An abstraction over window.navigator object', {
+    factory: () => inject(WINDOW).navigator
+});
+
+class Network {
+    constructor(_platform, _window, _navigator) {
+        this._platform = _platform;
+        this._window = _window;
+        this._navigator = _navigator;
+        // Data.
+        this._online$ = of(true);
+        this.getOnlineObservable();
+    }
+    online() {
+        return this._online$;
+    }
+    getOnlineObservable() {
+        // Validate we are on a browser.
+        if (!this._platform.isBrowser) {
+            return;
+        }
+        // Get all the events from the window.
+        const online$ = fromEvent(this._window, 'online').pipe(mapTo(true));
+        const offline$ = fromEvent(this._window, 'offline').pipe(mapTo(false));
+        const now$ = new Observable(subscriber => {
+            subscriber.next(this._navigator?.onLine);
+            subscriber.complete();
+        });
+        // Merge all event so we get notified when
+        // a user is online/offline.
+        this._online$ = merge(now$, online$, offline$).pipe(map(value => value), distinctUntilChanged(), shareReplay(1));
+    }
+}
+Network.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Network, deps: [{ token: Platform }, { token: WINDOW, optional: true }, { token: NAVIGATOR, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+Network.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Network, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Network, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: Platform }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [WINDOW]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [NAVIGATOR]
+                }] }]; } });
+
+class Patch {
+    constructor(_platform, _window, _document) {
+        this._platform = _platform;
+        this._window = _window;
+        this._document = _document;
+        this._hasPatchedMobileVerticalHeight = false;
+        // Subscriptions.
+        this._subscription = new Subscription();
+    }
+    mobileVerticalHeight() {
+        // Check if the user has already patched
+        // the mobile vertical height.
+        if (this._hasPatchedMobileVerticalHeight) {
+            return;
+        }
+        this.periodicallySetDocumentVerticalProperty();
+        this._hasPatchedMobileVerticalHeight = true;
+    }
+    ngOnDestroy() {
+        this._subscription?.unsubscribe();
+    }
+    periodicallySetDocumentVerticalProperty() {
+        // Validate we are using a browser.
+        if (!this._platform.isBrowser) {
+            return;
+        }
+        // Listen to a debounced window resize event.
+        const resize$ = fromEvent(this._window, 'resize').pipe(debounceTime(25), startWith(0));
+        // Subscribe to the resize observable.
+        const subscription = resize$.subscribe(() => {
+            const verticalHeight = this._window?.innerHeight * 0.01;
+            this._document?.documentElement?.style?.setProperty('--vh', `${verticalHeight}px`);
+        });
+        // Save the subscription so we can destroy it later.
+        this._subscription.add(subscription);
+    }
+}
+Patch.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Patch, deps: [{ token: Platform }, { token: WINDOW, optional: true }, { token: DOCUMENT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+Patch.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Patch, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Patch, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: Platform }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [WINDOW]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+
+class Clipboard {
+    constructor(_document) {
+        this._document = _document;
+    }
+    copy(text) {
+        const pendingCopy = this.beginCopy(text);
+        const successful = pendingCopy.copy();
+        pendingCopy.destroy();
+        return successful;
+    }
+    beginCopy(text) {
+        return new ClipboardCopy(text, this._document);
+    }
+}
+Clipboard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Clipboard, deps: [{ token: DOCUMENT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+Clipboard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Clipboard, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Clipboard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+class ClipboardCopy {
+    constructor(_text, _document) {
+        this._text = _text;
+        this._document = _document;
+        this.initialize();
+    }
+    copy() {
+        const textarea = this._textarea;
+        let successful = false;
+        try {
+            const currentFocus = this._document.activeElement;
+            textarea?.select?.();
+            textarea?.setSelectionRange?.(0, textarea?.value?.length);
+            successful = this._document?.execCommand?.('copy');
+            currentFocus?.focus?.();
+        }
+        catch {
+            // Do nothing.
+        }
+        return successful;
+    }
+    destroy() {
+        this._textarea?.parentNode?.removeChild?.(this._textarea);
+        this._textarea = undefined;
+    }
+    initialize() {
+        const textarea = this._textarea = this._document.createElement('textarea');
+        const styles = textarea.style;
+        // Hide the element for display and accessibility. Set a fixed position so the page layout
+        // isn't affected. We use `fixed` with `top: 0`, because focus is moved into the textarea
+        // for a split second and if it's off-screen, some browsers will attempt to scroll it into view.
+        styles.position = 'fixed';
+        styles.top = styles.opacity = '0';
+        styles.left = '-999em';
+        textarea.setAttribute('aria-hidden', 'true');
+        textarea.value = this._text;
+        this._document.body.appendChild(textarea);
+    }
+}
+
+function mixinDisabled(base) {
+    return class extends base {
+        constructor(...args) {
+            super(...args);
+            this._disable = false;
+        }
+        get disabled() {
+            return this._disable;
+        }
+        set disabled(value) {
+            this._disable = coerceBooleanProperty(value);
+        }
+    };
+}
+
+function mixinLoad(base) {
+    return class extends base {
+        constructor(...args) {
+            super(...args);
+            this._loading = false;
+        }
+        get loading() {
+            return this._loading;
+        }
+        set loading(value) {
+            this._loading = coerceBooleanProperty(value);
+        }
+    };
+}
+
+function mixinError(base) {
+    return class extends base {
+        constructor(...args) {
+            super(...args);
+            this._error = false;
+        }
+        get error() {
+            return this._error;
+        }
+        set error(value) {
+            this._error = coerceBooleanProperty(value);
+        }
+    };
+}
+
+function mixinHideErrors(base) {
+    return class extends base {
+        constructor(...args) {
+            super(...args);
+            this._hideErrors = false;
+        }
+        get hideErrors() {
+            return this._hideErrors;
+        }
+        set hideErrors(value) {
+            this._hideErrors = coerceBooleanProperty(value);
+        }
+    };
+}
+
+function mixinFocused(base) {
+    return class extends base {
+        constructor(...args) {
+            super(...args);
+            this._focused = false;
+        }
+        get focused() {
+            return this._focused;
+        }
+        set focused(value) {
+            this._focused = coerceBooleanProperty(value);
+        }
+    };
+}
+
+function mixinGrouped(base) {
+    return class extends base {
+        constructor(...args) {
+            super(...args);
+            this._grouped = false;
+        }
+        get grouped() {
+            return this._grouped;
+        }
+        set grouped(value) {
+            this._grouped = coerceBooleanProperty(value);
+        }
+    };
+}
+
+function mixinReadonly(base) {
+    return class extends base {
+        constructor(...args) {
+            super(...args);
+            this._readonly = false;
+        }
+        get readonly() {
+            return this._readonly;
+        }
+        set readonly(value) {
+            this._readonly = coerceBooleanProperty(value);
+        }
+    };
+}
+
+function mixinRequired(base) {
+    return class extends base {
+        constructor(...args) {
+            super(...args);
+            this._required = false;
+        }
+        get required() {
+            return this._required;
+        }
+        set required(value) {
+            this._required = coerceBooleanProperty(value);
+        }
+    };
+}
+
+const BASE_URL = new InjectionToken('BaseUrl');
+
+const COOKIE = new InjectionToken('Cookie');
+
+const LOCATION = new InjectionToken('An abstraction over window.location object', {
+    factory: () => inject(WINDOW).location
+});
+
+const BbRegex = {
+    email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
+    fullNumber: /^\d*[1-9]\d*$/
+};
+
+class BbValidator {
+    static email(control) {
+        if (isEmptyInputValue(control.value)) {
+            return null;
+        }
+        return BbRegex.email.test(control.value) ? null : { email: true };
+    }
+    static fullNumber(control) {
+        if (isEmptyInputValue(control.value)) {
+            return null;
+        }
+        return BbRegex.fullNumber.test(control.value) ? null : { fullNumber: true };
+    }
+    static maxFileSize(bytes) {
+        const validator = (control) => {
+            const value = control.value;
+            // Validate if the value is a file.
+            if (!(value instanceof File)) {
+                return null;
+            }
+            if (value.size <= bytes) {
+                return null;
+            }
+            let maxSize = '0 Bytes';
+            if (bytes !== 0) {
+                const k = 1024;
+                const dm = 2;
+                const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+                const index = Math.floor(Math.log(bytes) / Math.log(k));
+                maxSize = parseFloat((bytes / Math.pow(k, index)).toFixed(dm)) + ' ' + sizes[index];
+            }
+            return { maxFileSize: { maxSize } };
+        };
+        return validator;
+    }
+    static confirm(fieldName, error = 'confirm') {
+        const validator = (control) => {
+            if (isEmptyInputValue(control.value)) {
+                return null;
+            }
+            const field = control?.parent?.get(fieldName);
+            return control?.value === field?.value
+                ? null
+                : { [error]: true };
+        };
+        return validator;
+    }
+    static maxDate(date, error = 'maxDate') {
+        const formattedDate = date.toString() !== 'Invalid Date'
+            ? formatDate(date, 'yyyy-MM-dd', 'en-US')
+            : null;
+        const validator = (control) => {
+            if (isEmptyInputValue(control.value)) {
+                return null;
+            }
+            const controlDate = new Date(control.value);
+            return controlDate.getTime() > date.getTime()
+                ? { [error]: { date: formattedDate } }
+                : null;
+        };
+        return validator;
+    }
+    static minDate(date, error = 'minDate') {
+        const formattedDate = date.toString() !== 'Invalid Date'
+            ? formatDate(date, 'yyyy-MM-dd', 'en-US')
+            : null;
+        const validator = (control) => {
+            if (isEmptyInputValue(control.value)) {
+                return null;
+            }
+            const controlDate = new Date(control.value);
+            return controlDate.getTime() < date.getTime()
+                ? { [error]: { date: formattedDate } }
+                : null;
+        };
+        return validator;
+    }
+}
+function isEmptyInputValue(value) {
+    // We don't check for string here so it also works with arrays.
+    return value == null || value.length === 0;
+}
+
+/*
+ * Public API Surface of bb-foundation
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ACCEPT_LANGUAGE, BASE_URL, BbRegex, BbValidator, COOKIE, Clipboard, ClipboardCopy, Exif, FileLoader, ImageConverter, LOCATION, Languages, NAVIGATOR, Network, Patch, Platform, WINDOW, mixinDisabled, mixinError, mixinFocused, mixinGrouped, mixinHideErrors, mixinLoad, mixinReadonly, mixinRequired };
+//# sourceMappingURL=bravobit-bb-foundation.mjs.map