@formio/vpat 2.6.1

package/lib/components/button/Button.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_1 = require("@formio/js");
+const Button_form_1 = __importDefault(require("./Button.form"));
+const Button = js_1.Components.components.button;
+class ButtonComponent extends Button {
+}
+exports.default = ButtonComponent;
+ButtonComponent.editForm = Button_form_1.default;

package/lib/components/button/editForm/Button.edit.display.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    key: string;
+    ignore: boolean;
+}[];
+export default _default;

package/lib/components/button/editForm/Button.edit.display.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = [
+    {
+        key: 'labelPosition',
+        ignore: true,
+    },
+    {
+        key: 'placeholder',
+        ignore: true,
+    },
+    {
+        key: 'tabindex',
+        ignore: true,
+    },
+    {
+        key: 'hidden',
+        ignore: true,
+    },
+    {
+        key: 'autofocus',
+        ignore: true,
+    },
+    {
+        key: 'hideLabel',
+        ignore: true,
+    },
+    {
+        key: 'tooltip',
+        ignore: true,
+    },
+];

package/lib/components/checkbox/Checkbox.d.ts

@@ -0,0 +1,17 @@
+import editForm from './Checkbox.form';
+declare const Checkbox: any;
+interface ICheckboxRefs {
+    label: HTMLElement;
+    input: HTMLElement;
+}
+export default class CheckboxComponent extends Checkbox {
+    static editForm: typeof editForm;
+    refs: ICheckboxRefs;
+    isIE: any;
+    addHiddenMessage: any;
+    noField: any;
+    render(element: any): any;
+    clearErrorClasses(elements: any[]): void;
+    setErrorClasses(elements: any[], dirty: boolean, hasErrors: boolean, hasMessages: boolean): void;
+}
+export {};

package/lib/components/checkbox/Checkbox.form.d.ts

@@ -0,0 +1 @@
+export default function (...extend: any[]): any;

package/lib/components/checkbox/Checkbox.form.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_1 = require("@formio/js");
+const baseEditForm = js_1.Components.components.checkbox.editForm;
+const Checkbox_edit_data_1 = __importDefault(require("./editForm/Checkbox.edit.data"));
+const Checkbox_edit_display_1 = __importDefault(require("./editForm/Checkbox.edit.display"));
+function default_1(...extend) {
+    return baseEditForm([
+        {
+            key: 'display',
+            components: Checkbox_edit_display_1.default,
+        },
+        {
+            key: 'data',
+            components: Checkbox_edit_data_1.default,
+        },
+    ], ...extend);
+}
+exports.default = default_1;

package/lib/components/checkbox/Checkbox.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_1 = require("@formio/js");
+const Checkbox_form_1 = __importDefault(require("./Checkbox.form"));
+const Checkbox = js_1.Components.components.checkbox;
+class CheckboxComponent extends Checkbox {
+    render(element) {
+        this.noField = true;
+        return super.render(element);
+    }
+    clearErrorClasses(elements) {
+        const hiddentInvalidEntryMessage = document.getElementById(`invalid-entry-${this.id}`);
+        if (hiddentInvalidEntryMessage) {
+            this.refs.label.removeChild(hiddentInvalidEntryMessage);
+        }
+        // @ts-ignore
+        super.clearErrorClasses(elements);
+    }
+    setErrorClasses(elements, dirty, hasErrors, hasMessages) {
+        // @ts-ignore
+        super.setErrorClasses(elements, dirty, hasErrors, hasMessages);
+        elements.forEach((input) => input.removeAttribute('aria-invalid'));
+        const hiddentInvalidEntryMessage = document.getElementById(`invalid-entry-${this.id}`);
+        if (hasErrors && !hiddentInvalidEntryMessage) {
+            this.addHiddenMessage(', invalid entry, ', this.refs.label);
+        }
+    }
+}
+exports.default = CheckboxComponent;
+CheckboxComponent.editForm = Checkbox_form_1.default;

package/lib/components/checkbox/editForm/Checkbox.edit.data.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    key: string;
+    ignore: boolean;
+}[];
+export default _default;

package/lib/components/checkbox/editForm/Checkbox.edit.data.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = [
+    {
+        key: 'clearOnHide',
+        ignore: true,
+    },
+    {
+        key: 'redrawOn',
+        ignore: true,
+    },
+];

package/lib/components/checkbox/editForm/Checkbox.edit.display.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    key: string;
+    ignore: boolean;
+}[];
+export default _default;

package/lib/components/checkbox/editForm/Checkbox.edit.display.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = [
+    {
+        key: 'labelPosition',
+        ignore: true,
+    },
+    {
+        key: 'placeholder',
+        ignore: true,
+    },
+    {
+        key: 'autofocus',
+        ignore: true,
+    },
+    {
+        key: 'tabindex',
+        ignore: true,
+    },
+    {
+        key: 'hidden',
+        ignore: true,
+    },
+    {
+        key: 'hideLabel',
+        ignore: true,
+    },
+    {
+        key: 'labelWidth',
+        ignore: true,
+    },
+    {
+        key: 'labelMargin',
+        ignore: true,
+    },
+    {
+        key: 'shortcut',
+        ignore: true,
+    },
+    {
+        key: 'inputType',
+        ignore: true,
+    },
+];

package/lib/components/columns/Columns.d.ts

@@ -0,0 +1,6 @@
+import editForm from './Columns.form';
+declare const Columns: any;
+export default class ColumnsComponent extends Columns {
+    static editForm: typeof editForm;
+}
+export {};

package/lib/components/columns/Columns.form.d.ts

@@ -0,0 +1 @@
+export default function (...extend: any[]): any;

package/lib/components/columns/Columns.form.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_1 = require("@formio/js");
+const columnsEditForm = js_1.Components.components.columns.editForm;
+const Columns_edit_display_1 = __importDefault(require("./editForm/Columns.edit.display"));
+function default_1(...extend) {
+    return columnsEditForm([
+        {
+            key: 'display',
+            components: Columns_edit_display_1.default,
+        },
+    ], ...extend);
+}
+exports.default = default_1;

package/lib/components/columns/Columns.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_1 = require("@formio/js");
+const Columns_form_1 = __importDefault(require("./Columns.form"));
+const Columns = js_1.Components.components.columns;
+class ColumnsComponent extends Columns {
+}
+exports.default = ColumnsComponent;
+ColumnsComponent.editForm = Columns_form_1.default;

package/lib/components/columns/editForm/Columns.edit.display.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    key: string;
+    ignore: boolean;
+}[];
+export default _default;

package/lib/components/columns/editForm/Columns.edit.display.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = [
+    {
+        key: 'hideLabel',
+        ignore: true,
+    },
+    {
+        key: 'hidden',
+        ignore: true,
+    },
+    {
+        key: 'hideOnChildrenHidden',
+        ignore: true,
+    },
+];

package/lib/components/component/Component.d.ts

@@ -0,0 +1,2 @@
+declare const Component: any;
+export default Component;

package/lib/components/component/Component.js

@@ -0,0 +1,316 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_1 = require("@formio/js");
+const ComponentModal_1 = __importDefault(require("../componentmodal/ComponentModal"));
+const Tooltip_1 = __importDefault(require("../tooltip/Tooltip"));
+const ModalUtils = __importStar(require("../../util/modalUtils"));
+const Component = js_1.Components.components.component;
+const attach = Component.prototype.attach;
+Component.prototype.isIE = () => {
+    const userAgent = window.navigator.userAgent;
+    const msie = userAgent.indexOf('MSIE ');
+    if (msie > 0) {
+        // IE 10 or older => return version number
+        return parseInt(userAgent.substring(msie + 5, userAgent.indexOf('.', msie)), 10);
+    }
+    const trident = userAgent.indexOf('Trident/');
+    if (trident > 0) {
+        // IE 11 => return version number
+        const rv = userAgent.indexOf('rv:');
+        return parseInt(userAgent.substring(rv + 3, userAgent.indexOf('.', rv)), 10);
+    }
+    const edge = userAgent.indexOf('Edge/');
+    if (edge > 0) {
+        // IE 12 (aka Edge) => return version number
+        return parseInt(userAgent.substring(edge + 5, userAgent.indexOf('.', edge)), 10);
+    }
+    // other browser
+    return false;
+};
+Component.prototype.isFirefox = () => {
+    const userAgent = window.navigator.userAgent;
+    const firefox = userAgent.indexOf('Firefox');
+    const seamonkey = userAgent.indexOf('Seamonkey');
+    if (firefox > 0 && seamonkey === -1) {
+        // returns version number
+        return parseInt(userAgent.substring(firefox + 8, userAgent.indexOf('.', firefox)), 10);
+    }
+    // other browser
+    return false;
+};
+Component.prototype.addMessages = function (messages) {
+    if (!messages) {
+        return;
+    }
+    // Standardize on array of objects for message.
+    if (typeof messages === 'string') {
+        messages = {
+            messages,
+            level: 'error',
+        };
+    }
+    if (!Array.isArray(messages)) {
+        messages = [messages];
+    }
+    const renderMessageContainer = (messageContainer) => {
+        this.setContent(messageContainer, messages.map((message, index) => {
+            const key = this.component.key + index;
+            return this.renderTemplate('message', Object.assign(Object.assign({}, message), { key }));
+        }).join(''));
+    };
+    if (this.refs.messageContainer) {
+        renderMessageContainer(this.refs.messageContainer);
+        if (this.refs.modalMessageContainer) {
+            renderMessageContainer(this.refs.modalMessageContainer);
+        }
+    }
+};
+Component.prototype.createComponentModal = function (element, modalShouldBeOpened, currentValue) {
+    return new ComponentModal_1.default(this, element, modalShouldBeOpened, currentValue);
+};
+Component.prototype.attach = function (element) {
+    const superAttach = attach.call(this, element);
+    this.loadRefs(element, {
+        modalMessageContainer: 'single',
+        messageContainer: 'single',
+        tooltip: 'multiple',
+        label: 'single',
+        component: 'single',
+    });
+    return superAttach;
+};
+Component.prototype.attachTooltips = function (toolTipsRefs) {
+    const tooltip = toolTipsRefs && toolTipsRefs[0];
+    if (tooltip) {
+        const title = this.interpolate(tooltip.getAttribute('data-title') || tooltip.getAttribute('data-tooltip')).replace(/(?:\r\n|\r|\n)/g, '<br />');
+        this.tooltips[0] = new Tooltip_1.default(tooltip, {
+            position: 'right',
+            title,
+        });
+    }
+};
+Component.prototype.addHiddenMessage = function (message, parent) {
+    if (parent) {
+        const hiddenMessage = this.ce('span', { class: this.transform('class', 'sr-only'), id: `invalid-entry-${this.id}` });
+        this.setContent(hiddenMessage, this.t(message, {}));
+        parent.appendChild(hiddenMessage);
+    }
+};
+Component.prototype.addHiddenMessageBeforeChild = function (parent, child, message, params) {
+    const hiddenMessage = this.ce('span', Object.assign({ class: this.transform('class', 'sr-only') }, params));
+    this.setContent(hiddenMessage, this.t(message, {}));
+    parent.insertBefore(hiddenMessage, child);
+};
+Component.prototype.hiddenMessageRemovalByID = function (elemIDs) {
+    elemIDs.forEach((elemID) => {
+        const elem = document.getElementById(elemID);
+        if (elem) {
+            if (this.isIE()) {
+                const parentElement = elem.parentElement;
+                if (parentElement) {
+                    parentElement.removeChild(elem);
+                }
+            }
+            else {
+                elem.remove();
+            }
+        }
+    });
+};
+Component.prototype.clearErrorID = (attributeName, element) => {
+    const descRefs = element && element.getAttribute(attributeName);
+    // Removes an error message elem id
+    if (descRefs) {
+        const updatedDescRefs = descRefs.replace(/\b(e-\w*-\w*)/g, '').trim();
+        if (updatedDescRefs) {
+            element.setAttribute(attributeName, updatedDescRefs);
+        }
+        else {
+            element.removeAttribute(attributeName);
+        }
+    }
+};
+const createModal = Component.prototype.createModal;
+Component.prototype.createModal = function (element, attr, confirm) {
+    const dialog = createModal.call(this, element, attr, confirm);
+    const dialogClose = dialog.close;
+    const focusableElements = ModalUtils.getFocusableElements(dialog.refs.dialogContents);
+    const focusTrapHandler = ModalUtils.focusTrap.bind(this, focusableElements);
+    ModalUtils.toggleHideBackgroundElements(dialog.refs.dialogContents, true);
+    this.addEventListener(dialog.refs.dialogContents, 'keydown', focusTrapHandler);
+    focusableElements[0].focus();
+    dialog.close = () => {
+        this.removeEventListener(dialog.refs.dialogContents, 'keydown', focusTrapHandler);
+        ModalUtils.toggleHideBackgroundElements(dialog.refs.dialogContents, false);
+        dialogClose();
+    };
+    return dialog;
+};
+Component.prototype.addErrorID = function (attributeName, element) {
+    if (element) {
+        let descRefs = element.getAttribute(attributeName);
+        if (!descRefs || descRefs.search(/\b(e-\w*-\w*)/g) === -1) {
+            this.errors.forEach((error, index) => {
+                const errorID = `e-${this.id}-${this.component.key}${index}`;
+                element.setAttribute(attributeName, `${descRefs || ''} ${errorID}`);
+                descRefs = element.getAttribute(attributeName);
+            });
+        }
+    }
+};
+Component.prototype.setDescribingAttribute = (attributeName, element, values) => {
+    let descRefs = element.getAttribute(attributeName) || '';
+    values.forEach((value) => descRefs = descRefs.replace(value, '').trim());
+    values.forEach((value) => descRefs += ` ${value}`);
+    descRefs.trim();
+    element.setAttribute(attributeName, descRefs);
+};
+Component.prototype.clearDescribingAttribute = (attributeName, element, values) => {
+    let descRefs = element.getAttribute(attributeName) || '';
+    values.forEach((value) => descRefs = descRefs.replace(value, '').trim());
+    element.setAttribute(attributeName, descRefs);
+};
+Component.prototype.clearErrorClasses = function (elements) {
+    var _a;
+    this.removeClass(this.refs.label, this.transform('class', 'formio-label-error'));
+    this.removeClass(this.element, this.transform('class', 'formio-form-error'));
+    const fields = this.refs.input
+        ? this.refs.input
+        : elements instanceof Array
+            ? elements
+            : [elements];
+    if (fields) {
+        fields.forEach((element) => {
+            if (element) {
+                this.removeClass(element, this.transform('class', 'formio-input-error'));
+                element.setAttribute('aria-invalid', false);
+                if (element.type === 'textarea') {
+                    this.clearErrorID('aria-labelledby', element);
+                    return;
+                }
+                this.clearErrorID('aria-describedby', element);
+            }
+        });
+        if (this.refs.input &&
+            (this.component.type === 'datetime' || ((_a = this.component.widget) === null || _a === void 0 ? void 0 : _a.type) === 'calendar')) {
+            const input = this.refs.input[0];
+            if (input === null || input === void 0 ? void 0 : input.widget.calendar) {
+                const element = input.nextSibling;
+                this.removeClass(element, this.transform('class', 'formio-input-error'));
+                element.removeAttribute('aria-invalid');
+                this.clearErrorID('aria-describedby', element);
+            }
+        }
+        if (this.component.modalEdit && this.refs.openModal) {
+            if (this.refs.component) {
+                this.removeClass(this.refs.component, this.transform('class', 'formio-form-error'));
+            }
+            const openModalButton = this.refs.openModal;
+            this.clearErrorID('aria-describedby', openModalButton);
+            openModalButton.removeAttribute('aria-invalid');
+        }
+    }
+};
+Component.prototype.checkModal = () => {
+    return;
+};
+Component.prototype.setErrorClasses = function (elements, dirty, hasErrors, hasMessages) {
+    this.clearErrorClasses(elements);
+    this.setSuccessClasses(false);
+    const handleInvalidFields = (element) => {
+        this.addClass(element, this.transform('class', 'formio-input-error'));
+        element.setAttribute('aria-invalid', 'true');
+        if (element.type === 'textarea') {
+            this.addErrorID('aria-labelledby', element);
+        }
+        else {
+            this.addErrorID('aria-describedby', element);
+        }
+    };
+    if (hasErrors) {
+        this.addClass(this.refs.label, this.transform('class', 'formio-label-error'));
+        this.addClass(this.element, this.transform('class', 'formio-form-error'));
+        elements.forEach((input) => {
+            var _a;
+            if (input) {
+                if (this.type === 'datetime' || ((_a = this.component.widget) === null || _a === void 0 ? void 0 : _a.type) === 'calendar') {
+                    handleInvalidFields(input.nextSibling);
+                }
+                else {
+                    handleInvalidFields(input);
+                }
+            }
+        });
+        if (this.component.modalEdit && this.refs.openModal) {
+            if (!this.component.components && this.refs.component) {
+                this.addClass(this.refs.component, this.transform('class', 'formio-form-error'));
+            }
+            const openModalButton = this.refs.openModal;
+            this.addErrorID('aria-describedby', openModalButton);
+            openModalButton.setAttribute('aria-invalid', 'true');
+        }
+    }
+};
+Component.prototype.setComponentValidity = function (messages, dirty, silentCheck) {
+    const hasErrors = !!messages.filter(message => message.level === 'error').length;
+    if (messages.length && (!silentCheck || this.error) && (dirty || !this.pristine)) {
+        this.setCustomValidity(messages, dirty);
+        this.setSuccessClasses(false);
+    }
+    else if (!silentCheck) {
+        this.setCustomValidity('');
+        if ((dirty || !this.pristine) && !this.component.disabled) {
+            this.setSuccessClasses(true);
+        }
+    }
+    return !hasErrors;
+};
+Component.prototype.setSuccessClasses = function (isSuccess) {
+    var _a;
+    const handleSuccessClass = (element, isSuccess) => {
+        isSuccess
+            ? this.addClass(element, this.transform('class', 'formio-input-success'))
+            : this.removeClass(element, this.transform('class', 'formio-input-success'));
+    };
+    if (this.refs.input && this.refs.input[0]) {
+        handleSuccessClass(this.refs.input[0], isSuccess);
+        if (this.component.type === 'datetime' || ((_a = this.component.widget) === null || _a === void 0 ? void 0 : _a.type) === 'calendar') {
+            handleSuccessClass(this.refs.input[0].nextSibling, isSuccess);
+        }
+    }
+    if (this.refs.selectContainer) {
+        handleSuccessClass(this.refs.selectContainer, isSuccess);
+    }
+    if (this.component.type === 'day') {
+        handleSuccessClass(this.refs.day, isSuccess);
+        handleSuccessClass(this.refs.month, isSuccess);
+        handleSuccessClass(this.refs.year, isSuccess);
+    }
+};
+exports.default = Component;

package/lib/components/componentmodal/ComponentModal.d.ts

@@ -0,0 +1,2 @@
+declare const ComponentModal: any;
+export default ComponentModal;