@akylas/nativescript-cli 8.7.2

package/lib/services/project-service.js

@@ -0,0 +1,204 @@
+"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.ProjectService = void 0;
+const constants = require("../constants");
+const path = require("path");
+const simple_git_1 = require("simple-git");
+const decorators_1 = require("../common/decorators");
+const constants_1 = require("../constants");
+const decorators_2 = require("../common/decorators");
+const yok_1 = require("../common/yok");
+class ProjectService {
+    constructor($options, $hooksService, $packageManager, $errors, $fs, $logger, $pacoteService, $projectDataService, $projectConfigService, $projectHelper, $projectNameService, $projectTemplatesService, $tempService, $staticConfig, $childProcess) {
+        this.$options = $options;
+        this.$hooksService = $hooksService;
+        this.$packageManager = $packageManager;
+        this.$errors = $errors;
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$pacoteService = $pacoteService;
+        this.$projectDataService = $projectDataService;
+        this.$projectConfigService = $projectConfigService;
+        this.$projectHelper = $projectHelper;
+        this.$projectNameService = $projectNameService;
+        this.$projectTemplatesService = $projectTemplatesService;
+        this.$tempService = $tempService;
+        this.$staticConfig = $staticConfig;
+        this.$childProcess = $childProcess;
+    }
+    validateProjectName(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let projectName = opts.projectName;
+            if (!projectName) {
+                this.$errors.failWithHelp("You must specify <App name> when creating a new project.");
+            }
+            projectName = yield this.$projectNameService.ensureValidName(projectName, {
+                force: opts.force,
+            });
+            const projectDir = this.getValidProjectDir(opts.pathToProject, projectName);
+            if (this.$fs.exists(projectDir) && !this.$fs.isEmptyDir(projectDir)) {
+                this.$errors.fail("Path already exists and is not empty %s", projectDir);
+            }
+            return projectName;
+        });
+    }
+    createProject(projectOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projectName = yield this.validateProjectName({
+                projectName: projectOptions.projectName,
+                force: projectOptions.force,
+                pathToProject: projectOptions.pathToProject,
+            });
+            const projectDir = this.getValidProjectDir(projectOptions.pathToProject, projectName);
+            this.$fs.createDirectory(projectDir);
+            const appId = projectOptions.appId ||
+                this.$projectHelper.generateDefaultAppId(projectName, constants.DEFAULT_APP_IDENTIFIER_PREFIX);
+            this.$logger.trace(`Creating a new NativeScript project with name ${projectName} and id ${appId} at location ${projectDir}`);
+            const projectCreationData = yield this.createProjectCore({
+                template: projectOptions.template,
+                projectDir,
+                ignoreScripts: projectOptions.ignoreScripts,
+                appId: appId,
+                projectName,
+            });
+            if (this.$options.git) {
+                try {
+                    if (!this.$options.force) {
+                        const git = (0, simple_git_1.default)(projectDir);
+                        if (yield git.checkIsRepo()) {
+                            throw new Error("Already part of a git repository.");
+                        }
+                    }
+                    yield this.$childProcess.exec(`git init ${projectDir}`);
+                    yield this.$childProcess.exec(`git -C ${projectDir} add --all`);
+                    yield this.$childProcess.exec(`git -C ${projectDir} commit --no-verify -m "init"`);
+                }
+                catch (err) {
+                    this.$logger.trace("Unable to initialize git repository. Error is: ", err);
+                }
+            }
+            this.$logger.trace(`Project ${projectName} was successfully created.`);
+            return projectCreationData;
+        });
+    }
+    isValidNativeScriptProject(pathToProject) {
+        try {
+            const projectData = this.$projectDataService.getProjectData(pathToProject);
+            return (!!projectData &&
+                !!projectData.projectDir &&
+                !!(projectData.projectIdentifiers.ios &&
+                    projectData.projectIdentifiers.android));
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    getValidProjectDir(pathToProject, projectName) {
+        const selectedPath = path.resolve(pathToProject || ".");
+        const projectDir = path.join(selectedPath, projectName);
+        return projectDir;
+    }
+    createProjectCore(projectCreationSettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { template, projectDir, appId, projectName, ignoreScripts, } = projectCreationSettings;
+            try {
+                const templateData = yield this.$projectTemplatesService.prepareTemplate(template, projectDir);
+                yield this.extractTemplate(projectDir, templateData);
+                this.alterPackageJsonData(projectCreationSettings);
+                this.$projectConfigService.writeDefaultConfig(projectDir, appId);
+                yield this.ensureAppResourcesExist(projectDir);
+                yield this.$packageManager.install(projectDir, projectDir, {
+                    disableNpmInstall: false,
+                    frameworkPath: null,
+                    ignoreScripts,
+                });
+            }
+            catch (err) {
+                this.$fs.deleteDirectory(projectDir);
+                throw err;
+            }
+            yield this.$hooksService.executeAfterHooks(constants_1.Hooks.createProject, {
+                hookArgs: projectCreationSettings,
+            });
+            return { projectName, projectDir };
+        });
+    }
+    extractTemplate(projectDir, templateData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$fs.ensureDirectoryExists(projectDir);
+            const fullTemplateName = templateData.version
+                ? `${templateData.templateName}@${templateData.version}`
+                : templateData.templateName;
+            yield this.$pacoteService.extractPackage(fullTemplateName, projectDir);
+        });
+    }
+    ensureAppResourcesExist(projectDir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projectData = this.$projectDataService.getProjectData(projectDir);
+            const appResourcesDestinationPath = projectData.getAppResourcesDirectoryPath(projectDir);
+            if (!this.$fs.exists(appResourcesDestinationPath)) {
+                this.$logger.trace("Project does not have App_Resources - fetching from default template.");
+                this.$fs.createDirectory(appResourcesDestinationPath);
+                const tempDir = yield this.$tempService.mkdirSync("ns-default-template");
+                yield this.$pacoteService.extractPackage(constants.RESERVED_TEMPLATE_NAMES["default"], tempDir);
+                const templateProjectData = this.$projectDataService.getProjectData(tempDir);
+                const templateAppResourcesDir = templateProjectData.getAppResourcesDirectoryPath(tempDir);
+                this.$fs.copyFile(path.join(templateAppResourcesDir, "*"), appResourcesDestinationPath);
+            }
+        });
+    }
+    alterPackageJsonData(projectCreationSettings) {
+        const { projectDir, projectName } = projectCreationSettings;
+        const projectFilePath = path.join(projectDir, this.$staticConfig.PROJECT_FILE_NAME);
+        let packageJsonData = this.$fs.readJson(projectFilePath);
+        Object.keys(packageJsonData).forEach((key) => {
+            if (key.startsWith("_") ||
+                constants.TemplatesV2PackageJsonKeysToRemove.includes(key)) {
+                delete packageJsonData[key];
+            }
+        });
+        const packageJsonSchema = {
+            name: projectName,
+            main: "",
+            version: "1.0.0",
+            private: true,
+            dependencies: {},
+            devDependencies: {},
+        };
+        packageJsonData = Object.assign(packageJsonSchema, packageJsonData);
+        this.$fs.writeJson(projectFilePath, packageJsonData);
+    }
+}
+__decorate([
+    (0, decorators_1.exported)("projectService"),
+    (0, decorators_2.performanceLog)()
+], ProjectService.prototype, "createProject", null);
+__decorate([
+    (0, decorators_1.exported)("projectService")
+], ProjectService.prototype, "isValidNativeScriptProject", null);
+__decorate([
+    (0, decorators_2.performanceLog)()
+], ProjectService.prototype, "extractTemplate", null);
+__decorate([
+    (0, decorators_2.performanceLog)()
+], ProjectService.prototype, "ensureAppResourcesExist", null);
+__decorate([
+    (0, decorators_2.performanceLog)()
+], ProjectService.prototype, "alterPackageJsonData", null);
+exports.ProjectService = ProjectService;
+yok_1.injector.register("projectService", ProjectService);

package/lib/services/project-templates-service.js

@@ -0,0 +1,114 @@
+"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.ProjectTemplatesService = void 0;
+const path = require("path");
+const semver = require("semver");
+const constants = require("../constants");
+const decorators_1 = require("../common/decorators");
+const yok_1 = require("../common/yok");
+class ProjectTemplatesService {
+    constructor($analyticsService, $fs, $logger, $packageInstallationManager, $pacoteService, $packageManager, $staticConfig) {
+        this.$analyticsService = $analyticsService;
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$packageInstallationManager = $packageInstallationManager;
+        this.$pacoteService = $pacoteService;
+        this.$packageManager = $packageManager;
+        this.$staticConfig = $staticConfig;
+        this.templatePackageContents = {};
+    }
+    prepareTemplate(templateValue, projectDir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!templateValue) {
+                templateValue = constants.RESERVED_TEMPLATE_NAMES["default"];
+            }
+            const templateNameParts = yield this.$packageManager.getPackageNameParts(templateValue);
+            templateValue =
+                constants.RESERVED_TEMPLATE_NAMES[templateNameParts.name] ||
+                    templateNameParts.name;
+            const version = yield this.getDesiredVersion(templateValue, templateNameParts.version);
+            const fullTemplateName = yield this.$packageManager.getPackageFullName({
+                name: templateValue,
+                version: version,
+            });
+            const templatePackageJsonContent = yield this.getTemplatePackageJsonContent(fullTemplateName);
+            const templateNameToBeTracked = this.getTemplateNameToBeTracked(templateValue, templatePackageJsonContent);
+            if (templateNameToBeTracked) {
+                yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                    action: "Create project",
+                    isForDevice: null,
+                    additionalData: templateNameToBeTracked,
+                });
+                yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                    action: "Using Template",
+                    additionalData: templateNameToBeTracked,
+                });
+            }
+            return {
+                templateName: templateValue,
+                templatePackageJsonContent,
+                version,
+            };
+        });
+    }
+    getTemplatePackageJsonContent(templateName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.templatePackageContents[templateName]) {
+                this.templatePackageContents[templateName] = yield this.$pacoteService.manifest(templateName, {
+                    fullMetadata: true,
+                });
+            }
+            return this.templatePackageContents[templateName];
+        });
+    }
+    getTemplateNameToBeTracked(templateName, packageJsonContent) {
+        try {
+            if (this.$fs.exists(templateName)) {
+                const templateNameToBeTracked = (packageJsonContent && packageJsonContent.name) ||
+                    path.basename(templateName);
+                return `${constants.ANALYTICS_LOCAL_TEMPLATE_PREFIX}${templateNameToBeTracked}`;
+            }
+            return templateName;
+        }
+        catch (err) {
+            this.$logger.trace(`Unable to get template name to be tracked, error is: ${err}`);
+        }
+    }
+    getDesiredVersion(templateName, defaultVersion) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (defaultVersion) {
+                return defaultVersion;
+            }
+            if (this.$fs.exists(templateName)) {
+                return "";
+            }
+            try {
+                const cliMajorVersion = semver.parse(semver.coerce(this.$staticConfig.version)).major;
+                return `^${cliMajorVersion}.0.0`;
+            }
+            catch (err) {
+                return this.$packageInstallationManager.getLatestCompatibleVersionSafe(templateName);
+            }
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.performanceLog)()
+], ProjectTemplatesService.prototype, "prepareTemplate", null);
+exports.ProjectTemplatesService = ProjectTemplatesService;
+yok_1.injector.register("projectTemplatesService", ProjectTemplatesService);

package/lib/services/qr-code-terminal-service.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QrCodeTerminalService = void 0;
+const qrcode = require("qrcode-terminal");
+const yok_1 = require("../common/yok");
+class QrCodeTerminalService {
+    constructor($logger) {
+        this.$logger = $logger;
+    }
+    generate(url) {
+        try {
+            qrcode.generate(url);
+        }
+        catch (err) {
+            this.$logger.info(`Failed to generate QR code for ${url}`, err);
+        }
+    }
+}
+exports.QrCodeTerminalService = QrCodeTerminalService;
+yok_1.injector.register("qrCodeTerminalService", QrCodeTerminalService);

package/lib/services/require-service.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequireService = void 0;
+const yok_1 = require("../common/yok");
+class RequireService {
+    require(module) {
+        return require(module);
+    }
+}
+exports.RequireService = RequireService;
+yok_1.injector.register("requireService", RequireService);

package/lib/services/start-service.js

@@ -0,0 +1,116 @@
+"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 yok_1 = require("../common/yok");
+class StartService {
+    constructor($keyCommandHelper, $childProcess, $devicePlatformsConstants, $projectData, $logger, $staticConfig) {
+        this.$keyCommandHelper = $keyCommandHelper;
+        this.$childProcess = $childProcess;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$projectData = $projectData;
+        this.$logger = $logger;
+        this.$staticConfig = $staticConfig;
+        this.verbose = false;
+    }
+    toggleVerbose() {
+        this.verbose = true;
+        this.$logger.info(this.verbose ? `Verbose logging enabled` : `Verbose logging disabled`);
+    }
+    format(data, platform) {
+        return data;
+    }
+    runForPlatform(platform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platformLowerCase = platform.toLowerCase();
+            this[platformLowerCase] = this.$childProcess.spawn("node", [this.$staticConfig.cliBinPath, "run", platform.toLowerCase()], {
+                cwd: this.$projectData.projectDir,
+                stdio: ["ipc"],
+                env: Object.assign({ FORCE_COLOR: 1, HIDE_HEADER: true, NS_IS_INTERACTIVE: true }, process.env),
+            });
+            this[platformLowerCase].stdout.on("data", (data) => {
+                process.stdout.write(this.format(data, platform));
+            });
+            this[platformLowerCase].stderr.on("data", (data) => {
+                process.stderr.write(this.format(data, platform));
+            });
+        });
+    }
+    runIOS() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.runForPlatform(this.$devicePlatformsConstants.iOS);
+        });
+    }
+    runVisionOS() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.runForPlatform(this.$devicePlatformsConstants.visionOS);
+        });
+    }
+    runAndroid() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.runForPlatform(this.$devicePlatformsConstants.Android);
+        });
+    }
+    stopIOS() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.ios) {
+                this.ios.kill("SIGINT");
+            }
+        });
+    }
+    stopVisionOS() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.visionos) {
+                this.visionos.kill("SIGINT");
+            }
+        });
+    }
+    stopAndroid() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.android) {
+                this.android.kill("SIGINT");
+            }
+        });
+    }
+    start() {
+        this.addKeyCommandOverrides();
+        this.$keyCommandHelper.attachKeyCommands("all", "start");
+        this.$keyCommandHelper.printCommands("all");
+    }
+    addKeyCommandOverrides() {
+        const keys = ["w", "r", "R"];
+        for (let key of keys) {
+            this.$keyCommandHelper.addOverride(key, () => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                (_a = this.ios) === null || _a === void 0 ? void 0 : _a.send(key);
+                (_b = this.android) === null || _b === void 0 ? void 0 : _b.send(key);
+                return false;
+            }));
+        }
+        this.$keyCommandHelper.addOverride("c", () => __awaiter(this, void 0, void 0, function* () {
+            yield this.stopIOS();
+            yield this.stopAndroid();
+            const clean = this.$childProcess.spawn("node", [
+                this.$staticConfig.cliBinPath,
+                "clean",
+            ]);
+            clean.stdout.on("data", (data) => {
+                process.stdout.write(data);
+                if (data.toString().includes("Project successfully cleaned.") ||
+                    data.toString().includes("Project unsuccessfully cleaned.")) {
+                    clean.kill("SIGINT");
+                }
+            });
+            return false;
+        }));
+    }
+}
+exports.default = StartService;
+yok_1.injector.register("startService", StartService);

package/lib/services/temp-service.js

@@ -0,0 +1,36 @@
+"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.TempService = void 0;
+const temp = require("temp");
+const yok_1 = require("../common/yok");
+class TempService {
+    constructor($cleanupService) {
+        this.$cleanupService = $cleanupService;
+        temp.track();
+    }
+    mkdirSync(affixes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pathToDir = temp.mkdirSync(affixes);
+            yield this.$cleanupService.addCleanupDeleteAction(pathToDir);
+            return pathToDir;
+        });
+    }
+    path(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pathToFile = temp.path(options);
+            yield this.$cleanupService.addCleanupDeleteAction(pathToFile);
+            return pathToFile;
+        });
+    }
+}
+exports.TempService = TempService;
+yok_1.injector.register("tempService", TempService);

package/lib/services/terminal-spinner-service.js

@@ -0,0 +1,38 @@
+"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.TerminalSpinnerService = void 0;
+const ora = require("ora");
+const yok_1 = require("../common/yok");
+class TerminalSpinnerService {
+    createSpinner(spinnerOptions = {}) {
+        spinnerOptions.stream = spinnerOptions.stream || process.stdout;
+        return ora(spinnerOptions);
+    }
+    execute(spinnerOptions, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const spinner = this.createSpinner(spinnerOptions);
+            spinner.start();
+            let result = null;
+            try {
+                result = yield action();
+            }
+            catch (err) {
+                spinner.fail();
+                return null;
+            }
+            spinner.succeed();
+            return result;
+        });
+    }
+}
+exports.TerminalSpinnerService = TerminalSpinnerService;
+yok_1.injector.register("terminalSpinnerService", TerminalSpinnerService);