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/module-name-resolver/module-name-resolver.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Provides ModuleNameResolver class used for loading files based on device capabilities.
+ * @module "module-name-resolver"
+ */ /** */
+
+import { PlatformContext } from "./qualifier-matcher";
+export { PlatformContext } from "./qualifier-matcher";
+
+export type ModuleListProvider = () => string[];
+
+export class ModuleNameResolver {
+    constructor(context: PlatformContext, moduleListProvider?: ModuleListProvider);
+    resolveModuleName(path: string, ext: string): string;
+    clearCache(): void;
+}
+
+export function resolveModuleName(path: string, ext: string): string;
+export function clearCache(): void;
+
+export function _setResolver(resolver: ModuleNameResolver);

nativescript-core/module-name-resolver/module-name-resolver.ts

@@ -0,0 +1,107 @@
+import { ModuleNameResolver as ModuleNameResolverDefinition, ModuleListProvider } from "./";
+import { screen, device } from "../platform/platform";
+import * as appCommonModule from "../application/application-common";
+import { PlatformContext, findMatch } from "./qualifier-matcher";
+import { registerModulesFromFileSystem } from "./non-bundle-workflow-compat";
+import {
+    isEnabled as traceEnabled,
+    write as traceWrite,
+    categories as traceCategories
+} from "../trace";
+
+export class ModuleNameResolver implements ModuleNameResolverDefinition {
+    private _cache = {};
+
+    constructor(private context: PlatformContext, private moduleListProvider: ModuleListProvider = global.getRegisteredModules) {
+    }
+
+    public resolveModuleName(path: string, ext: string): string {
+        const key = path + ext;
+        let result: string = this._cache[key];
+        if (result === undefined) {
+            result = this.resolveModuleNameImpl(path, ext);
+            this._cache[key] = result;
+        }
+
+        if (traceEnabled()) {
+            traceWrite(`path: '${path}' with ext: '${ext}' resolved: '${result}'`, traceCategories.ModuleNameResolver);
+        }
+
+        return result;
+    }
+
+    public clearCache(): void {
+        this._cache = {};
+    }
+
+    private resolveModuleNameImpl(path: string, ext: string): string {
+        let result: string = null;
+        ext = ext ? "." + ext : "";
+
+        // Compatibility path for non-webpack workflow
+        // register modules from FS first
+        if (!global.TNS_WEBPACK) {
+            registerModulesFromFileSystem(path);
+        }
+
+        let candidates = this.getCandidates(path, ext);
+        result = findMatch(path, ext, candidates, this.context);
+
+        return result;
+    }
+
+    private getCandidates(path: string, ext: string): Array<string> {
+        const candidates = this.moduleListProvider()
+            .filter((moduleName) => moduleName.startsWith(path) && (!ext || moduleName.endsWith(ext)));
+
+        return candidates;
+    }
+}
+
+let resolverInstance: ModuleNameResolver;
+
+export function resolveModuleName(path: string, ext: string): string {
+    if (global.__snapshot) {
+        return resolveModuleSnapshot(path, ext);
+    }
+
+    if (!resolverInstance) {
+        resolverInstance = new ModuleNameResolver({
+            width: screen.mainScreen.widthDIPs,
+            height: screen.mainScreen.heightDIPs,
+            os: device.os,
+            deviceType: device.deviceType
+        });
+    }
+
+    return resolverInstance.resolveModuleName(path, ext);
+}
+
+function resolveModuleSnapshot(path, ext) {
+    traceWrite(`Resolving module in SNAPSHOT context - path: '${path}' with ext: '${ext}'`, traceCategories.ModuleNameResolver);
+
+    // Platform module when in snapshot. So resolve modules with default android phone.
+    // NB: The only module name that should ever be resolved while in snapshot is app.css, because it is
+    // applied explicitly in the snapshot by [NativeScriptSnapshotPlugin](https://github.com/NativeScript/nativescript-dev-webpack/blob/48b26f412fd70c19dc0b9c7763e08e9505a0ae11/plugins/NativeScriptSnapshotPlugin/index.js#L48-L56)
+    return new ModuleNameResolver({
+        width: 400,
+        height: 800,
+        os: "Android",
+        deviceType: "Phone"
+    }).resolveModuleName(path, ext);
+}
+
+export function clearCache() {
+    if (resolverInstance) {
+        resolverInstance.clearCache();
+    }
+}
+
+export function _setResolver(resolver: ModuleNameResolver) {
+    resolverInstance = resolver;
+}
+
+appCommonModule.on("livesync", args => clearCache());
+appCommonModule.on("orientationChanged", args => {
+    resolverInstance = undefined;
+});

nativescript-core/module-name-resolver/non-bundle-workflow-compat.ts

@@ -0,0 +1,141 @@
+import * as fs from "../file-system/file-system";
+import * as appCommonModule from "../application/application-common";
+import {
+    isEnabled as traceEnabled,
+    write as traceWrite,
+    categories as traceCategories
+} from "../trace";
+
+const cache = new Set<string>();
+let initialized = false;
+
+function register(name: string, loader: (name?: string) => void) {
+    if (traceEnabled()) {
+        traceWrite(`[Compat] Register module: ${name}`, traceCategories.ModuleNameResolver);
+    }
+    global.registerModule(name, loader);
+
+    if (name.startsWith("tns_modules")) {
+        const nonTnsModulesName = name.substr("tns_modules".length + 1);
+        if (traceEnabled()) {
+            traceWrite(`[Compat] Register module: ${nonTnsModulesName}`, traceCategories.ModuleNameResolver);
+        }
+        global.registerModule(nonTnsModulesName, loader);
+    }
+}
+
+function processFile(file: fs.File) {
+    const filePathRelativeToApp = file.path.substr(fs.knownFolders.currentApp().path.length + 1);
+    const loadContent = () => file.readTextSync();
+
+    switch (file.extension.toLocaleLowerCase()) {
+        case ".js":
+            const noExtPath = filePathRelativeToApp.substr(0, filePathRelativeToApp.length - ".js".length);
+
+            register(filePathRelativeToApp, function () { return global.require(file.path); });
+            register(noExtPath, function () { return global.require(file.path); });
+            break;
+
+        case ".css":
+            register(filePathRelativeToApp, loadContent);
+            break;
+
+        case ".xml":
+            register(filePathRelativeToApp, loadContent);
+            break;
+    }
+
+    if (file.name === "package.json") {
+        const json = global.require(file.path);
+        if (json.main) {
+            let name = filePathRelativeToApp.substr(0, filePathRelativeToApp.length - "package.json".length - 1);
+            let requirePath = fs.path.join(file.parent.path, json.main);
+
+            register(name, () => global.require(requirePath));
+        }
+    }
+}
+
+/**
+ * Processes folder and returns true if folder was not empty.
+ * @param Folder path
+ */
+function processFolder(path: string): boolean {
+    if (cache.has(path)) {
+        return true;
+    }
+    cache.add(path);
+
+    if (traceEnabled()) {
+        traceWrite(`[Compat] Processing folder: ${path}`, traceCategories.ModuleNameResolver);
+    }
+
+    let folderEmpty = true;
+
+    if (fs.Folder.exists(path)) {
+        const folder = fs.Folder.fromPath(path);
+
+        folder.eachEntity((file) => {
+            if (file instanceof fs.File) {
+                processFile(file);
+                folderEmpty = false;
+            }
+
+            return true;
+        });
+    }
+
+    return !folderEmpty;
+}
+
+/**
+ * Registers loaders for all files from the containing folder with global.registerModule().
+ * Compatibility method for non-webpack workflow (like in playground).
+ * @param moduleName
+ */
+export function registerModulesFromFileSystem(moduleName: string) {
+    initialize();
+
+    let folderProcessed = false;
+    let parentFolderProcessed = false;
+    // moduleName is a folder with package.json
+    const path = fs.path.join(fs.knownFolders.currentApp().path, moduleName);
+    if (fs.Folder.exists(path)) {
+        folderProcessed = processFolder(path);
+    }
+
+    // moduleName is file - load all files in its parent folder
+    const parentName = moduleName.substr(0, moduleName.lastIndexOf(fs.path.separator));
+    const parentFolderPath = fs.path.join(fs.knownFolders.currentApp().path, parentName);
+    if (fs.Folder.exists(parentFolderPath)) {
+        parentFolderProcessed = processFolder(parentFolderPath);
+    }
+
+    // Return only if we processed the actual folder or its parent folder.
+    // If the parent folder is empty we should still check tns_modules
+    // as this might be just a name of a plugin (ex. "nativescript-ui-autocomplete")
+    if (folderProcessed || (parentFolderProcessed && parentName)) {
+        return;
+    }
+
+    // moduleName is a folder in tns_modules ex. "nativescript-ui-chart"
+    const tnsModulesPath = fs.path.join(fs.knownFolders.currentApp().path, "tns_modules", moduleName);
+    if (fs.Folder.exists(tnsModulesPath)) {
+        processFolder(tnsModulesPath);
+    }
+
+    // moduleName a file in tns_modules/plugin. Avoid traversing the whole tns_modules folder if parentName is empty
+    if (parentName) {
+        const tnsParentFolderPath = fs.path.join(fs.knownFolders.currentApp().path, "tns_modules", parentName);
+        if (fs.Folder.exists(tnsParentFolderPath)) {
+            processFolder(tnsParentFolderPath);
+        }
+    }
+}
+
+function initialize() {
+    if (!initialized) {
+        appCommonModule.on("livesync", args => cache.clear());
+        initialized = true;
+    }
+}

nativescript-core/module-name-resolver/package.json

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

nativescript-core/module-name-resolver/qualifier-matcher/package.json

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

nativescript-core/module-name-resolver/qualifier-matcher/qualifier-matcher.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Provides ModuleNameResolver class used for loading files based on device capabilities.
+ * @module "module-name-resolver/qualifier-matcher"
+ */ /** */
+
+export interface PlatformContext {
+    width: number;
+    height: number;
+    os: string;
+    deviceType: string;
+}
+
+export function findMatch(path: string, ext: string, candidates: Array<string>, context: PlatformContext): string;

nativescript-core/module-name-resolver/qualifier-matcher/qualifier-matcher.ts

@@ -0,0 +1,158 @@
+import { PlatformContext } from "./";
+const MIN_WH: string = "minWH";
+const MIN_W: string = "minW";
+const MIN_H: string = "minH";
+const PRIORITY_STEP = 10000;
+
+interface QualifierSpec {
+    isMatch(value: string): boolean;
+    getMatchValue(value: string, context: PlatformContext): number;
+}
+
+const minWidthHeightQualifier: QualifierSpec = {
+    isMatch: function (value: string): boolean {
+        return value.indexOf(MIN_WH) === 0;
+
+    },
+    getMatchValue(value: string, context: PlatformContext): number {
+        const numVal = parseInt(value.substr(MIN_WH.length));
+        if (isNaN(numVal)) {
+            return -1;
+        }
+
+        const actualLength = Math.min(context.width, context.height);
+        if (actualLength < numVal) {
+            return -1;
+        }
+
+        return PRIORITY_STEP - (actualLength - numVal);
+    }
+};
+
+const minWidthQualifier: QualifierSpec = {
+    isMatch: function (value: string): boolean {
+        return value.indexOf(MIN_W) === 0 && value.indexOf(MIN_WH) < 0;
+
+    },
+    getMatchValue(value: string, context: PlatformContext): number {
+        const numVal = parseInt(value.substr(MIN_W.length));
+        if (isNaN(numVal)) {
+            return -1;
+        }
+
+        const actualWidth = context.width;
+        if (actualWidth < numVal) {
+            return -1;
+        }
+
+        return PRIORITY_STEP - (actualWidth - numVal);
+    }
+};
+
+const minHeightQualifier: QualifierSpec = {
+    isMatch: function (value: string): boolean {
+        return value.indexOf(MIN_H) === 0 && value.indexOf(MIN_WH) < 0;
+
+    },
+    getMatchValue(value: string, context: PlatformContext): number {
+        const numVal = parseInt(value.substr(MIN_H.length));
+        if (isNaN(numVal)) {
+            return -1;
+        }
+
+        const actualHeight = context.height;
+        if (actualHeight < numVal) {
+            return -1;
+        }
+
+        return PRIORITY_STEP - (actualHeight - numVal);
+    }
+};
+
+const platformQualifier: QualifierSpec = {
+    isMatch: function (value: string): boolean {
+        return value === "android" ||
+            value === "ios";
+
+    },
+    getMatchValue(value: string, context: PlatformContext): number {
+        return value === context.os.toLowerCase() ? 1 : -1;
+    }
+};
+
+const orientationQualifier: QualifierSpec = {
+    isMatch: function (value: string): boolean {
+        return value === "land" ||
+            value === "port";
+
+    },
+    getMatchValue(value: string, context: PlatformContext): number {
+        const isLandscape: number = (context.width > context.height) ? 1 : -1;
+
+        return (value === "land") ? isLandscape : -isLandscape;
+    }
+};
+
+// List of supported qualifiers ordered by priority
+const supportedQualifiers: Array<QualifierSpec> = [
+    minWidthHeightQualifier,
+    minWidthQualifier,
+    minHeightQualifier,
+    orientationQualifier,
+    platformQualifier
+];
+
+function checkQualifiers(qualifiers: Array<string>, context: PlatformContext): number {
+    let result = 0;
+    let value: number;
+    for (let i = 0; i < qualifiers.length; i++) {
+        if (qualifiers[i]) {
+            value = checkQualifier(qualifiers[i], context);
+            if (value < 0) {
+                // Non of the supported qualifiers matched this or the match was not satisfied
+                return -1;
+            }
+
+            result += value;
+        }
+    }
+
+    return result;
+}
+
+function checkQualifier(value: string, context: PlatformContext) {
+    let result: number;
+    for (let i = 0; i < supportedQualifiers.length; i++) {
+        if (supportedQualifiers[i].isMatch(value)) {
+            result = supportedQualifiers[i].getMatchValue(value, context);
+            if (result > 0) {
+                result += (supportedQualifiers.length - i) * PRIORITY_STEP;
+            }
+
+            return result;
+        }
+    }
+
+    return -1;
+}
+
+export function findMatch(path: string, ext: string, candidates: Array<string>, context: PlatformContext): string {
+    let bestValue = -1;
+    let result: string = null;
+
+    for (let i = 0; i < candidates.length; i++) {
+        const filePath = candidates[i];
+        const qualifiersStr: string = filePath.substr(path.length, filePath.length - path.length - (ext ? ext.length : 0));
+
+        const qualifiers = qualifiersStr.split(".");
+
+        const value = checkQualifiers(qualifiers, context);
+
+        if (value >= 0 && value > bestValue) {
+            bestValue = value;
+            result = candidates[i];
+        }
+    }
+
+    return result;
+}