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/platform/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "platform",
+  "main": "platform",
+  "types": "platform.d.ts",
+  "nativescript": {}
+}

nativescript-core/platform/platform.android.ts

@@ -0,0 +1,155 @@
+/* tslint:disable:class-name */
+import { Device as DeviceDefinition, ScreenMetrics as ScreenMetricsDefinition } from ".";
+import * as appModule from "../application";
+
+const MIN_TABLET_PIXELS = 600;
+
+export module platformNames {
+    export const android = "Android";
+    export const ios = "iOS";
+}
+
+class Device implements DeviceDefinition {
+    private _manufacturer: string;
+    private _model: string;
+    private _osVersion: string;
+    private _sdkVersion: string;
+    private _deviceType: "Phone" | "Tablet";
+    private _uuid: string;
+    private _language: string;
+    private _region: string;
+
+    get manufacturer(): string {
+        if (!this._manufacturer) {
+            this._manufacturer = android.os.Build.MANUFACTURER;
+        }
+
+        return this._manufacturer;
+    }
+
+    get os(): string {
+        return platformNames.android;
+    }
+
+    get osVersion(): string {
+        if (!this._osVersion) {
+            this._osVersion = android.os.Build.VERSION.RELEASE;
+        }
+
+        return this._osVersion;
+    }
+
+    get model(): string {
+        if (!this._model) {
+            this._model = android.os.Build.MODEL;
+        }
+
+        return this._model;
+    }
+
+    get sdkVersion(): string {
+        if (!this._sdkVersion) {
+            this._sdkVersion = android.os.Build.VERSION.SDK;
+        }
+
+        return this._sdkVersion;
+    }
+
+    get deviceType(): "Phone" | "Tablet" {
+        if (!this._deviceType) {
+            const dips = Math.min(screen.mainScreen.widthPixels, screen.mainScreen.heightPixels) / screen.mainScreen.scale;
+            // If the device has more than 600 dips it is considered to be a tablet.
+            if (dips >= MIN_TABLET_PIXELS) {
+                this._deviceType = "Tablet";
+            }
+            else {
+                this._deviceType = "Phone";
+            }
+        }
+
+        return this._deviceType;
+    }
+
+    get uuid(): string {
+        if (!this._uuid) {
+            const nativeApp = <android.app.Application>appModule.android.nativeApp;
+            this._uuid = android.provider.Settings.Secure.getString(
+                nativeApp.getContentResolver(),
+                android.provider.Settings.Secure.ANDROID_ID
+            );
+        }
+
+        return this._uuid;
+    }
+
+    get language(): string {
+        if (!this._language) {
+            this._language = java.util.Locale.getDefault().getLanguage().replace("_", "-");
+        }
+
+        return this._language;
+    }
+
+    get region(): string {
+        if (!this._region) {
+            this._region = java.util.Locale.getDefault().getCountry();
+        }
+
+        return this._region;
+    }
+}
+
+class MainScreen implements ScreenMetricsDefinition {
+    private _metrics: android.util.DisplayMetrics;
+
+    private reinitMetrics(): void {
+        if (!this._metrics) {
+            this._metrics = new android.util.DisplayMetrics();
+        }
+        this.initMetrics();
+    }
+
+    private initMetrics(): void {
+        const nativeApp = <android.app.Application>appModule.getNativeApplication();
+        nativeApp.getSystemService(android.content.Context.WINDOW_SERVICE).getDefaultDisplay().getRealMetrics(this._metrics);
+    }
+
+    private get metrics(): android.util.DisplayMetrics {
+        if (!this._metrics) {
+            // NOTE: This will be memory leak but we MainScreen is singleton
+            appModule.on("cssChanged", this.reinitMetrics, this);
+            appModule.on(appModule.orientationChangedEvent, this.reinitMetrics, this);
+
+            this._metrics = new android.util.DisplayMetrics();
+            this.initMetrics();
+        }
+
+        return this._metrics;
+    }
+
+    get widthPixels(): number {
+        return this.metrics.widthPixels;
+    }
+    get heightPixels(): number {
+        return this.metrics.heightPixels;
+    }
+    get scale(): number {
+        return this.metrics.density;
+    }
+    get widthDIPs(): number {
+        return this.metrics.widthPixels / this.metrics.density;
+    }
+    get heightDIPs(): number {
+        return this.metrics.heightPixels / this.metrics.density;
+    }
+
+}
+
+export const device = new Device();
+
+export module screen {
+    export const mainScreen = new MainScreen();
+}
+
+export const isAndroid = true;
+export const isIOS = false;

nativescript-core/platform/platform.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Contains all kinds of information about the device, its operating system and software.
+ * @module "platform"
+ */ /** */
+
+/* tslint:disable:class-name */
+
+/**
+ * Gets a value indicating if the app is running on the Android platform.
+ */
+export const isAndroid: boolean;
+
+/**
+ * Gets a value indicating if the app is running on the iOS platform.
+ */
+export const isIOS: boolean;
+
+/*
+ * Enum holding platform names.
+ */
+export module platformNames {
+    export const android: string;
+    export const ios: string;
+}
+
+/*
+ * An object containing device specific information.
+ */
+export interface Device {
+    /**
+     * Gets the manufacturer of the device.
+     * For example: "Apple" or "HTC" or "Samsung".
+     */
+    manufacturer: string;
+
+    /**
+     * Gets the model of the device.
+     * For example: "Nexus 5" or "iPhone".
+     */
+    model: string;
+
+    /**
+     * Gets the OS of the device.
+     * For example: "Android" or "iOS".
+     */
+    os: string;
+
+    /**
+     * Gets the OS version.
+     * For example: 4.4.4(android), 8.1(ios)
+     */
+    osVersion: string;
+
+    /**
+     * Gets the SDK version.
+     * For example: 19(android), 8.1(ios).
+     */
+    sdkVersion: string;
+
+    /**
+     * Gets the type of the current device.
+     * Available values: "Phone", "Tablet".
+     */
+    deviceType: "Phone" | "Tablet";
+
+    /**
+     * Gets the uuid.
+     * On iOS this will return a new uuid if the application is re-installed on the device.
+     * If you need to receive the same uuid even after the application has been re-installed on the device,
+     * use this plugin: https://www.npmjs.com/package/nativescript-ios-uuid
+     */
+    uuid: string;
+
+    /**
+     * Gets the preferred language. For example "en" or "en-US".
+     */
+    language: string;
+
+    /**
+     * Gets the preferred region. For example "US".
+     */
+    region: string;
+}
+
+/**
+ * An object containing screen information.
+ */
+export interface ScreenMetrics {
+    /**
+     * Gets the absolute width of the screen in pixels.
+     */
+    widthPixels: number;
+
+    /**
+     * Gets the absolute height of the screen in pixels.
+     */
+    heightPixels: number;
+
+    /**
+     * Gets the absolute width of the screen in density independent pixels.
+     */
+    widthDIPs: number;
+
+    /**
+     * Gets the absolute height of the screen in density independent pixels.
+     */
+    heightDIPs: number;
+
+    /**
+     * The logical density of the display. This is a scaling factor for the Density Independent Pixel unit.
+     */
+    scale: number;
+}
+
+/**
+ * An object describing general information about a display.
+ */
+export module screen {
+    /**
+     * Gets information about the main screen of the current device.
+     */
+    export const mainScreen: ScreenMetrics;
+}
+
+/**
+ * Gets the current device information.
+ */
+export const device: Device;

nativescript-core/platform/platform.ios.ts

@@ -0,0 +1,129 @@
+/* tslint:disable:class-name */
+import { Device as DeviceDefinition, ScreenMetrics as ScreenMetricsDefinition } from ".";
+
+export module platformNames {
+    export const android = "Android";
+    export const ios = "iOS";
+}
+
+class Device implements DeviceDefinition {
+    private _model: string;
+    private _osVersion: string;
+    private _sdkVersion: string;
+    private _deviceType: "Phone" | "Tablet";
+    private _language: string;
+    private _region: string;
+
+    get manufacturer(): string {
+        return "Apple";
+    }
+
+    get os(): string {
+        return platformNames.ios;
+    }
+
+    get osVersion(): string {
+        if (!this._osVersion) {
+            this._osVersion = UIDevice.currentDevice.systemVersion;
+        }
+
+        return this._osVersion;
+    }
+
+    get model(): string {
+        if (!this._model) {
+            this._model = UIDevice.currentDevice.model;
+        }
+
+        return this._model;
+    }
+
+    get sdkVersion(): string {
+        if (!this._sdkVersion) {
+            this._sdkVersion = UIDevice.currentDevice.systemVersion;
+        }
+
+        return this._sdkVersion;
+    }
+
+    get deviceType(): "Phone" | "Tablet" {
+        if (!this._deviceType) {
+            if (UIDevice.currentDevice.userInterfaceIdiom === UIUserInterfaceIdiom.Phone) {
+                this._deviceType = "Phone";
+            }
+            else {
+                this._deviceType = "Tablet";
+            }
+        }
+
+        return this._deviceType;
+    }
+
+    get uuid(): string {
+        const userDefaults = NSUserDefaults.standardUserDefaults;
+        const uuid_key = "TNSUUID";
+        let app_uuid = userDefaults.stringForKey(uuid_key);
+
+        if (!app_uuid) {
+            app_uuid = NSUUID.UUID().UUIDString;
+            userDefaults.setObjectForKey(app_uuid, uuid_key);
+            userDefaults.synchronize();
+        }
+
+        return app_uuid;
+    }
+
+    get language(): string {
+        if (!this._language) {
+            const languages = NSLocale.preferredLanguages;
+            this._language = languages[0];
+        }
+
+        return this._language;
+    }
+
+    get region(): string {
+        if (!this._region) {
+            this._region = NSLocale.currentLocale.objectForKey(NSLocaleCountryCode);
+        }
+
+        return this._region;
+    }
+}
+
+class MainScreen implements ScreenMetricsDefinition {
+    private _screen: UIScreen;
+
+    private get screen(): UIScreen {
+        if (!this._screen) {
+            this._screen = UIScreen.mainScreen;
+        }
+
+        return this._screen;
+    }
+
+    get widthPixels(): number {
+        return this.widthDIPs * this.scale;
+    }
+    get heightPixels(): number {
+        return this.heightDIPs * this.scale;
+    }
+    get scale(): number {
+        return this.screen.scale;
+    }
+    get widthDIPs(): number {
+        return this.screen.bounds.size.width;
+    }
+    get heightDIPs(): number {
+        return this.screen.bounds.size.height;
+    }
+}
+
+export const device = new Device();
+
+export module screen {
+    export const mainScreen = new MainScreen();
+}
+
+export const isIOS = true;
+export const isAndroid = false;