nativescript 9.1.0-alpha.15 → 9.1.0-alpha.17

package/lib/services/require-service.js

@@ -9,4 +9,3 @@ class RequireService {
 }
 exports.RequireService = RequireService;
 yok_1.injector.register("requireService", RequireService);
-//# sourceMappingURL=require-service.js.map

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/start-service.js

@@ -96,4 +96,3 @@ class StartService {
 }
 exports.default = StartService;
 yok_1.injector.register("startService", StartService);
-//# sourceMappingURL=start-service.js.map

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/temp-service.js

@@ -8,14 +8,12 @@ const yok_1 = require("../common/yok");
 class TempService {
     constructor($cleanupService) {
         this.$cleanupService = $cleanupService;
-        // no-op
     }
     async mkdirSync(affixes) {
         var _a;
         const opts = typeof affixes === "string" ? { prefix: affixes } : affixes;
         const baseDir = (opts === null || opts === void 0 ? void 0 : opts.dir) ? opts.dir : (0, os_1.tmpdir)();
         const prefix = ((_a = opts === null || opts === void 0 ? void 0 : opts.prefix) !== null && _a !== void 0 ? _a : "ns-").replace(/\s+/g, "-");
-        // fs.mkdtempSync requires the full path prefix
         const pathToDir = fs.mkdtempSync(path.join(baseDir, prefix));
         await this.$cleanupService.addCleanupDeleteAction(pathToDir);
         return pathToDir;
@@ -35,4 +33,3 @@ class TempService {
 }
 exports.TempService = TempService;
 yok_1.injector.register("tempService", TempService);
-//# sourceMappingURL=temp-service.js.map

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/terminal-spinner-service.js

@@ -5,7 +5,6 @@ const ora = require("ora");
 const yok_1 = require("../common/yok");
 class TerminalSpinnerService {
     createSpinner(spinnerOptions = {}) {
-        // @ts-expect-error - options are readonly, however we still want to override them before passing them on...
         spinnerOptions.stream = spinnerOptions.stream || process.stdout;
         return ora(spinnerOptions);
     }
@@ -26,4 +25,3 @@ class TerminalSpinnerService {
 }
 exports.TerminalSpinnerService = TerminalSpinnerService;
 yok_1.injector.register("terminalSpinnerService", TerminalSpinnerService);
-//# sourceMappingURL=terminal-spinner-service.js.map

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-execution-service.js

@@ -4,6 +4,7 @@ exports.TestExecutionService = void 0;
 const constants = require("../constants");
 const path = require("path");
 const os = require("os");
+const enums_1 = require("../common/enums");
 const _ = require("lodash");
 const yok_1 = require("../common/yok");
 const package_path_helper_1 = require("../helpers/package-path-helper");
@@ -24,10 +25,8 @@ class TestExecutionService {
         platform = platform.toLowerCase();
         this.platform = platform;
         const projectData = this.$projectDataService.getProjectData(liveSyncInfo.projectDir);
-        // We need the dependencies installed here, so we can start the Karma server.
         await this.$pluginsService.ensureAllDependenciesAreInstalled(projectData);
         const karmaConfig = this.getKarmaConfiguration(platform, projectData);
-        // In case you want to debug the unit test runner, add "--inspect-brk=<port>" as a first element in the array of args.
         const karmaRunner = this.$childProcess.spawn(process.execPath, [path.join(__dirname, "karma-execution.js")], { stdio: ["inherit", "inherit", "inherit", "ipc"] });
         const launchKarmaTests = async (karmaData) => {
             this.$logger.trace("## Unit-testing: Parent process received message", karmaData);
@@ -44,8 +43,6 @@ class TestExecutionService {
                 const configJs = this.generateConfig(port, configOptions);
                 this.$fs.writeFile(path.join(liveSyncInfo.projectDir, TestExecutionService.CONFIG_FILE_NAME), configJs);
             }
-            // Prepare the project AFTER the TestExecutionService.CONFIG_FILE_NAME file is created in node_modules
-            // so it will be sent to device.
             await this.$runController.run({
                 liveSyncInfo,
                 deviceDescriptors,
@@ -58,13 +55,12 @@ class TestExecutionService {
             }
             launchKarmaTests(karmaData).catch((result) => {
                 this.$logger.error(result);
-                process.exit(130 /* ErrorCodes.KARMA_FAIL */);
+                process.exit(enums_1.ErrorCodes.KARMA_FAIL);
             });
         });
         return new Promise((resolve, reject) => {
             karmaRunner.on("exit", (exitCode) => {
                 if (exitCode !== 0) {
-                    //End our process with a non-zero exit code
                     const testError = new Error("Test run failed.");
                     reject(testError);
                 }
@@ -77,7 +73,7 @@ class TestExecutionService {
     }
     async canStartKarmaServer(projectData) {
         let canStartKarmaServer = true;
-        const requiredDependencies = ["@nativescript/unit-test-runner"]; // we need @nativescript/unit-test-runner at the local level because of hooks!
+        const requiredDependencies = ["@nativescript/unit-test-runner"];
         _.each(requiredDependencies, (dep) => {
             if (!projectData.dependencies[dep] && !projectData.devDependencies[dep]) {
                 canStartKarmaServer = false;
@@ -126,7 +122,6 @@ class TestExecutionService {
             karmaConfig.logLevel = "DEBUG";
         }
         if (!this.$options.watch) {
-            // Setting singleRun to true will automatically start the tests when new browser (device in our case) is registered in karma.
             karmaConfig.singleRun = true;
         }
         if (this.$options.debugBrk) {
@@ -145,4 +140,3 @@ exports.TestExecutionService = TestExecutionService;
 TestExecutionService.CONFIG_FILE_NAME = `node_modules/${constants.TEST_RUNNER_NAME}/config.js`;
 TestExecutionService.SOCKETIO_JS_FILE_NAME = `node_modules/${constants.TEST_RUNNER_NAME}/socket.io.js`;
 yok_1.injector.register("testExecutionService", TestExecutionService);
-//# sourceMappingURL=test-execution-service.js.map

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/test-initialization-service.js

@@ -34,9 +34,6 @@ class TestInitializationService {
         });
         return targetFrameworkDependencies;
     }
-    /**
-     * This method is used from test-init.md file so it is not allowed to use "this" inside the method's body.
-     */
     getFrameworkNames() {
         const configsPath = path.join(__dirname, "..", "..", "config");
         const dependenciesPath = path.join(configsPath, "test-dependencies.json");
@@ -55,4 +52,3 @@ __decorate([
     (0, decorators_1.cache)()
 ], TestInitializationService.prototype, "getFrameworkNames", null);
 yok_1.injector.register("testInitializationService", TestInitializationService);
-//# sourceMappingURL=test-initialization-service.js.map

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/timeline-profiler-service.js

@@ -98,4 +98,3 @@ __decorate([
     (0, decorators_1.cache)()
 ], TimelineProfilerService.prototype, "isEnabled", null);
 yok_1.injector.register("timelineProfilerService", TimelineProfilerService);
-//# sourceMappingURL=timeline-profiler-service.js.map

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/user-settings-service.js

@@ -32,4 +32,3 @@ class UserSettingsService {
 }
 exports.UserSettingsService = UserSettingsService;
 yok_1.injector.register("userSettingsService", UserSettingsService);
-//# sourceMappingURL=user-settings-service.js.map

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

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

package/lib/services/versions-service.js

@@ -7,6 +7,7 @@ const semver = require("semver");
 const path = require("path");
 const _ = require("lodash");
 const yok_1 = require("../common/yok");
+const constants_1 = require("../constants");
 var VersionInformationType;
 (function (VersionInformationType) {
     VersionInformationType["UpToDate"] = "UpToDate";
@@ -47,7 +48,6 @@ class VersionsService {
             const tnsCoreModulesPath = path.join(nodeModulesPath, constants.TNS_CORE_MODULES_NAME);
             const dependsOnNonScopedPackage = !!this.projectData.dependencies[constants.TNS_CORE_MODULES_NAME];
             const dependsOnScopedPackage = !!this.projectData.dependencies[constants.SCOPED_TNS_CORE_MODULES];
-            // ensure the dependencies are installed, so we can get their actual versions from node_modules
             if (!this.$fs.exists(nodeModulesPath) ||
                 (dependsOnNonScopedPackage && !this.$fs.exists(tnsCoreModulesPath)) ||
                 (dependsOnScopedPackage && !this.$fs.exists(scopedPackagePath))) {
@@ -74,16 +74,16 @@ class VersionsService {
         return versionInformations;
     }
     async getRuntimesVersions(platform) {
-        const iosRuntime = this.$projectDataService.getRuntimePackage(this.projectData.projectDir, "ios" /* constants.PlatformTypes.ios */);
-        const androidRuntime = this.$projectDataService.getRuntimePackage(this.projectData.projectDir, "android" /* constants.PlatformTypes.android */);
+        const iosRuntime = this.$projectDataService.getRuntimePackage(this.projectData.projectDir, constants.PlatformTypes.ios);
+        const androidRuntime = this.$projectDataService.getRuntimePackage(this.projectData.projectDir, constants.PlatformTypes.android);
         let runtimes = [];
         if (!platform) {
             runtimes = [iosRuntime, androidRuntime];
         }
-        else if (platform === "ios" /* PlatformTypes.ios */) {
+        else if (platform === constants_1.PlatformTypes.ios) {
             runtimes.push(iosRuntime);
         }
-        else if (platform === "android" /* PlatformTypes.android */) {
+        else if (platform === constants_1.PlatformTypes.android) {
             runtimes.push(androidRuntime);
         }
         const runtimesVersions = await Promise.all(runtimes.map(async (runtime) => {
@@ -176,4 +176,3 @@ VersionsService.UP_TO_DATE_MESSAGE = "up to date";
 VersionsService.UPDATE_AVAILABLE_MESSAGE = "Update available";
 VersionsService.NOT_INSTALLED_MESSAGE = "not installed";
 yok_1.injector.register("versionsService", VersionsService);
-//# sourceMappingURL=versions-service.js.map

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/watch-ignore-list-service.js

@@ -18,4 +18,3 @@ class WatchIgnoreListService {
 }
 exports.WatchIgnoreListService = WatchIgnoreListService;
 yok_1.injector.register("watchIgnoreListService", WatchIgnoreListService);
-//# sourceMappingURL=watch-ignore-list-service.js.map

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/xcconfig-service.js

@@ -5,9 +5,10 @@ const path = require("path");
 const constants_1 = require("../common/constants");
 const yok_1 = require("../common/yok");
 class XcconfigService {
-    constructor($childProcess, $fs) {
+    constructor($childProcess, $fs, $logger) {
         this.$childProcess = $childProcess;
         this.$fs = $fs;
+        this.$logger = $logger;
     }
     getPluginsXcconfigFilePaths(projectRoot) {
         return {
@@ -25,16 +26,49 @@ class XcconfigService {
         if (!this.$fs.exists(destinationFile)) {
             this.$fs.writeFile(destinationFile, "");
         }
-        const escapedDestinationFile = destinationFile.replace(/'/g, "\\'");
-        const escapedSourceFile = sourceFile.replace(/'/g, "\\'");
-        const mergeScript = `require 'xcodeproj';
-		userConfig = Xcodeproj::Config.new('${escapedDestinationFile}')
-		existingConfig = Xcodeproj::Config.new('${escapedSourceFile}')
-		userConfig.attributes.each do |key,|
-  			existingConfig.attributes.delete(key) if (userConfig.attributes.key?(key) && existingConfig.attributes.key?(key))
+        const mergeScript = `require 'xcodeproj'
+		require 'json'
+		destination, source = ARGV
+		userConfig = Xcodeproj::Config.new(destination)
+		existingConfig = Xcodeproj::Config.new(source)
+		conflicts = []
+		userConfig.attributes.each do |key, kept|
+			if existingConfig.attributes.key?(key)
+				ignored = existingConfig.attributes[key]
+				conflicts << { 'key' => key, 'kept' => kept.to_s, 'ignored' => ignored.to_s } if ignored.to_s != kept.to_s
+				existingConfig.attributes.delete(key)
+			end
 		end
-		userConfig.merge(existingConfig).save_as(Pathname.new('${escapedDestinationFile}'))`;
-        await this.$childProcess.exec(`ruby -e "${mergeScript}"`);
+		userConfig.merge(existingConfig).save_as(Pathname.new(destination))
+		print '${XcconfigService.CONFLICT_MARKER}' + JSON.generate(conflicts)`;
+        const output = await this.$childProcess.execFile("ruby", [
+            "-e",
+            mergeScript,
+            destinationFile,
+            sourceFile,
+        ]);
+        this.warnAboutConflicts(sourceFile, output);
+    }
+    warnAboutConflicts(sourceFile, output) {
+        const text = output === null || output === undefined ? "" : `${output}`;
+        const markerIndex = text.lastIndexOf(XcconfigService.CONFLICT_MARKER);
+        if (markerIndex === -1) {
+            return;
+        }
+        let conflicts;
+        try {
+            conflicts = JSON.parse(text.substring(markerIndex + XcconfigService.CONFLICT_MARKER.length));
+        }
+        catch (err) {
+            this.$logger.trace(`Unable to read xcconfig conflicts for ${sourceFile}: ${err}`);
+            return;
+        }
+        for (const conflict of conflicts || []) {
+            this.$logger.warn(`Ignoring ${conflict.key} = ${conflict.ignored} from ${sourceFile}: ` +
+                `already set to ${conflict.kept} by a higher precedence xcconfig. ` +
+                `The app's App_Resources xcconfig is applied first, then each ` +
+                `plugin's in dependency order.`);
+        }
     }
     readPropertyValue(xcconfigFilePath, propertyName) {
         if (this.$fs.exists(xcconfigFilePath)) {
@@ -55,7 +89,6 @@ class XcconfigService {
                 }
             });
             if (isPropertyParsed) {
-                // property can be an empty string, so we don't check for that.
                 return property;
             }
         }
@@ -63,5 +96,5 @@ class XcconfigService {
     }
 }
 exports.XcconfigService = XcconfigService;
+XcconfigService.CONFLICT_MARKER = "NS_XCCONFIG_CONFLICTS:";
 yok_1.injector.register("xcconfigService", XcconfigService);
-//# sourceMappingURL=xcconfig-service.js.map

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

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

package/lib/services/xcproj-service.js

@@ -21,4 +21,3 @@ class XcprojService {
     }
 }
 yok_1.injector.register("xcprojService", XcprojService);
-//# sourceMappingURL=xcproj-service.js.map

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

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

package/lib/shared-event-bus.js

@@ -2,12 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const events_1 = require("events");
 const yok_1 = require("./common/yok");
-/**
- * Event Bus used by different services to emit state changes and
- * allow listening for these state changes without needing a reference
- * to the emitting service.
- */
 class SharedEventBus extends events_1.EventEmitter {
 }
 yok_1.injector.register("sharedEventBus", SharedEventBus);
-//# sourceMappingURL=shared-event-bus.js.map

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/sys-info.js

@@ -15,6 +15,7 @@ const verify_node_version_1 = require("./common/verify-node-version");
 const decorators_1 = require("./common/decorators");
 const semver = require("semver");
 const yok_1 = require("./common/yok");
+const system_warnings_1 = require("./definitions/system-warnings");
 class SysInfo {
     constructor($fs, $hostInfo) {
         this.$fs = $fs;
@@ -79,7 +80,7 @@ class SysInfo {
         if (macOSVersion && macOSVersion < constants_1.MacOSVersions.HighSierra) {
             return {
                 message: (0, util_1.format)(constants_1.MacOSDeprecationStringFormat, macOSVersion),
-                severity: "high" /* SystemWarningsSeverity.high */,
+                severity: system_warnings_1.SystemWarningsSeverity.high,
             };
         }
         return null;
@@ -101,4 +102,3 @@ __decorate([
     (0, decorators_1.exported)("sysInfo")
 ], SysInfo.prototype, "getSupportedNodeVersionRange", null);
 yok_1.injector.register("sysInfo", SysInfo);
-//# sourceMappingURL=sys-info.js.map

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,23 +39,30 @@ 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(".");
             const name = parts.shift();
             const property = this.getProperty(name, parent);
-            // no android key, add it to parent to root
             if (!property) {
                 return undefined;
             }
@@ -65,14 +72,11 @@ class ConfigTransformer {
             if (!_parent) {
                 return undefined;
             }
-            // add nonExistent.deep to android: {}
             return this.getProperty(parts.join("."), _parent);
         }
-        // if we have a parent, we are reading the property from it
         if (parent) {
             return parent.getProperty(key);
         }
-        // otherwise we just read it from the root exports object
         return this.getProperty(key, this.getDefaultExportValue());
     }
     addProperty(key, value, parent = null) {
@@ -246,22 +250,15 @@ class ConfigTransformer {
         }
         this.setInitializerValue(initializer, newValue);
     }
-    /**
-     * @internal
-     */
     getFullText() {
         return this.config.getFullText();
     }
-    /**
-     * @internal
-     */
     getValue(key) {
         return this.getPropertyValue(this.getProperty(key));
     }
     setValue(key, value) {
         const property = this.getProperty(key);
         if (!property) {
-            // add new property
             this.addProperty(key, value);
         }
         else {
@@ -271,4 +268,3 @@ class ConfigTransformer {
     }
 }
 exports.ConfigTransformer = ConfigTransformer;
-//# sourceMappingURL=config-transformer.js.map

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-builder.js

@@ -29,4 +29,3 @@ class NodeModulesBuilder {
 }
 exports.NodeModulesBuilder = NodeModulesBuilder;
 yok_1.injector.register("nodeModulesBuilder", NodeModulesBuilder);
-//# sourceMappingURL=node-modules-builder.js.map

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;
+}