333

schangxiang@126.com

2025-09-19 18966e02fb573c7e2bb0c6426ed792b38b910940

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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
'use strict';
 
const match = (array, value) =>
    array.some(x => (x instanceof RegExp ? x.test(value) : x === value));
 
const dargs = (input, options) => {
    const args = [];
    let extraArgs = [];
    let separatedArgs = [];
 
    options = Object.assign({
        useEquals: true
    }, options);
 
    const makeArg = (key, value) => {
        key =
            '--' +
            (options.allowCamelCase ?
                key :
                key.replace(/[A-Z]/g, '-$&').toLowerCase());
 
        if (options.useEquals) {
            args.push(key + (value ? `=${value}` : ''));
        } else {
            args.push(key);
 
            if (value) {
                args.push(value);
            }
        }
    };
 
    const makeAliasArg = (key, value) => {
        args.push(`-${key}`);
 
        if (value) {
            args.push(value);
        }
    };
 
    // TODO: Use Object.entries() when targeting Node.js 8
    for (let key of Object.keys(input)) {
        const value = input[key];
        let pushArg = makeArg;
 
        if (Array.isArray(options.excludes) && match(options.excludes, key)) {
            continue;
        }
 
        if (Array.isArray(options.includes) && !match(options.includes, key)) {
            continue;
        }
 
        if (typeof options.aliases === 'object' && options.aliases[key]) {
            key = options.aliases[key];
            pushArg = makeAliasArg;
        }
 
        if (key === '--') {
            if (!Array.isArray(value)) {
                throw new TypeError(
                    `Expected key \`--\` to be Array, got ${typeof value}`
                );
            }
 
            separatedArgs = value;
            continue;
        }
 
        if (key === '_') {
            if (!Array.isArray(value)) {
                throw new TypeError(
                    `Expected key \`_\` to be Array, got ${typeof value}`
                );
            }
 
            extraArgs = value;
            continue;
        }
 
        if (value === true) {
            pushArg(key, '');
        }
 
        if (value === false && !options.ignoreFalse) {
            pushArg(`no-${key}`);
        }
 
        if (typeof value === 'string') {
            pushArg(key, value);
        }
 
        if (typeof value === 'number' && !Number.isNaN(value)) {
            pushArg(key, String(value));
        }
 
        if (Array.isArray(value)) {
            for (const arrayValue of value) {
                pushArg(key, arrayValue);
            }
        }
    }
 
    for (const x of extraArgs) {
        args.push(String(x));
    }
 
    if (separatedArgs.length > 0) {
        args.push('--');
    }
 
    for (const x of separatedArgs) {
        args.push(String(x));
    }
 
    return args;
};
 
module.exports = dargs;