Merge branch 'master'

nativescript-core/data/virtual-array/virtual-array.ts

@@ -0,0 +1,165 @@
+import { Observable, EventData } from "../observable";
+import * as virtualArrayDef from ".";
+
+const CHANGE = "change";
+const UPDATE = "update";
+const DELETE = "delete";
+const ADD = "add";
+
+export class ChangeType implements virtualArrayDef.ChangeType {
+    static Add = ADD;
+    static Delete = DELETE;
+    static Update = UPDATE;
+    static Splice = CHANGE;
+}
+
+export class VirtualArray<T> extends Observable implements virtualArrayDef.VirtualArray<T> {
+    public static changeEvent = CHANGE;
+    public static itemsLoadingEvent = "itemsLoading";
+
+    private _requestedIndexes: Array<number>;
+    private _loadedIndexes: Array<number>;
+    private _length: number;
+    private _cache: {};
+
+    constructor(length = 0) {
+        super();
+
+        this._length = length;
+        this._cache = {};
+
+        this._requestedIndexes = [];
+        this._loadedIndexes = [];
+    }
+
+    get length(): number {
+        return this._length;
+    }
+    set length(value: number) {
+        if (this._length !== value) {
+
+            const index = this._length;
+            const count = value - this._length;
+
+            this._length = value;
+
+            this.notify({
+                eventName: CHANGE, object: this,
+                action: count > 0 ? ADD : DELETE,
+                index: index,
+                removed: new Array(count < 0 ? Math.abs(count) : 0),
+                addedCount: count > 0 ? count : 0
+            });
+        }
+    }
+
+    private _loadSize: number;
+    get loadSize(): number {
+        return this._loadSize;
+    }
+    set loadSize(value: number) {
+        this._loadSize = value;
+    }
+
+    getItem(index: number): T {
+        const item = this._cache[index];
+
+        if (item === undefined) {
+            if (index >= 0 && index < this.length && this._requestedIndexes.indexOf(index) < 0 && this._loadedIndexes.indexOf(index) < 0) {
+                this.requestItems(index);
+            }
+        }
+
+        return item;
+    }
+
+    setItem(index: number, value: T) {
+        if (this._cache[index] !== value) {
+            this.load(index, [value]);
+        }
+    }
+
+    load(index: number, items: T[]): void {
+        for (let i = 0; i < items.length; i++) {
+
+            const itemIndex = index + i;
+
+            this._cache[itemIndex] = items[i];
+
+            this._requestedIndexes.splice(this._requestedIndexes.indexOf(itemIndex), 1);
+
+            if (this._loadedIndexes.indexOf(itemIndex) < 0) {
+                this._loadedIndexes.push(itemIndex);
+            }
+        }
+
+        // Remove requested but never loaded indexes.
+        if (this._requestedIndexes.length > 0) {
+            for (let i = 0; i < this.loadSize - items.length; i++) {
+                this._requestedIndexes.splice(this._requestedIndexes.indexOf(index + i), 1);
+            }
+        }
+
+        this.notify({
+            eventName: CHANGE, object: this,
+            action: UPDATE,
+            index: index,
+            removed: new Array(items.length),
+            addedCount: items.length
+        });
+    }
+
+    private requestItems(index: number): void {
+        const indexesToLoad = [];
+
+        const pageIndex = this._loadSize > 0 ? this._loadSize * Math.floor(index / this._loadSize) : index;
+        let count = 0;
+        let start = -1;
+
+        for (let i = 0; i < this.loadSize; i++) {
+            const itemIndex = pageIndex + i;
+
+            if (itemIndex >= this._length) {
+                break;
+            }
+
+            if (this._loadedIndexes.indexOf(itemIndex) < 0) {
+                if (start < 0) {
+                    start = itemIndex;
+                }
+
+                indexesToLoad.push(itemIndex);
+
+                if (this._requestedIndexes.indexOf(itemIndex) < 0) {
+                    this._requestedIndexes.push(itemIndex);
+                }
+
+                count++;
+            } else {
+                if (count > 0) {
+                    this.notify({
+                        eventName: VirtualArray.itemsLoadingEvent, object: this,
+                        index: start,
+                        count: count
+                    });
+                }
+
+                start = -1;
+                count = 0;
+            }
+        }
+
+        if (start >= 0 && count > 0) {
+            this.notify({
+                eventName: VirtualArray.itemsLoadingEvent, object: this,
+                index: start,
+                count: count
+            });
+        }
+    }
+}
+export interface VirtualArray<T> {
+    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);
+    on(event: "itemsLoading", callback: (args: virtualArrayDef.ItemsLoading) => void, thisArg?: any);
+    on(event: "change", callback: (args: virtualArrayDef.ChangedData<T>) => void, thisArg?: any);
+}