@formio/js 5.0.0-rc.5

package/lib/cjs/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/cjs/providers/storage/s3.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const native_promise_only_1 = __importDefault(require("native-promise-only"));
+const xhr_1 = __importDefault(require("./xhr"));
+const s3 = (formio) => ({
+    uploadFile(file, fileName, dir, progressCallback, url, options, fileKey, groupPermissions, groupId, abortCallback) {
+        return xhr_1.default.upload(formio, 's3', (xhr, response) => {
+            response.data.fileName = fileName;
+            response.data.key = xhr_1.default.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_1.default.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_1.default.trim(file.bucket)}&key=${xhr_1.default.trim(file.key)}`, 'GET');
+        }
+        else {
+            return native_promise_only_1.default.resolve(file);
+        }
+    }
+});
+s3.title = 'S3';
+exports.default = s3;

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

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

package/lib/cjs/providers/storage/uploadAdapter.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFormioUploadAdapterPlugin = void 0;
+const utils_1 = require("../../utils/utils");
+const native_promise_only_1 = __importDefault(require("native-promise-only"));
+/**
+ * UploadAdapter for CKEditor https://ckeditor.com/docs/ckeditor5/latest/framework/guides/deep-dive/upload-adapter.html
+ */
+class FormioUploadAdapter {
+    constructor(loader, fileService, component) {
+        this.loader = loader;
+        this.fileService = fileService;
+        this.component = component;
+    }
+    upload() {
+        return this.loader.file
+            .then(file => new native_promise_only_1.default((resolve, reject) => {
+            const { uploadStorage, uploadUrl, uploadOptions, uploadDir, fileKey } = this.component.component;
+            const uploadParams = [
+                uploadStorage,
+                file,
+                (0, utils_1.uniqueName)(file.name),
+                uploadDir || '',
+                (evt) => this.onUploadProgress(evt),
+                uploadUrl,
+                uploadOptions,
+                fileKey,
+                null,
+                null
+            ];
+            const uploadPromise = this.fileService.uploadFile(...uploadParams, () => this.component.emit('fileUploadingStart', uploadPromise)).then((result) => {
+                return this.fileService.downloadFile(result);
+            }).then((result) => {
+                return resolve({
+                    default: result.url
+                });
+            }).catch((err) => {
+                console.warn('An Error occured while uploading file', err);
+                reject(err);
+            }).finally(() => {
+                this.component.emit('fileUploadingEnd', uploadPromise);
+            });
+        }));
+    }
+    abort() { }
+    onUploadProgress(evt) {
+        if (evt.lengthComputable) {
+            this.loader.uploadTotal = evt.total;
+            this.loader.uploaded = evt.loaded;
+        }
+    }
+}
+const getFormioUploadAdapterPlugin = (fileService, component) => (editor) => {
+    editor.plugins.get('FileRepository').createUploadAdapter = (loader) => {
+        return new FormioUploadAdapter(loader, fileService, component);
+    };
+};
+exports.getFormioUploadAdapterPlugin = getFormioUploadAdapterPlugin;

package/lib/cjs/providers/storage/url.d.ts

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

package/lib/cjs/providers/storage/url.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const native_promise_only_1 = __importDefault(require("native-promise-only"));
+const url = (formio) => {
+    const xhrRequest = (url, name, query, data, options, progressCallback, abortCallback) => {
+        return new native_promise_only_1.default((resolve, reject) => {
+            const xhr = new XMLHttpRequest();
+            const json = (typeof data === 'string');
+            const fd = new FormData();
+            if (typeof progressCallback === 'function') {
+                xhr.upload.onprogress = progressCallback;
+            }
+            if (typeof abortCallback === 'function') {
+                abortCallback(() => xhr.abort());
+            }
+            if (!json) {
+                for (const key in data) {
+                    fd.append(key, data[key]);
+                }
+            }
+            xhr.onload = () => {
+                if (xhr.status >= 200 && xhr.status < 300) {
+                    // Need to test if xhr.response is decoded or not.
+                    let respData = {};
+                    try {
+                        respData = (typeof xhr.response === 'string') ? JSON.parse(xhr.response) : {};
+                        respData = (respData && respData.data) ? respData.data : respData;
+                    }
+                    catch (err) {
+                        respData = {};
+                    }
+                    // Get the url of the file.
+                    let respUrl = respData.hasOwnProperty('url') ? respData.url : `${xhr.responseURL}/${name}`;
+                    // If they provide relative url, then prepend the url.
+                    if (respUrl && respUrl[0] === '/') {
+                        respUrl = `${url}${respUrl}`;
+                    }
+                    resolve({ url: respUrl, data: respData });
+                }
+                else {
+                    reject(xhr.response || 'Unable to upload file');
+                }
+            };
+            xhr.onerror = () => reject(xhr);
+            xhr.onabort = () => reject(xhr);
+            let requestUrl = url + (url.indexOf('?') > -1 ? '&' : '?');
+            for (const key in query) {
+                requestUrl += `${key}=${query[key]}&`;
+            }
+            if (requestUrl[requestUrl.length - 1] === '&') {
+                requestUrl = requestUrl.substr(0, requestUrl.length - 1);
+            }
+            xhr.open('POST', requestUrl);
+            if (json) {
+                xhr.setRequestHeader('Content-Type', 'application/json');
+            }
+            const token = formio.getToken();
+            if (token) {
+                xhr.setRequestHeader('x-jwt-token', token);
+            }
+            //Overrides previous request props
+            if (options) {
+                const parsedOptions = typeof options === 'string' ? JSON.parse(options) : options;
+                for (const prop in parsedOptions) {
+                    xhr[prop] = parsedOptions[prop];
+                }
+            }
+            xhr.send(json ? data : fd);
+        });
+    };
+    return {
+        title: 'Url',
+        name: 'url',
+        uploadFile(file, name, dir, progressCallback, url, options, fileKey, groupPermissions, groupId, abortCallback) {
+            const uploadRequest = function (form) {
+                return xhrRequest(url, name, {
+                    baseUrl: encodeURIComponent(formio.projectUrl),
+                    project: form ? form.project : '',
+                    form: form ? form._id : ''
+                }, {
+                    [fileKey]: file,
+                    name,
+                    dir
+                }, options, progressCallback, abortCallback).then(response => {
+                    // Store the project and form url along with the metadata.
+                    response.data = response.data || {};
+                    response.data.baseUrl = formio.projectUrl;
+                    response.data.project = form ? form.project : '';
+                    response.data.form = form ? form._id : '';
+                    return {
+                        storage: 'url',
+                        name,
+                        url: response.url,
+                        size: file.size,
+                        type: file.type,
+                        data: response.data
+                    };
+                });
+            };
+            if (file.private && formio.formId) {
+                return formio.loadForm().then((form) => uploadRequest(form));
+            }
+            else {
+                return uploadRequest();
+            }
+        },
+        deleteFile(fileInfo) {
+            return new native_promise_only_1.default((resolve, reject) => {
+                const xhr = new XMLHttpRequest();
+                xhr.open('DELETE', fileInfo.url, true);
+                xhr.onload = () => {
+                    if (xhr.status >= 200 && xhr.status < 300) {
+                        resolve('File deleted');
+                    }
+                    else {
+                        reject(xhr.response || 'Unable to delete file');
+                    }
+                };
+                xhr.send(null);
+            });
+        },
+        downloadFile(file) {
+            if (file.private) {
+                if (formio.submissionId && file.data) {
+                    file.data.submission = formio.submissionId;
+                }
+                return xhrRequest(file.url, file.name, {}, JSON.stringify(file)).then(response => response.data);
+            }
+            // Return the original as there is nothing to do.
+            return native_promise_only_1.default.resolve(file);
+        }
+    };
+};
+url.title = 'Url';
+exports.default = url;

package/lib/cjs/providers/storage/xhr.d.ts

@@ -0,0 +1,7 @@
+export function setXhrHeaders(formio: any, xhr: any): void;
+export default XHR;
+declare namespace XHR {
+    function trim(text: any): any;
+    function path(items: any): any;
+    function upload(formio: any, type: any, xhrCb: any, file: any, fileName: any, dir: any, progressCallback: any, groupPermissions: any, groupId: any, abortCallback: any): any;
+}

package/lib/cjs/providers/storage/xhr.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setXhrHeaders = void 0;
+const native_promise_only_1 = __importDefault(require("native-promise-only"));
+const trim_1 = __importDefault(require("lodash/trim"));
+const setXhrHeaders = (formio, xhr) => {
+    const { headers } = formio.options;
+    if (headers) {
+        const ValidHeaders = {
+            'Content-Disposition': true,
+            'Authorization': true,
+        };
+        for (const header in headers) {
+            if (ValidHeaders[header]) {
+                xhr.setRequestHeader(header, headers[header]);
+            }
+        }
+    }
+};
+exports.setXhrHeaders = setXhrHeaders;
+const XHR = {
+    trim(text) {
+        return (0, trim_1.default)(text, '/');
+    },
+    path(items) {
+        return items.filter(item => !!item).map(XHR.trim).join('/');
+    },
+    upload(formio, type, xhrCb, file, fileName, dir, progressCallback, groupPermissions, groupId, abortCallback) {
+        return new native_promise_only_1.default(((resolve, reject) => {
+            // Send the pre response to sign the upload.
+            const pre = new XMLHttpRequest();
+            // This only fires on a network error.
+            pre.onerror = (err) => {
+                err.networkError = true;
+                reject(err);
+            };
+            pre.onabort = reject;
+            pre.onload = () => {
+                if (pre.status >= 200 && pre.status < 300) {
+                    const response = JSON.parse(pre.response);
+                    // Send the file with data.
+                    const xhr = new XMLHttpRequest();
+                    if (typeof progressCallback === 'function') {
+                        xhr.upload.onprogress = progressCallback;
+                    }
+                    if (typeof abortCallback === 'function') {
+                        abortCallback(() => xhr.abort());
+                    }
+                    xhr.openAndSetHeaders = (...params) => {
+                        xhr.open(...params);
+                        (0, exports.setXhrHeaders)(formio, xhr);
+                    };
+                    // 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) {
+                            resolve(response);
+                        }
+                        else {
+                            reject(xhr.response || 'Unable to upload file');
+                        }
+                    };
+                    // Set the onabort error callback.
+                    xhr.onabort = reject;
+                    // Get the request and send it to the server.
+                    xhr.send(xhrCb(xhr, response));
+                }
+                else {
+                    reject(pre.response || 'Unable to sign file');
+                }
+            };
+            pre.open('POST', `${formio.formUrl}/storage/${type}`);
+            pre.setRequestHeader('Accept', 'application/json');
+            pre.setRequestHeader('Content-Type', 'application/json; charset=UTF-8');
+            const token = formio.getToken();
+            if (token) {
+                pre.setRequestHeader('x-jwt-token', token);
+            }
+            pre.send(JSON.stringify({
+                name: XHR.path([dir, fileName]),
+                size: file.size,
+                type: file.type,
+                groupPermissions,
+                groupId,
+            }));
+        }));
+    }
+};
+exports.default = XHR;

package/lib/cjs/templates/Templates.d.ts

@@ -0,0 +1,11 @@
+export default class Templates {
+    static get templates(): any;
+    static addTemplate(name: any, template: any): void;
+    static extendTemplate(name: any, template: any): void;
+    static setTemplate(name: any, template: any): void;
+    static set current(arg: any);
+    static get current(): any;
+    static get defaultTemplates(): any;
+    static set framework(arg: any);
+    static get framework(): any;
+}

package/lib/cjs/templates/Templates.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+const lodash_1 = __importDefault(require("lodash"));
+class Templates {
+    static get templates() {
+        if (!Templates._templates) {
+            Templates._templates = index_1.default;
+        }
+        return Templates._templates;
+    }
+    static addTemplate(name, template) {
+        Templates.templates[name] = template;
+    }
+    static extendTemplate(name, template) {
+        Templates.templates[name] = lodash_1.default.merge({}, Templates.templates[name], template);
+    }
+    static setTemplate(name, template) {
+        Templates.addTemplate(name, template);
+    }
+    static set current(templates) {
+        const defaultTemplates = Templates.current;
+        Templates._current = lodash_1.default.merge({}, defaultTemplates, templates);
+    }
+    static get current() {
+        if (Templates._current) {
+            return Templates._current;
+        }
+        return Templates.defaultTemplates;
+    }
+    static get defaultTemplates() {
+        return Templates.templates.bootstrap;
+    }
+    static set framework(framework) {
+        if (Templates.templates.hasOwnProperty(framework)) {
+            Templates._framework = framework;
+            Templates._current = Templates.templates[framework];
+        }
+    }
+    static get framework() {
+        return Templates._framework;
+    }
+}
+exports.default = Templates;

package/lib/cjs/templates/index.d.ts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    const bootstrap: any;
+}
+export default _default;

package/lib/cjs/templates/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const bootstrap5_1 = __importDefault(require("@formio/bootstrap/bootstrap5"));
+exports.default = {
+    bootstrap: bootstrap5_1.default.templates.bootstrap5
+};

package/lib/cjs/translations/en.d.ts

@@ -0,0 +1,66 @@
+declare namespace _default {
+    const unsavedRowsError: string;
+    const invalidRowsError: string;
+    const invalidRowError: string;
+    const alertMessageWithLabel: string;
+    const alertMessage: string;
+    const complete: string;
+    const error: string;
+    const errorListHotkey: string;
+    const errorsListNavigationMessage: string;
+    const submitError: string;
+    const required: string;
+    const unique: string;
+    const array: string;
+    const array_nonempty: string;
+    const nonarray: string;
+    const select: string;
+    const pattern: string;
+    const minLength: string;
+    const maxLength: string;
+    const minWords: string;
+    const maxWords: string;
+    const min: string;
+    const max: string;
+    const maxDate: string;
+    const minDate: string;
+    const maxYear: string;
+    const minYear: string;
+    const invalid_email: string;
+    const invalid_url: string;
+    const invalid_regex: string;
+    const invalid_date: string;
+    const invalid_day: string;
+    const mask: string;
+    const valueIsNotAvailable: string;
+    const stripe: string;
+    const month: string;
+    const day: string;
+    const year: string;
+    const january: string;
+    const february: string;
+    const march: string;
+    const april: string;
+    const may: string;
+    const june: string;
+    const july: string;
+    const august: string;
+    const september: string;
+    const october: string;
+    const november: string;
+    const december: string;
+    const next: string;
+    const previous: string;
+    const cancel: string;
+    const submit: string;
+    const confirmCancel: string;
+    const saveDraftInstanceError: string;
+    const saveDraftAuthError: string;
+    const restoreDraftInstanceError: string;
+    const time: string;
+    const cancelButtonAriaLabel: string;
+    const previousButtonAriaLabel: string;
+    const nextButtonAriaLabel: string;
+    const submitButtonAriaLabel: string;
+}
+export default _default;

package/lib/cjs/translations/en.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    unsavedRowsError: 'Please save all rows before proceeding.',
+    invalidRowsError: 'Please correct invalid rows before proceeding.',
+    invalidRowError: 'Invalid row. Please correct it or delete.',
+    alertMessageWithLabel: '{{label}}: {{message}}',
+    alertMessage: '{{message}}',
+    complete: 'Submission Complete',
+    error: 'Please fix the following errors before submitting.',
+    errorListHotkey: 'Press Ctrl + Alt + X to go back to the error list.',
+    errorsListNavigationMessage: 'Click to navigate to the field with following error.',
+    submitError: 'Please check the form and correct all errors before submitting.',
+    required: '{{field}} is required',
+    unique: '{{field}} must be unique',
+    array: '{{field}} must be an array',
+    array_nonempty: '{{field}} must be a non-empty array',
+    nonarray: '{{field}} must not be an array',
+    select: '{{field}} contains an invalid selection',
+    pattern: '{{field}} does not match the pattern {{pattern}}',
+    minLength: '{{field}} must have at least {{length}} characters.',
+    maxLength: '{{field}} must have no more than {{length}} characters.',
+    minWords: '{{field}} must have at least {{length}} words.',
+    maxWords: '{{field}} must have no more than {{length}} words.',
+    min: '{{field}} cannot be less than {{min}}.',
+    max: '{{field}} cannot be greater than {{max}}.',
+    maxDate: '{{field}} should not contain date after {{- maxDate}}',
+    minDate: '{{field}} should not contain date before {{- minDate}}',
+    maxYear: '{{field}} should not contain year greater than {{maxYear}}',
+    minYear: '{{field}} should not contain year less than {{minYear}}',
+    invalid_email: '{{field}} must be a valid email.',
+    invalid_url: '{{field}} must be a valid url.',
+    invalid_regex: '{{field}} does not match the pattern {{regex}}.',
+    invalid_date: '{{field}} is not a valid date.',
+    invalid_day: '{{field}} is not a valid day.',
+    mask: '{{field}} does not match the mask.',
+    valueIsNotAvailable: '{{ field }} is an invalid value.',
+    stripe: '{{stripe}}',
+    month: 'Month',
+    day: 'Day',
+    year: 'Year',
+    january: 'January',
+    february: 'February',
+    march: 'March',
+    april: 'April',
+    may: 'May',
+    june: 'June',
+    july: 'July',
+    august: 'August',
+    september: 'September',
+    october: 'October',
+    november: 'November',
+    december: 'December',
+    next: 'Next',
+    previous: 'Previous',
+    cancel: 'Cancel',
+    submit: 'Submit Form',
+    confirmCancel: 'Are you sure you want to cancel?',
+    saveDraftInstanceError: 'Cannot save draft because there is no formio instance.',
+    saveDraftAuthError: 'Cannot save draft unless a user is authenticated.',
+    restoreDraftInstanceError: 'Cannot restore draft because there is no formio instance.',
+    time: 'Invalid time',
+    cancelButtonAriaLabel: 'Cancel button. Click to reset the form',
+    previousButtonAriaLabel: 'Previous button. Click to go back to the previous tab',
+    nextButtonAriaLabel: 'Next button. Click to go to the next tab',
+    submitButtonAriaLabel: 'Submit Form button. Click to submit the form',
+};

package/lib/cjs/utils/ChoicesWrapper.d.ts

@@ -0,0 +1,37 @@
+export namespace KEY_CODES {
+    const BACK_KEY: number;
+    const DELETE_KEY: number;
+    const TAB_KEY: number;
+    const ENTER_KEY: number;
+    const A_KEY: number;
+    const ESC_KEY: number;
+    const UP_KEY: number;
+    const DOWN_KEY: number;
+    const PAGE_UP_KEY: number;
+    const PAGE_DOWN_KEY: number;
+}
+export default ChoicesWrapper;
+declare class ChoicesWrapper extends Choices {
+    constructor(...args: any[]);
+    _onTabKey({ activeItems, hasActiveDropdown }: {
+        activeItems: any;
+        hasActiveDropdown: any;
+    }): void;
+    isDirectionUsing: boolean;
+    shouldOpenDropDown: boolean;
+    _handleButtonAction(activeItems: any, element: any): void;
+    _onEnterKey(args: any): void;
+    _onDirectionKey(...args: any[]): void;
+    timeout: NodeJS.Timeout | undefined;
+    _selectHighlightedChoice(activeItems: any): void;
+    _onKeyDown(event: any): void;
+    onSelectValue({ event, activeItems, hasActiveDropdown }: {
+        event: any;
+        activeItems: any;
+        hasActiveDropdown: any;
+    }): void;
+    showDropdown(...args: any[]): void;
+    hideDropdown(...args: any[]): void;
+    _onBlur(...args: any[]): void;
+}
+import Choices from '@formio/choices.js';