nativescript 9.1.0-alpha.16 → 9.1.0-alpha.17

package/lib/services/project-service.d.ts

@@ -0,0 +1,34 @@
+import { IProjectService, IProjectDataService, IProjectTemplatesService, ICreateProjectData, IProjectSettings, IProjectConfigService } from "../definitions/project";
+import { INodePackageManager, IOptions, IProjectNameService, IStaticConfig } from "../declarations";
+import { IHooksService, IErrors, IFileSystem, IProjectHelper, IChildProcess } from "../common/declarations";
+import { ITempService } from "../definitions/temp-service";
+export declare class ProjectService implements IProjectService {
+    private $options;
+    private $hooksService;
+    private $packageManager;
+    private $errors;
+    private $fs;
+    private $logger;
+    private $pacoteService;
+    private $projectDataService;
+    private $projectConfigService;
+    private $projectHelper;
+    private $projectNameService;
+    private $projectTemplatesService;
+    private $tempService;
+    private $staticConfig;
+    private $childProcess;
+    constructor($options: IOptions, $hooksService: IHooksService, $packageManager: INodePackageManager, $errors: IErrors, $fs: IFileSystem, $logger: ILogger, $pacoteService: IPacoteService, $projectDataService: IProjectDataService, $projectConfigService: IProjectConfigService, $projectHelper: IProjectHelper, $projectNameService: IProjectNameService, $projectTemplatesService: IProjectTemplatesService, $tempService: ITempService, $staticConfig: IStaticConfig, $childProcess: IChildProcess);
+    validateProjectName(opts: {
+        projectName: string;
+        force: boolean;
+        pathToProject: string;
+    }): Promise<string>;
+    createProject(projectOptions: IProjectSettings): Promise<ICreateProjectData>;
+    isValidNativeScriptProject(pathToProject?: string): boolean;
+    private getValidProjectDir;
+    private createProjectCore;
+    private extractTemplate;
+    ensureAppResourcesExist(projectDir: string): Promise<void>;
+    private alterPackageJsonData;
+}

package/lib/services/project-templates-service.d.ts

@@ -0,0 +1,18 @@
+import { IProjectTemplatesService, ITemplateData } from "../definitions/project";
+import { IPackageInstallationManager, INodePackageManager, IStaticConfig } from "../declarations";
+import { IFileSystem, IAnalyticsService } from "../common/declarations";
+export declare class ProjectTemplatesService implements IProjectTemplatesService {
+    private $analyticsService;
+    private $fs;
+    private $logger;
+    private $packageInstallationManager;
+    private $pacoteService;
+    private $packageManager;
+    private $staticConfig;
+    private templatePackageContents;
+    constructor($analyticsService: IAnalyticsService, $fs: IFileSystem, $logger: ILogger, $packageInstallationManager: IPackageInstallationManager, $pacoteService: IPacoteService, $packageManager: INodePackageManager, $staticConfig: IStaticConfig);
+    prepareTemplate(templateValue: string, projectDir: string): Promise<ITemplateData>;
+    private getTemplatePackageJsonContent;
+    private getTemplateNameToBeTracked;
+    private getDesiredVersion;
+}

package/lib/services/qr-code-terminal-service.d.ts

@@ -0,0 +1,5 @@
+export declare class QrCodeTerminalService implements IQrCodeTerminalService {
+    private $logger;
+    constructor($logger: ILogger);
+    generate(url: string): void;
+}

package/lib/services/require-service.d.ts

@@ -0,0 +1,3 @@
+export declare class RequireService implements IRequireService {
+    require(module: string): any;
+}

package/lib/services/start-service.d.ts

@@ -0,0 +1,30 @@
+import { ChildProcess } from "child_process";
+import { IChildProcess } from "../common/declarations";
+import { IKeyCommandHelper } from "../common/definitions/key-commands";
+import { IProjectData } from "../definitions/project";
+import { IStartService } from "./../definitions/start-service.d";
+import { IStaticConfig } from "../declarations";
+export default class StartService implements IStartService {
+    private $keyCommandHelper;
+    private $childProcess;
+    private $devicePlatformsConstants;
+    private $projectData;
+    private $logger;
+    private $staticConfig;
+    ios: ChildProcess;
+    visionos: ChildProcess;
+    android: ChildProcess;
+    verbose: boolean;
+    constructor($keyCommandHelper: IKeyCommandHelper, $childProcess: IChildProcess, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $projectData: IProjectData, $logger: ILogger, $staticConfig: IStaticConfig);
+    toggleVerbose(): void;
+    format(data: Buffer, platform: string): Buffer<ArrayBufferLike>;
+    runForPlatform(platform: string): Promise<void>;
+    runIOS(): Promise<void>;
+    runVisionOS(): Promise<void>;
+    runAndroid(): Promise<void>;
+    stopIOS(): Promise<void>;
+    stopVisionOS(): Promise<void>;
+    stopAndroid(): Promise<void>;
+    start(): void;
+    addKeyCommandOverrides(): void;
+}

package/lib/services/temp-service.d.ts

@@ -0,0 +1,14 @@
+import { ICleanupService } from "../definitions/cleanup-service";
+import { ITempService } from "../definitions/temp-service";
+type TempAffixOptions = {
+    prefix?: string;
+    suffix?: string;
+    dir?: string;
+};
+export declare class TempService implements ITempService {
+    private $cleanupService;
+    constructor($cleanupService: ICleanupService);
+    mkdirSync(affixes: string | TempAffixOptions): Promise<string>;
+    path(options: string | TempAffixOptions): Promise<string>;
+}
+export {};

package/lib/services/terminal-spinner-service.d.ts

@@ -0,0 +1,5 @@
+import { ITerminalSpinner, ITerminalSpinnerOptions, ITerminalSpinnerService } from "../definitions/terminal-spinner-service";
+export declare class TerminalSpinnerService implements ITerminalSpinnerService {
+    createSpinner(spinnerOptions?: ITerminalSpinnerOptions): ITerminalSpinner;
+    execute<T>(spinnerOptions: ITerminalSpinnerOptions, action: () => Promise<T>): Promise<T>;
+}

package/lib/services/test-execution-service.d.ts

@@ -0,0 +1,26 @@
+import { RunController } from "../controllers/run-controller";
+import { ITestExecutionService, IProjectDataService, IProjectData } from "../definitions/project";
+import { IConfiguration, IOptions } from "../declarations";
+import { IPluginsService } from "../definitions/plugins";
+import { Server, IFileSystem, IChildProcess } from "../common/declarations";
+import { ICommandParameter } from "../common/definitions/commands";
+export declare class TestExecutionService implements ITestExecutionService {
+    private $runController;
+    private $httpClient;
+    private $config;
+    private $logger;
+    private $fs;
+    private $options;
+    private $pluginsService;
+    private $projectDataService;
+    private $childProcess;
+    private static CONFIG_FILE_NAME;
+    private static SOCKETIO_JS_FILE_NAME;
+    constructor($runController: RunController, $httpClient: Server.IHttpClient, $config: IConfiguration, $logger: ILogger, $fs: IFileSystem, $options: IOptions, $pluginsService: IPluginsService, $projectDataService: IProjectDataService, $childProcess: IChildProcess);
+    platform: string;
+    startKarmaServer(platform: string, liveSyncInfo: ILiveSyncInfo, deviceDescriptors: ILiveSyncDeviceDescriptor[]): Promise<void>;
+    canStartKarmaServer(projectData: IProjectData): Promise<boolean>;
+    allowedParameters: ICommandParameter[];
+    private generateConfig;
+    private getKarmaConfiguration;
+}

package/lib/services/test-initialization-service.d.ts

@@ -0,0 +1,10 @@
+import { ITestInitializationService } from "../definitions/project";
+import { IErrors, IFileSystem, IDependencyInformation } from "../common/declarations";
+export declare class TestInitializationService implements ITestInitializationService {
+    private $errors;
+    private $fs;
+    private configsPath;
+    constructor($errors: IErrors, $fs: IFileSystem);
+    getDependencies(selectedFramework: string): IDependencyInformation[];
+    getFrameworkNames(): string[];
+}

package/lib/services/timeline-profiler-service.d.ts

@@ -0,0 +1,18 @@
+import { IFileSystem } from "../common/declarations";
+import { IProjectConfigService } from "../definitions/project";
+export interface ITimelineProfilerService {
+    processLogData(data: string, deviceIdentifier: string): void;
+}
+export declare class TimelineProfilerService implements ITimelineProfilerService {
+    private $projectConfigService;
+    private $fs;
+    private $logger;
+    private timelines;
+    private attachedExitHandler;
+    constructor($projectConfigService: IProjectConfigService, $fs: IFileSystem, $logger: ILogger);
+    private attachExitHanlder;
+    processLogData(data: string, deviceIdentifier: string): void;
+    private isEnabled;
+    private toTrace;
+    private writeTimelines;
+}

package/lib/services/user-settings-service.d.ts

@@ -0,0 +1,14 @@
+import { IInjector } from "../common/definitions/yok";
+import { IUserSettingsService, ISettingsService, IDictionary } from "../common/declarations";
+import { ICacheTimeoutOpts, IUseCacheOpts } from "../common/definitions/json-file-settings-service";
+export declare class UserSettingsService implements IUserSettingsService {
+    private $injector;
+    private $settingsService;
+    private get $jsonFileSettingsService();
+    constructor($injector: IInjector, $settingsService: ISettingsService);
+    getSettingValue<T>(settingName: string, cacheOpts?: ICacheTimeoutOpts): Promise<T>;
+    saveSetting<T>(key: string, value: T, cacheOpts?: IUseCacheOpts): Promise<void>;
+    saveSettings(data: IDictionary<{}>, cacheOpts?: IUseCacheOpts): Promise<void>;
+    removeSetting(key: string): Promise<void>;
+    loadUserSettingsFile(): Promise<void>;
+}

package/lib/services/versions-service.d.ts

@@ -0,0 +1,5 @@
+export declare enum VersionInformationType {
+    UpToDate = "UpToDate",
+    UpdateAvailable = "UpdateAvailable",
+    NotInstalled = "NotInstalled"
+}

package/lib/services/watch-ignore-list-service.d.ts

@@ -0,0 +1,7 @@
+import { IWatchIgnoreListService } from "../declarations";
+export declare class WatchIgnoreListService implements IWatchIgnoreListService {
+    private ignoreMap;
+    addFileToIgnoreList(filePath: string): void;
+    removeFileFromIgnoreList(filePath: string): void;
+    isFileInIgnoreList(filePath: string): boolean;
+}

package/lib/services/xcconfig-service.d.ts

@@ -0,0 +1,15 @@
+import { IXcconfigService } from "../declarations";
+import { IChildProcess, IFileSystem, IStringDictionary } from "../common/declarations";
+export declare class XcconfigService implements IXcconfigService {
+    private $childProcess;
+    private $fs;
+    private $logger;
+    private static readonly CONFLICT_MARKER;
+    constructor($childProcess: IChildProcess, $fs: IFileSystem, $logger: ILogger);
+    getPluginsXcconfigFilePaths(projectRoot: string): IStringDictionary;
+    private getPluginsDebugXcconfigFilePath;
+    private getPluginsReleaseXcconfigFilePath;
+    mergeFiles(sourceFile: string, destinationFile: string): Promise<void>;
+    private warnAboutConflicts;
+    readPropertyValue(xcconfigFilePath: string, propertyName: string): string;
+}

package/lib/services/xcproj-service.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/shared-event-bus.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/sys-info.d.ts

@@ -0,0 +1,18 @@
+import { ISysInfo, IFileSystem, IHostInfo, ISystemWarning } from "./common/declarations";
+export declare class SysInfo implements ISysInfo {
+    private $fs;
+    private $hostInfo;
+    private sysInfo;
+    constructor($fs: IFileSystem, $hostInfo: IHostInfo);
+    getSysInfo(config?: NativeScriptDoctor.ISysInfoConfig): Promise<NativeScriptDoctor.ISysInfoData>;
+    getXcodeVersion(): Promise<string>;
+    getCocoaPodsVersion(): Promise<string>;
+    getJavaPath(): Promise<string>;
+    getJavaCompilerVersion(): Promise<string>;
+    getJavaVersionFromPath(): Promise<string>;
+    getJavaVersionFromJavaHome(): Promise<string>;
+    getSystemWarnings(): Promise<ISystemWarning[]>;
+    getSupportedNodeVersionRange(): string;
+    getMacOSWarningMessage(): Promise<ISystemWarning>;
+    getXcodeWarning(): Promise<string>;
+}

package/lib/tools/config-manipulation/config-transformer.d.ts

@@ -0,0 +1,28 @@
+export type SupportedConfigValues = string | number | boolean | {
+    [key: string]: SupportedConfigValues;
+} | any[];
+export interface IConfigTransformer {
+    setValue(path: string, value: SupportedConfigValues): string;
+}
+export declare class ConfigTransformer implements IConfigTransformer {
+    private project;
+    private config;
+    private readonly scriptKind;
+    constructor(content: string);
+    private getDefaultExportValue;
+    private unwrapObjectLiteral;
+    private getProperty;
+    private addProperty;
+    private createInitializer;
+    private isBooleanLiteralNode;
+    private replaceInitializer;
+    private setInitializerValue;
+    private getInitializerValue;
+    private getIdentifierValue;
+    private setIdentifierValue;
+    private getPropertyValue;
+    private setPropertyValue;
+    getFullText(): string;
+    getValue(key: string): any;
+    setValue(key: string, value: SupportedConfigValues): string;
+}

package/lib/tools/config-manipulation/config-transformer.js

@@ -25,7 +25,7 @@ class ConfigTransformer {
                         const expression = statement.getExpressionIfKind(ts_morph_1.SyntaxKind.BinaryExpression);
                         const leftSide = expression.getLeft();
                         if (leftSide.getFullText().trim() === "module.exports") {
-                            exportValue = expression.getRight();
+                            exportValue = this.unwrapObjectLiteral(expression.getRight());
                             return true;
                         }
                     }
@@ -39,17 +39,25 @@ class ConfigTransformer {
             const exports = this.config
                 .getDefaultExportSymbolOrThrow()
                 .getDeclarations()[0];
-            const expr = exports.getExpression();
-            exportValue =
-                expr.getChildCount() > 0
-                    ? expr.getChildAtIndex(0)
-                    : expr;
+            exportValue = this.unwrapObjectLiteral(exports.getExpression());
         }
-        if (!ts_morph_1.Node.isObjectLiteralExpression(exportValue)) {
+        if (!exportValue) {
             throw new Error("default export must be an object!");
         }
         return exportValue;
     }
+    unwrapObjectLiteral(node) {
+        if (ts_morph_1.Node.isObjectLiteralExpression(node)) {
+            return node;
+        }
+        if (ts_morph_1.Node.isParenthesizedExpression(node) ||
+            ts_morph_1.Node.isAsExpression(node) ||
+            ts_morph_1.Node.isSatisfiesExpression(node) ||
+            ts_morph_1.Node.isTypeAssertion(node)) {
+            return this.unwrapObjectLiteral(node.getExpression());
+        }
+        return undefined;
+    }
     getProperty(key, parent = null) {
         if (key.includes(".")) {
             const parts = key.split(".");

package/lib/tools/node-modules/node-modules-builder.d.ts

@@ -0,0 +1,9 @@
+import { INodeModulesBuilder, INodeModulesDependenciesBuilder, IPrepareNodeModulesData } from "../../definitions/platform";
+import { IPluginsService } from "../../definitions/plugins";
+export declare class NodeModulesBuilder implements INodeModulesBuilder {
+    private $logger;
+    private $nodeModulesDependenciesBuilder;
+    private $pluginsService;
+    constructor($logger: ILogger, $nodeModulesDependenciesBuilder: INodeModulesDependenciesBuilder, $pluginsService: IPluginsService);
+    prepareNodeModules({ platformData, projectData, }: IPrepareNodeModulesData): Promise<void>;
+}

package/lib/tools/node-modules/node-modules-dependencies-builder.d.ts

@@ -0,0 +1,10 @@
+import { INodeModulesDependenciesBuilder } from "../../definitions/platform";
+import { IDependencyData } from "../../declarations";
+import { IFileSystem } from "../../common/declarations";
+export declare class NodeModulesDependenciesBuilder implements INodeModulesDependenciesBuilder {
+    private $fs;
+    constructor($fs: IFileSystem);
+    getProductionDependencies(projectPath: string, ignore?: string[]): IDependencyData[];
+    private findModule;
+    private getDependencyData;
+}

package/lib/tools/plist-merge/plist-session.d.ts

@@ -0,0 +1,30 @@
+export interface Reporter {
+    log?(msg: string): void;
+    warn?(msg: string): void;
+}
+export interface Patch {
+    name: string;
+    read(): string;
+}
+export interface ICFBundleURLType {
+    CFBundleTypeRole: string;
+    CFBundleURLSchemes: string[];
+}
+export declare class PlistMerger {
+    private reporter?;
+    constructor(reporter?: Reporter);
+    merge(base: any, patch: any): any;
+    private mergeCFBundleURLTypes;
+    private mergeLSApplicationQueriesSchemes;
+    private customizer;
+    private warn;
+}
+export declare class PlistSession {
+    private reporter?;
+    private patches;
+    constructor(reporter?: Reporter);
+    get hasPatches(): boolean;
+    patch(patch: Patch): void;
+    build(): string;
+    private log;
+}

package/lib/tools/plist-merge/plist-session.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlistSession = exports.PlistMerger = void 0;
+const plist = require("plist");
+const _ = require("lodash");
+const CF_BUNDLE_URL_TYPES = "CFBundleURLTypes";
+const LS_APPLICATION_QUERIES_SCHEMES = "LSApplicationQueriesSchemes";
+class PlistMerger {
+    constructor(reporter) {
+        this.reporter = reporter;
+    }
+    merge(base, patch) {
+        const baseClone = _.cloneDeep(base);
+        _.mergeWith(baseClone, patch, this.customizer.bind(this));
+        return baseClone;
+    }
+    mergeCFBundleURLTypes(baseValue, patchValue) {
+        for (const patchElement of patchValue) {
+            let shouldAddToBase = true;
+            for (const baseElement of baseValue) {
+                if (!patchElement.CFBundleTypeRole || !baseElement.CFBundleTypeRole) {
+                    this.warn(`Merging ${CF_BUNDLE_URL_TYPES}: Property CFBundleTypeRole is required!`);
+                }
+                if (patchElement.CFBundleTypeRole === baseElement.CFBundleTypeRole) {
+                    baseElement.CFBundleURLSchemes =
+                        baseElement.CFBundleURLSchemes.concat(patchElement.CFBundleURLSchemes);
+                    shouldAddToBase = false;
+                }
+            }
+            if (shouldAddToBase) {
+                baseValue.push(patchElement);
+            }
+        }
+        return baseValue;
+    }
+    mergeLSApplicationQueriesSchemes(baseValue, patchValue) {
+        for (const patchElement of patchValue) {
+            if (!baseValue.some((x) => x === patchElement)) {
+                baseValue.push(patchElement);
+            }
+        }
+        return baseValue;
+    }
+    customizer(baseValue, patchValue, key) {
+        if (key === CF_BUNDLE_URL_TYPES && !!baseValue) {
+            return this.mergeCFBundleURLTypes(baseValue, patchValue);
+        }
+        else if (key === LS_APPLICATION_QUERIES_SCHEMES && !!baseValue) {
+            return this.mergeLSApplicationQueriesSchemes(baseValue, patchValue);
+        }
+        if (_.isArray(baseValue)) {
+            return patchValue;
+        }
+    }
+    warn(msg) {
+        if (this.reporter && this.reporter.warn) {
+            this.reporter.warn(msg);
+        }
+    }
+}
+exports.PlistMerger = PlistMerger;
+class PlistSession {
+    constructor(reporter) {
+        this.reporter = reporter;
+        this.patches = [];
+    }
+    get hasPatches() {
+        return this.patches.length > 0;
+    }
+    patch(patch) {
+        this.patches.push(patch);
+    }
+    build() {
+        this.log(`Start`);
+        const plistMerger = new PlistMerger(this.reporter);
+        let jsonPlist = {};
+        for (const patch of this.patches) {
+            this.log(`Patch '${patch.name}'`);
+            const patchJson = plist.parse(patch.read());
+            jsonPlist = plistMerger.merge(jsonPlist, patchJson);
+        }
+        const resultString = plist.build(jsonPlist);
+        this.log(`Complete`);
+        return resultString;
+    }
+    log(msg) {
+        if (this.reporter && this.reporter.log) {
+            this.reporter.log(msg);
+        }
+    }
+}
+exports.PlistSession = PlistSession;

package/lib/yarn-package-manager.d.ts

@@ -0,0 +1,16 @@
+import { BasePackageManager } from "./base-package-manager";
+import { INodePackageManagerInstallOptions, INpmInstallResultInfo, INpmsResult } from "./declarations";
+import { IChildProcess, IErrors, IFileSystem, IHostInfo, Server, IDictionary } from "./common/declarations";
+export declare class YarnPackageManager extends BasePackageManager {
+    private $errors;
+    private $httpClient;
+    private $logger;
+    constructor($childProcess: IChildProcess, $errors: IErrors, $fs: IFileSystem, $hostInfo: IHostInfo, $httpClient: Server.IHttpClient, $logger: ILogger, $pacoteService: IPacoteService);
+    install(packageName: string, pathToSave: string, config: INodePackageManagerInstallOptions): Promise<INpmInstallResultInfo>;
+    uninstall(packageName: string, config?: IDictionary<string | boolean>, cwd?: string): Promise<string>;
+    view(packageName: string, config: Object): Promise<any>;
+    search(filter: string[], config: IDictionary<string | boolean>): Promise<string>;
+    searchNpms(keyword: string): Promise<INpmsResult>;
+    getRegistryPackageData(packageName: string): Promise<any>;
+    getCachePath(): Promise<string>;
+}

package/lib/yarn2-package-manager.d.ts

@@ -0,0 +1,18 @@
+import { BasePackageManager } from "./base-package-manager";
+import { INodePackageManagerInstallOptions, INpmInstallResultInfo, INpmsResult } from "./declarations";
+import { IChildProcess, IErrors, IFileSystem, IHostInfo, Server, IDictionary } from "./common/declarations";
+export declare class Yarn2PackageManager extends BasePackageManager {
+    private $errors;
+    private $httpClient;
+    private $logger;
+    private $hostInfo_;
+    constructor($childProcess: IChildProcess, $errors: IErrors, $fs: IFileSystem, $hostInfo: IHostInfo, $httpClient: Server.IHttpClient, $logger: ILogger, $pacoteService: IPacoteService);
+    protected getPackageManagerExecutableName(): string;
+    install(packageName: string, pathToSave: string, config: INodePackageManagerInstallOptions): Promise<INpmInstallResultInfo>;
+    uninstall(packageName: string, config?: IDictionary<string | boolean>, cwd?: string): Promise<string>;
+    view(packageName: string, config: Object): Promise<any>;
+    search(filter: string[], config: IDictionary<string | boolean>): Promise<string>;
+    searchNpms(keyword: string): Promise<INpmsResult>;
+    getRegistryPackageData(packageName: string): Promise<any>;
+    getCachePath(): Promise<string>;
+}