@akylas/nativescript-cli 8.7.2

package/lib/project-data.js

@@ -0,0 +1,237 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectData = void 0;
+const constants = require("./constants");
+const path = require("path");
+const _ = require("lodash");
+const helpers_1 = require("./common/helpers");
+const os_1 = require("os");
+const decorators_1 = require("./common/decorators");
+const yok_1 = require("./common/yok");
+class ProjectData {
+    get projectId() {
+        this.warnProjectId();
+        return this.projectIdentifiers.ios;
+    }
+    set projectId(identifier) {
+        this.warnProjectId();
+        this.projectIdentifiers.ios = identifier;
+        this.projectIdentifiers.android = identifier;
+        this.projectIdentifiers.visionos = identifier;
+    }
+    constructor($fs, $errors, $projectHelper, $staticConfig, $options, $logger, $injector, $androidResourcesMigrationService, $devicePlatformsConstants) {
+        this.$fs = $fs;
+        this.$errors = $errors;
+        this.$projectHelper = $projectHelper;
+        this.$staticConfig = $staticConfig;
+        this.$options = $options;
+        this.$logger = $logger;
+        this.$injector = $injector;
+        this.$androidResourcesMigrationService = $androidResourcesMigrationService;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+    }
+    get projectConfig() {
+        return this.$injector.resolve("projectConfigService");
+    }
+    initializeProjectData(projectDir) {
+        if (this.initialized) {
+            return;
+        }
+        projectDir = projectDir || this.$projectHelper.projectDir;
+        if (projectDir) {
+            const projectFilePath = this.getProjectFilePath(projectDir);
+            if (this.$fs.exists(projectFilePath)) {
+                const packageJsonContent = this.$fs.readText(projectFilePath);
+                this.initializeProjectDataFromContent(packageJsonContent, projectDir);
+                this.initialized = true;
+            }
+            return;
+        }
+        this.errorInvalidProject(projectDir);
+    }
+    initializeProjectDataFromContent(packageJsonContent, projectDir) {
+        projectDir = projectDir || this.$projectHelper.projectDir || "";
+        this.projectDir = projectDir;
+        const projectFilePath = this.getProjectFilePath(projectDir);
+        const nsConfig = this.projectConfig.readConfig(projectDir);
+        let packageJsonData = null;
+        try {
+            packageJsonData = (0, helpers_1.parseJson)(packageJsonContent);
+        }
+        catch (err) {
+            this.$errors.fail(`The project file ${this.projectFilePath} is corrupted. ${os_1.EOL}` +
+                `Consider restoring an earlier version from your source control or backup.${os_1.EOL}` +
+                `Additional technical info: ${err.toString()}`);
+        }
+        if (packageJsonData) {
+            this.projectName = this.$projectHelper.sanitizeName(path.basename(projectDir));
+            this.nsConfig = nsConfig;
+            this.platformsDir = path.join(projectDir, this.getBuildRelativeDirectoryPath());
+            this.projectFilePath = projectFilePath;
+            this.projectIdentifiers = this.initializeProjectIdentifiers(nsConfig);
+            this.packageJsonData = packageJsonData;
+            this.dependencies = packageJsonData.dependencies;
+            this.devDependencies = packageJsonData.devDependencies;
+            this.projectType = this.getProjectType();
+            this.ignoredDependencies = nsConfig === null || nsConfig === void 0 ? void 0 : nsConfig.ignoredNativeDependencies;
+            this.appDirectoryPath = this.getAppDirectoryPath();
+            this.appResourcesDirectoryPath = this.getAppResourcesDirectoryPath();
+            this.androidManifestPath = this.getPathToAndroidManifest(this.appResourcesDirectoryPath);
+            this.gradleFilesDirectoryPath = path.join(this.appResourcesDirectoryPath, this.$devicePlatformsConstants.Android);
+            this.appGradlePath = path.join(this.gradleFilesDirectoryPath, constants.APP_GRADLE_FILE_NAME);
+            this.infoPlistPath = path.join(this.appResourcesDirectoryPath, this.$devicePlatformsConstants.iOS, constants.INFO_PLIST_FILE_NAME);
+            this.buildXcconfigPath = path.join(this.appResourcesDirectoryPath, this.$devicePlatformsConstants.iOS, constants.BUILD_XCCONFIG_FILE_NAME);
+            this.podfilePath = path.join(this.appResourcesDirectoryPath, this.$devicePlatformsConstants.iOS, constants.PODFILE_NAME);
+            this.isShared = !!(this.nsConfig && this.nsConfig.shared);
+            this.webpackConfigPath =
+                this.nsConfig && this.nsConfig.webpackConfigPath
+                    ? path.resolve(this.projectDir, this.nsConfig.webpackConfigPath)
+                    : path.join(this.projectDir, "webpack.config.js");
+            return;
+        }
+        this.errorInvalidProject(projectDir);
+    }
+    getPathToAndroidManifest(appResourcesDir) {
+        const androidDirPath = path.join(appResourcesDir, this.$devicePlatformsConstants.Android);
+        const androidManifestDir = this.$androidResourcesMigrationService.hasMigrated(appResourcesDir)
+            ? path.join(androidDirPath, constants.SRC_DIR, constants.MAIN_DIR)
+            : androidDirPath;
+        return path.join(androidManifestDir, constants.MANIFEST_FILE_NAME);
+    }
+    errorInvalidProject(projectDir) {
+        const currentDir = path.resolve(".");
+        this.$logger.trace(`Unable to find project. projectDir: ${projectDir}, options.path: ${this.$options.path}, ${currentDir}`);
+        this.$errors.fail("No project found at or above '%s' and neither was a --path specified.", projectDir || this.$options.path || currentDir);
+    }
+    getProjectFilePath(projectDir) {
+        return path.join(projectDir, this.$staticConfig.PROJECT_FILE_NAME);
+    }
+    getAppResourcesDirectoryPath(projectDir) {
+        const appResourcesRelativePath = this.getAppResourcesRelativeDirectoryPath();
+        return this.resolveToProjectDir(appResourcesRelativePath, projectDir);
+    }
+    getAppResourcesRelativeDirectoryPath() {
+        if (this.nsConfig &&
+            this.nsConfig[constants.CONFIG_NS_APP_RESOURCES_ENTRY]) {
+            return this.nsConfig[constants.CONFIG_NS_APP_RESOURCES_ENTRY];
+        }
+        return constants.APP_RESOURCES_FOLDER_NAME;
+    }
+    getAppDirectoryPath(projectDir) {
+        const appRelativePath = this.getAppDirectoryRelativePath();
+        return this.resolveToProjectDir(appRelativePath, projectDir);
+    }
+    getBuildRelativeDirectoryPath() {
+        if (this.nsConfig && this.nsConfig[constants.CONFIG_NS_BUILD_ENTRY]) {
+            return this.nsConfig[constants.CONFIG_NS_BUILD_ENTRY];
+        }
+        return constants.PLATFORMS_DIR_NAME;
+    }
+    getAppDirectoryRelativePath() {
+        if (this.nsConfig && this.nsConfig[constants.CONFIG_NS_APP_ENTRY]) {
+            return this.nsConfig[constants.CONFIG_NS_APP_ENTRY];
+        }
+        if (this.$fs.exists(path.resolve(this.projectDir, constants.SRC_DIR))) {
+            return constants.SRC_DIR;
+        }
+        else {
+            return constants.APP_FOLDER_NAME;
+        }
+    }
+    getNsConfigRelativePath() {
+        return constants.CONFIG_FILE_NAME_JS;
+    }
+    resolveToProjectDir(pathToResolve, projectDir) {
+        if (!projectDir) {
+            projectDir = this.projectDir;
+        }
+        if (!projectDir) {
+            return null;
+        }
+        return path.resolve(projectDir, pathToResolve);
+    }
+    initializeProjectIdentifiers(config) {
+        this.$logger.trace(`Initializing project identifiers. Config: `, config);
+        if (!config) {
+            this.$logger.error("Unable to determine app id.");
+            return {
+                ios: "",
+                android: "",
+                visionos: "",
+            };
+        }
+        const identifier = {
+            ios: config.id,
+            android: config.id,
+            visionos: config.id,
+        };
+        if (config.ios && config.ios.id) {
+            identifier.ios = config.ios.id;
+        }
+        if (config.android && config.android.id) {
+            identifier.android = config.android.id;
+        }
+        if (config.visionos && config.visionos.id) {
+            identifier.visionos = config.visionos.id;
+        }
+        return identifier;
+    }
+    getProjectType() {
+        let detectedProjectType = _.find(ProjectData.PROJECT_TYPES, (projectType) => projectType.isDefaultProjectType).type;
+        const deps = _.keys(this.dependencies).concat(_.keys(this.devDependencies));
+        _.each(ProjectData.PROJECT_TYPES, (projectType) => {
+            if (_.some(projectType.requiredDependencies, (requiredDependency) => deps.indexOf(requiredDependency) !== -1)) {
+                detectedProjectType = projectType.type;
+                return false;
+            }
+        });
+        return detectedProjectType;
+    }
+    warnProjectId() {
+        this.$logger.warn("[WARNING]: IProjectData.projectId is deprecated. Please use IProjectData.projectIdentifiers[platform].");
+    }
+}
+ProjectData.PROJECT_TYPES = [
+    {
+        type: constants.ProjectTypes.JsFlavorName,
+        isDefaultProjectType: true,
+    },
+    {
+        type: constants.ProjectTypes.NgFlavorName,
+        requiredDependencies: [
+            "@angular/core",
+            "nativescript-angular",
+            "@nativescript/angular",
+        ],
+    },
+    {
+        type: constants.ProjectTypes.VueFlavorName,
+        requiredDependencies: ["nativescript-vue"],
+    },
+    {
+        type: constants.ProjectTypes.ReactFlavorName,
+        requiredDependencies: ["react-nativescript"],
+    },
+    {
+        type: constants.ProjectTypes.SvelteFlavorName,
+        requiredDependencies: ["svelte-native"],
+    },
+    {
+        type: constants.ProjectTypes.TsFlavorName,
+        requiredDependencies: ["typescript", "nativescript-dev-typescript"],
+    },
+];
+__decorate([
+    (0, decorators_1.cache)()
+], ProjectData.prototype, "initializeProjectIdentifiers", null);
+__decorate([
+    (0, decorators_1.cache)()
+], ProjectData.prototype, "warnProjectId", null);
+exports.ProjectData = ProjectData;
+yok_1.injector.register("projectData", ProjectData, true);

package/lib/providers/project-files-provider.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectFilesProvider = void 0;
+const minimatch_1 = require("minimatch");
+const constants = require("../constants");
+const path = require("path");
+const _ = require("lodash");
+const project_files_provider_base_1 = require("../common/services/project-files-provider-base");
+const yok_1 = require("../common/yok");
+class ProjectFilesProvider extends project_files_provider_base_1.ProjectFilesProviderBase {
+    constructor($platformsDataService, $mobileHelper, $options) {
+        super($mobileHelper, $options);
+        this.$platformsDataService = $platformsDataService;
+    }
+    mapFilePath(filePath, platform, projectData, projectFilesConfig) {
+        const platformData = this.$platformsDataService.getPlatformData(platform.toLowerCase(), projectData);
+        const parsedFilePath = this.getPreparedFilePath(filePath, projectFilesConfig);
+        let mappedFilePath = "";
+        let relativePath;
+        if (parsedFilePath.indexOf(constants.NODE_MODULES_FOLDER_NAME) > -1) {
+            relativePath = path.relative(path.join(projectData.projectDir, constants.NODE_MODULES_FOLDER_NAME), parsedFilePath);
+            mappedFilePath = path.join(platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME, constants.TNS_MODULES_FOLDER_NAME, relativePath);
+        }
+        else {
+            relativePath = path.relative(projectData.appDirectoryPath, parsedFilePath);
+            mappedFilePath = path.join(platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME, relativePath);
+        }
+        const appResourcesDirectoryPath = projectData.appResourcesDirectoryPath;
+        const platformSpecificAppResourcesDirectoryPath = path.join(appResourcesDirectoryPath, platformData.normalizedPlatformName);
+        if (parsedFilePath.indexOf(appResourcesDirectoryPath) > -1 &&
+            parsedFilePath.indexOf(platformSpecificAppResourcesDirectoryPath) === -1) {
+            return null;
+        }
+        if (parsedFilePath.indexOf(platformSpecificAppResourcesDirectoryPath) > -1) {
+            const appResourcesRelativePath = path.relative(path.join(projectData.appResourcesDirectoryPath, platformData.normalizedPlatformName), parsedFilePath);
+            mappedFilePath = path.join(platformData.platformProjectService.getAppResourcesDestinationDirectoryPath(projectData), appResourcesRelativePath);
+        }
+        return mappedFilePath;
+    }
+    isFileExcluded(filePath) {
+        return !!_.find(ProjectFilesProvider.INTERNAL_NONPROJECT_FILES, (pattern) => (0, minimatch_1.minimatch)(filePath, pattern, { nocase: true }));
+    }
+}
+ProjectFilesProvider.INTERNAL_NONPROJECT_FILES = ["**/*.ts"];
+exports.ProjectFilesProvider = ProjectFilesProvider;
+yok_1.injector.register("projectFilesProvider", ProjectFilesProvider);

package/lib/resolvers/livesync-service-resolver.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveSyncServiceResolver = void 0;
+const yok_1 = require("../common/yok");
+class LiveSyncServiceResolver {
+    constructor($errors, $injector, $mobileHelper) {
+        this.$errors = $errors;
+        this.$injector = $injector;
+        this.$mobileHelper = $mobileHelper;
+    }
+    resolveLiveSyncService(platform) {
+        if (this.$mobileHelper.isApplePlatform(platform)) {
+            return this.$injector.resolve("iOSLiveSyncService");
+        }
+        else if (this.$mobileHelper.isAndroidPlatform(platform)) {
+            return this.$injector.resolve("androidLiveSyncService");
+        }
+        this.$errors.fail(`Invalid platform ${platform}. Supported platforms are: ${this.$mobileHelper.platformNames.join(", ")}`);
+    }
+}
+exports.LiveSyncServiceResolver = LiveSyncServiceResolver;
+yok_1.injector.register("liveSyncServiceResolver", LiveSyncServiceResolver);

package/lib/services/analytics/analytics-broker-process.js

@@ -0,0 +1,77 @@
+"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 });
+const fs = require("fs");
+const analytics_broker_1 = require("./analytics-broker");
+const file_log_service_1 = require("../../detached-processes/file-log-service");
+const yok_1 = require("../../common/yok");
+const pathToBootstrap = process.argv[2];
+if (!pathToBootstrap || !fs.existsSync(pathToBootstrap)) {
+    throw new Error("Invalid path to bootstrap.");
+}
+const logFile = process.argv[3];
+require(pathToBootstrap);
+const analyticsLoggingService = yok_1.injector.resolve(file_log_service_1.FileLogService, { logFile });
+analyticsLoggingService.logData({ message: "Initializing AnalyticsBroker." });
+const analyticsBroker = yok_1.injector.resolve(analytics_broker_1.AnalyticsBroker, {
+    pathToBootstrap,
+    analyticsLoggingService,
+});
+let trackingQueue = Promise.resolve();
+const sendDataForTracking = (data) => __awaiter(void 0, void 0, void 0, function* () {
+    trackingQueue = trackingQueue.then(() => analyticsBroker.sendDataForTracking(data));
+    yield trackingQueue;
+});
+const finishTracking = (data) => __awaiter(void 0, void 0, void 0, function* () {
+    analyticsLoggingService.logData({
+        message: `analytics-broker-process finish tracking started`,
+    });
+    yield trackingQueue;
+    analyticsLoggingService.logData({
+        message: `analytics-broker-process tracking finished`,
+    });
+});
+const killCurrentProcessGracefully = () => {
+    yok_1.injector.dispose();
+    process.exit();
+};
+process.on("message", (data) => __awaiter(void 0, void 0, void 0, function* () {
+    analyticsLoggingService.logData({
+        message: `analytics-broker-process received message of type: ${JSON.stringify(data)}`,
+    });
+    if (data.type === "FinishTracking") {
+        yield finishTracking();
+        if (process.connected) {
+            analyticsLoggingService.logData({
+                message: `analytics-broker-process will send ${"ProcessFinishedTasks"} message`,
+            });
+            process.send("ProcessFinishedTasks", () => {
+                analyticsLoggingService.logData({
+                    message: `analytics-broker-process sent ${"ProcessFinishedTasks"} message and will exit gracefully now`,
+                });
+                killCurrentProcessGracefully();
+            });
+        }
+        return;
+    }
+    yield sendDataForTracking(data);
+}));
+process.on("disconnect", () => __awaiter(void 0, void 0, void 0, function* () {
+    analyticsLoggingService.logData({
+        message: "analytics-broker-process received process.disconnect event",
+    });
+    yield finishTracking();
+    killCurrentProcessGracefully();
+}));
+analyticsLoggingService.logData({
+    message: `analytics-broker-process will send ${"ProcessReadyToReceive"} message`,
+});
+process.send("ProcessReadyToReceive");

package/lib/services/analytics/analytics-broker.js

@@ -0,0 +1,53 @@
+"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.AnalyticsBroker = void 0;
+const decorators_1 = require("../../common/decorators");
+class AnalyticsBroker {
+    getGoogleAnalyticsProvider() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const clientId = yield this.$analyticsSettingsService.getClientId();
+            return this.$injector.resolve("googleAnalyticsProvider", {
+                clientId,
+                analyticsLoggingService: this.analyticsLoggingService,
+            });
+        });
+    }
+    constructor($analyticsSettingsService, $injector, analyticsLoggingService) {
+        this.$analyticsSettingsService = $analyticsSettingsService;
+        this.$injector = $injector;
+        this.analyticsLoggingService = analyticsLoggingService;
+    }
+    sendDataForTracking(trackInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const googleProvider = yield this.getGoogleAnalyticsProvider();
+                yield googleProvider.trackHit(trackInfo);
+            }
+            catch (err) {
+                this.analyticsLoggingService.logData({
+                    message: `AnalyticsBroker unable to execute action in sendDataForTracking: ${err}`,
+                    type: "Error",
+                });
+            }
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], AnalyticsBroker.prototype, "getGoogleAnalyticsProvider", null);
+exports.AnalyticsBroker = AnalyticsBroker;