@akylas/nativescript-cli 8.7.2

package/lib/services/xcconfig-service.js

@@ -0,0 +1,76 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XcconfigService = void 0;
+const path = require("path");
+const constants_1 = require("../common/constants");
+const yok_1 = require("../common/yok");
+class XcconfigService {
+    constructor($childProcess, $fs) {
+        this.$childProcess = $childProcess;
+        this.$fs = $fs;
+    }
+    getPluginsXcconfigFilePaths(projectRoot) {
+        return {
+            [constants_1.Configurations.Debug.toLowerCase()]: this.getPluginsDebugXcconfigFilePath(projectRoot),
+            [constants_1.Configurations.Release.toLowerCase()]: this.getPluginsReleaseXcconfigFilePath(projectRoot),
+        };
+    }
+    getPluginsDebugXcconfigFilePath(projectRoot) {
+        return path.join(projectRoot, "plugins-debug.xcconfig");
+    }
+    getPluginsReleaseXcconfigFilePath(projectRoot) {
+        return path.join(projectRoot, "plugins-release.xcconfig");
+    }
+    mergeFiles(sourceFile, destinationFile) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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))
+		end
+		userConfig.merge(existingConfig).save_as(Pathname.new('${escapedDestinationFile}'))`;
+            yield this.$childProcess.exec(`ruby -e "${mergeScript}"`);
+        });
+    }
+    readPropertyValue(xcconfigFilePath, propertyName) {
+        if (this.$fs.exists(xcconfigFilePath)) {
+            const text = this.$fs.readText(xcconfigFilePath);
+            let property;
+            let isPropertyParsed = false;
+            text.split(/\r?\n/).forEach((line) => {
+                line = line.replace(/\/(\/)[^\n]*$/, "");
+                if (line.indexOf(propertyName) >= 0) {
+                    const parts = line.split("=");
+                    if (parts.length > 1 && parts[1]) {
+                        property = parts[1].trim();
+                        isPropertyParsed = true;
+                        if (property[property.length - 1] === ";") {
+                            property = property.slice(0, -1);
+                        }
+                    }
+                }
+            });
+            if (isPropertyParsed) {
+                return property;
+            }
+        }
+        return null;
+    }
+}
+exports.XcconfigService = XcconfigService;
+yok_1.injector.register("xcconfigService", XcconfigService);

package/lib/services/xcproj-service.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const constants_1 = require("../constants");
+const yok_1 = require("../common/yok");
+class XcprojService {
+    getXcodeprojPath(projectData, projectRoot) {
+        return path.join(projectRoot, projectData.projectName + constants_1.IosProjectConstants.XcodeProjExtName);
+    }
+}
+yok_1.injector.register("xcprojService", XcprojService);

package/lib/shared-event-bus.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+const yok_1 = require("./common/yok");
+class SharedEventBus extends events_1.EventEmitter {
+}
+yok_1.injector.register("sharedEventBus", SharedEventBus);

package/lib/sys-info.js

@@ -0,0 +1,120 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SysInfo = void 0;
+const path = require("path");
+const util_1 = require("util");
+const doctor_1 = require("@nativescript/doctor");
+const constants_1 = require("./constants");
+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");
+class SysInfo {
+    constructor($fs, $hostInfo) {
+        this.$fs = $fs;
+        this.$hostInfo = $hostInfo;
+        this.sysInfo = null;
+    }
+    getSysInfo(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.sysInfo) {
+                const pathToNativeScriptCliPackageJson = (config && config.pathToNativeScriptCliPackageJson) ||
+                    path.join(__dirname, "..", "package.json");
+                const androidToolsInfo = config && config.androidToolsInfo;
+                this.sysInfo = yield doctor_1.sysInfo.getSysInfo({
+                    pathToNativeScriptCliPackageJson,
+                    androidToolsInfo,
+                });
+            }
+            return this.sysInfo;
+        });
+    }
+    getXcodeVersion() {
+        return doctor_1.sysInfo.getXcodeVersion();
+    }
+    getCocoaPodsVersion() {
+        return doctor_1.sysInfo.getCocoaPodsVersion();
+    }
+    getJavaPath() {
+        return doctor_1.sysInfo.getJavaPath();
+    }
+    getJavaCompilerVersion() {
+        return doctor_1.sysInfo.getJavaCompilerVersion();
+    }
+    getJavaVersionFromPath() {
+        return doctor_1.sysInfo.getJavaVersionFromPath();
+    }
+    getJavaVersionFromJavaHome() {
+        return doctor_1.sysInfo.getJavaVersionFromJavaHome();
+    }
+    getSystemWarnings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const warnings = [];
+            const macOSWarningMessage = yield this.getMacOSWarningMessage();
+            if (macOSWarningMessage) {
+                macOSWarningMessage.toString = function () {
+                    return this.message;
+                };
+                warnings.push(macOSWarningMessage);
+            }
+            const nodeWarning = (0, verify_node_version_1.getNodeWarning)();
+            if (nodeWarning) {
+                nodeWarning.toString = function () {
+                    return this.message;
+                };
+                warnings.push(nodeWarning);
+            }
+            return warnings;
+        });
+    }
+    getSupportedNodeVersionRange() {
+        const pathToCLIPackageJson = path.join(__dirname, "..", "package.json");
+        const jsonContent = this.$fs.readJson(pathToCLIPackageJson);
+        return jsonContent && jsonContent.engines && jsonContent.engines.node;
+    }
+    getMacOSWarningMessage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const macOSVersion = yield this.$hostInfo.getMacOSVersion();
+            if (macOSVersion && macOSVersion < constants_1.MacOSVersions.HighSierra) {
+                return {
+                    message: (0, util_1.format)(constants_1.MacOSDeprecationStringFormat, macOSVersion),
+                    severity: "high",
+                };
+            }
+            return null;
+        });
+    }
+    getXcodeWarning() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const xcodeVersion = yield this.getXcodeVersion();
+            if (xcodeVersion && semver.lt(semver.coerce(xcodeVersion), "11.0.0")) {
+                const message = (0, util_1.format)(constants_1.XcodeDeprecationStringFormat, xcodeVersion);
+                return message;
+            }
+            return null;
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.exported)("sysInfo")
+], SysInfo.prototype, "getSystemWarnings", null);
+__decorate([
+    (0, decorators_1.exported)("sysInfo")
+], SysInfo.prototype, "getSupportedNodeVersionRange", null);
+exports.SysInfo = SysInfo;
+yok_1.injector.register("sysInfo", SysInfo);

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

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigTransformer = void 0;
+const ts_morph_1 = require("ts-morph");
+class ConfigTransformer {
+    constructor(content) {
+        this.project = new ts_morph_1.Project({
+            compilerOptions: {
+                allowJs: true,
+            },
+        });
+        this.scriptKind = content.includes("module.exports")
+            ? ts_morph_1.ScriptKind.JS
+            : ts_morph_1.ScriptKind.TS;
+        this.config = this.project.createSourceFile("virtual_nativescript.config.ts", content, {
+            scriptKind: this.scriptKind,
+        });
+    }
+    getDefaultExportValue() {
+        let exportValue;
+        if (this.scriptKind === ts_morph_1.ScriptKind.JS) {
+            this.config.getStatements().find((statement) => {
+                try {
+                    if (statement.getKind() === ts_morph_1.SyntaxKind.ExpressionStatement) {
+                        const expression = statement.getExpressionIfKind(ts_morph_1.SyntaxKind.BinaryExpression);
+                        const leftSide = expression.getLeft();
+                        if (leftSide.getFullText().trim() === "module.exports") {
+                            exportValue = expression.getRight();
+                            return true;
+                        }
+                    }
+                }
+                catch (err) {
+                    return false;
+                }
+            });
+        }
+        else {
+            const exports = this.config
+                .getDefaultExportSymbolOrThrow()
+                .getDeclarations()[0];
+            const expr = exports.getExpression();
+            exportValue =
+                expr.getChildCount() > 0
+                    ? expr.getChildAtIndex(0)
+                    : expr;
+        }
+        if (!ts_morph_1.Node.isObjectLiteralExpression(exportValue)) {
+            throw new Error("default export must be an object!");
+        }
+        return exportValue;
+    }
+    getProperty(key, parent = null) {
+        if (key.includes(".")) {
+            const parts = key.split(".");
+            const name = parts.shift();
+            const property = this.getProperty(name, parent);
+            if (!property) {
+                return undefined;
+            }
+            const _parent = property.getLastChild((child) => {
+                return ts_morph_1.Node.isObjectLiteralExpression(child);
+            });
+            if (!_parent) {
+                return undefined;
+            }
+            return this.getProperty(parts.join("."), _parent);
+        }
+        if (parent) {
+            return parent.getProperty(key);
+        }
+        return this.getProperty(key, this.getDefaultExportValue());
+    }
+    addProperty(key, value, parent = null) {
+        if (key.includes(".")) {
+            const parts = key.split(".");
+            const name = parts.shift();
+            let property = this.getProperty(name, parent);
+            if (!property) {
+                property = this.addProperty(name, {}, parent || this.getDefaultExportValue());
+            }
+            const _parent = property.getLastChild((child) => {
+                return ts_morph_1.Node.isObjectLiteralExpression(child);
+            });
+            if (!_parent) {
+                throw new Error(`Could not add property '${parts[0]}'.`);
+            }
+            return this.addProperty(parts.join("."), value, _parent);
+        }
+        if (parent) {
+            return parent.addPropertyAssignment({
+                name: key,
+                initializer: this.createInitializer(value),
+            });
+        }
+        return this.addProperty(key, value, this.getDefaultExportValue());
+    }
+    createInitializer(value) {
+        if (typeof value === "string") {
+            return `'${value}'`;
+        }
+        else if (typeof value === "number" || typeof value === "boolean") {
+            return `${value}`;
+        }
+        return `{}`;
+    }
+    setInitializerValue(initializer, newValue) {
+        if (ts_morph_1.Node.isStringLiteral(initializer)) {
+            return initializer.setLiteralValue(newValue);
+        }
+        if (ts_morph_1.Node.isNumericLiteral(initializer)) {
+            return initializer.setLiteralValue(newValue);
+        }
+        if (ts_morph_1.Node.isBooleanKeyword(initializer)) {
+            return initializer.setLiteralValue(newValue);
+        }
+        if (ts_morph_1.Node.isIdentifier(initializer)) {
+            return this.setIdentifierValue(initializer, newValue);
+        }
+        throw new Error("Unsupported value type: " + initializer.getKindName());
+    }
+    getInitializerValue(initializer) {
+        if (ts_morph_1.Node.isStringLiteral(initializer)) {
+            return initializer.getLiteralValue();
+        }
+        if (ts_morph_1.Node.isNumericLiteral(initializer)) {
+            return initializer.getLiteralValue();
+        }
+        if (ts_morph_1.Node.isBooleanKeyword(initializer)) {
+            return initializer.getLiteralValue();
+        }
+        if (ts_morph_1.Node.isIdentifier(initializer)) {
+            return this.getIdentifierValue(initializer);
+        }
+        throw new Error("Unsupported value type: " + initializer.getKindName());
+    }
+    getIdentifierValue(identifier) {
+        const decl = this.config.getVariableDeclarationOrThrow(identifier.getText());
+        const initializer = decl.getInitializerOrThrow();
+        return this.getInitializerValue(initializer);
+    }
+    setIdentifierValue(identifier, newValue) {
+        const decl = this.config.getVariableDeclarationOrThrow(identifier.getText());
+        const initializer = decl.getInitializerOrThrow();
+        this.setInitializerValue(initializer, newValue);
+    }
+    getPropertyValue(objectProperty) {
+        if (!objectProperty) {
+            return undefined;
+        }
+        let initializer;
+        if (objectProperty instanceof ts_morph_1.PropertyAssignment ||
+            objectProperty instanceof ts_morph_1.ShorthandPropertyAssignment) {
+            initializer = objectProperty.getInitializer();
+        }
+        else {
+            throw new Error("getPropertyValue Unsupported value found: " +
+                objectProperty.getKindName());
+        }
+        if (ts_morph_1.Node.isStringLiteral(initializer)) {
+            return initializer.getLiteralValue();
+        }
+        if (ts_morph_1.Node.isNumericLiteral(initializer)) {
+            return initializer.getLiteralValue();
+        }
+        if (ts_morph_1.Node.isBooleanKeyword(initializer)) {
+            return initializer.getLiteralValue();
+        }
+        if (ts_morph_1.Node.isIdentifier(initializer)) {
+            return this.getIdentifierValue(initializer);
+        }
+    }
+    setPropertyValue(objectProperty, newValue) {
+        let initializer;
+        if (objectProperty instanceof ts_morph_1.PropertyAssignment ||
+            objectProperty instanceof ts_morph_1.ShorthandPropertyAssignment) {
+            initializer = objectProperty.getInitializer();
+        }
+        else {
+            throw new Error("Unsupported value found.");
+        }
+        this.setInitializerValue(initializer, newValue);
+    }
+    getFullText() {
+        return this.config.getFullText();
+    }
+    getValue(key) {
+        return this.getPropertyValue(this.getProperty(key));
+    }
+    setValue(key, value) {
+        const property = this.getProperty(key);
+        if (!property) {
+            this.addProperty(key, value);
+        }
+        else {
+            this.setPropertyValue(property, value);
+        }
+        return this.getFullText();
+    }
+}
+exports.ConfigTransformer = ConfigTransformer;

package/lib/tools/node-modules/node-modules-builder.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeModulesBuilder = void 0;
+const _ = require("lodash");
+const yok_1 = require("../../common/yok");
+class NodeModulesBuilder {
+    constructor($logger, $nodeModulesDependenciesBuilder, $pluginsService) {
+        this.$logger = $logger;
+        this.$nodeModulesDependenciesBuilder = $nodeModulesDependenciesBuilder;
+        this.$pluginsService = $pluginsService;
+    }
+    prepareNodeModules({ platformData, projectData, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let dependencies = this.$nodeModulesDependenciesBuilder.getProductionDependencies(projectData.projectDir, projectData.ignoredDependencies);
+            dependencies = yield platformData.platformProjectService.beforePrepareAllPlugins(projectData, dependencies);
+            const pluginsData = this.$pluginsService.getAllProductionPlugins(projectData, platformData.platformNameLowerCase, dependencies);
+            if (_.isEmpty(pluginsData)) {
+                return;
+            }
+            for (let i = 0; i < pluginsData.length; i++) {
+                const pluginData = pluginsData[i];
+                yield this.$pluginsService.preparePluginNativeCode({
+                    pluginData,
+                    platform: platformData.normalizedPlatformName.toLowerCase(),
+                    projectData,
+                });
+                this.$logger.trace(`Successfully prepared plugin ${pluginData.name} for ${platformData.normalizedPlatformName.toLowerCase()}.`);
+            }
+        });
+    }
+}
+exports.NodeModulesBuilder = NodeModulesBuilder;
+yok_1.injector.register("nodeModulesBuilder", NodeModulesBuilder);

package/lib/tools/node-modules/node-modules-dependencies-builder.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeModulesDependenciesBuilder = void 0;
+const path = require("path");
+const constants_1 = require("../../constants");
+const _ = require("lodash");
+const yok_1 = require("../../common/yok");
+const resolve_package_path_1 = require("@rigor789/resolve-package-path");
+class NodeModulesDependenciesBuilder {
+    constructor($fs) {
+        this.$fs = $fs;
+    }
+    getProductionDependencies(projectPath, ignore) {
+        const projectPackageJsonPath = path.join(projectPath, constants_1.PACKAGE_JSON_FILE_NAME);
+        const packageJsonContent = this.$fs.readJson(projectPackageJsonPath);
+        const dependencies = packageJsonContent && packageJsonContent.dependencies;
+        const resolvedDependencies = [];
+        const queue = _.keys(dependencies).map((dependencyName) => ({
+            parent: null,
+            parentDir: projectPath,
+            name: dependencyName,
+            depth: 0,
+        }));
+        while (queue.length) {
+            const currentModule = queue.shift();
+            const resolvedDependency = this.findModule(currentModule, resolvedDependencies, projectPath);
+            if (resolvedDependency &&
+                !_.some(resolvedDependencies, (r) => r.directory === resolvedDependency.directory)) {
+                _.each(resolvedDependency.dependencies, (d) => {
+                    const dependency = {
+                        parent: currentModule,
+                        name: d,
+                        parentDir: resolvedDependency.directory,
+                        depth: resolvedDependency.depth + 1,
+                    };
+                    const shouldAdd = !_.some(queue, (element) => element.parent === dependency.parent &&
+                        element.name === dependency.name &&
+                        element.parentDir === dependency.parentDir &&
+                        element.depth === dependency.depth);
+                    if (shouldAdd) {
+                        queue.push(dependency);
+                    }
+                });
+                resolvedDependencies.push(resolvedDependency);
+            }
+        }
+        if (ignore && ignore.length > 0) {
+            return resolvedDependencies.filter((d) => ignore.indexOf(d.name) === -1);
+        }
+        return resolvedDependencies;
+    }
+    findModule(depDescription, resolvedDependencies, rootPath) {
+        var _a, _b;
+        try {
+            const parentModulesPath = (_a = depDescription === null || depDescription === void 0 ? void 0 : depDescription.parentDir) !== null && _a !== void 0 ? _a : (_b = depDescription === null || depDescription === void 0 ? void 0 : depDescription.parent) === null || _b === void 0 ? void 0 : _b.parentDir;
+            let modulePath = (0, resolve_package_path_1.resolvePackagePath)(depDescription.name, {
+                paths: [parentModulesPath],
+            });
+            if (!modulePath) {
+                modulePath = (0, resolve_package_path_1.resolvePackagePath)(depDescription.name, {
+                    paths: [rootPath],
+                });
+            }
+            if (!modulePath) {
+                return null;
+            }
+            if (resolvedDependencies.some((r) => {
+                return r.name === depDescription.name && r.directory === modulePath;
+            })) {
+                return null;
+            }
+            return this.getDependencyData(depDescription.name, modulePath, depDescription.depth);
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    getDependencyData(name, directory, depth) {
+        const dependency = {
+            name,
+            directory,
+            depth,
+            version: null,
+        };
+        const packageJsonPath = path.join(directory, constants_1.PACKAGE_JSON_FILE_NAME);
+        const packageJsonExists = this.$fs.getLsStats(packageJsonPath).isFile();
+        if (packageJsonExists) {
+            const packageJsonContents = this.$fs.readJson(packageJsonPath);
+            dependency.version = packageJsonContents.version;
+            if (!!packageJsonContents.nativescript) {
+                dependency.nativescript = packageJsonContents.nativescript;
+            }
+            dependency.dependencies = _.keys(packageJsonContents.dependencies);
+            return dependency;
+        }
+        return null;
+    }
+}
+exports.NodeModulesDependenciesBuilder = NodeModulesDependenciesBuilder;
+yok_1.injector.register("nodeModulesDependenciesBuilder", NodeModulesDependenciesBuilder);