@formio/js 5.0.0-rc.5

package/lib/mjs/validator/rules/Select.js

@@ -0,0 +1,87 @@
+import { interpolate } from '../../utils/utils';
+import NativePromise from 'native-promise-only';
+import fetchPonyfill from 'fetch-ponyfill';
+const { fetch, Headers, Request } = fetchPonyfill({
+    Promise: NativePromise
+});
+import _ from 'lodash';
+const Rule = require('./Rule');
+module.exports = class Select extends Rule {
+    defaultMessage = '{{field}} contains an invalid selection';
+    check(value, data, row, async) {
+        // Skip if value is empty
+        if (!value || _.isEmpty(value)) {
+            return true;
+        }
+        // Skip if we're not async-capable
+        if (!async) {
+            return true;
+        }
+        const schema = this.component.component;
+        // Initialize the request options
+        const requestOptions = {
+            url: this.settings.url,
+            method: 'GET',
+            qs: {},
+            json: true,
+            headers: {}
+        };
+        // If the url is a boolean value
+        if (_.isBoolean(requestOptions.url)) {
+            requestOptions.url = !!requestOptions.url;
+            if (!requestOptions.url ||
+                schema.dataSrc !== 'url' ||
+                !schema.data.url ||
+                !schema.searchField) {
+                return true;
+            }
+            // Get the validation url
+            requestOptions.url = schema.data.url;
+            // Add the search field
+            requestOptions.qs[schema.searchField] = value;
+            // Add the filters
+            if (schema.filter) {
+                requestOptions.url += (!requestOptions.url.includes('?') ? '?' : '&') + schema.filter;
+            }
+            // If they only wish to return certain fields.
+            if (schema.selectFields) {
+                requestOptions.qs.select = schema.selectFields;
+            }
+        }
+        if (!requestOptions.url) {
+            return true;
+        }
+        // Make sure to interpolate.
+        requestOptions.url = interpolate(requestOptions.url, { data: this.component.data });
+        // Add query string to URL
+        requestOptions.url += (requestOptions.url.includes('?') ? '&' : '?') + _.chain(requestOptions.qs)
+            .map((val, key) => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`)
+            .join('&')
+            .value();
+        // Set custom headers.
+        if (schema.data && schema.data.headers) {
+            _.each(schema.data.headers, header => {
+                if (header.key) {
+                    requestOptions.headers[header.key] = header.value;
+                }
+            });
+        }
+        // Set form.io authentication.
+        if (schema.authenticate && this.config.token) {
+            requestOptions.headers['x-jwt-token'] = this.config.token;
+        }
+        return fetch(new Request(requestOptions.url, {
+            headers: new Headers(requestOptions.headers)
+        }))
+            .then(response => {
+            if (!response.ok) {
+                return false;
+            }
+            return response.json();
+        })
+            .then((results) => {
+            return results && results.length;
+        })
+            .catch(() => false);
+    }
+};

package/lib/mjs/validator/rules/Time.d.ts

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

package/lib/mjs/validator/rules/Time.js

@@ -0,0 +1,10 @@
+const Rule = require('./Rule');
+import moment from 'moment';
+module.exports = class Time extends Rule {
+    defaultMessage = '{{field}} must contain valid time';
+    check(value) {
+        if (this.component.isEmpty(value))
+            return true;
+        return moment(value, this.component.component.format).isValid();
+    }
+};

package/lib/mjs/validator/rules/Unique.d.ts

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

package/lib/mjs/validator/rules/Unique.js

@@ -0,0 +1,61 @@
+import { escapeRegExCharacters } from '../../utils/utils';
+import _ from 'lodash';
+import NativePromise from 'native-promise-only';
+const Rule = require('./Rule');
+module.exports = class Unique extends Rule {
+    defaultMessage = '{{field}} must be unique';
+    check(value) {
+        // Skip if value is empty object or falsy
+        if (!value || _.isObjectLike(value) && _.isEmpty(value)) {
+            return true;
+        }
+        // Skip if we don't have a database connection
+        if (!this.config.db) {
+            return true;
+        }
+        return new NativePromise(resolve => {
+            const form = this.config.form;
+            const submission = this.config.submission;
+            const path = `data.${this.component.path}`;
+            // Build the query
+            const query = { form: form._id };
+            if (_.isString(value)) {
+                query[path] = {
+                    $regex: new RegExp(`^${escapeRegExCharacters(value)}$`),
+                    $options: 'i'
+                };
+            }
+            else if (_.isPlainObject(value) &&
+                value.address &&
+                value.address['address_components'] &&
+                value.address['place_id']) {
+                query[`${path}.address.place_id`] = {
+                    $regex: new RegExp(`^${escapeRegExCharacters(value.address['place_id'])}$`),
+                    $options: 'i'
+                };
+            }
+            // Compare the contents of arrays vs the order.
+            else if (_.isArray(value)) {
+                query[path] = { $all: value };
+            }
+            else if (_.isObject(value) || _.isNumber(value)) {
+                query[path] = { $eq: value };
+            }
+            // Only search for non-deleted items
+            query.deleted = { $eq: null };
+            // Try to find an existing value within the form
+            this.config.db.findOne(query, (err, result) => {
+                if (err) {
+                    return resolve(false);
+                }
+                else if (result) {
+                    // Only OK if it matches the current submission
+                    return resolve(submission._id && (result._id.toString() === submission._id));
+                }
+                else {
+                    return resolve(true);
+                }
+            });
+        }).catch(() => false);
+    }
+};

package/lib/mjs/validator/rules/Url.d.ts

@@ -0,0 +1,6 @@
+export = Url;
+declare class Url extends Rule {
+    defaultMessage: string;
+    check(value: any): boolean;
+}
+import Rule = require("./Rule");

package/lib/mjs/validator/rules/Url.js

@@ -0,0 +1,15 @@
+"use strict";
+const Rule = require('./Rule');
+module.exports = class Url extends Rule {
+    defaultMessage = '{{field}} must be a valid url.';
+    check(value) {
+        /* eslint-disable max-len */
+        // From https://stackoverflow.com/questions/8667070/javascript-regular-expression-to-validate-url
+        const re = /^(?:(?:(?:https?|ftp):)?\/\/)?(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)*(?:\.(?:[a-z\u00a1-\uffff]{2,})))(?::\d{2,5})?(?:[/?#]\S*)?$/i;
+        // From http://stackoverflow.com/questions/46155/validate-email-address-in-javascript
+        const emailRe = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+        /* eslint-enable max-len */
+        // Allow urls to be valid if the component is pristine and no value is provided.
+        return !value || (re.test(value) && !emailRe.test(value));
+    }
+};

package/lib/mjs/validator/rules/index.d.ts

@@ -0,0 +1,23 @@
+import custom = require("./Custom");
+import date = require("./Date");
+import day = require("./Day");
+import email = require("./Email");
+import json = require("./JSON");
+import mask = require("./Mask");
+import max = require("./Max");
+import maxDate = require("./MaxDate");
+import maxLength = require("./MaxLength");
+import maxWords = require("./MaxWords");
+import min = require("./Min");
+import minDate = require("./MinDate");
+import minLength = require("./MinLength");
+import minWords = require("./MinWords");
+import pattern = require("./Pattern");
+import required = require("./Required");
+import select = require("./Select");
+import unique = require("./Unique");
+import url = require("./Url");
+import minYear = require("./MinYear");
+import maxYear = require("./MaxYear");
+import time = require("./Time");
+export { custom, date, day, email, json, mask, max, maxDate, maxLength, maxWords, min, minDate, minLength, minWords, pattern, required, select, unique, url, minYear, maxYear, time };

package/lib/mjs/validator/rules/index.js

@@ -0,0 +1,47 @@
+"use strict";
+const custom = require('./Custom');
+const date = require('./Date');
+const day = require('./Day');
+const email = require('./Email');
+const json = require('./JSON');
+const mask = require('./Mask');
+const max = require('./Max');
+const maxDate = require('./MaxDate');
+const maxLength = require('./MaxLength');
+const maxWords = require('./MaxWords');
+const min = require('./Min');
+const minDate = require('./MinDate');
+const minLength = require('./MinLength');
+const minWords = require('./MinWords');
+const pattern = require('./Pattern');
+const required = require('./Required');
+const select = require('./Select');
+const unique = require('./Unique');
+const url = require('./Url');
+const minYear = require('./MinYear');
+const maxYear = require('./MaxYear');
+const time = require('./Time');
+module.exports = {
+    custom,
+    date,
+    day,
+    email,
+    json,
+    mask,
+    max,
+    maxDate,
+    maxLength,
+    maxWords,
+    min,
+    minDate,
+    minLength,
+    minWords,
+    pattern,
+    required,
+    select,
+    unique,
+    url,
+    minYear,
+    maxYear,
+    time,
+};

package/lib/mjs/validator/transformers/index.d.ts

@@ -0,0 +1,7 @@
+export default class Transformers {
+    static transformers: {};
+    static addTransformer(name: any, transformer: any): void;
+    static addTransformers(transformers: any): void;
+    static getTransformer(name: any): any;
+    static getTransformers(): {};
+}

package/lib/mjs/validator/transformers/index.js

@@ -0,0 +1,16 @@
+class Transformers {
+    static transformers = {};
+    static addTransformer(name, transformer) {
+        Transformers.transformers[name] = transformer;
+    }
+    static addTransformers(transformers) {
+        Transformers.transformers = { ...Transformers.transformers, ...transformers };
+    }
+    static getTransformer(name) {
+        return Transformers.transformers[name];
+    }
+    static getTransformers() {
+        return Transformers.transformers;
+    }
+}
+export default Transformers;

package/lib/mjs/validator/valueSources/index.d.ts

@@ -0,0 +1,7 @@
+export default class ValueSources {
+    static valueSources: {};
+    static addValueSource(name: any, valueSource: any): void;
+    static addValueSources(valueSources: any): void;
+    static getValueSource(name: any): any;
+    static getValueSources(): {};
+}

package/lib/mjs/validator/valueSources/index.js

@@ -0,0 +1,16 @@
+class ValueSources {
+    static valueSources = {};
+    static addValueSource(name, valueSource) {
+        ValueSources.valueSources[name] = valueSource;
+    }
+    static addValueSources(valueSources) {
+        ValueSources.valueSources = { ...ValueSources.valueSources, ...valueSources };
+    }
+    static getValueSource(name) {
+        return ValueSources.valueSources[name];
+    }
+    static getValueSources() {
+        return ValueSources.valueSources;
+    }
+}
+export default ValueSources;

package/lib/mjs/widgets/CalendarWidget.d.ts

@@ -0,0 +1,96 @@
+export default class CalendarWidget extends InputWidget {
+    static get defaultSettings(): {
+        type: string;
+        altInput: boolean;
+        allowInput: boolean;
+        clickOpens: boolean;
+        enableDate: boolean;
+        enableTime: boolean;
+        mode: string;
+        noCalendar: boolean;
+        format: string;
+        dateFormat: string;
+        useLocaleSettings: boolean;
+        language: string;
+        hourIncrement: number;
+        minuteIncrement: number;
+        time_24hr: boolean;
+        saveAs: string;
+        displayInTimezone: string;
+        timezone: string;
+        disable: never[];
+        minDate: string;
+        maxDate: string;
+    };
+    zoneLoading: boolean;
+    timezonesUrl: string;
+    /**
+     * Load the timezones.
+     *
+     * @return {boolean} TRUE if the zones are loading, FALSE otherwise.
+     */
+    loadZones(): boolean;
+    defaultFormat: {
+        date: string;
+        time: string;
+    } | undefined;
+    closedOn: number | undefined;
+    valueFormat: any;
+    valueMomentFormat: string | undefined;
+    get disableWeekends(): (date: any) => boolean;
+    get disableWeekdays(): (date: any) => boolean;
+    get disableFunction(): (date: any) => any;
+    get timezone(): any;
+    get defaultSettings(): {
+        type: string;
+        altInput: boolean;
+        allowInput: boolean;
+        clickOpens: boolean;
+        enableDate: boolean;
+        enableTime: boolean;
+        mode: string;
+        noCalendar: boolean;
+        format: string;
+        dateFormat: string;
+        useLocaleSettings: boolean;
+        language: string;
+        hourIncrement: number;
+        minuteIncrement: number;
+        time_24hr: boolean;
+        saveAs: string;
+        displayInTimezone: string;
+        timezone: string;
+        disable: never[];
+        minDate: string;
+        maxDate: string;
+    };
+    addSuffix(suffix: any): any;
+    get disabledDates(): any;
+    get localeFormat(): string;
+    get dateTimeFormat(): string;
+    get dateFormat(): any;
+    /**
+     * Return the date value.
+     *
+     * @param date
+     * @param format
+     * @return {string}
+     */
+    getDateValue(date: any, format: any, useTimezone: any): string;
+    isValueISO8601(value: any): any;
+    /**
+     * Set the selected date value.
+     *
+     * @param value
+     */
+    setValue(value: any): void;
+    getValueAsString(value: any, format: any): string;
+    setErrorClasses(hasErrors: any): void;
+    isCalendarElement(element: any): any;
+    initFlatpickr(Flatpickr: any): void;
+    calendar: any;
+    initShortcutButtonsPlugin(ShortcutButtonsPlugin: any): void;
+    get componentValue(): any;
+    getFlatpickrFormatDate(Flatpickr: any): (date: any, format: any) => any;
+}
+import InputWidget from './InputWidget';