backend/helper/observe.js at dev · OpenHausIO/backend · GitHub

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
// https://javascript.info/task/observable

/**
 * @function observe
 * Observe a object like thing
 *
 * @param {Object} target
 * @param {Object} options
 * @param {Function} setter
 * @param {Function} getter
 *
 * @deprecated
 * Use "reactive" instead.
 *
 * @returns {Proxy} Observed object
 */
function observe(target, options, getter, setter) {

    if (options instanceof Function && !getter) {
        getter = options;
        options = {};
    }

    if (!(options instanceof Object)) {
        throw new Error(`Expected a object as options paramteter, got "${typeof options}"`);
    }

    if (!setter) {
        setter = () => { };
    }

    if (!getter) {
        getter = () => { };
    }

    if (!(setter instanceof Function)) {
        throw new Error(`Expected a functions as "setter" parameter, got "${typeof options}"`);
    }

    if (!(getter instanceof Function)) {
        throw new Error(`Expected a functions as "getter" parameter, got "${typeof options}"`);
    }


    options = Object.assign({
        intercept: false,
        recursiv: true
    }, options);


    if (options.recursiv) {
        for (let prop in target) {
            if (target[prop] instanceof Object) {
                target[prop] = observe(target[prop], options, getter, setter);
            }
        }
    }

    return new Proxy(target, {
        set(target, prop, value, receiver) {
            if (options.intercept) {

                if (!setter(prop, value, target, receiver)) {
                    return false;
                }

                return Reflect.set(...arguments);

            } else {

                let success = Reflect.set(...arguments);

                if (success) {
                    setter(prop, value, target, receiver);
                }

                return success;

            }
        },
        get(target, prop, receiver) {
            if (options.intercept) {

                if (!getter(target, prop, receiver)) {
                    return target[prop];
                }

                return undefined;

            } else {

                getter(target, prop, receiver);
                return Reflect.get(target, prop);

            }
        }
    });

}


module.exports = observe;