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/ui/web-view/package.json

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

nativescript-core/ui/web-view/web-view-common.ts

@@ -0,0 +1,96 @@
+import { WebView as WebViewDefinition, LoadEventData, NavigationType } from ".";
+import { ContainerView, Property, EventData, CSSType } from "../core/view";
+import { File, knownFolders, path } from "../../file-system";
+
+export { File, knownFolders, path, NavigationType };
+export * from "../core/view";
+
+export const srcProperty = new Property<WebViewBase, string>({ name: "src" });
+
+@CSSType("WebView")
+export abstract class WebViewBase extends ContainerView implements WebViewDefinition {
+    public static loadStartedEvent = "loadStarted";
+    public static loadFinishedEvent = "loadFinished";
+
+    public src: string;
+
+    public _onLoadFinished(url: string, error?: string) {
+        let args = <LoadEventData>{
+            eventName: WebViewBase.loadFinishedEvent,
+            object: this,
+            url: url,
+            navigationType: undefined,
+            error: error
+        };
+
+        this.notify(args);
+    }
+
+    public _onLoadStarted(url: string, navigationType: NavigationType) {
+        let args = <LoadEventData>{
+            eventName: WebViewBase.loadStartedEvent,
+            object: this,
+            url: url,
+            navigationType: navigationType,
+            error: undefined
+        };
+
+        this.notify(args);
+    }
+
+    abstract _loadUrl(src: string): void;
+
+    abstract _loadData(src: string): void;
+
+    abstract stopLoading(): void;
+
+    get canGoBack(): boolean {
+        throw new Error("This member is abstract.");
+    }
+
+    get canGoForward(): boolean {
+        throw new Error("This member is abstract.");
+    }
+
+    abstract goBack(): void;
+
+    abstract goForward(): void;
+
+    abstract reload(): void;
+
+    [srcProperty.getDefault](): string {
+        return "";
+    }
+    [srcProperty.setNative](src: string) {
+        this.stopLoading();
+
+        // Add file:/// prefix for local files.
+        // They should be loaded with _loadUrl() method as it handles query params.
+        if (src.indexOf("~/") === 0) {
+            src = `file:///${knownFolders.currentApp().path}/` + src.substr(2);
+        } else if (src.indexOf("/") === 0) {
+            src = "file://" + src;
+        }
+
+        // loading local files from paths with spaces may fail
+        if (src.toLowerCase().indexOf("file:///") === 0) {
+            src = encodeURI(src);
+        }
+
+        if (src.toLowerCase().indexOf("http://") === 0 ||
+            src.toLowerCase().indexOf("https://") === 0 ||
+            src.toLowerCase().indexOf("file:///") === 0) {
+            this._loadUrl(src);
+        } else {
+            this._loadData(src);
+        }
+    }
+}
+
+export interface WebViewBase {
+    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);
+    on(event: "loadFinished", callback: (args: LoadEventData) => void, thisArg?: any);
+    on(event: "loadStarted", callback: (args: LoadEventData) => void, thisArg?: any);
+}
+
+srcProperty.register(WebViewBase);

nativescript-core/ui/web-view/web-view.android.ts

@@ -0,0 +1,183 @@
+import { WebViewBase, knownFolders, traceEnabled, traceWrite, traceCategories } from "./web-view-common";
+
+export * from "./web-view-common";
+
+interface WebViewClient {
+    new(owner: WebView): android.webkit.WebViewClient;
+}
+
+let WebViewClient: WebViewClient;
+
+function initializeWebViewClient(): void {
+    if (WebViewClient) {
+        return;
+    }
+
+    class WebViewClientImpl extends android.webkit.WebViewClient {
+
+        constructor(public owner: WebViewBase) {
+            super();
+
+            return global.__native(this);
+        }
+
+        public shouldOverrideUrlLoading(view: android.webkit.WebView, url: string) {
+            if (traceEnabled()) {
+                traceWrite("WebViewClientClass.shouldOverrideUrlLoading(" + url + ")", traceCategories.Debug);
+            }
+
+            return false;
+        }
+
+        public onPageStarted(view: android.webkit.WebView, url: string, favicon: android.graphics.Bitmap) {
+            super.onPageStarted(view, url, favicon);
+            const owner = this.owner;
+            if (owner) {
+                if (traceEnabled()) {
+                    traceWrite("WebViewClientClass.onPageStarted(" + url + ", " + favicon + ")", traceCategories.Debug);
+                }
+                owner._onLoadStarted(url, undefined);
+            }
+        }
+
+        public onPageFinished(view: android.webkit.WebView, url: string) {
+            super.onPageFinished(view, url);
+            const owner = this.owner;
+            if (owner) {
+                if (traceEnabled()) {
+                    traceWrite("WebViewClientClass.onPageFinished(" + url + ")", traceCategories.Debug);
+                }
+                owner._onLoadFinished(url, undefined);
+            }
+        }
+
+        public onReceivedError() {
+            let view: android.webkit.WebView = arguments[0];
+
+            if (arguments.length === 4) {
+                let errorCode: number = arguments[1];
+                let description: string = arguments[2];
+                let failingUrl: string = arguments[3];
+
+                super.onReceivedError(view, errorCode, description, failingUrl);
+
+                const owner = this.owner;
+                if (owner) {
+                    if (traceEnabled()) {
+                        traceWrite("WebViewClientClass.onReceivedError(" + errorCode + ", " + description + ", " + failingUrl + ")", traceCategories.Debug);
+                    }
+                    owner._onLoadFinished(failingUrl, description + "(" + errorCode + ")");
+                }
+            } else {
+                let request: any = arguments[1];
+                let error: any = arguments[2];
+
+                // before API version 23 there's no onReceiveError with 3 parameters, so it shouldn't come here
+                // but we don't have the onReceivedError with 3 parameters there and that's why we are ignorint tye typescript error
+                // @ts-ignore TS2554
+                super.onReceivedError(view, request, error);
+
+                const owner = this.owner;
+                if (owner) {
+                    if (traceEnabled()) {
+                        traceWrite("WebViewClientClass.onReceivedError(" + error.getErrorCode() + ", " + error.getDescription() + ", " + (error.getUrl && error.getUrl()) + ")", traceCategories.Debug);
+                    }
+                    owner._onLoadFinished(error.getUrl && error.getUrl(), error.getDescription() + "(" + error.getErrorCode() + ")");
+                }
+            }
+        }
+    }
+
+    WebViewClient = WebViewClientImpl;
+}
+
+export class WebView extends WebViewBase {
+    nativeViewProtected: android.webkit.WebView;
+
+    public createNativeView() {
+        const nativeView = new android.webkit.WebView(this._context);
+        nativeView.getSettings().setJavaScriptEnabled(true);
+        nativeView.getSettings().setBuiltInZoomControls(true);
+
+        return nativeView;
+    }
+
+    public initNativeView(): void {
+        super.initNativeView();
+        initializeWebViewClient();
+        const nativeView = this.nativeViewProtected;
+        const client = new WebViewClient(this);
+        nativeView.setWebViewClient(client);
+        (<any>nativeView).client = client;
+    }
+
+    public disposeNativeView() {
+        const nativeView = this.nativeViewProtected;
+        if (nativeView) {
+            nativeView.destroy();
+        }
+
+        (<any>nativeView).client.owner = null;
+        super.disposeNativeView();
+    }
+
+    public _loadUrl(src: string) {
+        const nativeView = this.nativeViewProtected;
+        if (!nativeView) {
+            return;
+        }
+
+        nativeView.loadUrl(src);
+    }
+
+    public _loadData(src: string) {
+        const nativeView = this.nativeViewProtected;
+        if (!nativeView) {
+            return;
+        }
+
+        const baseUrl = `file:///${knownFolders.currentApp().path}/`;
+        nativeView.loadDataWithBaseURL(baseUrl, src, "text/html", "utf-8", null);
+    }
+
+    get canGoBack(): boolean {
+        return this.nativeViewProtected.canGoBack();
+    }
+
+    public stopLoading() {
+        const nativeView = this.nativeViewProtected;
+        if (nativeView) {
+            nativeView.stopLoading();
+        }
+    }
+
+    get canGoForward(): boolean {
+        const nativeView = this.nativeViewProtected;
+        if (nativeView) {
+            return nativeView.canGoForward();
+        }
+
+        return false;
+    }
+
+    public goBack() {
+        const nativeView = this.nativeViewProtected;
+        if (nativeView) {
+            return nativeView.goBack();
+        }
+    }
+
+    public goForward() {
+        const nativeView = this.nativeViewProtected;
+        if (nativeView) {
+            return nativeView.goForward();
+        }
+    }
+
+    public reload() {
+        const nativeView = this.nativeViewProtected;
+        if (nativeView) {
+            return nativeView.reload();
+        }
+    }
+}

nativescript-core/ui/web-view/web-view.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Contains the WebView class, which represents a standard browser widget.
+ * @module "ui/web-view"
+ */ /** */
+
+import { View, Property, EventData } from "../core/view";
+
+/**
+ * Represents the observable property backing the Url property of each WebView instance.
+ */
+export const urlProperty: Property<WebView, string>;
+
+/**
+ * Represents navigation type
+ */
+export type NavigationType = "linkClicked" | "formSubmitted" | "backForward" | "reload" | "formResubmitted" | "other" | undefined;
+
+/**
+ * Represents a standard WebView widget.
+ */
+export class WebView extends View {
+    /**
+     * String value used when hooking to loadStarted event.
+     */
+    public static loadStartedEvent: string;
+
+    /**
+     * String value used when hooking to loadFinished event.
+     */
+    public static loadFinishedEvent: string;
+
+    /**
+     * Gets the native [android widget](http://developer.android.com/reference/android/webkit/WebView.html) that represents the user interface for this component. Valid only when running on Android OS.
+     */
+    android: any /* android.webkit.WebView */;
+
+    /**
+     * Gets the native [WKWebView](https://developer.apple.com/documentation/webkit/wkwebview/) that represents the user interface for this component. Valid only when running on iOS.
+     */
+    ios: any /* WKWebView */;
+
+    /**
+     * Gets or sets the url, local file path or HTML string.
+     */
+    src: string;
+
+    /**
+     * Gets a value indicating whether the WebView can navigate back.
+     */
+    canGoBack: boolean;
+
+    /**
+     * Gets a value indicating whether the WebView can navigate forward.
+     */
+    canGoForward: boolean;
+
+    /**
+     * Stops loading the current content (if any).
+     */
+    stopLoading(): void;
+
+    /**
+     * Navigates back.
+     */
+    goBack();
+
+    /**
+     * Navigates forward.
+     */
+    goForward();
+
+    /**
+     * Reloads the current url.
+     */
+    reload();
+
+    /**
+     * 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 a loadFinished event occurs.
+     */
+    on(event: "loadFinished", callback: (args: LoadEventData) => void, thisArg?: any);
+
+    /**
+     * Raised when a loadStarted event occurs.
+     */
+    on(event: "loadStarted", callback: (args: LoadEventData) => void, thisArg?: any);
+}
+
+/**
+ * Event data containing information for the loading events of a WebView.
+ */
+export interface LoadEventData extends EventData {
+    /**
+     * Gets the url of the web-view.
+     */
+    url: string;
+
+    /**
+     * Gets the navigation type of the web-view.
+     */
+    navigationType: NavigationType;
+
+    /**
+     * Gets the error (if any).
+     */
+    error: string;
+}

nativescript-core/ui/web-view/web-view.ios.ts

@@ -0,0 +1,180 @@
+import { WebViewBase, knownFolders, traceWrite, traceEnabled, traceCategories, NavigationType } from "./web-view-common";
+import { profile } from "../../profiling";
+export * from "./web-view-common";
+
+class WKNavigationDelegateImpl extends NSObject
+    implements WKNavigationDelegate {
+    public static ObjCProtocols = [WKNavigationDelegate];
+    public static initWithOwner(owner: WeakRef<WebView>): WKNavigationDelegateImpl {
+        const handler = <WKNavigationDelegateImpl>WKNavigationDelegateImpl.new();
+        handler._owner = owner;
+
+        return handler;
+    }
+    private _owner: WeakRef<WebView>;
+
+    public webViewDecidePolicyForNavigationActionDecisionHandler(webView: WKWebView, navigationAction: WKNavigationAction, decisionHandler: any): void {
+        const owner = this._owner.get();
+        if (owner && navigationAction.request.URL) {
+            let navType: NavigationType = "other";
+
+            switch (navigationAction.navigationType) {
+                case WKNavigationType.LinkActivated:
+                    navType = "linkClicked";
+                    break;
+                case WKNavigationType.FormSubmitted:
+                    navType = "formSubmitted";
+                    break;
+                case WKNavigationType.BackForward:
+                    navType = "backForward";
+                    break;
+                case WKNavigationType.Reload:
+                    navType = "reload";
+                    break;
+                case WKNavigationType.FormResubmitted:
+                    navType = "formResubmitted";
+                    break;
+            }
+            decisionHandler(WKNavigationActionPolicy.Allow);
+
+            if (traceEnabled()) {
+                traceWrite("WKNavigationDelegateClass.webViewDecidePolicyForNavigationActionDecisionHandler(" + navigationAction.request.URL.absoluteString + ", " + navigationAction.navigationType + ")", traceCategories.Debug);
+            }
+            owner._onLoadStarted(navigationAction.request.URL.absoluteString, navType);
+        }
+    }
+
+    public webViewDidStartProvisionalNavigation(webView: WKWebView, navigation: WKNavigation): void {
+        if (traceEnabled()) {
+            traceWrite("WKNavigationDelegateClass.webViewDidStartProvisionalNavigation(" + webView.URL + ")", traceCategories.Debug);
+        }
+    }
+
+    public webViewDidFinishNavigation(webView: WKWebView, navigation: WKNavigation): void {
+        if (traceEnabled()) {
+            traceWrite("WKNavigationDelegateClass.webViewDidFinishNavigation(" + webView.URL + ")", traceCategories.Debug);
+        }
+        const owner = this._owner.get();
+        if (owner) {
+            let src = owner.src;
+            if (webView.URL) {
+                src = webView.URL.absoluteString;
+            }
+            owner._onLoadFinished(src);
+        }
+    }
+
+    public webViewDidFailNavigationWithError(webView: WKWebView, navigation: WKNavigation, error: NSError): void {
+        const owner = this._owner.get();
+        if (owner) {
+            let src = owner.src;
+            if (webView.URL) {
+                src = webView.URL.absoluteString;
+            }
+            if (traceEnabled()) {
+                traceWrite("WKNavigationDelegateClass.webViewDidFailNavigationWithError(" + error.localizedDescription + ")", traceCategories.Debug);
+            }
+            owner._onLoadFinished(src, error.localizedDescription);
+        }
+    }
+
+    public webViewDidFailProvisionalNavigationWithError(webView: WKWebView, navigation: WKNavigation, error: NSError): void {
+        const owner = this._owner.get();
+        if (owner) {
+            let src = owner.src;
+            if (webView.URL) {
+                src = webView.URL.absoluteString;
+            }
+            if (traceEnabled()) {
+                traceWrite("WKNavigationDelegateClass.webViewDidFailProvisionalNavigationWithError(" + error.localizedDescription + ")", traceCategories.Debug);
+            }
+            owner._onLoadFinished(src, error.localizedDescription);
+        }
+    }
+
+}
+
+export class WebView extends WebViewBase {
+    nativeViewProtected: WKWebView;
+    private _delegate: any;
+
+    createNativeView() {
+        const jScript = "var meta = document.createElement('meta'); meta.setAttribute('name', 'viewport'); meta.setAttribute('content', 'initial-scale=1.0'); document.getElementsByTagName('head')[0].appendChild(meta);";
+        const wkUScript = WKUserScript.alloc().initWithSourceInjectionTimeForMainFrameOnly(jScript, WKUserScriptInjectionTime.AtDocumentEnd, true);
+        const wkUController = WKUserContentController.new();
+        wkUController.addUserScript(wkUScript);
+        const configuration = WKWebViewConfiguration.new();
+        configuration.userContentController = wkUController;
+        configuration.preferences.setValueForKey(
+            true,
+            "allowFileAccessFromFileURLs"
+        );
+
+        return new WKWebView({
+            frame: CGRectZero,
+            configuration: configuration
+        });
+    }
+
+    initNativeView() {
+        super.initNativeView();
+        this._delegate = WKNavigationDelegateImpl.initWithOwner(new WeakRef(this));
+    }
+
+    disposeNativeView() {
+        this._delegate = null;
+        super.disposeNativeView();
+    }
+
+    @profile
+    public onLoaded() {
+        super.onLoaded();
+        this.ios.navigationDelegate = this._delegate;
+    }
+
+    public onUnloaded() {
+        this.ios.navigationDelegate = null;
+        super.onUnloaded();
+    }
+
+    get ios(): WKWebView {
+        return this.nativeViewProtected;
+    }
+
+    public stopLoading() {
+        this.ios.stopLoading();
+    }
+
+    public _loadUrl(src: string) {
+        if (src.startsWith("file:///")) {
+            const cachePath = src.substring(0, src.lastIndexOf("/"));
+            this.ios.loadFileURLAllowingReadAccessToURL(NSURL.URLWithString(src), NSURL.URLWithString(cachePath));
+        } else {
+            this.ios.loadRequest(NSURLRequest.requestWithURL(NSURL.URLWithString(src)));
+        }
+    }
+
+    public _loadData(content: string) {
+        this.ios.loadHTMLStringBaseURL(content, NSURL.alloc().initWithString(`file:///${knownFolders.currentApp().path}/`));
+    }
+
+    get canGoBack(): boolean {
+        return this.ios.canGoBack;
+    }
+
+    get canGoForward(): boolean {
+        return this.ios.canGoForward;
+    }
+
+    public goBack() {
+        this.ios.goBack();
+    }
+
+    public goForward() {
+        this.ios.goForward();
+    }
+
+    public reload() {
+        this.ios.reload();
+    }
+}