修改禁引可视域

‘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
'use strict';
 
const Hoek = require('@hapi/hoek');
 
const Any = require('../any');
 
 
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();