@formio/js 5.0.0-rc.44 → 5.0.0-rc.45

package/lib/cjs/CDN.d.ts

@@ -0,0 +1,33 @@
+export default CDN;
+declare class CDN {
+    static defaultCDN: string;
+    constructor(baseUrl: any, overrides?: {});
+    baseUrl: any;
+    overrides: {};
+    libs: {
+        js: string;
+        ace: string;
+        bootstrap: string;
+        bootstrap4: string;
+        bootstrap5: string;
+        'bootstrap-icons': string;
+        ckeditor: string;
+        flatpickr: string;
+        'flatpickr-formio': string;
+        'font-awesome': string;
+        grid: string;
+        'moment-timezone': string;
+        quill: string;
+        'shortcut-buttons-flatpickr': string;
+        uswds: string;
+        core: string;
+    };
+    getVersion(lib: any): any;
+    setVersion(lib: any, version: any): void;
+    setBaseUrl(url: any): void;
+    setOverrideUrl(lib: any, url: any): void;
+    removeOverride(lib: any): void;
+    removeOverrides(): void;
+    buildUrl(cdnUrl: any, lib: any, version: any): any;
+    updateUrls(): void;
+}

package/lib/cjs/Element.d.ts

@@ -0,0 +1,257 @@
+/**
+ * The root component for all elements within the Form.io renderer.
+ */
+export default class Element {
+    constructor(options: any);
+    /**
+     * The options for this component.
+     * @type {{}}
+     */
+    options: {};
+    /**
+     * The ID of this component. This value is auto-generated when the component is created, but
+     * can also be provided from the component.id value passed into the constructor.
+     * @type {string}
+     */
+    id: string;
+    /**
+     * An array of event handlers so that the destry command can deregister them.
+     * @type {Array}
+     */
+    eventHandlers: any[];
+    i18next: any;
+    /**
+     * An instance of the EventEmitter class to handle the emitting and registration of events.
+     *
+     * @type {EventEmitter}
+     */
+    events: EventEmitter;
+    defaultMask: any[] | null;
+    /**
+     * Conditional to show or hide helplinks in editForm
+     *
+     * @type {*|boolean}
+     */
+    helplinks: any | boolean;
+    /**
+     * Register for a new event within this component.
+     *
+     * @example
+     * let component = new BaseComponent({
+     *   type: 'textfield',
+     *   label: 'First Name',
+     *   key: 'firstName'
+     * });
+     * component.on('componentChange', (changed) => {
+     *   console.log('this element is changed.');
+     * });
+     *
+     *
+     * @param {string} event - The event you wish to register the handler for.
+     * @param {function} cb - The callback handler to handle this event.
+     * @param {boolean} [internal] - This is an internal event handler.
+     * @param {boolean} [once] - This event should only fire once.
+     */
+    on(event: string, cb: Function, internal?: boolean | undefined, once?: boolean | undefined): EventEmitter | undefined;
+    /**
+     * Register for a new single-fire event within this component.
+     *
+     * @param {string} event - The event you wish to register the handler for.
+     * @param {function} cb - The callback handler to handle this event.
+     */
+    once(event: string, cb: Function, internal: any): EventEmitter | undefined;
+    /**
+     * Allow catching any event.
+     *
+     * @param cb
+     * @returns {this}
+     */
+    onAny(cb: any): this;
+    /**
+     * Removes the listener that will be fired when any event is emitted.
+     *
+     * @param cb
+     * @returns {this}
+     */
+    offAny(cb: any): this;
+    /**
+     * Removes a listener for a certain event. Not passing the 2nd arg will remove all listeners for that event.
+     *
+     * @param {string} event - The event you wish to register the handler for.
+     * @param {function|undefined} cb - The callback handler to handle this event.
+     */
+    off(event: string, cb: Function | undefined): void;
+    /**
+     * Emit a new event.
+     *
+     * @param {string} event - The event to emit.
+     * @param {Object} data - The data to emit with the handler.
+     */
+    emit(event: string, ...data: Object): void;
+    /**
+     * Check if the component has an event handler set up for the event.
+     *
+     * @param {string} event - The event name.
+     * @returns {boolean}
+     */
+    hasEventHandler(event: string): boolean;
+    /**
+     * Wrapper method to add an event listener to an HTML element.
+     *
+     * @param obj
+     *   The DOM element to add the event to.
+     * @param type
+     *   The event name to add.
+     * @param func
+     *   The callback function to be executed when the listener is triggered.
+     * @param persistent
+     *   If this listener should persist beyond "destroy" commands.
+     */
+    addEventListener(obj: any, type: any, func: any, persistent: any, capture: any): this | undefined;
+    /**
+     * Remove an event listener from the object.
+     *
+     * @param obj
+     * @param type
+     */
+    removeEventListener(obj: any, type: any, func?: null): this | undefined;
+    removeEventListeners(): void;
+    removeAllEvents(includeExternal: any): void;
+    teardown(): void;
+    /**
+     * Removes all event listeners attached to this component.
+     */
+    destroy(all?: boolean): void;
+    /**
+     * Append an HTML DOM element to a container.
+     *
+     * @param element
+     * @param container
+     */
+    appendTo(element: any, container: any): this;
+    /**
+     * Prepend an HTML DOM element to a container.
+     *
+     * @param {HTMLElement} element - The DOM element to prepend.
+     * @param {HTMLElement} container - The DOM element that is the container of the element getting prepended.
+     */
+    prependTo(element: HTMLElement, container: HTMLElement): this;
+    /**
+     * Removes an HTML DOM element from its bounding container.
+     *
+     * @param {HTMLElement} element - The element to remove.
+     * @param {HTMLElement} container - The DOM element that is the container of the element to remove.
+     */
+    removeChildFrom(element: HTMLElement, container: HTMLElement): this;
+    /**
+     * Alias for document.createElement.
+     *
+     * @param {string} type - The type of element to create
+     * @param {Object} attr - The element attributes to add to the created element.
+     * @param {Various} children - Child elements. Can be a DOM Element, string or array of both.
+     *
+     * @return {HTMLElement} - The created element.
+     */
+    ce(type: string, attr: Object, children?: Various): HTMLElement;
+    /**
+     * Append different types of children.
+     *
+     * @param child
+     */
+    appendChild(element: any, child: any): this;
+    /**
+     * Creates a new input mask placeholder.
+     * @param {HTMLElement} mask - The input mask.
+     * @returns {string} - The placeholder that will exist within the input as they type.
+     */
+    maskPlaceholder(mask: HTMLElement): string;
+    get placeholderChar(): any;
+    /**
+     * Sets the input mask for an input.
+     *
+     * @param {HTMLElement} input - The html input to apply the mask to.
+     * @param {String} inputMask - The input mask to add to this input.
+     * @param {Boolean} usePlaceholder - Set the mask placeholder on the input.
+     */
+    setInputMask(input: HTMLElement, inputMask: string, usePlaceholder: boolean): void;
+    /**
+     * Translate a text using the i18n system.
+     *
+     * @param {string|Array<string>} text - The i18n identifier.
+     * @param {Object} params - The i18n parameters to use for translation.
+     */
+    t(text: string | Array<string>, ...args: any[]): any;
+    /**
+     * Alias to create a text node.
+     * @param text
+     * @returns {Text}
+     */
+    text(text: any): Text;
+    /**
+     * Adds an object of attributes onto an element.
+     * @param {HtmlElement} element - The element to add the attributes to.
+     * @param {Object} attr - The attributes to add to the input element.
+     */
+    attr(element: HtmlElement, attr: Object): void;
+    /**
+     * Determines if an element has a class.
+     *
+     * Taken from jQuery https://j11y.io/jquery/#v=1.5.0&fn=jQuery.fn.hasClass
+     */
+    hasClass(element: any, className: any): boolean;
+    /**
+     * Adds a class to a DOM element.
+     *
+     * @param element
+     *   The element to add a class to.
+     * @param className
+     *   The name of the class to add.
+     */
+    addClass(element: any, className: any): this;
+    /**
+     * Remove a class from a DOM element.
+     *
+     * @param element
+     *   The DOM element to remove the class from.
+     * @param className
+     *   The name of the class that is to be removed.
+     */
+    removeClass(element: any, className: any): this;
+    /**
+     * Empty's an HTML DOM element.
+     *
+     * @param {HTMLElement} element - The element you wish to empty.
+     */
+    empty(element: HTMLElement): void;
+    /**
+     * Create an evaluation context for all script executions and interpolations.
+     *
+     * @param additional
+     * @return {*}
+     */
+    evalContext(additional: any): any;
+    /**
+     * Performs an interpolation using the evaluation context of this component.
+     *
+     * @param string
+     * @param data
+     * @return {XML|string|*|void}
+     */
+    interpolate(string: any, data: any, options?: {}): XML | string | any | void;
+    /**
+     * Performs an evaluation using the evaluation context of this component.
+     *
+     * @param func
+     * @param args
+     * @param ret
+     * @param tokenize
+     * @return {*}
+     */
+    evaluate(func: any, args: any, ret: any, tokenize: any): any;
+    /**
+     * Allow for options to hook into the functionality of this renderer.
+     * @return {*}
+     */
+    hook(...args: any[]): any;
+}
+import EventEmitter from './EventEmitter';

package/lib/cjs/Embed.d.ts

@@ -0,0 +1,60 @@
+export class Formio {
+    static FormioClass: null;
+    static baseUrl: any;
+    static projectUrl: any;
+    static pathType: any;
+    static language: any;
+    static config: {};
+    static cdn: any;
+    static modules: any[];
+    static icons: string;
+    static license: string;
+    static formioReady: Promise<any>;
+    static version: string;
+    static setLicense(license: any, norecurse?: boolean): void;
+    static setBaseUrl(url: any, norecurse?: boolean): void;
+    static setApiUrl(url: any, norecurse?: boolean): void;
+    static setProjectUrl(url: any, norecurse?: boolean): void;
+    static setAppUrl(url: any, norecurse?: boolean): void;
+    static setPathType(type: any, norecurse?: boolean): void;
+    static debug(...args: any[]): void;
+    static clearCache(): void;
+    static global(prop: any, flag?: string): any;
+    static use(module: any): void;
+    static createElement(type: any, attrs: any, children: any): any;
+    static addScript(wrapper: any, src: any, name: any, flag?: string): Promise<any>;
+    static addStyles(wrapper: any, href: any): Promise<void>;
+    static submitDone(instance: any, submission: any): Promise<void>;
+    static formioScript(script: any, builder: any): any;
+    static addLibrary(wrapper: any, lib: any, name: any): Promise<void>;
+    static addLoader(wrapper: any): Promise<void>;
+    static init(element: any, options?: {}, builder?: boolean): Promise<any>;
+    static afterCreate(instance: any, wrapper: any, readyEvent: any): Promise<any>;
+    static createForm(element: any, form: any, options?: {}): Promise<any>;
+    static builder(element: any, form: any, options?: {}): Promise<any>;
+    static Report: {
+        create: (element: any, submission: any, options?: {}) => Promise<any>;
+    };
+}
+export namespace Formio {
+    export { Form };
+    export { FormBuilder };
+}
+export class Form {
+    constructor(element: any, form: any, options: any);
+    form: any;
+    element: any;
+    options: any;
+    instance: {
+        proxy: boolean;
+        ready: Promise<any> | Promise<void> | undefined;
+        destroy: () => void;
+    };
+    init(): void;
+    ready: Promise<any> | Promise<void> | undefined;
+    create(): Promise<any>;
+    setForm(form: any): void;
+    setDisplay(display: any): Promise<any> | undefined;
+}
+export class FormBuilder extends Form {
+}

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/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';

package/lib/cjs/FormBuilder.d.ts

@@ -0,0 +1,6 @@
+export default class FormBuilder extends Form {
+    static options: {};
+    constructor(element: any, form: any, options: any);
+    create(display: any): any;
+}
+import Form from './Form';

package/lib/cjs/Formio.d.ts

@@ -0,0 +1 @@
+export { FormioCore as Formio };

package/lib/cjs/PDF.d.ts

@@ -0,0 +1,40 @@
+export default class PDF extends Webform {
+    constructor(element: any, options: any);
+    components: any[];
+    init(): void;
+    submitButton: import("./components/_classes/component/Component").default | undefined;
+    attachComponents(element: any, components: any, container: any): Promise<void>;
+    attach(element: any): Promise<void>;
+    iframeReady: Promise<any> | undefined;
+    iframeReadyResolve: ((value: any) => void) | undefined;
+    iframeReadyReject: ((reason?: any) => void) | undefined;
+    iframeElement: any;
+    /**
+     * Get the submission from the iframe.
+     *
+     * @return {Promise<any>}
+     */
+    getSubmission(): Promise<any>;
+    /**
+     * Ensure we have the submission from the iframe before we submit the form.
+     *
+     * @param options
+     * @return {*}
+     */
+    submitForm(options?: {}): any;
+    getSrc(): string;
+    setForm(form: any, flags?: {}): any;
+    /**
+     * Set's the value of this form component.
+     *
+     * @param submission
+     * @param flags
+     */
+    setValue(submission: any, flags?: {}): boolean;
+    postMessage(message: any): void;
+    iframeFormSetUp: boolean | undefined;
+    focusOnComponent(key: any): void;
+    showErrors(error: any, triggerEvent: any): void;
+    isSubmitButtonHidden(): boolean;
+}
+import Webform from './Webform';

package/lib/cjs/PDFBuilder.d.ts

@@ -0,0 +1,55 @@
+export default class PDFBuilder extends WebformBuilder {
+    get defaultGroups(): {
+        pdf: {
+            title: string;
+            weight: number;
+            default: boolean;
+            components: {
+                textfield: boolean;
+                number: boolean;
+                password: boolean;
+                email: boolean;
+                phoneNumber: boolean;
+                currency: boolean;
+                checkbox: boolean;
+                signature: boolean;
+                select: boolean;
+                textarea: boolean;
+                datetime: boolean;
+                file: boolean;
+                htmlelement: boolean;
+                signrequestsignature: boolean;
+            };
+        };
+        basic: boolean;
+        advanced: boolean;
+        layout: boolean;
+        data: boolean;
+        premium: boolean;
+        resource: boolean;
+    };
+    get hasPDF(): any;
+    get projectUrl(): any;
+    afterAttach(): void;
+    pdfLoaded: boolean | undefined;
+    upload(file: any): void;
+    setUploadError(message: any): void;
+    getParentContainer(component: any): {
+        formioComponent: any;
+        formioContainer: any[];
+        originalComponent: null;
+    };
+    initIframeEvents(): void;
+    initDropzoneEvents(): void;
+    updateDragAndDrop(): void;
+    prepSidebarComponentsForDrag(): void;
+    updateDropzoneDimensions(): void;
+    onDragStart(e: any): void;
+    itemOffsetX: any;
+    itemOffsetY: any;
+    dropEmitted: boolean | undefined;
+    onDropzoneDrop(e: any): boolean;
+    dropEvent: any;
+    onDragEnd(e: any): void;
+}
+import WebformBuilder from './WebformBuilder';