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/button/button-common.ts

@@ -0,0 +1,22 @@
+import { Button as ButtonDefinition } from ".";
+import { TextBase, booleanConverter, CSSType } from "../text-base";
+
+export * from "../text-base";
+
+@CSSType("Button")
+export abstract class ButtonBase extends TextBase implements ButtonDefinition {
+    public static tapEvent = "tap";
+
+    get textWrap(): boolean {
+        return this.style.whiteSpace === "normal";
+    }
+    set textWrap(value: boolean) {
+        if (typeof value === "string") {
+            value = booleanConverter(value);
+        }
+
+        this.style.whiteSpace = value ? "normal" : "nowrap";
+    }
+}
+
+ButtonBase.prototype.recycleNativeView = "auto";

nativescript-core/ui/button/button.android.ts

@@ -0,0 +1,179 @@
+import {
+    ButtonBase, PseudoClassHandler,
+    paddingLeftProperty, paddingTopProperty, paddingRightProperty, paddingBottomProperty,
+    Length, zIndexProperty, textAlignmentProperty, TextAlignment
+} from "./button-common";
+import { profile } from "../../profiling";
+import { TouchGestureEventData, GestureTypes, TouchAction } from "../gestures";
+import { device } from "../../platform";
+import lazy from "../../utils/lazy";
+
+export * from "./button-common";
+
+const sdkVersion = lazy(() => parseInt(device.sdkVersion));
+
+interface ClickListener {
+    new(owner: Button): android.view.View.OnClickListener;
+}
+
+let ClickListener: ClickListener;
+let APILEVEL: number;
+let AndroidButton: typeof android.widget.Button;
+
+function initializeClickListener(): void {
+    if (ClickListener) {
+        return;
+    }
+
+    @Interfaces([android.view.View.OnClickListener])
+    class ClickListenerImpl extends java.lang.Object implements android.view.View.OnClickListener {
+        constructor(public owner: Button) {
+            super();
+
+            return global.__native(this);
+        }
+
+        public onClick(v: android.view.View): void {
+            const owner = this.owner;
+            if (owner) {
+                owner._emit(ButtonBase.tapEvent);
+            }
+        }
+    }
+
+    ClickListener = ClickListenerImpl;
+}
+
+export class Button extends ButtonBase {
+    nativeViewProtected: android.widget.Button;
+
+    constructor() {
+        super();
+        if (!APILEVEL) {
+            APILEVEL = android.os.Build.VERSION.SDK_INT;
+        }
+    }
+
+    private _stateListAnimator: any;
+    private _highlightedHandler: (args: TouchGestureEventData) => void;
+
+    @profile
+    public createNativeView() {
+        if (!AndroidButton) {
+            AndroidButton = android.widget.Button;
+        }
+
+        return new AndroidButton(this._context);
+    }
+
+    public initNativeView(): void {
+        super.initNativeView();
+        const nativeView = this.nativeViewProtected;
+        initializeClickListener();
+        const clickListener = new ClickListener(this);
+        nativeView.setOnClickListener(clickListener);
+        (<any>nativeView).clickListener = clickListener;
+    }
+
+    public disposeNativeView() {
+        if (this.nativeViewProtected) {
+            (<any>this.nativeViewProtected).clickListener.owner = null;
+        }
+        super.disposeNativeView();
+    }
+
+    public resetNativeView(): void {
+        super.resetNativeView();
+
+        if (this._stateListAnimator && APILEVEL >= 21) {
+            (<any>this.nativeViewProtected).setStateListAnimator(this._stateListAnimator);
+            this._stateListAnimator = undefined;
+        }
+    }
+
+    @PseudoClassHandler("normal", "highlighted", "pressed", "active")
+    _updateButtonStateChangeHandler(subscribe: boolean) {
+        if (subscribe) {
+            this._highlightedHandler = this._highlightedHandler || ((args: TouchGestureEventData) => {
+                switch (args.action) {
+                    case TouchAction.up:
+                    case TouchAction.cancel:
+                        this._goToVisualState("normal");
+                        break;
+                    case TouchAction.down:
+                        this._goToVisualState("highlighted");
+                        break;
+                }
+            });
+            this.on(GestureTypes.touch, this._highlightedHandler);
+        } else {
+            this.off(GestureTypes.touch, this._highlightedHandler);
+        }
+    }
+
+    [paddingTopProperty.getDefault](): Length {
+        return { value: this._defaultPaddingTop, unit: "px" };
+    }
+    [paddingTopProperty.setNative](value: Length) {
+        org.nativescript.widgets.ViewHelper.setPaddingTop(this.nativeViewProtected, Length.toDevicePixels(value, 0) + Length.toDevicePixels(this.style.borderTopWidth, 0));
+    }
+
+    [paddingRightProperty.getDefault](): Length {
+        return { value: this._defaultPaddingRight, unit: "px" };
+    }
+    [paddingRightProperty.setNative](value: Length) {
+        org.nativescript.widgets.ViewHelper.setPaddingRight(this.nativeViewProtected, Length.toDevicePixels(value, 0) + Length.toDevicePixels(this.style.borderRightWidth, 0));
+    }
+
+    [paddingBottomProperty.getDefault](): Length {
+        return { value: this._defaultPaddingBottom, unit: "px" };
+    }
+    [paddingBottomProperty.setNative](value: Length) {
+        org.nativescript.widgets.ViewHelper.setPaddingBottom(this.nativeViewProtected, Length.toDevicePixels(value, 0) + Length.toDevicePixels(this.style.borderBottomWidth, 0));
+    }
+
+    [paddingLeftProperty.getDefault](): Length {
+        return { value: this._defaultPaddingLeft, unit: "px" };
+    }
+    [paddingLeftProperty.setNative](value: Length) {
+        org.nativescript.widgets.ViewHelper.setPaddingLeft(this.nativeViewProtected, Length.toDevicePixels(value, 0) + Length.toDevicePixels(this.style.borderLeftWidth, 0));
+    }
+
+    [zIndexProperty.setNative](value: number) {
+        // API >= 21
+        if (APILEVEL >= 21) {
+            const nativeView = this.nativeViewProtected;
+            if (!this._stateListAnimator) {
+                this._stateListAnimator = (<any>nativeView).getStateListAnimator();
+            }
+            (<any>nativeView).setStateListAnimator(null);
+        }
+
+        org.nativescript.widgets.ViewHelper.setZIndex(this.nativeViewProtected, value);
+    }
+
+    [textAlignmentProperty.setNative](value: TextAlignment) {
+        // Button initial value is center.
+        const newValue = value === "initial" ? "center" : value;
+        super[textAlignmentProperty.setNative](newValue);
+    }
+
+    protected getDefaultElevation(): number {
+        if (sdkVersion() < 21) {
+            return 0;
+        }
+
+        // NOTE: Button widget has StateListAnimator that defines the elevation value and
+        // at the time of the getDefault() query the animator is not applied yet so we
+        // return the hardcoded @dimen/button_elevation_material value 2dp here instead
+        return 2;
+    }
+
+    protected getDefaultDynamicElevationOffset(): number {
+        if (sdkVersion() < 21) {
+            return 0;
+        }
+
+        return 4; // 4dp @dimen/button_pressed_z_material
+    }
+}

nativescript-core/ui/button/button.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Contains the Button class, which represents a standard button widget.
+ * @module "ui/button"
+ */ /** */
+
+import { TextBase, EventData } from "../text-base";
+
+/**
+ * Represents a standard Button widget.
+ */
+export class Button extends TextBase {
+    /**
+     * String value used when hooking to tap event.
+     */
+    public static tapEvent: string;
+
+    /**
+     * Gets the native [android widget](http://developer.android.com/reference/android/widget/Button.html) that represents the user interface for this component. Valid only when running on Android OS.
+     */
+    android: any /* android.widget.Button */;
+
+    /**
+     * Gets the native [UIButton](https://developer.apple.com/library/ios/documentation/UIKit/Reference/UIButton_Class/) that represents the user interface for this component. Valid only when running on iOS.
+     */
+    ios: any /* UIButton */;
+
+    /**
+     * Gets or sets whether the Button wraps text or not.
+     */
+    textWrap: boolean;
+
+    /**
+     * 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 tap event occurs.
+     */
+    on(event: "tap", callback: (args: EventData) => void, thisArg?: any);
+}

nativescript-core/ui/button/button.ios.ts

@@ -0,0 +1,248 @@
+import { ControlStateChangeListener } from "../core/control-state-change";
+import {
+    ButtonBase, PseudoClassHandler, Length, layout,
+    borderTopWidthProperty, borderRightWidthProperty, borderBottomWidthProperty, borderLeftWidthProperty,
+    paddingTopProperty, paddingRightProperty, paddingBottomProperty, paddingLeftProperty,
+    whiteSpaceProperty, WhiteSpace, textAlignmentProperty, TextAlignment, View
+} from "./button-common";
+
+export * from "./button-common";
+
+export class Button extends ButtonBase {
+    public nativeViewProtected: UIButton;
+
+    private _tapHandler: NSObject;
+    private _stateChangedHandler: ControlStateChangeListener;
+
+    createNativeView() {
+        return UIButton.buttonWithType(UIButtonType.System);
+    }
+
+    public initNativeView(): void {
+        super.initNativeView();
+        const nativeView = this.nativeViewProtected;
+        this._tapHandler = TapHandlerImpl.initWithOwner(new WeakRef(this));
+        nativeView.addTargetActionForControlEvents(this._tapHandler, "tap", UIControlEvents.TouchUpInside);
+    }
+
+    public disposeNativeView(): void {
+        this._tapHandler = null;
+        super.disposeNativeView();
+    }
+
+    get ios() {
+        return this.nativeViewProtected;
+    }
+
+    public onUnloaded() {
+        super.onUnloaded();
+        if (this._stateChangedHandler) {
+            this._stateChangedHandler.stop();
+        }
+    }
+
+    @PseudoClassHandler("normal", "highlighted", "pressed", "active")
+    _updateButtonStateChangeHandler(subscribe: boolean) {
+        if (subscribe) {
+            if (!this._stateChangedHandler) {
+                this._stateChangedHandler = new ControlStateChangeListener(this.nativeViewProtected, (s: string) => {
+                    this._goToVisualState(s);
+                });
+            }
+            this._stateChangedHandler.start();
+        } else {
+            this._stateChangedHandler.stop();
+        }
+    }
+
+    [borderTopWidthProperty.getDefault](): Length {
+        return {
+            value: this.nativeViewProtected.contentEdgeInsets.top,
+            unit: "px"
+        };
+    }
+    [borderTopWidthProperty.setNative](value: Length) {
+        let inset = this.nativeViewProtected.contentEdgeInsets;
+        let top = layout.toDeviceIndependentPixels(this.effectivePaddingTop + this.effectiveBorderTopWidth);
+        this.nativeViewProtected.contentEdgeInsets = { top: top, left: inset.left, bottom: inset.bottom, right: inset.right };
+    }
+
+    [borderRightWidthProperty.getDefault](): Length {
+        return {
+            value: this.nativeViewProtected.contentEdgeInsets.right,
+            unit: "px"
+        };
+    }
+    [borderRightWidthProperty.setNative](value: Length) {
+        let inset = this.nativeViewProtected.contentEdgeInsets;
+        let right = layout.toDeviceIndependentPixels(this.effectivePaddingRight + this.effectiveBorderRightWidth);
+        this.nativeViewProtected.contentEdgeInsets = { top: inset.top, left: inset.left, bottom: inset.bottom, right: right };
+    }
+
+    [borderBottomWidthProperty.getDefault](): Length {
+        return {
+            value: this.nativeViewProtected.contentEdgeInsets.bottom,
+            unit: "px"
+        };
+    }
+    [borderBottomWidthProperty.setNative](value: Length) {
+        let inset = this.nativeViewProtected.contentEdgeInsets;
+        let bottom = layout.toDeviceIndependentPixels(this.effectivePaddingBottom + this.effectiveBorderBottomWidth);
+        this.nativeViewProtected.contentEdgeInsets = { top: inset.top, left: inset.left, bottom: bottom, right: inset.right };
+    }
+
+    [borderLeftWidthProperty.getDefault](): Length {
+        return {
+            value: this.nativeViewProtected.contentEdgeInsets.left,
+            unit: "px"
+        };
+    }
+    [borderLeftWidthProperty.setNative](value: Length) {
+        let inset = this.nativeViewProtected.contentEdgeInsets;
+        let left = layout.toDeviceIndependentPixels(this.effectivePaddingLeft + this.effectiveBorderLeftWidth);
+        this.nativeViewProtected.contentEdgeInsets = { top: inset.top, left: left, bottom: inset.bottom, right: inset.right };
+    }
+
+    [paddingTopProperty.getDefault](): Length {
+        return {
+            value: this.nativeViewProtected.contentEdgeInsets.top,
+            unit: "px"
+        };
+    }
+    [paddingTopProperty.setNative](value: Length) {
+        let inset = this.nativeViewProtected.contentEdgeInsets;
+        let top = layout.toDeviceIndependentPixels(this.effectivePaddingTop + this.effectiveBorderTopWidth);
+        this.nativeViewProtected.contentEdgeInsets = { top: top, left: inset.left, bottom: inset.bottom, right: inset.right };
+    }
+
+    [paddingRightProperty.getDefault](): Length {
+        return {
+            value: this.nativeViewProtected.contentEdgeInsets.right,
+            unit: "px"
+        };
+    }
+    [paddingRightProperty.setNative](value: Length) {
+        let inset = this.nativeViewProtected.contentEdgeInsets;
+        let right = layout.toDeviceIndependentPixels(this.effectivePaddingRight + this.effectiveBorderRightWidth);
+        this.nativeViewProtected.contentEdgeInsets = { top: inset.top, left: inset.left, bottom: inset.bottom, right: right };
+    }
+
+    [paddingBottomProperty.getDefault](): Length {
+        return {
+            value: this.nativeViewProtected.contentEdgeInsets.bottom,
+            unit: "px"
+        };
+    }
+    [paddingBottomProperty.setNative](value: Length) {
+        let inset = this.nativeViewProtected.contentEdgeInsets;
+        let bottom = layout.toDeviceIndependentPixels(this.effectivePaddingBottom + this.effectiveBorderBottomWidth);
+        this.nativeViewProtected.contentEdgeInsets = { top: inset.top, left: inset.left, bottom: bottom, right: inset.right };
+    }
+
+    [paddingLeftProperty.getDefault](): Length {
+        return {
+            value: this.nativeViewProtected.contentEdgeInsets.left,
+            unit: "px"
+        };
+    }
+    [paddingLeftProperty.setNative](value: Length) {
+        let inset = this.nativeViewProtected.contentEdgeInsets;
+        let left = layout.toDeviceIndependentPixels(this.effectivePaddingLeft + this.effectiveBorderLeftWidth);
+        this.nativeViewProtected.contentEdgeInsets = { top: inset.top, left: left, bottom: inset.bottom, right: inset.right };
+    }
+
+    [textAlignmentProperty.setNative](value: TextAlignment) {
+        switch (value) {
+            case "left":
+                this.nativeViewProtected.titleLabel.textAlignment = NSTextAlignment.Left;
+                this.nativeViewProtected.contentHorizontalAlignment = UIControlContentHorizontalAlignment.Left;
+                break;
+            case "initial":
+            case "center":
+                this.nativeViewProtected.titleLabel.textAlignment = NSTextAlignment.Center;
+                this.nativeViewProtected.contentHorizontalAlignment = UIControlContentHorizontalAlignment.Center;
+                break;
+            case "right":
+                this.nativeViewProtected.titleLabel.textAlignment = NSTextAlignment.Right;
+                this.nativeViewProtected.contentHorizontalAlignment = UIControlContentHorizontalAlignment.Right;
+                break;
+        }
+    }
+
+    [whiteSpaceProperty.setNative](value: WhiteSpace) {
+        const nativeView = this.nativeViewProtected.titleLabel;
+        switch (value) {
+            case "normal":
+                nativeView.lineBreakMode = NSLineBreakMode.ByWordWrapping;
+                nativeView.numberOfLines = 0;
+                break;
+            case "nowrap":
+            case "initial":
+                nativeView.lineBreakMode = NSLineBreakMode.ByTruncatingMiddle;
+                nativeView.numberOfLines = 1;
+                break;
+        }
+    }
+
+    public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
+        // If there is text-wrap UIButton.sizeThatFits will return wrong result (not respecting the text wrap).
+        // So fallback to original onMeasure if there is no text-wrap and use custom measure otherwise.
+        if (!this.textWrap) {
+            return super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+        }
+
+        let nativeView = this.nativeViewProtected;
+        if (nativeView) {
+            const width = layout.getMeasureSpecSize(widthMeasureSpec);
+            const widthMode = layout.getMeasureSpecMode(widthMeasureSpec);
+            const height = layout.getMeasureSpecSize(heightMeasureSpec);
+            const heightMode = layout.getMeasureSpecMode(heightMeasureSpec);
+
+            const horizontalPadding = this.effectivePaddingLeft + this.effectiveBorderLeftWidth + this.effectivePaddingRight + this.effectiveBorderRightWidth;
+            let verticalPadding = this.effectivePaddingTop + this.effectiveBorderTopWidth + this.effectivePaddingBottom + this.effectiveBorderBottomWidth;
+
+            // The default button padding for UIButton - 6dip top and bottom.
+            if (verticalPadding === 0) {
+                verticalPadding = layout.toDevicePixels(12);
+            }
+
+            const desiredSize = layout.measureNativeView(
+                nativeView.titleLabel,
+                width - horizontalPadding, widthMode,
+                height - verticalPadding, heightMode);
+
+            desiredSize.width = desiredSize.width + horizontalPadding;
+            desiredSize.height = desiredSize.height + verticalPadding;
+
+            const measureWidth = Math.max(desiredSize.width, this.effectiveMinWidth);
+            const measureHeight = Math.max(desiredSize.height, this.effectiveMinHeight);
+
+            const widthAndState = View.resolveSizeAndState(measureWidth, width, widthMode, 0);
+            const heightAndState = View.resolveSizeAndState(measureHeight, height, heightMode, 0);
+
+            this.setMeasuredDimension(widthAndState, heightAndState);
+        }
+    }
+}
+
+class TapHandlerImpl extends NSObject {
+    private _owner: WeakRef<Button>;
+
+    public static initWithOwner(owner: WeakRef<Button>): TapHandlerImpl {
+        let handler = <TapHandlerImpl>TapHandlerImpl.new();
+        handler._owner = owner;
+
+        return handler;
+    }
+
+    public tap(args) {
+        let owner = this._owner.get();
+        if (owner) {
+            owner._emit(ButtonBase.tapEvent);
+        }
+    }
+
+    public static ObjCExposedMethods = {
+        "tap": { returns: interop.types.void, params: [interop.types.id] }
+    };
+}

nativescript-core/ui/button/package.json

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