@formio/js 5.0.0-dev.5543.ff15a6a → 5.0.0-dev.5584.9c8ee6a

package/lib/cjs/Embed.js

@@ -0,0 +1,450 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormBuilder = exports.Form = exports.Formio = void 0;
+const CDN_js_1 = __importDefault(require("./CDN.js"));
+class Formio {
+    static setLicense(license, norecurse = false) {
+        _a.license = license;
+        if (!norecurse && _a.FormioClass) {
+            _a.FormioClass.setLicense(license);
+        }
+    }
+    static setBaseUrl(url, norecurse = false) {
+        _a.baseUrl = url;
+        if (!norecurse && _a.FormioClass) {
+            _a.FormioClass.setBaseUrl(url);
+        }
+    }
+    static setApiUrl(url, norecurse = false) {
+        _a.baseUrl = url;
+        if (!norecurse && _a.FormioClass) {
+            _a.FormioClass.setApiUrl(url);
+        }
+    }
+    static setProjectUrl(url, norecurse = false) {
+        _a.projectUrl = url;
+        if (!norecurse && _a.FormioClass) {
+            _a.FormioClass.setProjectUrl(url);
+        }
+    }
+    static setAppUrl(url, norecurse = false) {
+        _a.projectUrl = url;
+        if (!norecurse && _a.FormioClass) {
+            _a.FormioClass.setAppUrl(url);
+        }
+    }
+    static setPathType(type, norecurse = false) {
+        _a.pathType = type;
+        if (!norecurse && _a.FormioClass) {
+            _a.FormioClass.setPathType(type);
+        }
+    }
+    static debug(...args) {
+        if (_a.config.debug) {
+            console.log(...args);
+        }
+    }
+    static clearCache() {
+        if (_a.FormioClass) {
+            _a.FormioClass.clearCache();
+        }
+    }
+    static global(prop, flag = '') {
+        const globalValue = window[prop];
+        if (flag && globalValue && !globalValue[flag]) {
+            return null;
+        }
+        _a.debug(`Getting global ${prop}`, globalValue);
+        return globalValue;
+    }
+    static use(module) {
+        if (_a.FormioClass && _a.FormioClass.isRenderer) {
+            _a.FormioClass.use(module);
+        }
+        else {
+            _a.modules.push(module);
+        }
+    }
+    static createElement(type, attrs, children) {
+        const element = document.createElement(type);
+        Object.keys(attrs).forEach(key => {
+            element.setAttribute(key, attrs[key]);
+        });
+        (children || []).forEach(child => {
+            element.appendChild(_a.createElement(child.tag, child.attrs, child.children));
+        });
+        return element;
+    }
+    static addScript(wrapper, src, name, flag = '') {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!src) {
+                return Promise.resolve();
+            }
+            if (typeof src !== 'string' && src.length) {
+                return Promise.all(src.map(ref => _a.addScript(wrapper, ref)));
+            }
+            if (name && _a.global(name, flag)) {
+                _a.debug(`${name} already loaded.`);
+                return Promise.resolve(_a.global(name));
+            }
+            _a.debug('Adding Script', src);
+            try {
+                wrapper.appendChild(_a.createElement('script', {
+                    src
+                }));
+            }
+            catch (err) {
+                _a.debug(err);
+                return Promise.resolve();
+            }
+            if (!name) {
+                return Promise.resolve();
+            }
+            return new Promise((resolve) => {
+                _a.debug(`Waiting to load ${name}`);
+                const wait = setInterval(() => {
+                    if (_a.global(name, flag)) {
+                        clearInterval(wait);
+                        _a.debug(`${name} loaded.`);
+                        resolve(_a.global(name));
+                    }
+                }, 100);
+            });
+        });
+    }
+    static addStyles(wrapper, href) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!href) {
+                return;
+            }
+            if (typeof href !== 'string' && href.length) {
+                href.forEach(ref => _a.addStyles(wrapper, ref));
+                return;
+            }
+            _a.debug('Adding Styles', href);
+            wrapper.appendChild(_a.createElement('link', {
+                rel: 'stylesheet',
+                href
+            }));
+        });
+    }
+    static submitDone(instance, submission) {
+        return __awaiter(this, void 0, void 0, function* () {
+            _a.debug('Submision Complete', submission);
+            const successMessage = (_a.config.success || '').toString();
+            if (successMessage && successMessage.toLowerCase() !== 'false' && instance.element) {
+                instance.element.innerHTML = `<div class="alert-success" role="alert">${successMessage}</div>`;
+            }
+            let returnUrl = _a.config.redirect;
+            // Allow form based configuration for return url.
+            if (!returnUrl &&
+                (instance._form &&
+                    instance._form.settings &&
+                    (instance._form.settings.returnUrl ||
+                        instance._form.settings.redirect))) {
+                _a.debug('Return url found in form configuration');
+                returnUrl = instance._form.settings.returnUrl || instance._form.settings.redirect;
+            }
+            if (returnUrl) {
+                const formSrc = instance.formio ? instance.formio.formUrl : '';
+                const hasQuery = !!returnUrl.match(/\?/);
+                const isOrigin = returnUrl.indexOf(location.origin) === 0;
+                returnUrl += hasQuery ? '&' : '?';
+                returnUrl += `sub=${submission._id}`;
+                if (!isOrigin && formSrc) {
+                    returnUrl += `&form=${encodeURIComponent(formSrc)}`;
+                }
+                _a.debug('Return URL', returnUrl);
+                window.location.href = returnUrl;
+                if (isOrigin) {
+                    window.location.reload();
+                }
+            }
+        });
+    }
+    // Return the full script if the builder is being used.
+    static formioScript(script, builder) {
+        builder = builder || _a.config.includeBuilder;
+        if (_a.fullAdded || builder) {
+            _a.fullAdded = true;
+            return script.replace('formio.form', 'formio.full');
+        }
+        return script;
+    }
+    static addLibrary(wrapper, lib, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!lib) {
+                return;
+            }
+            if (lib.dependencies) {
+                for (let i = 0; i < lib.dependencies.length; i++) {
+                    yield _a.addLibrary(wrapper, _a.cdn.libs[lib.dependencies[i]]);
+                }
+            }
+            if (lib.css) {
+                yield _a.addStyles(wrapper, lib.css);
+            }
+            if (lib.js) {
+                const module = yield _a.addScript(wrapper, lib.js, lib.use ? name : false);
+                if (lib.use) {
+                    _a.debug(`Using ${name}`);
+                    const options = lib.options || {};
+                    if (!options.license && _a.license) {
+                        options.license = _a.license;
+                    }
+                    _a.use((typeof lib.use === 'function' ? lib.use(module) : module), options);
+                }
+            }
+        });
+    }
+    static addLoader(wrapper) {
+        return __awaiter(this, void 0, void 0, function* () {
+            wrapper.appendChild(_a.createElement('div', {
+                'class': 'formio-loader'
+            }, [{
+                    tag: 'div',
+                    attrs: {
+                        class: 'loader-wrapper'
+                    },
+                    children: [{
+                            tag: 'div',
+                            attrs: {
+                                class: 'loader text-center'
+                            }
+                        }]
+                }]));
+        });
+    }
+    // eslint-disable-next-line max-statements
+    static init(element, options = {}, builder = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            _a.cdn = new CDN_js_1.default(_a.config.cdn, _a.config.cdnUrls || {});
+            _a.config.libs = _a.config.libs || {
+                uswds: {
+                    dependencies: ['fontawesome'],
+                    js: `${_a.cdn.uswds}/uswds.min.js`,
+                    css: `${_a.cdn.uswds}/uswds.min.css`,
+                    use: true
+                },
+                fontawesome: {
+                    css: `${_a.cdn['font-awesome']}/css/font-awesome.min.css`
+                },
+                bootstrap4: {
+                    dependencies: ['fontawesome'],
+                    css: `${_a.cdn.bootstrap4}/css/bootstrap.min.css`
+                },
+                bootstrap: {
+                    dependencies: ['bootstrap-icons'],
+                    css: `${_a.cdn.bootstrap}/css/bootstrap.min.css`
+                },
+                'bootstrap-icons': {
+                    css: `${_a.cdn['bootstrap-icons']}/css/bootstrap-icons.css`
+                }
+            };
+            const id = _a.config.id || `formio-${Math.random().toString(36).substring(7)}`;
+            // Create a new wrapper and add the element inside of a new wrapper.
+            let wrapper = _a.createElement('div', {
+                'id': `${id}-wrapper`
+            });
+            element.parentNode.insertBefore(wrapper, element);
+            // If we include the libraries, then we will attempt to run this in shadow dom.
+            const useShadowDom = _a.config.includeLibs && (typeof wrapper.attachShadow === 'function');
+            if (useShadowDom) {
+                wrapper = wrapper.attachShadow({
+                    mode: 'open'
+                });
+                options.shadowRoot = wrapper;
+            }
+            element.parentNode.removeChild(element);
+            wrapper.appendChild(element);
+            // If this is inside of shadow dom, then we need to add the styles and scripts to the shadow dom.
+            const libWrapper = useShadowDom ? wrapper : document.body;
+            // Load the renderer styles.
+            yield _a.addStyles(libWrapper, _a.config.embedCSS || `${_a.cdn.js}/formio.embed.css`);
+            // Add a loader.
+            _a.addLoader(wrapper);
+            const formioSrc = _a.config.full ? 'formio.full' : 'formio.form';
+            const renderer = _a.config.debug ? formioSrc : `${formioSrc}.min`;
+            _a.FormioClass = yield _a.addScript(libWrapper, _a.formioScript(_a.config.script || `${_a.cdn.js}/${renderer}.js`, builder), 'Formio', builder ? 'isBuilder' : 'isRenderer');
+            _a.FormioClass.cdn = _a.cdn;
+            _a.FormioClass.setBaseUrl(options.baseUrl || _a.baseUrl || _a.config.base);
+            _a.FormioClass.setProjectUrl(options.projectUrl || _a.projectUrl || _a.config.project);
+            _a.FormioClass.language = _a.language;
+            _a.setLicense(_a.license || _a.config.license || false);
+            _a.modules.forEach((module) => {
+                _a.FormioClass.use(module);
+            });
+            if (_a.icons) {
+                _a.FormioClass.icons = _a.icons;
+            }
+            if (_a.pathType) {
+                _a.FormioClass.setPathType(_a.pathType);
+            }
+            // Add libraries if they wish to include the libs.
+            if (_a.config.template && _a.config.includeLibs) {
+                yield _a.addLibrary(libWrapper, _a.config.libs[_a.config.template], _a.config.template);
+            }
+            // Add the premium modules.
+            if (_a.config.premium) {
+                _a.config.modules.premium = _a.config.premium;
+            }
+            // Allow adding dynamic modules.
+            if (_a.config.modules) {
+                for (const name in _a.config.modules) {
+                    const lib = _a.config.modules[name];
+                    lib.use = lib.use || true;
+                    yield _a.addLibrary(libWrapper, lib, name);
+                }
+            }
+            yield _a.addStyles(libWrapper, _a.formioScript(_a.config.style || `${_a.cdn.js}/${renderer}.css`, builder));
+            if (_a.config.before) {
+                yield _a.config.before(_a.FormioClass, element, _a.config);
+            }
+            _a.FormioClass.license = true;
+            _a._formioReady(_a.FormioClass);
+            return wrapper;
+        });
+    }
+    // Called after an instance has been created.
+    static afterCreate(instance, wrapper, readyEvent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const loader = wrapper.querySelector('.formio-loader');
+            if (loader) {
+                wrapper.removeChild(loader);
+            }
+            _a.FormioClass.events.emit(readyEvent, instance);
+            if (_a.config.after) {
+                _a.debug('Calling ready callback');
+                _a.config.after(instance, _a.config);
+            }
+            return instance;
+        });
+    }
+    // Create a new form.
+    static createForm(element, form, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (_a.FormioClass) {
+                return _a.FormioClass.createForm(element, form, Object.assign(Object.assign({}, options), { noLoader: true }));
+            }
+            const wrapper = yield _a.init(element, options);
+            return _a.FormioClass.createForm(element, form, Object.assign(Object.assign({}, options), { noLoader: true })).then((instance) => {
+                // Set the default submission data.
+                if (_a.config.submission) {
+                    _a.debug('Setting submission', _a.config.submission);
+                    instance.submission = _a.config.submission;
+                }
+                // Call the after create method.
+                _a.afterCreate(instance, wrapper, 'formEmbedded');
+                return instance;
+            });
+        });
+    }
+    // Create a form builder.
+    static builder(element, form, options = {}) {
+        var _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((_b = _a.FormioClass) === null || _b === void 0 ? void 0 : _b.builder) {
+                return _a.FormioClass.builder(element, form, options);
+            }
+            const wrapper = yield _a.init(element, options, true);
+            return _a.FormioClass.builder(element, form, options).then((instance) => {
+                _a.afterCreate(instance, wrapper, 'builderEmbedded');
+                return instance;
+            });
+        });
+    }
+}
+exports.Formio = Formio;
+_a = Formio;
+Formio.FormioClass = null;
+Formio.config = {};
+Formio.modules = [];
+Formio.icons = '';
+Formio.license = '';
+Formio.formioReady = new Promise((ready, reject) => {
+    _a._formioReady = ready;
+    _a._formioReadyReject = reject;
+});
+Formio.version = 'FORMIO_VERSION';
+// Create a report.
+Formio.Report = {
+    create: (element, submission, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+        var _b;
+        if ((_b = _a.FormioClass) === null || _b === void 0 ? void 0 : _b.Report) {
+            return _a.FormioClass.Report.create(element, submission, options);
+        }
+        const wrapper = yield _a.init(element, options, true);
+        return _a.FormioClass.Report.create(element, submission, options).then((instance) => {
+            _a.afterCreate(instance, wrapper, 'reportEmbedded');
+            return instance;
+        });
+    })
+};
+CDN_js_1.default.defaultCDN = Formio.version.includes('rc') ? 'https://cdn.test-form.io' : 'https://cdn.form.io';
+class Form {
+    constructor(element, form, options) {
+        this.form = form;
+        this.element = element;
+        this.options = options || {};
+        this.init();
+        this.instance = {
+            proxy: true,
+            ready: this.ready,
+            destroy: () => { }
+        };
+    }
+    init() {
+        if (this.instance && !this.instance.proxy) {
+            this.instance.destroy();
+        }
+        this.element.innerHTML = '';
+        this.ready = this.create().then((instance) => {
+            this.instance = instance;
+            this.form = instance.form;
+            return instance;
+        });
+    }
+    create() {
+        return Formio.createForm(this.element, this.form, this.options);
+    }
+    setForm(form) {
+        this.form = form;
+        if (this.instance) {
+            this.instance.setForm(form);
+        }
+    }
+    setDisplay(display) {
+        if (this.instance.proxy) {
+            return this.ready;
+        }
+        this.form.display = display;
+        this.instance.destroy();
+        this.ready = this.create().then((instance) => {
+            this.instance = instance;
+            this.setForm(this.form);
+        });
+        return this.ready;
+    }
+}
+exports.Form = Form;
+class FormBuilder extends Form {
+    create() {
+        return Formio.builder(this.element, this.form, this.options);
+    }
+}
+exports.FormBuilder = FormBuilder;
+Formio.Form = Form;
+Formio.FormBuilder = FormBuilder;

package/lib/cjs/EventEmitter.d.ts

@@ -0,0 +1,7 @@
+export default class EventEmitter extends EventEmitter3<string | symbol, any> {
+    constructor(conf?: {});
+    emit: (...args: any[]) => void;
+    onAny: (fn: any) => void;
+    offAny: (fn: any) => void;
+}
+import { EventEmitter as EventEmitter3 } from 'eventemitter3';

package/lib/cjs/EventEmitter.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const eventemitter3_1 = require("eventemitter3");
+const utils = __importStar(require("./utils/utils"));
+class EventEmitter extends eventemitter3_1.EventEmitter {
+    constructor(conf = {}) {
+        const { loadLimit = 1000, eventsSafeInterval = 300 } = conf;
+        super();
+        this.onAny = (fn) => {
+            this.on('any', fn);
+        };
+        this.offAny = (fn) => {
+            this.off('any', fn);
+        };
+        const overloadHandler = () => {
+            console.warn(`There were more than ${loadLimit} events emitted in ${eventsSafeInterval} ms. It might be caused by events' infinite loop`, this.id);
+        };
+        const dispatch = utils.observeOverload(overloadHandler, {
+            limit: loadLimit,
+            delay: eventsSafeInterval
+        });
+        this.emit = (...args) => {
+            super.emit(...args);
+            super.emit('any', ...args);
+            dispatch();
+        };
+    }
+}
+exports.default = EventEmitter;

package/lib/cjs/Form.d.ts

@@ -0,0 +1,101 @@
+export default class Form extends Element {
+    static embed(embed: any): Promise<any>;
+    /**
+     * Creates an easy to use interface for embedding webforms, pdfs, and wizards into your application.
+     *
+     * @param {Object} element - The DOM element you wish to render this form within.
+     * @param {Object | string} form - Either a Form JSON schema or the URL of a hosted form via. form.io.
+     * @param {Object} options - The options to create a new form instance.
+     * @param {boolean} options.readOnly - Set this form to readOnly
+     * @param {boolean} options.noAlerts - Set to true to disable the alerts dialog.
+     * @param {boolean} options.i18n - The translation file for this rendering. @see https://github.com/formio/formio.js/blob/master/i18n.js
+     * @param {boolean} options.template - Provides a way to inject custom logic into the creation of every element rendered within the form.
+     *
+     * @example
+     * import Form from '@formio/js/Form';
+     * const form = new Form(document.getElementById('formio'), 'https://examples.form.io/example');
+     * form.build();
+     */
+    constructor(...args: any[]);
+    ready: Promise<any>;
+    readyResolve: (value: any) => void;
+    readyReject: (reason?: any) => void;
+    instance: any;
+    element: any;
+    options: any;
+    display: string;
+    createElement(tag: any, attrs: any, children: any): any;
+    set loading(load: any);
+    loader: any;
+    /**
+     * Create a new form instance provided the display of the form.
+     *
+     * @param {string} display - The display of the form, either "wizard", "form", or "pdf"
+     * @return {*}
+     */
+    create(display: string): any;
+    /**
+     * Sets the form. Either as JSON or a URL to a form JSON schema.
+     *
+     * @param {string|object} formParam - Either the form JSON or the URL of the form json.
+     * @return {*}
+     */
+    set form(formParam: object);
+    /**
+     * Returns the loaded forms JSON.
+     *
+     * @return {object} - The loaded form's JSON
+     */
+    get form(): object;
+    errorForm(err: any): {
+        components: {
+            label: string;
+            tag: string;
+            className: string;
+            attrs: {
+                attr: string;
+                value: string;
+            }[];
+            key: string;
+            type: string;
+            input: boolean;
+            content: any;
+        }[];
+    };
+    /**
+    * Check Subdirectories path and provide correct options
+    *
+    * @param {string} url - The the URL of the form json.
+    * @param {form} object - The form json.
+    * @return {object} The initial options with base and project.
+    */
+    getFormInitOptions(url: string, form: any): object;
+    setForm(formParam: any): any;
+    _form: any;
+    getSubmission(formio: any, opts: any): any;
+    /**
+     * Changes the display of the form.
+     *
+     * @param {string} display - The display to set this form. Either "wizard", "form", or "pdf"
+     * @return {Promise<T>}
+     */
+    setDisplay(display: string): Promise<T>;
+    empty(): void;
+    /**
+     * Sanitize an html string.
+     *
+     * @param string
+     * @returns {*}
+     */
+    sanitize(dirty: any, forceSanitize: any): any;
+    setContent(element: any, content: any, forceSanitize: any): boolean;
+    /**
+     * Build a new form.
+     *
+     * @return {Promise<T>}
+     */
+    build(): Promise<T>;
+    render(): Promise<any>;
+    attach(element: any): any;
+}
+import Element from './Element';