nativescript 8.9.0-dev.2 → 8.9.0-dev.3

package/lib/services/project-service.js

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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");
@@ -41,64 +32,56 @@ class ProjectService {
         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;
+    async validateProjectName(opts) {
+        let projectName = opts.projectName;
+        if (!projectName) {
+            this.$errors.failWithHelp("You must specify <App name> when creating a new project.");
+        }
+        projectName = await 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,
-            });
-            // can pass --no-git to skip creating a git repo
-            // useful in monorepos where we're creating
-            // sub projects in an existing git repo.
-            if (this.$options.git) {
-                try {
-                    if (!this.$options.force) {
-                        const git = (0, simple_git_1.default)(projectDir);
-                        if (yield git.checkIsRepo()) {
-                            // throwing here since we're catching below.
-                            throw new Error("Already part of a git repository.");
-                        }
+    async createProject(projectOptions) {
+        const projectName = await 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 = await 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 (await 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);
                 }
+                await this.$childProcess.exec(`git init ${projectDir}`);
+                await this.$childProcess.exec(`git -C ${projectDir} add --all`);
+                await this.$childProcess.exec(`git -C ${projectDir} commit --no-verify -m "init"`);
             }
-            this.$logger.trace(`Project ${projectName} was successfully created.`);
-            return projectCreationData;
-        });
+            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 {
@@ -117,69 +100,59 @@ class ProjectService {
         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);
-                // Install devDependencies and execute all scripts:
-                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,
+    async createProjectCore(projectCreationSettings) {
+        const { template, projectDir, appId, projectName, ignoreScripts, } = projectCreationSettings;
+        try {
+            const templateData = await this.$projectTemplatesService.prepareTemplate(template, projectDir);
+            await this.extractTemplate(projectDir, templateData);
+            this.alterPackageJsonData(projectCreationSettings);
+            this.$projectConfigService.writeDefaultConfig(projectDir, appId);
+            await this.ensureAppResourcesExist(projectDir);
+            await this.$packageManager.install(projectDir, projectDir, {
+                disableNpmInstall: false,
+                frameworkPath: null,
+                ignoreScripts,
             });
-            return { projectName, projectDir };
+        }
+        catch (err) {
+            this.$fs.deleteDirectory(projectDir);
+            throw err;
+        }
+        await 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);
-        });
+    async extractTemplate(projectDir, templateData) {
+        this.$fs.ensureDirectoryExists(projectDir);
+        const fullTemplateName = templateData.version
+            ? `${templateData.templateName}@${templateData.version}`
+            : templateData.templateName;
+        await 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");
-                // the template installed doesn't have App_Resources -> get from a 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);
-            }
-        });
+    async ensureAppResourcesExist(projectDir) {
+        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 = await this.$tempService.mkdirSync("ns-default-template");
+            await 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);
-        // clean up keys from the template package.json that we don't care about.
         Object.keys(packageJsonData).forEach((key) => {
             if (key.startsWith("_") ||
                 constants.TemplatesV2PackageJsonKeysToRemove.includes(key)) {
                 delete packageJsonData[key];
             }
         });
-        // this is used to ensure the order of keys is consistent, the blanks are filled in from the template
         const packageJsonSchema = {
             name: projectName,
             main: "",
@@ -187,12 +160,12 @@ class ProjectService {
             private: true,
             dependencies: {},
             devDependencies: {},
-            // anythign else would go below
         };
         packageJsonData = Object.assign(packageJsonSchema, packageJsonData);
         this.$fs.writeJson(projectFilePath, packageJsonData);
     }
 }
+exports.ProjectService = ProjectService;
 __decorate([
     (0, decorators_1.exported)("projectService"),
     (0, decorators_2.performanceLog)()
@@ -209,6 +182,4 @@ __decorate([
 __decorate([
     (0, decorators_2.performanceLog)()
 ], ProjectService.prototype, "alterPackageJsonData", null);
-exports.ProjectService = ProjectService;
 yok_1.injector.register("projectService", ProjectService);
-//# sourceMappingURL=project-service.js.map

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

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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");
@@ -32,49 +23,45 @@ class ProjectTemplatesService {
         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" /* constants.TrackActionNames.CreateProject */,
-                    isForDevice: null,
-                    additionalData: templateNameToBeTracked,
-                });
-                yield this.$analyticsService.trackEventActionInGoogleAnalytics({
-                    action: "Using Template" /* constants.TrackActionNames.UsingTemplate */,
-                    additionalData: templateNameToBeTracked,
-                });
-            }
-            return {
-                templateName: templateValue,
-                templatePackageJsonContent,
-                version,
-            };
+    async prepareTemplate(templateValue, projectDir) {
+        if (!templateValue) {
+            templateValue = constants.RESERVED_TEMPLATE_NAMES["default"];
+        }
+        const templateNameParts = await this.$packageManager.getPackageNameParts(templateValue);
+        templateValue =
+            constants.RESERVED_TEMPLATE_NAMES[templateNameParts.name] ||
+                templateNameParts.name;
+        const version = await this.getDesiredVersion(templateValue, templateNameParts.version);
+        const fullTemplateName = await this.$packageManager.getPackageFullName({
+            name: templateValue,
+            version: version,
         });
+        const templatePackageJsonContent = await this.getTemplatePackageJsonContent(fullTemplateName);
+        const templateNameToBeTracked = this.getTemplateNameToBeTracked(templateValue, templatePackageJsonContent);
+        if (templateNameToBeTracked) {
+            await this.$analyticsService.trackEventActionInGoogleAnalytics({
+                action: "Create project",
+                isForDevice: null,
+                additionalData: templateNameToBeTracked,
+            });
+            await 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];
-        });
+    async getTemplatePackageJsonContent(templateName) {
+        if (!this.templatePackageContents[templateName]) {
+            this.templatePackageContents[templateName] = await this.$pacoteService.manifest(templateName, {
+                fullMetadata: true,
+            });
+        }
+        return this.templatePackageContents[templateName];
     }
     getTemplateNameToBeTracked(templateName, packageJsonContent) {
         try {
@@ -89,27 +76,24 @@ class ProjectTemplatesService {
             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);
-            }
-        });
+    async getDesiredVersion(templateName, defaultVersion) {
+        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);
+        }
     }
 }
+exports.ProjectTemplatesService = ProjectTemplatesService;
 __decorate([
     (0, decorators_1.performanceLog)()
 ], ProjectTemplatesService.prototype, "prepareTemplate", null);
-exports.ProjectTemplatesService = ProjectTemplatesService;
 yok_1.injector.register("projectTemplatesService", ProjectTemplatesService);
-//# sourceMappingURL=project-templates-service.js.map

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

@@ -18,4 +18,3 @@ class QrCodeTerminalService {
 }
 exports.QrCodeTerminalService = QrCodeTerminalService;
 yok_1.injector.register("qrCodeTerminalService", QrCodeTerminalService);
-//# sourceMappingURL=qr-code-terminal-service.js.map

package/lib/services/require-service.js

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

package/lib/services/start-service.js

@@ -1,13 +1,4 @@
 "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 {
@@ -27,57 +18,48 @@ class StartService {
     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));
-            });
+    async runForPlatform(platform) {
+        const platformLowerCase = platform.toLowerCase();
+        this[platformLowerCase] = this.$childProcess.spawn("node", [this.$staticConfig.cliBinPath, "run", platform.toLowerCase()], {
+            cwd: this.$projectData.projectDir,
+            stdio: ["ipc"],
+            env: {
+                FORCE_COLOR: 1,
+                HIDE_HEADER: true,
+                NS_IS_INTERACTIVE: true,
+                ...process.env,
+            },
         });
-    }
-    runIOS() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.runForPlatform(this.$devicePlatformsConstants.iOS);
+        this[platformLowerCase].stdout.on("data", (data) => {
+            process.stdout.write(this.format(data, platform));
         });
-    }
-    runVisionOS() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.runForPlatform(this.$devicePlatformsConstants.visionOS);
+        this[platformLowerCase].stderr.on("data", (data) => {
+            process.stderr.write(this.format(data, platform));
         });
     }
-    runAndroid() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.runForPlatform(this.$devicePlatformsConstants.Android);
-        });
+    async runIOS() {
+        this.runForPlatform(this.$devicePlatformsConstants.iOS);
     }
-    stopIOS() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.ios) {
-                this.ios.kill("SIGINT");
-            }
-        });
+    async runVisionOS() {
+        this.runForPlatform(this.$devicePlatformsConstants.visionOS);
     }
-    stopVisionOS() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.visionos) {
-                this.visionos.kill("SIGINT");
-            }
-        });
+    async runAndroid() {
+        this.runForPlatform(this.$devicePlatformsConstants.Android);
     }
-    stopAndroid() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.android) {
-                this.android.kill("SIGINT");
-            }
-        });
+    async stopIOS() {
+        if (this.ios) {
+            this.ios.kill("SIGINT");
+        }
+    }
+    async stopVisionOS() {
+        if (this.visionos) {
+            this.visionos.kill("SIGINT");
+        }
+    }
+    async stopAndroid() {
+        if (this.android) {
+            this.android.kill("SIGINT");
+        }
     }
     start() {
         this.addKeyCommandOverrides();
@@ -87,16 +69,16 @@ class StartService {
     addKeyCommandOverrides() {
         const keys = ["w", "r", "R"];
         for (let key of keys) {
-            this.$keyCommandHelper.addOverride(key, () => __awaiter(this, void 0, void 0, function* () {
+            this.$keyCommandHelper.addOverride(key, async () => {
                 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();
+        this.$keyCommandHelper.addOverride("c", async () => {
+            await this.stopIOS();
+            await this.stopAndroid();
             const clean = this.$childProcess.spawn("node", [
                 this.$staticConfig.cliBinPath,
                 "clean",
@@ -109,9 +91,8 @@ class StartService {
                 }
             });
             return false;
-        }));
+        });
     }
 }
 exports.default = StartService;
 yok_1.injector.register("startService", StartService);
-//# sourceMappingURL=start-service.js.map

package/lib/services/temp-service.js

@@ -1,13 +1,4 @@
 "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");
@@ -17,21 +8,16 @@ class TempService {
         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;
-        });
+    async mkdirSync(affixes) {
+        const pathToDir = temp.mkdirSync(affixes);
+        await 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;
-        });
+    async path(options) {
+        const pathToFile = temp.path(options);
+        await this.$cleanupService.addCleanupDeleteAction(pathToFile);
+        return pathToFile;
     }
 }
 exports.TempService = TempService;
 yok_1.injector.register("tempService", TempService);
-//# sourceMappingURL=temp-service.js.map