@akylas/nativescript-cli 8.7.2

package/lib/controllers/platform-controller.js

@@ -0,0 +1,127 @@
+"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.PlatformController = void 0;
+const path = require("path");
+const yok_1 = require("../common/yok");
+class PlatformController {
+    constructor($addPlatformService, $errors, $fs, $logger, $packageInstallationManager, $projectDataService, $platformsDataService, $projectChangesService, $mobileHelper) {
+        this.$addPlatformService = $addPlatformService;
+        this.$errors = $errors;
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$packageInstallationManager = $packageInstallationManager;
+        this.$projectDataService = $projectDataService;
+        this.$platformsDataService = $platformsDataService;
+        this.$projectChangesService = $projectChangesService;
+        this.$mobileHelper = $mobileHelper;
+    }
+    addPlatform(addPlatformData, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [platform, version] = addPlatformData.platform
+                .toLowerCase()
+                .split("@");
+            projectData !== null && projectData !== void 0 ? projectData : (projectData = this.$projectDataService.getProjectData(addPlatformData.projectDir));
+            const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+            this.$logger.trace(`Creating NativeScript project for the ${platform} platform`);
+            this.$logger.trace(`Path: ${platformData.projectRoot}`);
+            this.$logger.trace(`Package: ${projectData.projectIdentifiers[platform]}`);
+            this.$logger.trace(`Name: ${projectData.projectName}`);
+            this.$logger.info("Copying template files...");
+            const packageToInstall = yield this.getPackageToInstall(platformData, projectData, addPlatformData.frameworkPath, version);
+            this.$logger.trace("Determined package to install is", packageToInstall);
+            const installedPlatformVersion = yield this.$addPlatformService.addPlatformSafe(projectData, platformData, packageToInstall, addPlatformData);
+            const buildPath = projectData.platformsDir;
+            this.$fs.ensureDirectoryExists(path.join(buildPath, platform));
+            if (this.$mobileHelper.isAndroidPlatform(platform)) {
+                const gradlePropertiesPath = path.resolve(platformData.projectRoot, "gradle.properties");
+                const commentHeader = "# App configuration";
+                const appPath = projectData.getAppDirectoryRelativePath();
+                const appResourcesPath = projectData.getAppResourcesRelativeDirectoryPath();
+                let gradlePropertiesContents = "";
+                if (this.$fs.exists(gradlePropertiesPath)) {
+                    gradlePropertiesContents = this.$fs
+                        .readFile(gradlePropertiesPath)
+                        .toString();
+                }
+                if (!gradlePropertiesContents.includes(commentHeader)) {
+                    const dataToWrite = [
+                        "",
+                        "",
+                        commentHeader,
+                        `appPath = ${appPath}`,
+                        `appResourcesPath = ${appResourcesPath}`,
+                        `buildPath = ${buildPath}`,
+                        "",
+                    ].join("\n");
+                    gradlePropertiesContents += dataToWrite;
+                    this.$logger.trace("Updated gradle.properties with project data...");
+                    this.$fs.writeFile(gradlePropertiesPath, gradlePropertiesContents);
+                }
+            }
+            this.$logger.info(`Platform ${platform} successfully added. v${installedPlatformVersion}`);
+        });
+    }
+    addPlatformIfNeeded(addPlatformData, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [platform] = addPlatformData.platform.toLowerCase().split("@");
+            projectData !== null && projectData !== void 0 ? projectData : (projectData = this.$projectDataService.getProjectData(addPlatformData.projectDir));
+            const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+            const shouldAddPlatform = this.shouldAddPlatform(platformData, projectData, addPlatformData.nativePrepare);
+            if (shouldAddPlatform) {
+                yield this.addPlatform(addPlatformData, projectData);
+            }
+        });
+    }
+    getPackageToInstall(platformData, projectData, frameworkPath, version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = null;
+            if (frameworkPath) {
+                if (!this.$fs.exists(frameworkPath)) {
+                    this.$errors.fail(`Invalid frameworkPath: ${frameworkPath}. Please ensure the specified frameworkPath exists.`);
+                }
+                result = "file:" + path.resolve(frameworkPath);
+            }
+            else {
+                const desiredRuntimePackage = this.$projectDataService.getRuntimePackage(projectData.projectDir, platformData.platformNameLowerCase);
+                if (version) {
+                    desiredRuntimePackage.version = version;
+                }
+                if (!desiredRuntimePackage.version) {
+                    desiredRuntimePackage.version =
+                        yield this.$packageInstallationManager.getLatestCompatibleVersion(desiredRuntimePackage.name);
+                }
+                result = `${desiredRuntimePackage.name}@${desiredRuntimePackage.version}`;
+            }
+            return result;
+        });
+    }
+    shouldAddPlatform(platformData, projectData, nativePrepare) {
+        const platformName = platformData.platformNameLowerCase;
+        const hasPlatformDirectory = this.$fs.exists(path.join(projectData.platformsDir, platformName));
+        const shouldAddNativePlatform = !nativePrepare || !nativePrepare.skipNativePrepare;
+        const prepareInfo = this.$projectChangesService.getPrepareInfo(platformData);
+        const requiresNativePlatformAdd = prepareInfo &&
+            prepareInfo.nativePlatformStatus ===
+                "1";
+        const shouldAddPlatform = !hasPlatformDirectory ||
+            (shouldAddNativePlatform && requiresNativePlatformAdd);
+        if (hasPlatformDirectory && !shouldAddPlatform) {
+            const platformDirectoryItemCount = this.$fs.readDirectory(path.join(projectData.platformsDir, platformName)).length;
+            if (platformDirectoryItemCount <= 2) {
+                this.$logger.warn(`The platforms/${platformName} folder appears to be invalid. If the build fails, run 'ns clean' and rebuild the app.`, { wrapMessageWithBorders: true });
+            }
+        }
+        return !!shouldAddPlatform;
+    }
+}
+exports.PlatformController = PlatformController;
+yok_1.injector.register("platformController", PlatformController);

package/lib/controllers/prepare-controller.js

@@ -0,0 +1,353 @@
+"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.PrepareController = void 0;
+const choki = require("chokidar");
+const events_1 = require("events");
+const _ = require("lodash");
+const path = require("path");
+const decorators_1 = require("../common/decorators");
+const helpers_1 = require("../common/helpers");
+const yok_1 = require("../common/yok");
+const constants_1 = require("../constants");
+class PrepareController extends events_1.EventEmitter {
+    constructor($platformController, $hooksService, $fs, $logger, $mobileHelper, $nodeModulesDependenciesBuilder, $platformsDataService, $pluginsService, $prepareNativePlatformService, $projectChangesService, $projectDataService, $webpackCompilerService, $watchIgnoreListService, $analyticsService, $markingModeService, $projectConfigService, $projectService) {
+        super();
+        this.$platformController = $platformController;
+        this.$hooksService = $hooksService;
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$mobileHelper = $mobileHelper;
+        this.$nodeModulesDependenciesBuilder = $nodeModulesDependenciesBuilder;
+        this.$platformsDataService = $platformsDataService;
+        this.$pluginsService = $pluginsService;
+        this.$prepareNativePlatformService = $prepareNativePlatformService;
+        this.$projectChangesService = $projectChangesService;
+        this.$projectDataService = $projectDataService;
+        this.$webpackCompilerService = $webpackCompilerService;
+        this.$watchIgnoreListService = $watchIgnoreListService;
+        this.$analyticsService = $analyticsService;
+        this.$markingModeService = $markingModeService;
+        this.$projectConfigService = $projectConfigService;
+        this.$projectService = $projectService;
+        this.watchersData = {};
+        this.isInitialPrepareReady = false;
+        this.persistedData = [];
+        this.webpackCompilerHandler = null;
+        this.pausedFileWatch = false;
+    }
+    prepare(prepareData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projectData = this.$projectDataService.getProjectData(prepareData.projectDir);
+            if (this.$mobileHelper.isAndroidPlatform(prepareData.platform)) {
+                yield this.$markingModeService.handleMarkingModeFullDeprecation({
+                    projectDir: projectData.projectDir,
+                });
+            }
+            yield this.$pluginsService.ensureAllDependenciesAreInstalled(projectData);
+            return this.prepareCore(prepareData, projectData);
+        });
+    }
+    stopWatchers(projectDir, platform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platformLowerCase = platform.toLowerCase();
+            if (this.watchersData &&
+                this.watchersData[projectDir] &&
+                this.watchersData[projectDir][platformLowerCase] &&
+                this.watchersData[projectDir][platformLowerCase].nativeFilesWatcher) {
+                yield this.watchersData[projectDir][platformLowerCase].nativeFilesWatcher.close();
+                this.watchersData[projectDir][platformLowerCase].nativeFilesWatcher =
+                    null;
+            }
+            if (this.watchersData &&
+                this.watchersData[projectDir] &&
+                this.watchersData[projectDir][platformLowerCase] &&
+                this.watchersData[projectDir][platformLowerCase].hasWebpackCompilerProcess) {
+                yield this.$webpackCompilerService.stopWebpackCompiler(platformLowerCase);
+                this.$webpackCompilerService.removeListener(constants_1.WEBPACK_COMPILATION_COMPLETE, this.webpackCompilerHandler);
+                this.watchersData[projectDir][platformLowerCase].hasWebpackCompilerProcess = false;
+            }
+        });
+    }
+    prepareCore(prepareData, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$projectService.ensureAppResourcesExist(projectData.projectDir);
+            yield this.$platformController.addPlatformIfNeeded(prepareData, projectData);
+            yield this.trackRuntimeVersion(prepareData.platform, projectData);
+            this.$logger.info("Preparing project...");
+            prepareData.env = prepareData.env || {};
+            prepareData.env.externals = prepareData.env.externals || [];
+            prepareData.env.externals.push("~/package.json");
+            prepareData.env.externals.push("package.json");
+            if (this.$mobileHelper.isAndroidPlatform(prepareData.platform)) {
+                yield this.$projectConfigService.writeLegacyNSConfigIfNeeded(projectData.projectDir, this.$projectDataService.getRuntimePackage(projectData.projectDir, prepareData.platform));
+            }
+            let result = null;
+            const platformData = this.$platformsDataService.getPlatformData(prepareData.platform, projectData);
+            if (prepareData.watch) {
+                result = yield this.startWatchersWithPrepare(platformData, projectData, prepareData);
+            }
+            else {
+                yield this.$webpackCompilerService.compileWithoutWatch(platformData, projectData, prepareData);
+                const hasNativeChanges = yield this.$prepareNativePlatformService.prepareNativePlatform(platformData, projectData, prepareData);
+                result = {
+                    hasNativeChanges,
+                    platform: prepareData.platform.toLowerCase(),
+                };
+            }
+            yield this.writeRuntimePackageJson(projectData, platformData);
+            yield this.$projectChangesService.savePrepareInfo(platformData, projectData, prepareData);
+            this.$logger.info(`Project successfully prepared (${prepareData.platform.toLowerCase()})`);
+            return result;
+        });
+    }
+    startWatchersWithPrepare(platformData, projectData, prepareData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.watchersData[projectData.projectDir]) {
+                this.watchersData[projectData.projectDir] = {};
+            }
+            if (!this.watchersData[projectData.projectDir][platformData.platformNameLowerCase]) {
+                this.watchersData[projectData.projectDir][platformData.platformNameLowerCase] = {
+                    nativeFilesWatcher: null,
+                    hasWebpackCompilerProcess: false,
+                    prepareArguments: {
+                        platformData,
+                        projectData,
+                        prepareData,
+                    },
+                };
+            }
+            yield this.startJSWatcherWithPrepare(platformData, projectData, prepareData);
+            const hasNativeChanges = yield this.startNativeWatcherWithPrepare(platformData, projectData, prepareData);
+            const result = {
+                platform: platformData.platformNameLowerCase,
+                hasNativeChanges,
+            };
+            const hasPersistedDataWithNativeChanges = this.persistedData.find((data) => data.platform === result.platform && data.hasNativeChanges);
+            if (hasPersistedDataWithNativeChanges) {
+                result.hasNativeChanges = true;
+            }
+            this.isInitialPrepareReady = true;
+            if (this.persistedData && this.persistedData.length) {
+                this.emitPrepareEvent({
+                    files: [],
+                    staleFiles: [],
+                    hasOnlyHotUpdateFiles: false,
+                    hasNativeChanges: result.hasNativeChanges,
+                    hmrData: null,
+                    platform: platformData.platformNameLowerCase,
+                });
+            }
+            return result;
+        });
+    }
+    startJSWatcherWithPrepare(platformData, projectData, prepareData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.watchersData[projectData.projectDir][platformData.platformNameLowerCase].hasWebpackCompilerProcess) {
+                const handler = (data) => {
+                    var _a;
+                    if (data.platform.toLowerCase() === platformData.platformNameLowerCase) {
+                        if (this.isFileWatcherPaused())
+                            return;
+                        this.emitPrepareEvent(Object.assign(Object.assign({}, data), { files: (_a = data.files) !== null && _a !== void 0 ? _a : [], hasNativeChanges: false }));
+                    }
+                };
+                this.webpackCompilerHandler = handler.bind(this);
+                this.$webpackCompilerService.on(constants_1.WEBPACK_COMPILATION_COMPLETE, this.webpackCompilerHandler);
+                this.watchersData[projectData.projectDir][platformData.platformNameLowerCase].hasWebpackCompilerProcess = true;
+                yield this.$webpackCompilerService.compileWithWatch(platformData, projectData, prepareData);
+            }
+        });
+    }
+    startNativeWatcherWithPrepare(platformData, projectData, prepareData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let newNativeWatchStarted = false;
+            let hasNativeChanges = false;
+            if (prepareData.watchNative) {
+                newNativeWatchStarted = yield this.startNativeWatcher(platformData, projectData);
+            }
+            if (newNativeWatchStarted) {
+                hasNativeChanges =
+                    yield this.$prepareNativePlatformService.prepareNativePlatform(platformData, projectData, prepareData);
+            }
+            return hasNativeChanges;
+        });
+    }
+    startNativeWatcher(platformData, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.watchersData[projectData.projectDir][platformData.platformNameLowerCase].nativeFilesWatcher) {
+                return false;
+            }
+            const patterns = yield this.getWatcherPatterns(platformData, projectData);
+            const watcherOptions = {
+                ignoreInitial: true,
+                cwd: projectData.projectDir,
+                awaitWriteFinish: {
+                    pollInterval: 100,
+                    stabilityThreshold: 500,
+                },
+                ignored: ["**/.*", ".*"],
+            };
+            const watcher = choki
+                .watch(patterns, watcherOptions)
+                .on("all", (event, filePath) => __awaiter(this, void 0, void 0, function* () {
+                if (this.isFileWatcherPaused())
+                    return;
+                filePath = path.join(projectData.projectDir, filePath);
+                if (this.$watchIgnoreListService.isFileInIgnoreList(filePath)) {
+                    this.$watchIgnoreListService.removeFileFromIgnoreList(filePath);
+                }
+                else {
+                    this.$logger.info(`Chokidar raised event ${event} for ${filePath}.`);
+                    yield this.writeRuntimePackageJson(projectData, platformData);
+                    this.emitPrepareEvent({
+                        files: [filePath],
+                        staleFiles: [],
+                        hasOnlyHotUpdateFiles: false,
+                        hmrData: null,
+                        hasNativeChanges: true,
+                        platform: platformData.platformNameLowerCase,
+                    });
+                }
+            }));
+            this.watchersData[projectData.projectDir][platformData.platformNameLowerCase].nativeFilesWatcher = watcher;
+            return true;
+        });
+    }
+    getWatcherPatterns(platformData, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dependencies = this.$nodeModulesDependenciesBuilder
+                .getProductionDependencies(projectData.projectDir, projectData.ignoredDependencies)
+                .filter((dep) => dep.nativescript);
+            const pluginsNativeDirectories = dependencies.map((dep) => path.join(dep.directory, constants_1.PLATFORMS_DIR_NAME, platformData.platformNameLowerCase));
+            const pluginsPackageJsonFiles = dependencies.map((dep) => path.join(dep.directory, constants_1.PACKAGE_JSON_FILE_NAME));
+            const patterns = [
+                path.join(projectData.projectDir, constants_1.PACKAGE_JSON_FILE_NAME),
+                path.join(projectData.projectDir, constants_1.CONFIG_FILE_NAME_JS),
+                path.join(projectData.projectDir, constants_1.CONFIG_FILE_NAME_TS),
+                path.join(projectData.getAppDirectoryPath(), constants_1.PACKAGE_JSON_FILE_NAME),
+                path.join(projectData.getAppResourcesRelativeDirectoryPath(), platformData.normalizedPlatformName),
+            ]
+                .concat(pluginsNativeDirectories)
+                .concat(pluginsPackageJsonFiles);
+            return patterns;
+        });
+    }
+    writeRuntimePackageJson(projectData, platformData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const configInfo = this.$projectConfigService.detectProjectConfigs(projectData.projectDir);
+            if (configInfo.usingNSConfig) {
+                return;
+            }
+            this.$logger.info("Updating runtime package.json with configuration values...");
+            const nsConfig = this.$projectConfigService.readConfig(projectData.projectDir);
+            const packageData = Object.assign(Object.assign(Object.assign({}, _.pick(projectData.packageJsonData, ["name"])), nsConfig), { main: "bundle" });
+            if (platformData.platformNameLowerCase === "ios" &&
+                packageData.ios &&
+                packageData.ios.discardUncaughtJsExceptions) {
+                packageData.discardUncaughtJsExceptions =
+                    packageData.ios.discardUncaughtJsExceptions;
+            }
+            if (platformData.platformNameLowerCase === "android" &&
+                packageData.android &&
+                packageData.android.discardUncaughtJsExceptions) {
+                packageData.discardUncaughtJsExceptions =
+                    packageData.android.discardUncaughtJsExceptions;
+            }
+            let packagePath;
+            if (this.$mobileHelper.isApplePlatform(platformData.platformNameLowerCase)) {
+                packagePath = path.join(platformData.projectRoot, projectData.projectName, "app", "package.json");
+            }
+            else {
+                packagePath = path.join(platformData.projectRoot, "app", "src", "main", "assets", "app", "package.json");
+            }
+            try {
+                const emittedPackageData = this.$fs.readJson(packagePath);
+                if (emittedPackageData === null || emittedPackageData === void 0 ? void 0 : emittedPackageData.main) {
+                    packageData.main = emittedPackageData.main;
+                }
+            }
+            catch (error) {
+                this.$logger.trace("Failed to read emitted package.json. Error is: ", error);
+            }
+            this.$fs.writeJson(packagePath, packageData);
+        });
+    }
+    emitPrepareEvent(filesChangeEventData) {
+        if (this.isInitialPrepareReady) {
+            this.emit(constants_1.PREPARE_READY_EVENT_NAME, filesChangeEventData);
+        }
+        else {
+            this.persistedData.push(filesChangeEventData);
+        }
+    }
+    trackRuntimeVersion(platform, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { version } = this.$projectDataService.getRuntimePackage(projectData.projectDir, platform);
+            if (!version) {
+                this.$logger.trace(`Unable to get runtime version for project directory: ${projectData.projectDir} and platform ${platform}.`);
+                return;
+            }
+            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                action: "Using Runtime Version",
+                additionalData: `${platform.toLowerCase()}${constants_1.AnalyticsEventLabelDelimiter}${version}`,
+            });
+        });
+    }
+    isFileWatcherPaused() {
+        return this.pausedFileWatch;
+    }
+    toggleFileWatcher() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.pausedFileWatch = !this.pausedFileWatch;
+            const watchers = Object.values(this.watchersData);
+            if (this.pausedFileWatch) {
+                for (const watcher of watchers) {
+                    for (const platform in watcher) {
+                        yield this.$webpackCompilerService.stopWebpackCompiler(platform);
+                        watcher[platform].hasWebpackCompilerProcess = false;
+                    }
+                }
+            }
+            else {
+                for (const watcher of watchers) {
+                    for (const platform in watcher) {
+                        const args = watcher[platform].prepareArguments;
+                        watcher[platform].hasWebpackCompilerProcess = true;
+                        yield this.$webpackCompilerService.compileWithWatch(args.platformData, args.projectData, args.prepareData);
+                    }
+                }
+            }
+            return this.pausedFileWatch;
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.performanceLog)(),
+    (0, helpers_1.hook)("prepare")
+], PrepareController.prototype, "prepareCore", null);
+__decorate([
+    (0, helpers_1.hook)("watch")
+], PrepareController.prototype, "startWatchersWithPrepare", null);
+__decorate([
+    (0, helpers_1.hook)("watchPatterns")
+], PrepareController.prototype, "getWatcherPatterns", null);
+__decorate([
+    (0, decorators_1.cache)()
+], PrepareController.prototype, "trackRuntimeVersion", null);
+exports.PrepareController = PrepareController;
+yok_1.injector.register("prepareController", PrepareController);