修改禁引可视域

‘liusuyi’

2023-10-30 3c450768402293d86350e8420f365210c83233fa

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
'use strict';
 
const Hoek = require('@hapi/hoek');
 
const Any = require('../any');
 
 
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();