@formio/js 5.0.0-rc.10

package/lib/cjs/validator/rules/Pattern.d.ts

@@ -0,0 +1,5 @@
+export default class Pattern extends Rule {
+    defaultMessage: string;
+    check(value: any): boolean;
+}
+import Rule from './Rule';

package/lib/cjs/validator/rules/Pattern.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Rule_1 = __importDefault(require("./Rule"));
+class Pattern extends Rule_1.default {
+    constructor() {
+        super(...arguments);
+        this.defaultMessage = '{{field}} does not match the pattern {{settings.pattern}}';
+    }
+    check(value) {
+        const { pattern } = this.settings;
+        if (!pattern) {
+            return true;
+        }
+        return (new RegExp(`^${pattern}$`)).test(value);
+    }
+}
+exports.default = Pattern;
+;

package/lib/cjs/validator/rules/Required.d.ts

@@ -0,0 +1,5 @@
+export default class Required extends Rule {
+    defaultMessage: string;
+    check(value: any): boolean;
+}
+import Rule from './Rule';

package/lib/cjs/validator/rules/Required.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Rule_1 = __importDefault(require("./Rule"));
+class Required extends Rule_1.default {
+    constructor() {
+        super(...arguments);
+        this.defaultMessage = '{{field}} is required';
+    }
+    check(value) {
+        // TODO: Day, Survey overrides.
+        return !this.component.isValueHidden() && !this.component.isEmpty(value);
+    }
+}
+exports.default = Required;
+;

package/lib/cjs/validator/rules/Rule.d.ts

@@ -0,0 +1,7 @@
+export default class Rule {
+    constructor(component: any, settings: any, config: any);
+    component: any;
+    settings: any;
+    config: any;
+    check(): void;
+}

package/lib/cjs/validator/rules/Rule.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Rule {
+    constructor(component, settings, config) {
+        this.component = component;
+        this.settings = settings;
+        this.config = config;
+    }
+    check() {
+    }
+}
+exports.default = Rule;
+;

package/lib/cjs/validator/rules/Select.d.ts

@@ -0,0 +1,5 @@
+export default class Select extends Rule {
+    defaultMessage: string;
+    check(value: any, data: any, row: any, async: any): any;
+}
+import Rule from './Rule';

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

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils/utils");
+const native_promise_only_1 = __importDefault(require("native-promise-only"));
+const fetch_ponyfill_1 = __importDefault(require("fetch-ponyfill"));
+const { fetch, Headers, Request } = (0, fetch_ponyfill_1.default)({
+    Promise: native_promise_only_1.default
+});
+const lodash_1 = __importDefault(require("lodash"));
+const Rule_1 = __importDefault(require("./Rule"));
+class Select extends Rule_1.default {
+    constructor() {
+        super(...arguments);
+        this.defaultMessage = '{{field}} contains an invalid selection';
+    }
+    check(value, data, row, async) {
+        // Skip if value is empty
+        if (!value || lodash_1.default.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 (lodash_1.default.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 = (0, utils_1.interpolate)(requestOptions.url, { data: this.component.data });
+        // Add query string to URL
+        requestOptions.url += (requestOptions.url.includes('?') ? '&' : '?') + lodash_1.default.chain(requestOptions.qs)
+            .map((val, key) => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`)
+            .join('&')
+            .value();
+        // Set custom headers.
+        if (schema.data && schema.data.headers) {
+            lodash_1.default.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);
+    }
+}
+exports.default = Select;
+;

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

@@ -0,0 +1,5 @@
+export default class Time extends Rule {
+    defaultMessage: string;
+    check(value: any): boolean;
+}
+import Rule from './Rule';

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

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Rule_1 = __importDefault(require("./Rule"));
+const moment_1 = __importDefault(require("moment"));
+class Time extends Rule_1.default {
+    constructor() {
+        super(...arguments);
+        this.defaultMessage = '{{field}} must contain valid time';
+    }
+    check(value) {
+        if (this.component.isEmpty(value))
+            return true;
+        return (0, moment_1.default)(value, this.component.component.format).isValid();
+    }
+}
+exports.default = Time;
+;

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

@@ -0,0 +1,5 @@
+export default class Unique extends Rule {
+    defaultMessage: string;
+    check(value: any): any;
+}
+import Rule from './Rule';

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

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils/utils");
+const lodash_1 = __importDefault(require("lodash"));
+const native_promise_only_1 = __importDefault(require("native-promise-only"));
+const Rule_1 = __importDefault(require("./Rule"));
+class Unique extends Rule_1.default {
+    constructor() {
+        super(...arguments);
+        this.defaultMessage = '{{field}} must be unique';
+    }
+    check(value) {
+        // Skip if value is empty object or falsy
+        if (!value || lodash_1.default.isObjectLike(value) && lodash_1.default.isEmpty(value)) {
+            return true;
+        }
+        // Skip if we don't have a database connection
+        if (!this.config.db) {
+            return true;
+        }
+        return new native_promise_only_1.default(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 (lodash_1.default.isString(value)) {
+                query[path] = {
+                    $regex: new RegExp(`^${(0, utils_1.escapeRegExCharacters)(value)}$`),
+                    $options: 'i'
+                };
+            }
+            else if (lodash_1.default.isPlainObject(value) &&
+                value.address &&
+                value.address['address_components'] &&
+                value.address['place_id']) {
+                query[`${path}.address.place_id`] = {
+                    $regex: new RegExp(`^${(0, utils_1.escapeRegExCharacters)(value.address['place_id'])}$`),
+                    $options: 'i'
+                };
+            }
+            // Compare the contents of arrays vs the order.
+            else if (lodash_1.default.isArray(value)) {
+                query[path] = { $all: value };
+            }
+            else if (lodash_1.default.isObject(value) || lodash_1.default.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);
+    }
+}
+exports.default = Unique;
+;

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

@@ -0,0 +1,5 @@
+export default class Url extends Rule {
+    defaultMessage: string;
+    check(value: any): boolean;
+}
+import Rule from './Rule';

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

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Rule_1 = __importDefault(require("./Rule"));
+class Url extends Rule_1.default {
+    constructor() {
+        super(...arguments);
+        this.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));
+    }
+}
+exports.default = Url;
+;

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

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

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

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Custom_1 = __importDefault(require("./Custom"));
+const Date_1 = __importDefault(require("./Date"));
+const Day_1 = __importDefault(require("./Day"));
+const Email_1 = __importDefault(require("./Email"));
+const JSON_1 = __importDefault(require("./JSON"));
+const Mask_1 = __importDefault(require("./Mask"));
+const Max_1 = __importDefault(require("./Max"));
+const MaxDate_1 = __importDefault(require("./MaxDate"));
+const MaxLength_1 = __importDefault(require("./MaxLength"));
+const MaxWords_1 = __importDefault(require("./MaxWords"));
+const Min_1 = __importDefault(require("./Min"));
+const MinDate_1 = __importDefault(require("./MinDate"));
+const MinLength_1 = __importDefault(require("./MinLength"));
+const MinWords_1 = __importDefault(require("./MinWords"));
+const Pattern_1 = __importDefault(require("./Pattern"));
+const Required_1 = __importDefault(require("./Required"));
+const Select_1 = __importDefault(require("./Select"));
+const Unique_1 = __importDefault(require("./Unique"));
+const Url_1 = __importDefault(require("./Url"));
+const MinYear_1 = __importDefault(require("./MinYear"));
+const MaxYear_1 = __importDefault(require("./MaxYear"));
+const Time_1 = __importDefault(require("./Time"));
+exports.default = {
+    custom: Custom_1.default,
+    date: Date_1.default,
+    day: Day_1.default,
+    email: Email_1.default,
+    json: JSON_1.default,
+    mask: Mask_1.default,
+    max: Max_1.default,
+    maxDate: MaxDate_1.default,
+    maxLength: MaxLength_1.default,
+    maxWords: MaxWords_1.default,
+    min: Min_1.default,
+    minDate: MinDate_1.default,
+    minLength: MinLength_1.default,
+    minWords: MinWords_1.default,
+    pattern: Pattern_1.default,
+    required: Required_1.default,
+    select: Select_1.default,
+    unique: Unique_1.default,
+    url: Url_1.default,
+    minYear: MinYear_1.default,
+    maxYear: MaxYear_1.default,
+    time: Time_1.default,
+};

package/lib/cjs/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/cjs/validator/transformers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Transformers {
+    static addTransformer(name, transformer) {
+        Transformers.transformers[name] = transformer;
+    }
+    static addTransformers(transformers) {
+        Transformers.transformers = Object.assign(Object.assign({}, Transformers.transformers), transformers);
+    }
+    static getTransformer(name) {
+        return Transformers.transformers[name];
+    }
+    static getTransformers() {
+        return Transformers.transformers;
+    }
+}
+Transformers.transformers = {};
+exports.default = Transformers;

package/lib/cjs/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/cjs/validator/valueSources/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ValueSources {
+    static addValueSource(name, valueSource) {
+        ValueSources.valueSources[name] = valueSource;
+    }
+    static addValueSources(valueSources) {
+        ValueSources.valueSources = Object.assign(Object.assign({}, ValueSources.valueSources), valueSources);
+    }
+    static getValueSource(name) {
+        return ValueSources.valueSources[name];
+    }
+    static getValueSources() {
+        return ValueSources.valueSources;
+    }
+}
+ValueSources.valueSources = {};
+exports.default = ValueSources;

package/lib/cjs/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';