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/connectivity/connectivity.android.ts

@@ -0,0 +1,67 @@
+import { getNativeApplication, android as androidApp } from "../application";
+
+export enum connectionType {
+    none = 0,
+    wifi = 1,
+    mobile = 2,
+    ethernet = 3,
+    bluetooth = 4
+}
+
+const wifi = "wifi";
+const mobile = "mobile";
+const ethernet = "ethernet";
+const bluetooth = "bluetooth";
+
+// Get Connection Type
+function getConnectivityManager(): android.net.ConnectivityManager {
+    return getNativeApplication().getApplicationContext().getSystemService(android.content.Context.CONNECTIVITY_SERVICE);
+}
+
+function getActiveNetworkInfo(): android.net.NetworkInfo {
+    let connectivityManager = getConnectivityManager();
+    if (!connectivityManager) {
+        return null;
+    }
+
+    return connectivityManager.getActiveNetworkInfo();
+}
+
+export function getConnectionType(): number {
+    let activeNetworkInfo = getActiveNetworkInfo();
+    if (!activeNetworkInfo || !activeNetworkInfo.isConnected()) {
+        return connectionType.none;
+    }
+
+    let type = activeNetworkInfo.getTypeName().toLowerCase();
+    if (type.indexOf(wifi) !== -1) {
+        return connectionType.wifi;
+    }
+
+    if (type.indexOf(mobile) !== -1) {
+        return connectionType.mobile;
+    }
+
+    if (type.indexOf(ethernet) !== -1) {
+        return connectionType.ethernet;
+    }
+
+    if (type.indexOf(bluetooth) !== -1) {
+        return connectionType.bluetooth;
+    }
+
+    return connectionType.none;
+}
+
+export function startMonitoring(connectionTypeChangedCallback: (newConnectionType: number) => void): void {
+    let onReceiveCallback = function onReceiveCallback(context: android.content.Context, intent: android.content.Intent) {
+        let newConnectionType = getConnectionType();
+        connectionTypeChangedCallback(newConnectionType);
+    };
+    let zoneCallback = <any>zonedCallback(onReceiveCallback);
+    androidApp.registerBroadcastReceiver(android.net.ConnectivityManager.CONNECTIVITY_ACTION, zoneCallback);
+}
+
+export function stopMonitoring(): void {
+    androidApp.unregisterBroadcastReceiver(android.net.ConnectivityManager.CONNECTIVITY_ACTION);
+}

nativescript-core/connectivity/connectivity.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Contains connectivity utility methods.
+ * @module "connectivity"
+ */ /** */
+
+/**
+ * Gets the type of connection.
+ * Returns a value from the connectivity.connectionType enumeration.
+ * To use this method on Android you need to have the android.permission.ACCESS_NETWORK_STATE permission added to the AndroidManifest.xml file.
+ */
+export function getConnectionType(): number;
+
+/**
+ * Defines the different connection types.
+ */
+export enum connectionType {
+    /**
+     * Denotes no connection.
+     */
+    none = 0,
+
+    /**
+     * Denotes a WiFi connection.
+     */
+    wifi = 1,
+
+    /**
+     * Denotes a mobile connection, i.e. cellular network or WAN.
+     */
+    mobile = 2,
+
+    /**
+     * Denotes an ethernet connection
+     */
+    ethernet = 3,
+
+    /**
+     * Denotes an bluetooth connection
+     */
+    bluetooth = 4
+}
+
+/**
+ * Starts monitoring the connection type.
+ * @param connectionTypeChangedCallback A function that will be called when the connection type changes.
+ */
+export function startMonitoring(connectionTypeChangedCallback: (newConnectionType: number) => void): void;
+
+/**
+ * Stops monitoring the connection type.
+ */
+export function stopMonitoring(): void;

nativescript-core/connectivity/connectivity.ios.ts

@@ -0,0 +1,91 @@
+export enum connectionType {
+    none = 0,
+    wifi = 1,
+    mobile = 2,
+}
+
+// Get Connection Type
+declare const sockaddr;
+function _createReachability(host?: string): any {
+    if (host) {
+        return SCNetworkReachabilityCreateWithName(null, host);
+    } else {
+        const zeroAddress = new interop.Reference<sockaddr>(sockaddr, {
+            sa_len: 16,
+            sa_family: 2
+        });
+
+        return SCNetworkReachabilityCreateWithAddress(null, zeroAddress);
+    }
+}
+
+function _getReachabilityFlags(host?: string): number {
+    const reachability = _createReachability(host);
+    const flagsRef = new interop.Reference<number>();
+    const gotFlags = SCNetworkReachabilityGetFlags(reachability, flagsRef);
+    if (!gotFlags) {
+        return null;
+    }
+
+    return flagsRef.value;
+}
+
+function _getConnectionType(host?: string): number {
+    const flags = _getReachabilityFlags(host);
+
+    return _getConnectionTypeFromFlags(flags);
+}
+
+function _getConnectionTypeFromFlags(flags: number): number {
+    if (!flags) {
+        return connectionType.none;
+    }
+
+    const isReachable = flags & SCNetworkReachabilityFlags.kSCNetworkReachabilityFlagsReachable;
+    const connectionRequired = flags & SCNetworkReachabilityFlags.kSCNetworkReachabilityFlagsConnectionRequired;
+    if (!isReachable || connectionRequired) {
+        return connectionType.none;
+    }
+
+    const isWWAN = flags & SCNetworkReachabilityFlags.kSCNetworkReachabilityFlagsIsWWAN;
+    if (isWWAN) {
+        return connectionType.mobile;
+    }
+
+    return connectionType.wifi;
+}
+
+export function getConnectionType(): number {
+    return _getConnectionType();
+}
+
+// Start/Stop Monitoring
+function _reachabilityCallback(target: any, flags: number, info: any) {
+    if (_connectionTypeChangedCallback) {
+        const newConnectionType = _getConnectionTypeFromFlags(flags);
+        _connectionTypeChangedCallback(newConnectionType);
+    }
+}
+
+const _reachabilityCallbackFunctionRef = new interop.FunctionReference(_reachabilityCallback);
+
+let _monitorReachabilityRef: any;
+let _connectionTypeChangedCallback: (newConnectionType: number) => void;
+
+export function startMonitoring(connectionTypeChangedCallback: (newConnectionType: number) => void): void {
+    if (!_monitorReachabilityRef) {
+        _monitorReachabilityRef = _createReachability();
+        _connectionTypeChangedCallback = <any>zonedCallback(connectionTypeChangedCallback);
+        SCNetworkReachabilitySetCallback(_monitorReachabilityRef, _reachabilityCallbackFunctionRef, null);
+        SCNetworkReachabilityScheduleWithRunLoop(_monitorReachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
+        _connectionTypeChangedCallback(_getConnectionType());
+    }
+}
+
+export function stopMonitoring(): void {
+    if (_monitorReachabilityRef) {
+        SCNetworkReachabilityUnscheduleFromRunLoop(_monitorReachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
+        _monitorReachabilityRef = undefined;
+        _connectionTypeChangedCallback = undefined;
+    }
+}

nativescript-core/connectivity/package.json

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