joi 14.2.0 → 17.2.0

package/lib/types/binary/index.js

@@ -1,100 +0,0 @@
-'use strict';
-
-// Load modules
-
-const Any = require('../any');
-const Hoek = require('hoek');
-
-
-// Declare internals
-
-const internals = {};
-
-
-internals.Binary = class extends Any {
-
-    constructor() {
-
-        super();
-        this._type = 'binary';
-    }
-
-    _base(value, state, options) {
-
-        const result = {
-            value
-        };
-
-        if (typeof value === 'string' &&
-            options.convert) {
-
-            try {
-                result.value = Buffer.from(value, this._flags.encoding);
-            }
-            catch (e) {
-            }
-        }
-
-        result.errors = Buffer.isBuffer(result.value) ? null : this.createError('binary.base', null, state, options);
-        return result;
-    }
-
-    encoding(encoding) {
-
-        Hoek.assert(Buffer.isEncoding(encoding), 'Invalid encoding:', encoding);
-
-        if (this._flags.encoding === encoding) {
-            return this;
-        }
-
-        const obj = this.clone();
-        obj._flags.encoding = encoding;
-        return obj;
-    }
-
-    min(limit) {
-
-        Hoek.assert(Number.isSafeInteger(limit) && limit >= 0, 'limit must be a positive integer');
-
-        return this._test('min', limit, function (value, state, options) {
-
-            if (value.length >= limit) {
-                return value;
-            }
-
-            return this.createError('binary.min', { limit, value }, state, options);
-        });
-    }
-
-    max(limit) {
-
-        Hoek.assert(Number.isSafeInteger(limit) && limit >= 0, 'limit must be a positive integer');
-
-        return this._test('max', limit, function (value, state, options) {
-
-            if (value.length <= limit) {
-                return value;
-            }
-
-            return this.createError('binary.max', { limit, value }, state, options);
-        });
-    }
-
-    length(limit) {
-
-        Hoek.assert(Number.isSafeInteger(limit) && limit >= 0, 'limit must be a positive integer');
-
-        return this._test('length', limit, function (value, state, options) {
-
-            if (value.length === limit) {
-                return value;
-            }
-
-            return this.createError('binary.length', { limit, value }, state, options);
-        });
-    }
-
-};
-
-
-module.exports = new internals.Binary();

package/lib/types/boolean/index.js

@@ -1,100 +0,0 @@
-'use strict';
-
-// Load modules
-
-const Any = require('../any');
-const Hoek = require('hoek');
-
-
-// Declare internals
-
-const internals = {
-    Set: require('../../set')
-};
-
-
-internals.Boolean = class extends Any {
-    constructor() {
-
-        super();
-        this._type = 'boolean';
-        this._flags.insensitive = true;
-        this._inner.truthySet = new internals.Set();
-        this._inner.falsySet = new internals.Set();
-    }
-
-    _base(value, state, options) {
-
-        const result = {
-            value
-        };
-
-        if (typeof value === 'string' &&
-            options.convert) {
-
-            const normalized = this._flags.insensitive ? value.toLowerCase() : value;
-            result.value = (normalized === 'true' ? true
-                : (normalized === 'false' ? false : value));
-        }
-
-        if (typeof result.value !== 'boolean') {
-            result.value = (this._inner.truthySet.has(value, null, null, this._flags.insensitive) ? true
-                : (this._inner.falsySet.has(value, null, null, this._flags.insensitive) ? false : value));
-        }
-
-        result.errors = (typeof result.value === 'boolean') ? null : this.createError('boolean.base', { value }, state, options);
-        return result;
-    }
-
-    truthy(...values) {
-
-        const obj = this.clone();
-        values = Hoek.flatten(values);
-        for (let i = 0; i < values.length; ++i) {
-            const value = values[i];
-
-            Hoek.assert(value !== undefined, 'Cannot call truthy with undefined');
-            obj._inner.truthySet.add(value);
-        }
-
-        return obj;
-    }
-
-    falsy(...values) {
-
-        const obj = this.clone();
-        values = Hoek.flatten(values);
-        for (let i = 0; i < values.length; ++i) {
-            const value = values[i];
-
-            Hoek.assert(value !== undefined, 'Cannot call falsy with undefined');
-            obj._inner.falsySet.add(value);
-        }
-
-        return obj;
-    }
-
-    insensitive(enabled) {
-
-        const insensitive = enabled === undefined ? true : !!enabled;
-
-        if (this._flags.insensitive === insensitive) {
-            return this;
-        }
-
-        const obj = this.clone();
-        obj._flags.insensitive = insensitive;
-        return obj;
-    }
-
-    describe() {
-
-        const description = super.describe();
-        description.truthy = [true, ...this._inner.truthySet.values()];
-        description.falsy = [false, ...this._inner.falsySet.values()];
-        return description;
-    }
-};
-
-
-module.exports = new internals.Boolean();

package/lib/types/date/index.js

@@ -1,182 +0,0 @@
-'use strict';
-
-// Load modules
-
-const Any = require('../any');
-const Ref = require('../../ref');
-const Hoek = require('hoek');
-
-
-// Declare internals
-
-const internals = {};
-
-internals.isoDate = /^(?:[-+]\d{2})?(?:\d{4}(?!\d{2}\b))(?:(-?)(?:(?:0[1-9]|1[0-2])(?:\1(?:[12]\d|0[1-9]|3[01]))?|W(?:[0-4]\d|5[0-2])(?:-?[1-7])?|(?:00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[1-6])))(?![T]$|[T][\d]+Z$)(?:[T\s](?:(?:(?:[01]\d|2[0-3])(?:(:?)[0-5]\d)?|24\:?00)(?:[.,]\d+(?!:))?)(?:\2[0-5]\d(?:[.,]\d+)?)?(?:[Z]|(?:[+-])(?:[01]\d|2[0-3])(?::?[0-5]\d)?)?)?)?$/;
-internals.invalidDate = new Date('');
-internals.isIsoDate = (() => {
-
-    const isoString = internals.isoDate.toString();
-
-    return (date) => {
-
-        return date && (date.toString() === isoString);
-    };
-})();
-
-internals.Date = class extends Any {
-
-    constructor() {
-
-        super();
-        this._type = 'date';
-    }
-
-    _base(value, state, options) {
-
-        const result = {
-            value: (options.convert && internals.Date.toDate(value, this._flags.format, this._flags.timestamp, this._flags.multiplier)) || value
-        };
-
-        if (result.value instanceof Date && !isNaN(result.value.getTime())) {
-            result.errors = null;
-        }
-        else if (!options.convert) {
-            result.errors = this.createError('date.strict', { value }, state, options);
-        }
-        else {
-            let type;
-            if (internals.isIsoDate(this._flags.format)) {
-                type = 'isoDate';
-            }
-            else if (this._flags.timestamp) {
-                type = `timestamp.${this._flags.timestamp}`;
-            }
-            else {
-                type = 'base';
-            }
-
-            result.errors = this.createError(`date.${type}`, { value }, state, options);
-        }
-
-        return result;
-    }
-
-    static toDate(value, format, timestamp, multiplier) {
-
-        if (value instanceof Date) {
-            return value;
-        }
-
-        if (typeof value === 'string' ||
-            (typeof value === 'number' && !isNaN(value) && isFinite(value))) {
-
-            const isIsoDate = format && internals.isIsoDate(format);
-            if (!isIsoDate &&
-                typeof value === 'string' &&
-                /^[+-]?\d+(\.\d+)?$/.test(value)) {
-
-                value = parseFloat(value);
-            }
-
-            let date;
-            if (isIsoDate) {
-                date = format.test(value) ? new Date(value.toString()) : internals.invalidDate;
-            }
-            else if (timestamp) {
-                date = /^\s*$/.test(value) ? internals.invalidDate : new Date(value * multiplier);
-            }
-            else {
-                date = new Date(value);
-            }
-
-            if (!isNaN(date.getTime())) {
-                return date;
-            }
-        }
-
-        return null;
-    }
-
-    iso() {
-
-        if (this._flags.format === internals.isoDate) {
-            return this;
-        }
-
-        const obj = this.clone();
-        obj._flags.format = internals.isoDate;
-        return obj;
-    }
-
-    timestamp(type = 'javascript') {
-
-        const allowed = ['javascript', 'unix'];
-        Hoek.assert(allowed.includes(type), '"type" must be one of "' + allowed.join('", "') + '"');
-
-        if (this._flags.timestamp === type) {
-            return this;
-        }
-
-        const obj = this.clone();
-        obj._flags.timestamp = type;
-        obj._flags.multiplier = type === 'unix' ? 1000 : 1;
-        return obj;
-    }
-
-    _isIsoDate(value) {
-
-        return internals.isoDate.test(value);
-    }
-
-};
-
-internals.compare = function (type, compare) {
-
-    return function (date) {
-
-        const isNow = date === 'now';
-        const isRef = Ref.isRef(date);
-
-        if (!isNow && !isRef) {
-            date = internals.Date.toDate(date);
-        }
-
-        Hoek.assert(date, 'Invalid date format');
-
-        return this._test(type, date, function (value, state, options) {
-
-            let compareTo;
-            if (isNow) {
-                compareTo = Date.now();
-            }
-            else if (isRef) {
-                const refValue = date(state.reference || state.parent, options);
-                compareTo = internals.Date.toDate(refValue);
-
-                if (!compareTo) {
-                    return this.createError('date.ref', { ref: date, value: refValue }, state, options);
-                }
-
-                compareTo = compareTo.getTime();
-            }
-            else {
-                compareTo = date.getTime();
-            }
-
-            if (compare(value.getTime(), compareTo)) {
-                return value;
-            }
-
-            return this.createError('date.' + type, { limit: new Date(compareTo), value }, state, options);
-        });
-    };
-};
-
-
-internals.Date.prototype.min = internals.compare('min', (value, date) => value >= date);
-internals.Date.prototype.max = internals.compare('max', (value, date) => value <= date);
-internals.Date.prototype.greater = internals.compare('greater', (value, date) => value > date);
-internals.Date.prototype.less = internals.compare('less', (value, date) => value < date);
-
-
-module.exports = new internals.Date();

package/lib/types/func/index.js

@@ -1,90 +0,0 @@
-'use strict';
-
-// Load modules
-
-const Hoek = require('hoek');
-const ObjectType = require('../object');
-const Ref = require('../../ref');
-
-
-// Declare internals
-
-const internals = {};
-
-
-internals.Func = class extends ObjectType.constructor {
-
-    constructor() {
-
-        super();
-        this._flags.func = true;
-    }
-
-    arity(n) {
-
-        Hoek.assert(Number.isSafeInteger(n) && n >= 0, 'n must be a positive integer');
-
-        return this._test('arity', n, function (value, state, options) {
-
-            if (value.length === n) {
-                return value;
-            }
-
-            return this.createError('function.arity', { n }, state, options);
-        });
-    }
-
-    minArity(n) {
-
-        Hoek.assert(Number.isSafeInteger(n) && n > 0, 'n must be a strict positive integer');
-
-        return this._test('minArity', n, function (value, state, options) {
-
-            if (value.length >= n) {
-                return value;
-            }
-
-            return this.createError('function.minArity', { n }, state, options);
-        });
-    }
-
-    maxArity(n) {
-
-        Hoek.assert(Number.isSafeInteger(n) && n >= 0, 'n must be a positive integer');
-
-        return this._test('maxArity', n, function (value, state, options) {
-
-            if (value.length <= n) {
-                return value;
-            }
-
-            return this.createError('function.maxArity', { n }, state, options);
-        });
-    }
-
-    ref() {
-
-        return this._test('ref', null, function (value, state, options) {
-
-            if (Ref.isRef(value)) {
-                return value;
-            }
-
-            return this.createError('function.ref', { value }, state, options);
-        });
-    }
-
-    class() {
-
-        return this._test('class', null, function (value, state, options) {
-
-            if ((/^\s*class\s/).test(value.toString())) {
-                return value;
-            }
-
-            return this.createError('function.class', { value }, state, options);
-        });
-    }
-};
-
-module.exports = new internals.Func();

package/lib/types/lazy/index.js

@@ -1,82 +0,0 @@
-'use strict';
-
-// Load modules
-
-const Any = require('../any');
-const Hoek = require('hoek');
-
-
-// Declare internals
-
-const internals = {};
-
-
-internals.Lazy = class extends Any {
-
-    constructor() {
-
-        super();
-        this._type = 'lazy';
-        this._flags.once = true;
-        this._cache = null;
-    }
-
-    _init(fn, options) {
-
-        return this.set(fn, options);
-    }
-
-    _base(value, state, options) {
-
-        let schema;
-        if (this._cache) {
-            schema = this._cache;
-        }
-        else {
-            const result = { value };
-            const lazy = this._flags.lazy;
-
-            if (!lazy) {
-                result.errors = this.createError('lazy.base', null, state, options);
-                return result;
-            }
-
-            schema = lazy();
-
-            if (!(schema instanceof Any)) {
-                result.errors = this.createError('lazy.schema', { schema }, state, options);
-                return result;
-            }
-
-            if (this._flags.once) {
-                this._cache = schema;
-            }
-        }
-
-        return schema._validate(value, state, options);
-    }
-
-    set(fn, options) {
-
-        Hoek.assert(typeof fn === 'function', 'You must provide a function as first argument');
-        Hoek.assert(options === undefined || (options && typeof options === 'object' && !Array.isArray(options)), `Options must be an object`);
-
-        if (options) {
-            const unknownOptions = Object.keys(options).filter((key) => !['once'].includes(key));
-            Hoek.assert(unknownOptions.length === 0, `Options contain unknown keys: ${unknownOptions}`);
-            Hoek.assert(options.once === undefined || typeof options.once === 'boolean', 'Option "once" must be a boolean');
-        }
-
-        const obj = this.clone();
-        obj._flags.lazy = fn;
-
-        if (options && options.once !== obj._flags.once) {
-            obj._flags.once = options.once;
-        }
-
-        return obj;
-    }
-
-};
-
-module.exports = new internals.Lazy();