neuron/lib/switch/async.js at master · cssrain/neuron · 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
104
105
106
107
108
109
110

function fackSync(data, callback){
    callback && callback();
};


var

METHODS = {
    _prepareItems: function(){
        var self = this,
            data = self.get('data'),
            data_max = self.get('dataLength') - 1,

            expect_left = Math.max(self.expectIndex, 0),

             // less than `dataLength`
            expect_right = Math.min(expect_left + self.get('stage') - 1, data_max),

            is_forward = expect_left - self.activeIndex >= 0,

            data_right = self.dataRight,
            data_left = self.dataLeft,

            prefetch = self.get('prefetch'),

            // basic preload
            load_left = data_left,
            load_right = data_right,

            async_needed = true,
            load_start,
            load_amount;

        // positive direction
        if(is_forward){
            load_right = Math.min(expect_right + prefetch, data_max);
        }else{
            load_left = Math.max(expect_left - prefetch, 0);
        }

        if(expect_right > data_right){
            load_start = data_right + 1;
            load_amount = load_right - data_right;

        }else if(expect_left < data_left){
            load_start = load_left;
            load_amount = data_left - load_left;

        }else{
            async_needed = false;
        }

        if(async_needed){
            // sync 变成一个获取和控制 async method 的方法，会自己处理异步请求结束的工作
            self.get('sync')({
                start: load_start,
                amount: load_amount

            }, function(rt){
                var itemData = rt.items, item, index,
                    start = load_start,
                    amount = load_amount,
                    i = 0,
                    renderer = self.get('itemRenderer');

                for(; i < amount; i ++ ){
                    index = start + i;
                    data[index] = itemData[i];

                    if(index >= expect_left && index <= expect_right && index < self.length){
                        item = self._getItem(index);
                        renderer.call(self, index).children().inject(item.empty().removeClass('pending'));
                    }
                }

                self.dataRight = Math.max(load_right, self.dataRight);
                self.dataLeft = Math.min(load_left, self.dataLeft);

                // self._lifeCycle.resume();
            });
        }

        self._before();
    }
};


module.exports = {
    name: 'async',

    ATTRS: {
        /**
         * @type {function()} method to fetching data
         */
        sync: {
            value: fackSync
        },

        prefetch: {
            getter: function(v){
                return v || this.get('move') * 2;
            }
        }
    },

    init: function(self){
        var EVENTS = self.get('EVENTS');
    }
};