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/fps-meter/fps-meter.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Allows you to capture the frames-per-second metrics of your application.
+ * @module "fps-meter"
+ */ /** */
+
+/**
+* Starts the frames-per-second meter.
+*/
+export function start(): void;
+
+/**
+* Stops the frames-per-second meter.
+*/
+export function stop(): void;
+
+/**
+* Returns a valid indicating whether the frames-per-second meter is currently running.
+*/
+export function running(): boolean;
+
+/**
+* Adds a callback function to be called each time FPS data is due to be reported. Returns an unique id which can be used to remove this callback later.
+*/
+export function addCallback(callback: (fps: number, minFps?: number) => void): number;
+
+/**
+* Removes the callback with the specified id.
+*/
+export function removeCallback(id: number);

nativescript-core/fps-meter/fps-meter.ts

@@ -0,0 +1,93 @@
+import * as fpsNative from "./fps-native";
+
+const callbacks = {};
+let idCounter = 0;
+let _minFps = 1000;
+let framesRendered = 0;
+let frameStartTime = 0;
+
+function doFrame(currentTimeMillis: number) {
+    let fps = 0;
+    if (frameStartTime > 0) {
+        // take the span in milliseconds
+        const timeSpan = (currentTimeMillis - frameStartTime);
+        framesRendered++;
+
+        if (timeSpan > 1000) {
+            fps = framesRendered * 1000 / timeSpan;
+            if (fps < _minFps) {
+                _minFps = fps;
+            }
+
+            notify(fps);
+
+            frameStartTime = currentTimeMillis;
+            framesRendered = 0;
+        }
+    } else {
+        frameStartTime = currentTimeMillis;
+    }
+}
+
+let native: fpsNative.FPSCallback;
+function ensureNative() {
+    if (!native) {
+        native = new fpsNative.FPSCallback(doFrame);
+    }
+}
+
+export function reset() {
+    _minFps = 1000;
+    frameStartTime = 0;
+    framesRendered = 0;
+}
+
+export function running(): boolean {
+    if (!native) {
+        return false;
+    }
+
+    return native.running;
+}
+
+export function minFps(): number {
+    return _minFps;
+}
+
+export function start() {
+    ensureNative();
+    native.start();
+}
+
+export function stop() {
+    if (!native) {
+        return;
+    }
+
+    native.stop();
+    reset();
+}
+
+export function addCallback(callback: (fps: number, minFps?: number) => void): number {
+    const id = idCounter;
+
+    // Wrap all calback in zonedCallback so that they work with the current zone.
+    callbacks[id] = zonedCallback(callback);
+    idCounter++;
+
+    return id;
+}
+
+export function removeCallback(id: number) {
+    if (id in callbacks) {
+        delete callbacks[id];
+    }
+}
+
+function notify(fps) {
+    let callback: Function;
+    for (let id in callbacks) {
+        callback = callbacks[id];
+        callback(fps, _minFps);
+    }
+}

nativescript-core/fps-meter/fps-native.android.ts

@@ -0,0 +1,48 @@
+import * as definition from "./fps-native";
+
+export class FPSCallback implements definition.FPSCallback {
+    private impl: android.view.Choreographer.FrameCallback;
+    private onFrame: (currentTimeMillis: number) => void;
+
+    public running: boolean;
+
+    constructor(onFrame: (currentTimeMillis: number) => void) {
+        this.running = false;
+        this.onFrame = onFrame;
+
+        this.impl = new android.view.Choreographer.FrameCallback({
+            doFrame: (nanos: number) => {
+                this.handleFrame(nanos);
+            }
+        });
+    }
+
+    public start() {
+        if (this.running) {
+            return;
+        }
+
+        android.view.Choreographer.getInstance().postFrameCallback(this.impl);
+        this.running = true;
+    }
+
+    public stop() {
+        if (!this.running) {
+            return;
+        }
+
+        android.view.Choreographer.getInstance().removeFrameCallback(this.impl);
+        this.running = false;
+    }
+
+    private handleFrame(nanos: number) {
+        if (!this.running) {
+            return;
+        }
+
+        // divide by 1 000 000 since the parameter is in nanoseconds
+        this.onFrame(nanos / 1000000);
+        // add the FrameCallback instance again since it is automatically removed from the Choreographer
+        android.view.Choreographer.getInstance().postFrameCallback(this.impl);
+    }
+}

nativescript-core/fps-meter/fps-native.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @module "fps-meter/fps-native"
+ */ /** */
+
+/**
+ * An utility class used to measure frames per second.
+ */
+export class FPSCallback {
+
+    /**
+     * Initializes a new instance of FPSCallback class.
+     */
+    constructor(onFrame: (currentTimeMillis: number) => void);
+
+    /**
+     * Starts the frame per seconds measurement.
+     */
+    start(): void;
+
+    /**
+     * Stops the frame per seconds measurement.
+     */
+    stop(): void;
+
+    /**
+     * Gets if the current instance of FPSCallback is running.
+     */
+    running: boolean;
+}

nativescript-core/fps-meter/fps-native.ios.ts

@@ -0,0 +1,71 @@
+import * as definition from "./fps-native";
+
+class FrameHandlerImpl extends NSObject {
+
+    private _owner: WeakRef<FPSCallback>;
+
+    public static initWithOwner(owner: WeakRef<FPSCallback>): FrameHandlerImpl {
+        let handler = <FrameHandlerImpl>FrameHandlerImpl.new();
+        handler._owner = owner;
+
+        return handler;
+    }
+
+    public handleFrame(sender: CADisplayLink): void {
+        let owner = this._owner.get();
+        if (owner) {
+            owner._handleFrame(sender);
+        }
+    }
+
+    public static ObjCExposedMethods = {
+        "handleFrame": { returns: interop.types.void, params: [CADisplayLink] }
+    };
+}
+
+export class FPSCallback implements definition.FPSCallback {
+    public running: boolean;
+    private onFrame: Function;
+    private displayLink: CADisplayLink;
+    private impl: FrameHandlerImpl;
+
+    constructor(onFrame: (currentTimeMillis: number) => void) {
+        this.onFrame = onFrame;
+
+        this.impl = FrameHandlerImpl.initWithOwner(new WeakRef(this));
+
+        this.displayLink = CADisplayLink.displayLinkWithTargetSelector(this.impl, "handleFrame");
+        this.displayLink.paused = true;
+        this.displayLink.addToRunLoopForMode(NSRunLoop.currentRunLoop, NSDefaultRunLoopMode);
+        // UIScrollView (including in UIITableView) will run a loop in UITrackingRunLoopMode during scrolling.
+        // If we do not add the CADisplayLink in this mode, it would appear paused during scrolling.
+        this.displayLink.addToRunLoopForMode(NSRunLoop.currentRunLoop, UITrackingRunLoopMode);
+    }
+
+    public start() {
+        if (this.running) {
+            return;
+        }
+
+        this.running = true;
+        this.displayLink.paused = false;
+    }
+
+    public stop() {
+        if (!this.running) {
+            return;
+        }
+
+        this.displayLink.paused = true;
+        this.running = false;
+    }
+
+    public _handleFrame(sender: CADisplayLink) {
+        if (!this.running) {
+            return;
+        }
+
+        // timestamp is CFTimeInterval, which is in seconds, the onFrame callback expects millis, so multiply by 1000
+        this.onFrame(sender.timestamp * 1000);
+    }
+}

nativescript-core/fps-meter/package.json

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