feat: Scoped Packages (#7911)

* chore: move tns-core-modules to nativescript-core

* chore: preparing compat generate script

* chore: add missing definitions

* chore: no need for http-request to be private

* chore: packages chore

* test: generate tests for tns-core-modules

* chore: add anroid module for consistency

* chore: add .npmignore

* chore: added privateModulesWhitelist

* chore(webpack): added bundle-entry-points

* chore: scripts

* chore: tests changed to use @ns/core

* test: add scoped-packages test project

* test: fix types

* test: update test project

* chore: build scripts

* chore: update build script

* chore: npm scripts cleanup

* chore: make the compat pgk work with old wp config

* test: generate diff friendly tests

* chore: create barrel exports

* chore: move files after rebase

* chore: typedoc config

* chore: compat mode

* chore: review of barrels

* chore: remove tns-core-modules import after rebase

* chore: dev workflow setup

* chore: update developer-workflow

* docs: experiment with API extractor

* chore: api-extractor and barrel exports

* chore: api-extractor configs

* chore: generate d.ts rollup with api-extractor

* refactor: move methods inside Frame

* chore: fic tests to use Frame static methods

* refactor: create Builder class

* refactor: use Builder class in tests

* refactor: include Style in ui barrel

* chore: separate compat build script

* chore: fix tslint errors

* chore: update NATIVESCRIPT_CORE_ARGS

* chore: fix compat pack

* chore: fix ui-test-app build with linked modules

* chore: Application, ApplicationSettings, Connectivity and Http

* chore: export Trace, Profiling and Utils

* refactor: Static create methods for ImageSource

* chore: fix deprecated usages of ImageSource

* chore: move Span and FormattedString to ui

* chore: add events-args and ImageSource to index files

* chore: check for CLI >= 6.2 when building for IOS

* chore: update travis build

* chore: copy Pod file to compat package

* chore: update error msg ui-tests-app

* refactor: Apply suggestions from code review

Co-Authored-By: Martin Yankov <m.i.yankov@gmail.com>

* chore: typings and refs

* chore: add missing d.ts files for public API

* chore: adress code review FB

* chore: update api-report

* chore: dev-workflow for other apps

* chore: api update

* chore: update api-report

nativescript-core/data/virtual-array/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "virtual-array",
+  "types": "virtual-array.d.ts",
+  "main": "virtual-array"
+}

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

@@ -0,0 +1,83 @@
+/**
+ * Contains the VirtualArray class, which is an advanced array like class that helps loading items on demand.
+ * @module "data/virtual-array"
+ */ /** */
+
+import { Observable, EventData } from "../observable";
+import { ObservableArray, ChangedData, ChangeType } from "../observable-array";
+export { ChangedData, ChangeType } from "../observable-array";
+
+/**
+ * Advanced array like class that helps loading items on demand.
+ */
+export class VirtualArray<T> extends Observable {
+    /**
+     * String value used when hooking to change event.
+     */
+    public static changeEvent: string;
+
+    /**
+     * String value used when hooking to itemsLoading event.
+     */
+    public static itemsLoadingEvent: string;
+
+    constructor(arrayLength?: number);
+
+    /**
+     * Gets or sets length for the virtual array.
+     */
+    length: number;
+
+    /**
+     * Gets or sets load size for the virtual array.
+     */
+    loadSize: number;
+
+    /**
+     * Returns item at specified index.
+     */
+    getItem(index: number): T;
+
+    /**
+     * Sets item at specified index.
+     */
+    setItem(index: number, value: T): void;
+
+    /**
+     * Loads items from an array starting at index.
+     */
+    load(index: number, items: T[]): void;
+
+    /**
+     * A basic method signature to hook an event listener (shortcut alias to the addEventListener method).
+     * @param eventNames - String corresponding to events (e.g. "propertyChange"). Optionally could be used more events separated by `,` (e.g. "propertyChange", "change").
+     * @param callback - Callback function which will be executed when event is raised.
+     * @param thisArg - An optional parameter which will be used as `this` context for callback execution.
+     */
+    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);
+
+    /**
+     * Raised when still not loaded items are requested.
+     */
+    on(event: "itemsLoading", callback: (args: ItemsLoading) => void, thisArg?: any);
+
+    /**
+     * Raised when a change occurs.
+     */
+    on(event: "change", callback: (args: ChangedData<T>) => void, thisArg?: any);
+}
+
+/**
+ * Event args for "itemsLoading" event.
+ */
+export interface ItemsLoading extends EventData {
+    /**
+     * Start index.
+     */
+    index: number;
+
+    /**
+     * Number of items to load.
+     */
+    count: number;
+}

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);
+}