@formio/js 5.0.0-rc.5

package/lib/mjs/providers/address/GoogleAddressProvider.js

@@ -0,0 +1,110 @@
+/* globals google */
+import { Formio } from '../../Formio';
+import _ from 'lodash';
+import { AddressProvider } from './AddressProvider';
+import NativePromise from 'native-promise-only';
+export class GoogleAddressProvider extends AddressProvider {
+    static get name() {
+        return 'google';
+    }
+    static get displayName() {
+        return 'Google Maps';
+    }
+    constructor(options = {}) {
+        super(options);
+        this.setAutocompleteOptions();
+        let src = 'https://maps.googleapis.com/maps/api/js?v=quarterly&libraries=places&callback=googleMapsCallback';
+        if (options.params?.key) {
+            src += `&key=${options.params.key}`;
+        }
+        Formio.requireLibrary(this.getLibraryName(), 'google.maps.places', src);
+    }
+    get displayValueProperty() {
+        return 'formattedPlace';
+    }
+    get alternativeDisplayValueProperty() {
+        return 'formatted_address';
+    }
+    set autocompleteOptions(options) {
+        this._autocompleteOptions = options;
+    }
+    get autocompleteOptions() {
+        return this._autocompleteOptions;
+    }
+    setAutocompleteOptions() {
+        let options = _.get(this.options, 'params.autocompleteOptions', {});
+        if (!_.isObject(options)) {
+            options = {};
+        }
+        this.addRequiredProviderOptions(options);
+        this.autocompleteOptions = options;
+    }
+    beforeMergeOptions(options) {
+        // providing support of old Google Provider option
+        this.convertRegionToAutocompleteOption(options);
+    }
+    getLibraryName() {
+        return 'googleMaps';
+    }
+    convertRegionToAutocompleteOption(options) {
+        const providerOptions = options;
+        let region = _.get(providerOptions, 'params.region', '');
+        if (region && !_.has(options, 'params.autocompleteOptions')) {
+            region = region.toUpperCase().trim();
+            // providing compatibility with ISO 3166-1 Alpha-2 county codes (for checking compatibility https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes)
+            const countryCodes = { 'UK': 'GB' };
+            if (countryCodes[region]) {
+                region = countryCodes[region];
+            }
+            _.set(providerOptions, 'params.autocompleteOptions.componentRestrictions.country', [region]);
+        }
+    }
+    getRequiredAddressProperties() {
+        return ['address_components', 'formatted_address', 'geometry', 'place_id', 'plus_code', 'types'];
+    }
+    addRequiredProviderOptions(options) {
+        const addressProperties = this.getRequiredAddressProperties();
+        if (_.isArray(options.fields) && options.fields.length > 0) {
+            options.fields.forEach(optionalField => {
+                if (!addressProperties.some(addressProp => optionalField === addressProp)) {
+                    addressProperties.push(optionalField);
+                }
+            });
+        }
+        options.fields = addressProperties;
+    }
+    filterPlace(place) {
+        place = place || {};
+        const filteredPlace = {};
+        if (this.autocompleteOptions) {
+            this.autocompleteOptions.fields.forEach(field => {
+                if (place[field]) {
+                    filteredPlace[field] = place[field];
+                }
+            });
+        }
+        return filteredPlace;
+    }
+    attachAutocomplete(elem, index, onSelectAddress) {
+        Formio.libraryReady(this.getLibraryName()).then(() => {
+            const autocomplete = new google.maps.places.Autocomplete(elem, this.autocompleteOptions);
+            autocomplete.addListener('place_changed', () => {
+                const place = this.filterPlace(autocomplete.getPlace());
+                place.formattedPlace = _.get(autocomplete, 'gm_accessors_.place.se.formattedPrediction', place[this.alternativeDisplayValueProperty]);
+                onSelectAddress(place, elem, index);
+            });
+        });
+    }
+    search() {
+        return NativePromise.resolve();
+    }
+    makeRequest() {
+        return NativePromise.resolve();
+    }
+    getDisplayValue(address) {
+        const displayedProperty = _.has(address, this.displayValueProperty)
+            ? this.displayValueProperty
+            : this.alternativeDisplayValueProperty;
+        return _.get(address, displayedProperty, '');
+    }
+}

package/lib/mjs/providers/address/NominatimAddressProvider.d.ts

@@ -0,0 +1,11 @@
+export class NominatimAddressProvider extends AddressProvider {
+    get defaultOptions(): {
+        params: {
+            addressdetails: string;
+            format: string;
+        };
+    };
+    get displayValueProperty(): string;
+    getRequestUrl(options?: {}): string;
+}
+import { AddressProvider } from './AddressProvider';

package/lib/mjs/providers/address/NominatimAddressProvider.js

@@ -0,0 +1,27 @@
+import { AddressProvider } from './AddressProvider';
+export class NominatimAddressProvider extends AddressProvider {
+    static get name() {
+        return 'nominatim';
+    }
+    static get displayName() {
+        return 'OpenStreetMap Nominatim';
+    }
+    get defaultOptions() {
+        return {
+            params: {
+                addressdetails: '1',
+                format: 'json',
+            },
+        };
+    }
+    get queryProperty() {
+        return 'q';
+    }
+    get displayValueProperty() {
+        return 'display_name';
+    }
+    getRequestUrl(options = {}) {
+        const { params } = options;
+        return `https://nominatim.openstreetmap.org/search?${this.serialize(params)}`;
+    }
+}

package/lib/mjs/providers/address/index.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    [x: string]: typeof CustomAddressProvider | typeof GoogleAddressProvider;
+};
+export default _default;
+import { CustomAddressProvider } from './CustomAddressProvider';
+import { GoogleAddressProvider } from './GoogleAddressProvider';

package/lib/mjs/providers/address/index.js

@@ -0,0 +1,10 @@
+import { AzureAddressProvider } from './AzureAddressProvider';
+import { CustomAddressProvider } from './CustomAddressProvider';
+import { GoogleAddressProvider } from './GoogleAddressProvider';
+import { NominatimAddressProvider } from './NominatimAddressProvider';
+export default {
+    [AzureAddressProvider.name]: AzureAddressProvider,
+    [CustomAddressProvider.name]: CustomAddressProvider,
+    [GoogleAddressProvider.name]: GoogleAddressProvider,
+    [NominatimAddressProvider.name]: NominatimAddressProvider,
+};

package/lib/mjs/providers/auth/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/lib/mjs/providers/auth/index.js

@@ -0,0 +1 @@
+export default {};

package/lib/mjs/providers/index.d.ts

@@ -0,0 +1,2 @@
+export default Providers;
+import Providers from './Providers';

package/lib/mjs/providers/index.js

@@ -0,0 +1,2 @@
+import Providers from './Providers';
+export default Providers;

package/lib/mjs/providers/processor/fileProcessor.d.ts

@@ -0,0 +1,2 @@
+export default fileProcessor;
+declare function fileProcessor(formio: any, config: any): (file: any, options: any) => any;

package/lib/mjs/providers/processor/fileProcessor.js

@@ -0,0 +1,39 @@
+import NativePromise from 'native-promise-only';
+const fileProcessor = (formio, config) => (file, options) => new NativePromise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    // Fire on network error.
+    xhr.onerror = (err) => {
+        err.networkError = true;
+        reject(err);
+    };
+    // Fire on network abort.
+    xhr.onabort = (err) => {
+        err.networkError = true;
+        reject(err);
+    };
+    // Fired when the response has made it back from the server.
+    xhr.onload = () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+            const mimetype = xhr.getResponseHeader('Content-Type') || file.type;
+            resolve(new File([xhr.response], file.name, { type: mimetype }));
+        }
+        else {
+            reject(xhr.response || 'Unable to process file');
+        }
+    };
+    // Set the onabort error callback.
+    xhr.onabort = reject;
+    xhr.open('POST', config.url);
+    const token = formio.getToken();
+    if (token) {
+        xhr.setRequestHeader('x-jwt-token', token);
+    }
+    xhr.responseType = 'arraybuffer';
+    const data = new FormData();
+    data.append('file', file);
+    data.append('processorOptions', JSON.stringify(config.options || {}));
+    data.append('options', JSON.stringify(options || {}));
+    // Get the request and send it to the server.
+    xhr.send(data);
+});
+export default fileProcessor;

package/lib/mjs/providers/storage/azure.d.ts

@@ -0,0 +1,8 @@
+export default azure;
+declare function azure(formio: any): {
+    uploadFile(file: any, fileName: any, dir: any, progressCallback: any, url: any, options: any, fileKey: any, groupPermissions: any, groupId: any, abortCallback: any): any;
+    downloadFile(file: any): any;
+};
+declare namespace azure {
+    const title: string;
+}

package/lib/mjs/providers/storage/azure.js

@@ -0,0 +1,25 @@
+import XHR from './xhr';
+const azure = (formio) => ({
+    uploadFile(file, fileName, dir, progressCallback, url, options, fileKey, groupPermissions, groupId, abortCallback) {
+        return XHR.upload(formio, 'azure', (xhr, response) => {
+            xhr.openAndSetHeaders('PUT', response.url);
+            xhr.setRequestHeader('Content-Type', file.type);
+            xhr.setRequestHeader('x-ms-blob-type', 'BlockBlob');
+            return file;
+        }, file, fileName, dir, progressCallback, groupPermissions, groupId, abortCallback).then(() => {
+            return {
+                storage: 'azure',
+                name: XHR.path([dir, fileName]),
+                size: file.size,
+                type: file.type,
+                groupPermissions,
+                groupId
+            };
+        });
+    },
+    downloadFile(file) {
+        return formio.makeRequest('file', `${formio.formUrl}/storage/azure?name=${XHR.trim(file.name)}`, 'GET');
+    }
+});
+azure.title = 'Azure File Services';
+export default azure;

package/lib/mjs/providers/storage/base64.d.ts

@@ -0,0 +1,10 @@
+export default base64;
+declare function base64(): {
+    title: string;
+    name: string;
+    uploadFile(file: any, fileName: any): any;
+    downloadFile(file: any): any;
+};
+declare namespace base64 {
+    const title: string;
+}

package/lib/mjs/providers/storage/base64.js

@@ -0,0 +1,30 @@
+import NativePromise from 'native-promise-only';
+const base64 = () => ({
+    title: 'Base64',
+    name: 'base64',
+    uploadFile(file, fileName) {
+        const reader = new FileReader();
+        return new NativePromise((resolve, reject) => {
+            reader.onload = (event) => {
+                const url = event.target.result;
+                resolve({
+                    storage: 'base64',
+                    name: fileName,
+                    url: url,
+                    size: file.size,
+                    type: file.type,
+                });
+            };
+            reader.onerror = () => {
+                return reject(this);
+            };
+            reader.readAsDataURL(file);
+        });
+    },
+    downloadFile(file) {
+        // Return the original as there is nothing to do.
+        return NativePromise.resolve(file);
+    }
+});
+base64.title = 'Base64';
+export default base64;

package/lib/mjs/providers/storage/dropbox.d.ts

@@ -0,0 +1,8 @@
+export default dropbox;
+declare function dropbox(formio: any): {
+    uploadFile(file: any, fileName: any, dir: any, progressCallback: any, url: any, options: any, fileKey: any, groupPermissions: any, groupId: any, abortCallback: any): any;
+    downloadFile(file: any): any;
+};
+declare namespace dropbox {
+    const title: string;
+}

package/lib/mjs/providers/storage/dropbox.js

@@ -0,0 +1,56 @@
+import NativePromise from 'native-promise-only';
+import { setXhrHeaders } from './xhr';
+const dropbox = (formio) => ({
+    uploadFile(file, fileName, dir, progressCallback, url, options, fileKey, groupPermissions, groupId, abortCallback) {
+        return new NativePromise(((resolve, reject) => {
+            // Send the file with data.
+            const xhr = new XMLHttpRequest();
+            if (typeof progressCallback === 'function') {
+                xhr.upload.onprogress = progressCallback;
+            }
+            if (typeof abortCallback === 'function') {
+                abortCallback(() => xhr.abort());
+            }
+            const fd = new FormData();
+            fd.append('name', fileName);
+            fd.append('dir', dir);
+            fd.append('file', file);
+            // Fire on network error.
+            xhr.onerror = (err) => {
+                err.networkError = true;
+                reject(err);
+            };
+            xhr.onload = () => {
+                if (xhr.status >= 200 && xhr.status < 300) {
+                    const response = JSON.parse(xhr.response);
+                    response.storage = 'dropbox';
+                    response.size = file.size;
+                    response.type = file.type;
+                    response.groupId = groupId;
+                    response.groupPermissions = groupPermissions;
+                    response.url = response.path_lower;
+                    resolve(response);
+                }
+                else {
+                    reject(xhr.response || 'Unable to upload file');
+                }
+            };
+            xhr.onabort = reject;
+            xhr.open('POST', `${formio.formUrl}/storage/dropbox`);
+            setXhrHeaders(formio, xhr);
+            const token = formio.getToken();
+            if (token) {
+                xhr.setRequestHeader('x-jwt-token', token);
+            }
+            xhr.send(fd);
+        }));
+    },
+    downloadFile(file) {
+        const token = formio.getToken();
+        file.url =
+            `${formio.formUrl}/storage/dropbox?path_lower=${file.path_lower}${token ? `&x-jwt-token=${token}` : ''}`;
+        return NativePromise.resolve(file);
+    }
+});
+dropbox.title = 'Dropbox';
+export default dropbox;

package/lib/mjs/providers/storage/googleDrive.d.ts

@@ -0,0 +1,8 @@
+export default googledrive;
+declare function googledrive(formio: any): {
+    uploadFile(file: any, fileName: any, dir: any, progressCallback: any, url: any, options: any, fileKey: any, groupPermissions: any, groupId: any, abortCallback: any): any;
+    downloadFile(file: any): any;
+};
+declare namespace googledrive {
+    const title: string;
+}

package/lib/mjs/providers/storage/googleDrive.js

@@ -0,0 +1,55 @@
+import NativePromise from 'native-promise-only';
+import { setXhrHeaders } from './xhr';
+const googledrive = (formio) => ({
+    uploadFile(file, fileName, dir, progressCallback, url, options, fileKey, groupPermissions, groupId, abortCallback) {
+        return new NativePromise(((resolve, reject) => {
+            // Send the file with data.
+            const xhr = new XMLHttpRequest();
+            if (typeof progressCallback === 'function') {
+                xhr.upload.onprogress = progressCallback;
+            }
+            if (typeof abortCallback === 'function') {
+                abortCallback(() => xhr.abort());
+            }
+            const fd = new FormData();
+            fd.append('name', fileName);
+            fd.append('dir', dir);
+            fd.append('file', file);
+            // Fire on network error.
+            xhr.onerror = (err) => {
+                err.networkError = true;
+                reject(err);
+            };
+            xhr.onload = () => {
+                if (xhr.status >= 200 && xhr.status < 300) {
+                    const response = JSON.parse(xhr.response);
+                    response.storage = 'googledrive';
+                    response.size = file.size;
+                    response.type = file.type;
+                    response.groupId = groupId;
+                    response.groupPermissions = groupPermissions;
+                    resolve(response);
+                }
+                else {
+                    reject(xhr.response || 'Unable to upload file');
+                }
+            };
+            xhr.onabort = reject;
+            xhr.open('POST', `${formio.formUrl}/storage/gdrive`);
+            setXhrHeaders(formio, xhr);
+            const token = formio.getToken();
+            if (token) {
+                xhr.setRequestHeader('x-jwt-token', token);
+            }
+            xhr.send(fd);
+        }));
+    },
+    downloadFile(file) {
+        const token = formio.getToken();
+        file.url =
+            `${formio.formUrl}/storage/gdrive?fileId=${file.id}&fileName=${file.originalName}${token ? `&x-jwt-token=${token}` : ''}`;
+        return NativePromise.resolve(file);
+    }
+});
+googledrive.title = 'Google Drive';
+export default googledrive;

package/lib/mjs/providers/storage/index.d.ts

@@ -0,0 +1,15 @@
+declare namespace _default {
+    export { base64 };
+    export { s3 };
+    export { url };
+    export { azure };
+    export { indexeddb };
+    export { googledrive };
+}
+export default _default;
+import base64 from './base64';
+import s3 from './s3';
+import url from './url';
+import azure from './azure';
+import indexeddb from './indexeddb';
+import googledrive from './googleDrive';

package/lib/mjs/providers/storage/index.js

@@ -0,0 +1,14 @@
+import base64 from './base64';
+import s3 from './s3';
+import azure from './azure';
+import url from './url';
+import indexeddb from './indexeddb';
+import googledrive from './googleDrive';
+export default {
+    base64,
+    s3,
+    url,
+    azure,
+    indexeddb,
+    googledrive
+};

package/lib/mjs/providers/storage/indexeddb.d.ts

@@ -0,0 +1,11 @@
+export default indexeddb;
+declare function indexeddb(): {
+    title: string;
+    name: string;
+    uploadFile(file: any, fileName: any, dir: any, progressCallback: any, url: any, options: any): any;
+    downloadFile(file: any, options: any): any;
+    deleteFile(file: any, options: any): any;
+};
+declare namespace indexeddb {
+    const title: string;
+}

package/lib/mjs/providers/storage/indexeddb.js

@@ -0,0 +1,119 @@
+import { v4 as uuidv4 } from 'uuid';
+import NativePromise from 'native-promise-only';
+const indexeddb = () => ({
+    title: 'indexedDB',
+    name: 'indexeddb',
+    uploadFile(file, fileName, dir, progressCallback, url, options) {
+        if (!('indexedDB' in window)) {
+            console.log('This browser doesn\'t support IndexedDB');
+            return;
+        }
+        return new NativePromise((resolve) => {
+            const request = indexedDB.open(options.indexeddb, 3);
+            request.onsuccess = function (event) {
+                const db = event.target.result;
+                resolve(db);
+            };
+            request.onupgradeneeded = function (e) {
+                const db = e.target.result;
+                db.createObjectStore(options.indexeddbTable);
+            };
+        }).then((db) => {
+            const reader = new FileReader();
+            return new NativePromise((resolve, reject) => {
+                reader.onload = () => {
+                    const blobObject = new Blob([file], { type: file.type });
+                    const id = uuidv4(blobObject);
+                    const data = {
+                        id,
+                        data: blobObject,
+                        name: file.name,
+                        size: file.size,
+                        type: file.type,
+                        url,
+                    };
+                    const trans = db.transaction([options.indexeddbTable], 'readwrite');
+                    const addReq = trans.objectStore(options.indexeddbTable).put(data, id);
+                    addReq.onerror = function (e) {
+                        console.log('error storing data');
+                        console.error(e);
+                    };
+                    trans.oncomplete = function () {
+                        resolve({
+                            storage: 'indexeddb',
+                            name: file.name,
+                            size: file.size,
+                            type: file.type,
+                            url: url,
+                            id,
+                        });
+                    };
+                };
+                reader.onerror = () => {
+                    return reject(this);
+                };
+                reader.readAsDataURL(file);
+            });
+        });
+    },
+    downloadFile(file, options) {
+        return new NativePromise((resolve) => {
+            const request = indexedDB.open(options.indexeddb, 3);
+            request.onsuccess = function (event) {
+                const db = event.target.result;
+                resolve(db);
+            };
+        }).then((db) => {
+            return new NativePromise((resolve, reject) => {
+                const trans = db.transaction([options.indexeddbTable], 'readonly');
+                const store = trans.objectStore(options.indexeddbTable).get(file.id);
+                store.onsuccess = () => {
+                    trans.oncomplete = () => {
+                        const result = store.result;
+                        const dbFile = new File([store.result.data], file.name, {
+                            type: store.result.type,
+                        });
+                        const reader = new FileReader();
+                        reader.onload = (event) => {
+                            result.url = event.target.result;
+                            result.storage = file.storage;
+                            resolve(result);
+                        };
+                        reader.onerror = () => {
+                            return reject(this);
+                        };
+                        reader.readAsDataURL(dbFile);
+                    };
+                };
+                store.onerror = () => {
+                    return reject(this);
+                };
+            });
+        });
+    },
+    deleteFile(file, options) {
+        return new NativePromise((resolve) => {
+            const request = indexedDB.open(options.indexeddb, 3);
+            request.onsuccess = function (event) {
+                const db = event.target.result;
+                resolve(db);
+            };
+        }).then((db) => {
+            return new NativePromise((resolve, reject) => {
+                const trans = db.transaction([options.indexeddbTable], 'readwrite');
+                const store = trans.objectStore(options.indexeddbTable).delete(file.id);
+                store.onsuccess = () => {
+                    trans.oncomplete = () => {
+                        const result = store.result;
+                        resolve(result);
+                    };
+                };
+                store.onerror = () => {
+                    return reject(this);
+                };
+            });
+        });
+    }
+});
+indexeddb.title = 'IndexedDB';
+export default indexeddb;

package/lib/mjs/providers/storage/s3.d.ts

@@ -0,0 +1,8 @@
+export default s3;
+declare function s3(formio: any): {
+    uploadFile(file: any, fileName: any, dir: any, progressCallback: any, url: any, options: any, fileKey: any, groupPermissions: any, groupId: any, abortCallback: any): any;
+    downloadFile(file: any): any;
+};
+declare namespace s3 {
+    const title: string;
+}

package/lib/mjs/providers/storage/s3.js

@@ -0,0 +1,45 @@
+import NativePromise from 'native-promise-only';
+import XHR from './xhr';
+const s3 = (formio) => ({
+    uploadFile(file, fileName, dir, progressCallback, url, options, fileKey, groupPermissions, groupId, abortCallback) {
+        return XHR.upload(formio, 's3', (xhr, response) => {
+            response.data.fileName = fileName;
+            response.data.key = XHR.path([response.data.key, dir, fileName]);
+            if (response.signed) {
+                xhr.openAndSetHeaders('PUT', response.signed);
+                xhr.setRequestHeader('Content-Type', file.type);
+                return file;
+            }
+            else {
+                const fd = new FormData();
+                for (const key in response.data) {
+                    fd.append(key, response.data[key]);
+                }
+                fd.append('file', file);
+                xhr.openAndSetHeaders('POST', response.url);
+                return fd;
+            }
+        }, file, fileName, dir, progressCallback, groupPermissions, groupId, abortCallback).then((response) => {
+            return {
+                storage: 's3',
+                name: fileName,
+                bucket: response.bucket,
+                key: response.data.key,
+                url: XHR.path([response.url, response.data.key]),
+                acl: response.data.acl,
+                size: file.size,
+                type: file.type
+            };
+        });
+    },
+    downloadFile(file) {
+        if (file.acl !== 'public-read') {
+            return formio.makeRequest('file', `${formio.formUrl}/storage/s3?bucket=${XHR.trim(file.bucket)}&key=${XHR.trim(file.key)}`, 'GET');
+        }
+        else {
+            return NativePromise.resolve(file);
+        }
+    }
+});
+s3.title = 'S3';
+export default s3;

package/lib/mjs/providers/storage/uploadAdapter.d.ts

@@ -0,0 +1 @@
+export function getFormioUploadAdapterPlugin(fileService: any, component: any): (editor: any) => void;