javascript/NativeScript
1
0
Fork 0
mirror of https://github.com/NativeScript/NativeScript.git synced 2025-11-05 13:26:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: Scoped Packages (#7911)

Browse Source 
* 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
This commit is contained in:
Alexander Vakrilov
2019-10-17 00:45:33 +03:00
committed by GitHub
parent 6c7139477e
commit cc97a16800
880 changed files with 9090 additions and 2104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
nativescript-core/ui/scroll-view/package.json Normal file
View File

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

112
nativescript-core/ui/scroll-view/scroll-view-common.ts Normal file
View File

@@ -0,0 +1,112 @@
import { ScrollView as ScrollViewDefinition, Orientation, ScrollEventData } from ".";
import { ContentView, Property, makeParser, makeValidator, EventData, booleanConverter, CSSType } from "../content-view";
import { profile } from "../../profiling";
export * from "../content-view";
@CSSType("ScrollView")
export abstract class ScrollViewBase extends ContentView implements ScrollViewDefinition {
private _scrollChangeCount: number = 0;
public static scrollEvent = "scroll";
public orientation: Orientation;
public scrollBarIndicatorVisible: boolean;
public isScrollEnabled: boolean;
public addEventListener(arg: string, callback: any, thisArg?: any) {
super.addEventListener(arg, callback, thisArg);
if (arg === ScrollViewBase.scrollEvent) {
this._scrollChangeCount++;
this.attach();
}
}
public removeEventListener(arg: string, callback: any, thisArg?: any) {
super.removeEventListener(arg, callback, thisArg);
if (arg === ScrollViewBase.scrollEvent) {
this._scrollChangeCount--;
this.dettach();
}
}
@profile
public onLoaded() {
super.onLoaded();
this.attach();
}
public onUnloaded() {
super.onUnloaded();
this.dettach();
}
private attach() {
if (this._scrollChangeCount > 0 && this.isLoaded) {
this.attachNative();
}
}
private dettach() {
if (this._scrollChangeCount === 0 && this.isLoaded) {
this.dettachNative();
}
}
protected attachNative() {
//
}
protected dettachNative() {
//
}
get horizontalOffset(): number {
return 0;
}
get verticalOffset(): number {
return 0;
}
get scrollableWidth(): number {
return 0;
}
get scrollableHeight(): number {
return 0;
}
public abstract scrollToVerticalOffset(value: number, animated: boolean);
public abstract scrollToHorizontalOffset(value: number, animated: boolean);
public abstract _onOrientationChanged();
}
export interface ScrollViewBase {
on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);
on(event: "scroll", callback: (args: ScrollEventData) => void, thisArg?: any);
}
const converter = makeParser<Orientation>(makeValidator("horizontal", "vertical"));
export const orientationProperty = new Property<ScrollViewBase, Orientation>({
name: "orientation", defaultValue: "vertical", affectsLayout: true,
valueChanged: (target: ScrollViewBase, oldValue: Orientation, newValue: Orientation) => {
target._onOrientationChanged();
},
valueConverter: converter
});
orientationProperty.register(ScrollViewBase);
export const scrollBarIndicatorVisibleProperty = new Property<ScrollViewBase, boolean>({
name: "scrollBarIndicatorVisible", defaultValue: true,
valueConverter: booleanConverter
});
scrollBarIndicatorVisibleProperty.register(ScrollViewBase);
export const isScrollEnabledProperty = new Property<ScrollViewBase, boolean>({
name: "isScrollEnabled", defaultValue: true,
valueConverter: booleanConverter
});
isScrollEnabledProperty.register(ScrollViewBase);

167
nativescript-core/ui/scroll-view/scroll-view.android.ts Normal file
View File

@@ -0,0 +1,167 @@
import { ScrollEventData } from ".";
import {
ScrollViewBase, layout, scrollBarIndicatorVisibleProperty,
isUserInteractionEnabledProperty, isScrollEnabledProperty
} from "./scroll-view-common";
export * from "./scroll-view-common";
export class ScrollView extends ScrollViewBase {
nativeViewProtected: org.nativescript.widgets.VerticalScrollView | org.nativescript.widgets.HorizontalScrollView;
private _androidViewId: number = -1;
private handler: android.view.ViewTreeObserver.OnScrollChangedListener;
get horizontalOffset(): number {
const nativeView = this.nativeViewProtected;
if (!nativeView) {
return 0;
}
return nativeView.getScrollX() / layout.getDisplayDensity();
}
get verticalOffset(): number {
const nativeView = this.nativeViewProtected;
if (!nativeView) {
return 0;
}
return nativeView.getScrollY() / layout.getDisplayDensity();
}
get scrollableWidth(): number {
const nativeView = this.nativeViewProtected;
if (!nativeView || this.orientation !== "horizontal") {
return 0;
}
return nativeView.getScrollableLength() / layout.getDisplayDensity();
}
get scrollableHeight(): number {
const nativeView = this.nativeViewProtected;
if (!nativeView || this.orientation !== "vertical") {
return 0;
}
return nativeView.getScrollableLength() / layout.getDisplayDensity();
}
[isUserInteractionEnabledProperty.setNative](value: boolean) {
// NOTE: different behavior on iOS & Android:
// iOS disables user interaction recursively for all subviews as well
this.nativeViewProtected.setClickable(value);
this.nativeViewProtected.setFocusable(value);
this.nativeViewProtected.setScrollEnabled(value);
}
[isScrollEnabledProperty.getDefault](): boolean {
return this.nativeViewProtected.getScrollEnabled();
}
[isScrollEnabledProperty.setNative](value: boolean) {
this.nativeViewProtected.setScrollEnabled(value);
}
[scrollBarIndicatorVisibleProperty.getDefault](): boolean {
return true;
}
[scrollBarIndicatorVisibleProperty.setNative](value: boolean) {
if (this.orientation === "horizontal") {
this.nativeViewProtected.setHorizontalScrollBarEnabled(value);
} else {
this.nativeViewProtected.setVerticalScrollBarEnabled(value);
}
}
public scrollToVerticalOffset(value: number, animated: boolean) {
const nativeView = this.nativeViewProtected;
if (nativeView && this.orientation === "vertical" && this.isScrollEnabled) {
value *= layout.getDisplayDensity();
if (animated) {
nativeView.smoothScrollTo(0, value);
} else {
nativeView.scrollTo(0, value);
}
}
}
public scrollToHorizontalOffset(value: number, animated: boolean) {
const nativeView = this.nativeViewProtected;
if (nativeView && this.orientation === "horizontal" && this.isScrollEnabled) {
value *= layout.getDisplayDensity();
if (animated) {
nativeView.smoothScrollTo(value, 0);
} else {
nativeView.scrollTo(value, 0);
}
}
}
public createNativeView() {
return this.orientation === "horizontal" ? new org.nativescript.widgets.HorizontalScrollView(this._context) : new org.nativescript.widgets.VerticalScrollView(this._context);
}
public initNativeView(): void {
super.initNativeView();
if (this._androidViewId < 0) {
this._androidViewId = android.view.View.generateViewId();
}
this.nativeViewProtected.setId(this._androidViewId);
}
public _onOrientationChanged() {
if (this.nativeViewProtected) {
const parent = this.parent;
if (parent) {
parent._removeView(this);
parent._addView(this);
}
}
}
protected attachNative() {
const that = new WeakRef(this);
this.handler = new android.view.ViewTreeObserver.OnScrollChangedListener({
onScrollChanged: function () {
const owner: ScrollView = that.get();
if (owner) {
owner._onScrollChanged();
}
}
});
this.nativeViewProtected.getViewTreeObserver().addOnScrollChangedListener(this.handler);
}
private _lastScrollX: number = -1;
private _lastScrollY: number = -1;
private _onScrollChanged() {
const nativeView = this.nativeViewProtected;
if (nativeView) {
// Event is only raised if the scroll values differ from the last time in order to wokraround a native Android bug.
// https://github.com/NativeScript/NativeScript/issues/2362
let newScrollX = nativeView.getScrollX();
let newScrollY = nativeView.getScrollY();
if (newScrollX !== this._lastScrollX || newScrollY !== this._lastScrollY) {
this.notify(<ScrollEventData>{
object: this,
eventName: ScrollView.scrollEvent,
scrollX: newScrollX / layout.getDisplayDensity(),
scrollY: newScrollY / layout.getDisplayDensity()
});
this._lastScrollX = newScrollX;
this._lastScrollY = newScrollY;
}
}
}
protected dettachNative() {
this.nativeViewProtected.getViewTreeObserver().removeOnScrollChangedListener(this.handler);
this.handler = null;
}
}
ScrollView.prototype.recycleNativeView = "never";

89
nativescript-core/ui/scroll-view/scroll-view.d.ts vendored Normal file
View File

@@ -0,0 +1,89 @@
/**
* Contains the ScrollView class, which represents a scrollable area that can have content that is larger than its bounds.
* @module "ui/scroll-view"
*/ /** */
import { ContentView, EventData, Property } from "../content-view";
/**
* Represents a scrollable area that can have content that is larger than its bounds.
*/
export class ScrollView extends ContentView {
/**
* String value used when hooking to scroll event.
*/
public static scrollEvent: string;
/**
* Gets or sets a value indicating whether scroll is enabled.
*/
isScrollEnabled: boolean;
/**
* Gets a value that contains the vertical offset of the scrolled content.
*/
verticalOffset: number;
/**
* Gets a value that contains the horizontal offset of the scrolled content.
*/
horizontalOffset: number;
/**
* Gets the maximum value for the verticalOffset.
*/
scrollableHeight: number;
/**
* Gets the maximum value for the horizontalOffset.
*/
scrollableWidth: number;
/**
* Toggles scrollbar indicator visibility
*/
scrollBarIndicatorVisible: boolean;
/**
* Scrolls the content the specified vertical offset position.
* @param value The offset value
* @param animated true for animated scroll, false for immediate scroll.
*/
scrollToVerticalOffset(value: number, animated: boolean);
/**
* Scrolls the content the specified horizontal offset position.
* @param value The offset value
* @param animated true for animated scroll, false for immediate scroll.
*/
scrollToHorizontalOffset(value: number, animated: boolean);
/**
* Gets or sets direction in which the content can be scrolled.
*/
orientation: Orientation;
/**
* 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 scroll event occurs.
*/
on(event: "scroll", callback: (args: ScrollEventData) => void, thisArg?: any);
_onOrientationChanged();
}
export interface ScrollEventData extends EventData {
scrollX: number;
scrollY: number;
}
export type Orientation = "horizontal" | "vertical";
export const orientationProperty: Property<ScrollView, Orientation>;

195
nativescript-core/ui/scroll-view/scroll-view.ios.ts Normal file
View File

@@ -0,0 +1,195 @@
import { ScrollEventData } from ".";
import {
View, layout, ScrollViewBase, scrollBarIndicatorVisibleProperty, isScrollEnabledProperty
} from "./scroll-view-common";
import { ios as iosUtils } from "../../utils/utils";
export * from "./scroll-view-common";
const majorVersion = iosUtils.MajorVersion;
class UIScrollViewDelegateImpl extends NSObject implements UIScrollViewDelegate {
private _owner: WeakRef<ScrollView>;
public static initWithOwner(owner: WeakRef<ScrollView>): UIScrollViewDelegateImpl {
let impl = <UIScrollViewDelegateImpl>UIScrollViewDelegateImpl.new();
impl._owner = owner;
return impl;
}
public scrollViewDidScroll(sv: UIScrollView): void {
let owner = this._owner.get();
if (owner) {
owner.notify(<ScrollEventData>{
object: owner,
eventName: "scroll",
scrollX: owner.horizontalOffset,
scrollY: owner.verticalOffset
});
}
}
public static ObjCProtocols = [UIScrollViewDelegate];
}
export class ScrollView extends ScrollViewBase {
public nativeViewProtected: UIScrollView;
private _contentMeasuredWidth: number = 0;
private _contentMeasuredHeight: number = 0;
private _delegate: UIScrollViewDelegateImpl;
public createNativeView() {
const view = UIScrollView.new();
return view;
}
initNativeView() {
super.initNativeView();
this.updateScrollBarVisibility(this.scrollBarIndicatorVisible);
this._setNativeClipToBounds();
}
_setNativeClipToBounds() {
// Always set clipsToBounds for scroll-view
this.nativeViewProtected.clipsToBounds = true;
}
protected attachNative() {
this._delegate = UIScrollViewDelegateImpl.initWithOwner(new WeakRef(this));
this.nativeViewProtected.delegate = this._delegate;
}
protected dettachNative() {
this.nativeViewProtected.delegate = null;
}
protected updateScrollBarVisibility(value) {
if (!this.nativeViewProtected) {
return;
}
if (this.orientation === "horizontal") {
this.nativeViewProtected.showsHorizontalScrollIndicator = value;
} else {
this.nativeViewProtected.showsVerticalScrollIndicator = value;
}
}
get horizontalOffset(): number {
return this.nativeViewProtected ? this.nativeViewProtected.contentOffset.x : 0;
}
get verticalOffset(): number {
return this.nativeViewProtected ? this.nativeViewProtected.contentOffset.y : 0;
}
get scrollableWidth(): number {
if (!this.nativeViewProtected || this.orientation !== "horizontal") {
return 0;
}
return Math.max(0, this.nativeViewProtected.contentSize.width - this.nativeViewProtected.bounds.size.width);
}
get scrollableHeight(): number {
if (!this.nativeViewProtected || this.orientation !== "vertical") {
return 0;
}
return Math.max(0, this.nativeViewProtected.contentSize.height - this.nativeViewProtected.bounds.size.height);
}
[isScrollEnabledProperty.getDefault](): boolean {
return this.nativeViewProtected.scrollEnabled;
}
[isScrollEnabledProperty.setNative](value: boolean) {
this.nativeViewProtected.scrollEnabled = value;
}
[scrollBarIndicatorVisibleProperty.getDefault](): boolean {
return true;
}
[scrollBarIndicatorVisibleProperty.setNative](value: boolean) {
this.updateScrollBarVisibility(value);
}
public scrollToVerticalOffset(value: number, animated: boolean) {
if (this.nativeViewProtected && this.orientation === "vertical" && this.isScrollEnabled) {
const bounds = this.nativeViewProtected.bounds.size;
this.nativeViewProtected.scrollRectToVisibleAnimated(CGRectMake(0, value, bounds.width, bounds.height), animated);
}
}
public scrollToHorizontalOffset(value: number, animated: boolean) {
if (this.nativeViewProtected && this.orientation === "horizontal" && this.isScrollEnabled) {
const bounds = this.nativeViewProtected.bounds.size;
this.nativeViewProtected.scrollRectToVisibleAnimated(CGRectMake(value, 0, bounds.width, bounds.height), animated);
}
}
public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
// Don't call measure because it will measure content twice.
const width = layout.getMeasureSpecSize(widthMeasureSpec);
const widthMode = layout.getMeasureSpecMode(widthMeasureSpec);
const height = layout.getMeasureSpecSize(heightMeasureSpec);
const heightMode = layout.getMeasureSpecMode(heightMeasureSpec);
const child = this.layoutView;
this._contentMeasuredWidth = this.effectiveMinWidth;
this._contentMeasuredHeight = this.effectiveMinHeight;
if (child) {
let childSize: { measuredWidth: number; measuredHeight: number };
if (this.orientation === "vertical") {
childSize = View.measureChild(this, child, widthMeasureSpec, layout.makeMeasureSpec(0, layout.UNSPECIFIED));
} else {
childSize = View.measureChild(this, child, layout.makeMeasureSpec(0, layout.UNSPECIFIED), heightMeasureSpec);
}
this._contentMeasuredWidth = Math.max(childSize.measuredWidth, this.effectiveMinWidth);
this._contentMeasuredHeight = Math.max(childSize.measuredHeight, this.effectiveMinHeight);
}
const widthAndState = View.resolveSizeAndState(this._contentMeasuredWidth, width, widthMode, 0);
const heightAndState = View.resolveSizeAndState(this._contentMeasuredHeight, height, heightMode, 0);
this.setMeasuredDimension(widthAndState, heightAndState);
}
public onLayout(left: number, top: number, right: number, bottom: number): void {
const insets = this.getSafeAreaInsets();
let width = (right - left - insets.right - insets.left);
let height = (bottom - top - insets.bottom - insets.top);
const nativeView = this.nativeViewProtected;
if (majorVersion > 10) {
// Disable automatic adjustment of scroll view insets
// Consider exposing this as property with all 4 modes
// https://developer.apple.com/documentation/uikit/uiscrollview/contentinsetadjustmentbehavior
nativeView.contentInsetAdjustmentBehavior = 2;
}
let scrollWidth = width + insets.left + insets.right;
let scrollHeight = height + insets.top + insets.bottom;
if (this.orientation === "horizontal") {
scrollWidth = Math.max(this._contentMeasuredWidth + insets.left + insets.right, scrollWidth);
width = Math.max(this._contentMeasuredWidth, width);
}
else {
scrollHeight = Math.max(this._contentMeasuredHeight + insets.top + insets.bottom, scrollHeight);
height = Math.max(this._contentMeasuredHeight, height);
}
nativeView.contentSize = CGSizeMake(layout.toDeviceIndependentPixels(scrollWidth), layout.toDeviceIndependentPixels(scrollHeight));
View.layoutChild(this, this.layoutView, insets.left, insets.top, insets.left + width, insets.top + height);
}
public _onOrientationChanged() {
this.updateScrollBarVisibility(this.scrollBarIndicatorVisible);
}
}
ScrollView.prototype.recycleNativeView = "auto";