StoreJs/store.js at main · fritzdultimate/StoreJs · 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
103
let $__DATA__$ = new Proxy({}, handler());
let $__Store = new Proxy({}, handler())
function storeSetup(object) {
    $__Store = new Proxy(object, handler());
    $__DATA__$ = Object.assign({}, $__Store.store.state());
}
function handler() {
    return {
        get: (target, prop, receiver) => {
            if(['[object Object]', '[object Array]'].indexOf(Object.prototype.toString.call(target[prop])) > -1) {
                return new Proxy(target[prop], handler(target))
            }
            let value =  Reflect.get(target, prop, receiver);
            return typeof value == 'function' ? value.bind(target) : value;
        },

        set: (target, prop, val, receiver) => {
            return Reflect.set(target, prop, val, receiver);
        },
    }
}

function storeGetters(getters) {
    let $_getters = {};
    if(Object.prototype.toString.call(getters) == '[object Object]') {
        try {
            for(let i = 0; i < Object.entries(getters).length; i++) {
                let property = Object.entries(getters)[i][1]
                if(!(property in $__Store.store.getters)) {
                    throw new Error('Unknown getter')
                }
                let get = $__Store.store.getters[property];
                $_getters[Object.entries(getters)[i][0]] = get($__DATA__$);
            }
        } catch(e) {
            console.error(e)
        }
    }
    return new Proxy($_getters, {
        get: (target, prop, receiver) => {
            if(['[object Object]', '[object Array]'].indexOf(Object.prototype.toString.call(target[prop])) > -1) {
                return new Proxy(target[prop], handler(target))
            }
            let value =  Reflect.get(target, prop, receiver);
            return typeof value == 'function' ? value.bind(target) : value;
        }
    });
}

function storeActions(actions) {
    let $_actions = {};
    if(Object.prototype.toString.call(actions) == '[object Object]') {
        try {
            for(let i = 0; i < Object.entries(actions).length; i++) {
                let property = Object.entries(actions)[i][0]
                if(!(property in $__Store.store.actions)) {
                    throw new Error('Unknown action')
                }
                let action = $__Store.store.actions[property];
                $_actions[Object.entries(actions)[i][1]] = action;
                let parameters_values = Object.entries(actions)[i][1];
                let parameter = action().arguments;
                let obj = {};
                Object.defineProperty(obj, parameter, {
                    value: parameters_values,
                    writable: false,
                    enumerable: true
                });
                // parameter = parameters_values
                let method = action().method;
                let a = commit.call(null, method,  obj );
            }
        } catch(e) {
            console.error(e)
        }
    }
    return new Proxy($_actions, {
        get: (target, prop, receiver) => {
            if(['[object Object]', '[object Array]'].indexOf(Object.prototype.toString.call(target[prop])) > -1) {
                return new Proxy(target[prop], handler(target))
            }
            let value =  Reflect.get(target, prop, receiver);
            return typeof value == 'function' ? value.bind(target) : value;
        },
        set: (target, prop, val) => {
            target[prop] = val;
            return true;
        }
    });
}

function commit(mutation, args) {
    let meth = $__Store.store.mutations[mutation];
    meth($__DATA__$, args);
}


export {
    storeSetup,
    storeGetters,
    storeActions
}