初始化项目

15815213711

2024-08-26 67b8b6731811983447e053d4396b3708c14dfe3c

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
'use strict';
const {URL} = require('url');
const is = require('@sindresorhus/is');
const knownHookEvents = require('./known-hook-events');
 
const merge = (target, ...sources) => {
    for (const source of sources) {
        for (const [key, sourceValue] of Object.entries(source)) {
            if (is.undefined(sourceValue)) {
                continue;
            }
 
            const targetValue = target[key];
            if (is.urlInstance(targetValue) && (is.urlInstance(sourceValue) || is.string(sourceValue))) {
                target[key] = new URL(sourceValue, targetValue);
            } else if (is.plainObject(sourceValue)) {
                if (is.plainObject(targetValue)) {
                    target[key] = merge({}, targetValue, sourceValue);
                } else {
                    target[key] = merge({}, sourceValue);
                }
            } else if (is.array(sourceValue)) {
                target[key] = merge([], sourceValue);
            } else {
                target[key] = sourceValue;
            }
        }
    }
 
    return target;
};
 
const mergeOptions = (...sources) => {
    sources = sources.map(source => source || {});
    const merged = merge({}, ...sources);
 
    const hooks = {};
    for (const hook of knownHookEvents) {
        hooks[hook] = [];
    }
 
    for (const source of sources) {
        if (source.hooks) {
            for (const hook of knownHookEvents) {
                hooks[hook] = hooks[hook].concat(source.hooks[hook]);
            }
        }
    }
 
    merged.hooks = hooks;
 
    return merged;
};
 
const mergeInstances = (instances, methods) => {
    const handlers = instances.map(instance => instance.defaults.handler);
    const size = instances.length - 1;
 
    return {
        methods,
        options: mergeOptions(...instances.map(instance => instance.defaults.options)),
        handler: (options, next) => {
            let iteration = -1;
            const iterate = options => handlers[++iteration](options, iteration === size ? next : iterate);
 
            return iterate(options);
        }
    };
};
 
module.exports = merge;
module.exports.options = mergeOptions;
module.exports.instances = mergeInstances;