nativescript 8.9.0-dev.0 → 8.9.0-dev.2

package/lib/services/project-service.js

@@ -5,6 +5,15 @@ 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");
@@ -32,56 +41,64 @@ class ProjectService {
         this.$staticConfig = $staticConfig;
         this.$childProcess = $childProcess;
     }
-    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,
+    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;
         });
-        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 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.");
+    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.");
+                        }
                     }
+                    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"`);
-            }
-            catch (err) {
-                this.$logger.trace("Unable to initialize git repository. Error is: ", err);
             }
-        }
-        this.$logger.trace(`Project ${projectName} was successfully created.`);
-        return projectCreationData;
+            this.$logger.trace(`Project ${projectName} was successfully created.`);
+            return projectCreationData;
+        });
     }
     isValidNativeScriptProject(pathToProject) {
         try {
@@ -100,59 +117,69 @@ class ProjectService {
         const projectDir = path.join(selectedPath, projectName);
         return projectDir;
     }
-    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,
+    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,
             });
-        }
-        catch (err) {
-            this.$fs.deleteDirectory(projectDir);
-            throw err;
-        }
-        await this.$hooksService.executeAfterHooks(constants_1.Hooks.createProject, {
-            hookArgs: projectCreationSettings,
+            return { projectName, projectDir };
         });
-        return { projectName, 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);
+    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 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);
-        }
+    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);
+            }
+        });
     }
     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: "",
@@ -160,12 +187,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)()
@@ -182,4 +209,6 @@ __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,6 +5,15 @@ 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");
@@ -23,45 +32,49 @@ class ProjectTemplatesService {
         this.$staticConfig = $staticConfig;
         this.templatePackageContents = {};
     }
-    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,
+    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,
             });
-        }
-        return {
-            templateName: templateValue,
-            templatePackageJsonContent,
-            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 getTemplatePackageJsonContent(templateName) {
-        if (!this.templatePackageContents[templateName]) {
-            this.templatePackageContents[templateName] = await this.$pacoteService.manifest(templateName, {
-                fullMetadata: true,
-            });
-        }
-        return this.templatePackageContents[templateName];
+    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 {
@@ -76,24 +89,27 @@ class ProjectTemplatesService {
             this.$logger.trace(`Unable to get template name to be tracked, error is: ${err}`);
         }
     }
-    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);
-        }
+    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);
+            }
+        });
     }
 }
-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,3 +18,4 @@ 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,3 +9,4 @@ class RequireService {
 }
 exports.RequireService = RequireService;
 yok_1.injector.register("requireService", RequireService);
+//# sourceMappingURL=require-service.js.map

package/lib/services/start-service.js

@@ -1,4 +1,13 @@
 "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 {
@@ -18,48 +27,57 @@ class StartService {
     format(data, platform) {
         return data;
     }
-    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,
-            },
-        });
-        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));
+    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 runIOS() {
-        this.runForPlatform(this.$devicePlatformsConstants.iOS);
+    runIOS() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.runForPlatform(this.$devicePlatformsConstants.iOS);
+        });
     }
-    async runVisionOS() {
-        this.runForPlatform(this.$devicePlatformsConstants.visionOS);
+    runVisionOS() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.runForPlatform(this.$devicePlatformsConstants.visionOS);
+        });
     }
-    async runAndroid() {
-        this.runForPlatform(this.$devicePlatformsConstants.Android);
+    runAndroid() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.runForPlatform(this.$devicePlatformsConstants.Android);
+        });
     }
-    async stopIOS() {
-        if (this.ios) {
-            this.ios.kill("SIGINT");
-        }
+    stopIOS() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.ios) {
+                this.ios.kill("SIGINT");
+            }
+        });
     }
-    async stopVisionOS() {
-        if (this.visionos) {
-            this.visionos.kill("SIGINT");
-        }
+    stopVisionOS() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.visionos) {
+                this.visionos.kill("SIGINT");
+            }
+        });
     }
-    async stopAndroid() {
-        if (this.android) {
-            this.android.kill("SIGINT");
-        }
+    stopAndroid() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.android) {
+                this.android.kill("SIGINT");
+            }
+        });
     }
     start() {
         this.addKeyCommandOverrides();
@@ -69,16 +87,16 @@ class StartService {
     addKeyCommandOverrides() {
         const keys = ["w", "r", "R"];
         for (let key of keys) {
-            this.$keyCommandHelper.addOverride(key, async () => {
+            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", async () => {
-            await this.stopIOS();
-            await this.stopAndroid();
+        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",
@@ -91,8 +109,9 @@ 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,4 +1,13 @@
 "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");
@@ -8,16 +17,21 @@ class TempService {
         this.$cleanupService = $cleanupService;
         temp.track();
     }
-    async mkdirSync(affixes) {
-        const pathToDir = temp.mkdirSync(affixes);
-        await this.$cleanupService.addCleanupDeleteAction(pathToDir);
-        return pathToDir;
+    mkdirSync(affixes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pathToDir = temp.mkdirSync(affixes);
+            yield this.$cleanupService.addCleanupDeleteAction(pathToDir);
+            return pathToDir;
+        });
     }
-    async path(options) {
-        const pathToFile = temp.path(options);
-        await this.$cleanupService.addCleanupDeleteAction(pathToFile);
-        return pathToFile;
+    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);
+//# sourceMappingURL=temp-service.js.map