joi 14.2.0 → 17.2.0

package/lib/set.js

@@ -1,191 +0,0 @@
-'use strict';
-
-const Ref = require('./ref');
-
-
-const internals = {};
-
-
-internals.extendedCheckForValue = function (value, insensitive) {
-
-    const valueType = typeof value;
-
-    if (valueType === 'object') {
-        if (value instanceof Date) {
-            return (item) => {
-
-                return item instanceof Date && value.getTime() === item.getTime();
-            };
-        }
-
-        if (Buffer.isBuffer(value)) {
-            return (item) => {
-
-                return Buffer.isBuffer(item) && value.length === item.length && value.toString('binary') === item.toString('binary');
-            };
-        }
-    }
-    else if (insensitive && valueType === 'string') {
-        const lowercaseValue = value.toLowerCase();
-        return (item) => {
-
-            return typeof item === 'string' && lowercaseValue === item.toLowerCase();
-        };
-    }
-
-    return null;
-};
-
-
-module.exports = class InternalSet {
-
-    constructor(from) {
-
-        this._set = new Set(from);
-        this._hasRef = false;
-    }
-
-    add(value, refs) {
-
-        const isRef = Ref.isRef(value);
-        if (!isRef && this.has(value, null, null, false)) {
-
-            return this;
-        }
-
-        if (refs !== undefined) { // If it's a merge, we don't have any refs
-            Ref.push(refs, value);
-        }
-
-        this._set.add(value);
-
-        this._hasRef |= isRef;
-
-        return this;
-    }
-
-    merge(add, remove) {
-
-        for (const item of add._set) {
-            this.add(item);
-        }
-
-        for (const item of remove._set) {
-            this.remove(item);
-        }
-
-        return this;
-    }
-
-    remove(value) {
-
-        this._set.delete(value);
-        return this;
-    }
-
-    has(value, state, options, insensitive) {
-
-        return !!this.get(value, state, options, insensitive);
-    }
-
-    get(value, state, options, insensitive) {
-
-        if (!this._set.size) {
-            return false;
-        }
-
-        const hasValue = this._set.has(value);
-        if (hasValue) {
-            return { value };
-        }
-
-        const extendedCheck = internals.extendedCheckForValue(value, insensitive);
-        if (!extendedCheck) {
-            if (state && this._hasRef) {
-                for (let item of this._set) {
-                    if (Ref.isRef(item)) {
-                        item = [].concat(item(state.reference || state.parent, options));
-                        const found = item.indexOf(value);
-                        if (found >= 0) {
-                            return { value: item[found] };
-                        }
-                    }
-                }
-            }
-
-            return false;
-        }
-
-        return this._has(value, state, options, extendedCheck);
-    }
-
-    _has(value, state, options, check) {
-
-        const checkRef = !!(state && this._hasRef);
-
-        const isReallyEqual = function (item) {
-
-            if (value === item) {
-                return true;
-            }
-
-            return check(item);
-        };
-
-        for (let item of this._set) {
-            if (checkRef && Ref.isRef(item)) { // Only resolve references if there is a state, otherwise it's a merge
-                item = item(state.reference || state.parent, options);
-
-                if (Array.isArray(item)) {
-                    const found = item.findIndex(isReallyEqual);
-                    if (found >= 0) {
-                        return {
-                            value: item[found]
-                        };
-                    }
-
-                    continue;
-                }
-            }
-
-            if (isReallyEqual(item)) {
-                return {
-                    value: item
-                };
-            }
-        }
-
-        return false;
-    }
-
-    values(options) {
-
-        if (options && options.stripUndefined) {
-            const values = [];
-
-            for (const item of this._set) {
-                if (item !== undefined) {
-                    values.push(item);
-                }
-            }
-
-            return values;
-        }
-
-        return Array.from(this._set);
-    }
-
-    slice() {
-
-        const set = new InternalSet(this._set);
-        set._hasRef = this._hasRef;
-        return set;
-    }
-
-    concat(source) {
-
-        const set = new InternalSet([...this._set, ...source._set]);
-        set._hasRef = !!(this._hasRef | source._hasRef);
-        return set;
-    }
-};

package/lib/types/alternatives/index.js

@@ -1,218 +0,0 @@
-'use strict';
-
-// Load modules
-
-const Hoek = require('hoek');
-const Any = require('../any');
-const Cast = require('../../cast');
-const Ref = require('../../ref');
-
-
-// Declare internals
-
-const internals = {};
-
-
-internals.Alternatives = class extends Any {
-
-    constructor() {
-
-        super();
-        this._type = 'alternatives';
-        this._invalids.remove(null);
-        this._inner.matches = [];
-    }
-
-    _init(...args) {
-
-        return args.length ? this.try(...args) : this;
-    }
-
-    _base(value, state, options) {
-
-        const errors = [];
-        const il = this._inner.matches.length;
-        const baseType = this._baseType;
-
-        for (let i = 0; i < il; ++i) {
-            const item = this._inner.matches[i];
-            if (!item.schema) {
-                const schema = item.peek || item.is;
-                const input = item.is ? item.ref(state.reference || state.parent, options) : value;
-                const failed = schema._validate(input, null, options, state.parent).errors;
-
-                if (failed) {
-                    if (item.otherwise) {
-                        return item.otherwise._validate(value, state, options);
-                    }
-                }
-                else if (item.then) {
-                    return item.then._validate(value, state, options);
-                }
-
-                if (i === (il - 1) && baseType) {
-                    return baseType._validate(value, state, options);
-                }
-
-                continue;
-            }
-
-            const result = item.schema._validate(value, state, options);
-            if (!result.errors) {     // Found a valid match
-                return result;
-            }
-
-            errors.push(...result.errors);
-        }
-
-        if (errors.length) {
-            return { errors: this.createError('alternatives.child', { reason: errors }, state, options) };
-        }
-
-        return { errors: this.createError('alternatives.base', null, state, options) };
-    }
-
-    try(...schemas) {
-
-        schemas = Hoek.flatten(schemas);
-        Hoek.assert(schemas.length, 'Cannot add other alternatives without at least one schema');
-
-        const obj = this.clone();
-
-        for (let i = 0; i < schemas.length; ++i) {
-            const cast = Cast.schema(this._currentJoi, schemas[i]);
-            if (cast._refs.length) {
-                obj._refs.push(...cast._refs);
-            }
-
-            obj._inner.matches.push({ schema: cast });
-        }
-
-        return obj;
-    }
-
-    when(condition, options) {
-
-        let schemaCondition = false;
-        Hoek.assert(Ref.isRef(condition) || typeof condition === 'string' || (schemaCondition = condition instanceof Any), 'Invalid condition:', condition);
-        Hoek.assert(options, 'Missing options');
-        Hoek.assert(typeof options === 'object', 'Invalid options');
-        if (schemaCondition) {
-            Hoek.assert(!options.hasOwnProperty('is'), '"is" can not be used with a schema condition');
-        }
-        else {
-            Hoek.assert(options.hasOwnProperty('is'), 'Missing "is" directive');
-        }
-
-        Hoek.assert(options.then !== undefined || options.otherwise !== undefined, 'options must have at least one of "then" or "otherwise"');
-
-        const obj = this.clone();
-        let is;
-        if (!schemaCondition) {
-            is = Cast.schema(this._currentJoi, options.is);
-
-            if (options.is === null || !(Ref.isRef(options.is) || options.is instanceof Any)) {
-
-                // Only apply required if this wasn't already a schema or a ref, we'll suppose people know what they're doing
-                is = is.required();
-            }
-        }
-
-        const item = {
-            ref: schemaCondition ? null : Cast.ref(condition),
-            peek: schemaCondition ? condition : null,
-            is,
-            then: options.then !== undefined ? Cast.schema(this._currentJoi, options.then) : undefined,
-            otherwise: options.otherwise !== undefined ? Cast.schema(this._currentJoi, options.otherwise) : undefined
-        };
-
-        if (obj._baseType) {
-
-            item.then = item.then && obj._baseType.concat(item.then);
-            item.otherwise = item.otherwise && obj._baseType.concat(item.otherwise);
-        }
-
-        if (!schemaCondition) {
-            Ref.push(obj._refs, item.ref);
-            obj._refs.push(...item.is._refs);
-        }
-
-        if (item.then && item.then._refs.length) {
-            obj._refs.push(...item.then._refs);
-        }
-
-        if (item.otherwise && item.otherwise._refs.length) {
-            obj._refs.push(...item.otherwise._refs);
-        }
-
-        obj._inner.matches.push(item);
-
-        return obj;
-    }
-
-    label(name) {
-
-        const obj = super.label(name);
-        obj._inner.matches = obj._inner.matches.map((match) => {
-
-            if (match.schema) {
-                return { schema: match.schema.label(name) };
-            }
-
-            match = Object.assign({}, match);
-            if (match.then) {
-                match.then = match.then.label(name);
-            }
-
-            if (match.otherwise) {
-                match.otherwise = match.otherwise.label(name);
-            }
-
-            return match;
-        });
-        return obj;
-    }
-
-    describe() {
-
-        const description = super.describe();
-        const alternatives = [];
-        for (let i = 0; i < this._inner.matches.length; ++i) {
-            const item = this._inner.matches[i];
-            if (item.schema) {
-
-                // try()
-
-                alternatives.push(item.schema.describe());
-            }
-            else {
-
-                // when()
-
-                const when = item.is ? {
-                    ref: item.ref.toString(),
-                    is: item.is.describe()
-                } : {
-                    peek: item.peek.describe()
-                };
-
-                if (item.then) {
-                    when.then = item.then.describe();
-                }
-
-                if (item.otherwise) {
-                    when.otherwise = item.otherwise.describe();
-                }
-
-                alternatives.push(when);
-            }
-        }
-
-        description.alternatives = alternatives;
-        return description;
-    }
-
-};
-
-
-module.exports = new internals.Alternatives();