@akylas/nativescript-cli 8.7.2

package/lib/definitions/prompter.d.ts

@@ -0,0 +1,27 @@
+import {
+	IPrompterOptions,
+	IAllowEmpty,
+	IDisposable,
+	IPrompterQuestion,
+} from "../common/declarations";
+
+declare global {
+	interface IPrompter extends IDisposable {
+		get(schemas: IPrompterQuestion[]): Promise<any>;
+		getPassword(prompt: string, options?: IAllowEmpty): Promise<string>;
+		getString(prompt: string, options?: IPrompterOptions): Promise<string>;
+		promptForChoice(
+			promptMessage: string,
+			choices:
+				| string[]
+				| { title: string; description?: string; value?: string }[],
+			multiple: boolean = false,
+			options: any = {}
+		): Promise<string>;
+		promptForDetailedChoice(
+			promptMessage: string,
+			choices: { key: string; description: string }[]
+		): Promise<string>;
+		confirm(prompt: string, defaultAction?: () => boolean): Promise<boolean>;
+	}
+}

package/lib/definitions/qr-code.d.ts

@@ -0,0 +1,3 @@
+interface IQrCodeTerminalService {
+	generate(url: string): void;
+}

package/lib/definitions/require.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Describes methods available in the require.
+ */
+interface IRequireService {
+	/**
+	 * Wrapper for the Node.js `require` method.
+	 * @param {string} module Module to be required.
+	 * @returns {any} The result of the require action.
+	 */
+	require(module: string): any;
+}

package/lib/definitions/run.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter } from "events";
+import { IBuildData } from "./build";
+
+declare global {
+	interface IRunData {
+		liveSyncInfo: ILiveSyncInfo;
+		deviceDescriptors: ILiveSyncDeviceDescriptor[];
+	}
+
+	interface IDeployData {
+		deviceDescriptors: ILiveSyncDeviceDescriptor[];
+	}
+
+	interface IStopRunData {
+		projectDir: string;
+		deviceIdentifiers?: string[];
+		stopOptions?: {
+			shouldAwaitAllActions: boolean;
+			keepProcessAlive?: boolean;
+		};
+	}
+
+	interface IRunController extends EventEmitter {
+		run(runData: IRunData): Promise<void>;
+		stop(data: IStopRunData): Promise<void>;
+		getDeviceDescriptors(data: {
+			projectDir: string;
+		}): ILiveSyncDeviceDescriptor[];
+	}
+
+	interface IDeviceInstallAppService {
+		installOnDevice(
+			device: Mobile.IDevice,
+			buildData: IBuildData
+		): Promise<void>;
+		installOnDeviceIfNeeded(
+			device: Mobile.IDevice,
+			buildData: IBuildData
+		): Promise<void>;
+		shouldInstall(
+			device: Mobile.IDevice,
+			buildData: IBuildData
+		): Promise<boolean>;
+	}
+}

package/lib/definitions/start-service.d.ts

@@ -0,0 +1,15 @@
+import { ChildProcess } from "child_process";
+
+export interface IStartService {
+	ios: ChildProcess;
+	android: ChildProcess;
+	start(): void;
+	toggleVerbose(): void;
+
+	runIOS(): Promise<void>;
+	runVisionOS(): Promise<void>;
+	runAndroid(): Promise<void>;
+	stopIOS(): Promise<void>;
+	stopVisionOS(): Promise<void>;
+	stopAndroid(): Promise<void>;
+}

package/lib/definitions/subscription-service.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Describes methods for subscribing to different NativeScript campaigns.
+ */
+interface ISubscriptionService {
+	/**
+	 * Subscribes users for NativeScript's newsletter by asking them for their email.
+	 * In case we've already asked the user for his email, this method will do nothing.
+	 * @returns {Promise<void>}
+	 */
+	subscribeForNewsletter(): Promise<void>;
+}

package/lib/definitions/system-warnings.d.ts

@@ -0,0 +1,4 @@
+declare const enum SystemWarningsSeverity {
+	medium = "medium",
+	high = "high",
+}

package/lib/definitions/temp-service.d.ts

@@ -0,0 +1,9 @@
+import { AffixOptions } from "temp";
+
+/**
+ * Declares wrapped functions of temp module
+ */
+interface ITempService {
+	mkdirSync(affixes: string | AffixOptions): Promise<string>;
+	path(options: string | AffixOptions): Promise<string>;
+}

package/lib/definitions/terminal-spinner-service.d.ts

@@ -0,0 +1,12 @@
+import type { Options, Ora } from "ora";
+
+type ITerminalSpinnerOptions = Options;
+type ITerminalSpinner = Ora;
+
+interface ITerminalSpinnerService {
+	createSpinner(spinnerOptions?: ITerminalSpinnerOptions): ITerminalSpinner;
+	execute<T>(
+		spinnerOptions: ITerminalSpinnerOptions,
+		action: () => Promise<T>
+	): Promise<T>;
+}

package/lib/definitions/update.d.ts

@@ -0,0 +1,16 @@
+interface IUpdateController {
+	update(updateOptions: IUpdateOptions): Promise<void>;
+	shouldUpdate({
+		projectDir,
+		version,
+	}: {
+		projectDir: string;
+		version?: string;
+	}): Promise<boolean>;
+}
+
+interface IUpdateOptions {
+	projectDir: string;
+	version?: string;
+	frameworkPath?: string;
+}

package/lib/definitions/xcode.d.ts

@@ -0,0 +1,12 @@
+/// <reference path="./nativescript-dev-xcode.d.ts" />
+
+import * as xcode from "nativescript-dev-xcode";
+
+declare global {
+	type IXcode = typeof xcode;
+	export namespace IXcode {
+		export type target = xcode.target;
+		export type project = xcode.project;
+		export interface Options extends xcode.Options {}
+	}
+}

package/lib/detached-processes/cleanup-js-subprocess.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const uuid_1 = require("uuid");
+const file_log_service_1 = require("./file-log-service");
+const yok_1 = require("../common/yok");
+const pathToBootstrap = process.argv[2];
+if (!pathToBootstrap || !fs.existsSync(pathToBootstrap)) {
+    throw new Error("Invalid path to bootstrap.");
+}
+require(pathToBootstrap);
+const logFile = process.argv[3];
+const jsFilePath = process.argv[4];
+const fileLogService = yok_1.injector.resolve(file_log_service_1.FileLogService, {
+    logFile,
+});
+const uniqueId = (0, uuid_1.v4)();
+fileLogService.logData({
+    message: `Initializing Cleanup process for path: ${jsFilePath} Unique id: ${uniqueId}`,
+});
+if (!fs.existsSync(jsFilePath)) {
+    throw new Error(`Unable to find file ${jsFilePath}. Ensure it exists.`);
+}
+let data;
+try {
+    data = process.argv[5] && JSON.parse(process.argv[5]);
+}
+catch (err) {
+    throw new Error(`Unable to parse data from argv ${process.argv[5]}.`);
+}
+const logMessage = (msg, type) => {
+    fileLogService.logData({ message: `[${uniqueId}] ${msg}`, type });
+};
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        logMessage(`Requiring file ${jsFilePath}`);
+        const func = require(jsFilePath);
+        if (func && typeof func === "function") {
+            try {
+                logMessage(`Passing data: ${JSON.stringify(data)} to the default function exported by currently required file ${jsFilePath}`);
+                yield func(data);
+                logMessage(`Finished execution with data: ${JSON.stringify(data)} to the default function exported by currently required file ${jsFilePath}`);
+            }
+            catch (err) {
+                logMessage(`Unable to execute action of file ${jsFilePath} when passed data is ${JSON.stringify(data)}. Error is: ${err}.`, "Error");
+            }
+        }
+    }
+    catch (err) {
+        logMessage(`Unable to require file: ${jsFilePath}. Error is: ${err}.`, "Error");
+    }
+}))();

package/lib/detached-processes/cleanup-process-definitions.d.ts

@@ -0,0 +1,70 @@
+import { IDictionary } from "../common/declarations";
+
+interface ITimeout {
+	/**
+	 * Timeout to execute the action.
+	 */
+	timeout?: number;
+}
+
+interface IFilePath {
+	/**
+	 * Path to file/directory to be deleted or required
+	 */
+	filePath: string;
+}
+
+interface ISpawnCommandInfo extends ITimeout {
+	/**
+	 * Executable to be started.
+	 */
+	command: string;
+
+	/**
+	 * Arguments that will be passed to the child process
+	 */
+	args: string[];
+
+	/**
+	 * Options to be passed to the child process
+	 */
+	options?: any;
+}
+
+interface IRequestInfo extends ITimeout {
+	url: string;
+	method: string;
+	body: any;
+	headers: any;
+}
+
+interface ICleanupMessageBase {
+	/**
+	 * Type of the message
+	 */
+	messageType: CleanupProcessMessage;
+}
+
+interface ISpawnCommandCleanupMessage extends ICleanupMessageBase {
+	/**
+	 * Describes the command that must be executed
+	 */
+	commandInfo: ISpawnCommandInfo;
+}
+
+interface IRequestCleanupMessage extends ICleanupMessageBase {
+	/**
+	 * Describes the request that must be executed
+	 */
+	requestInfo: IRequestInfo;
+}
+
+interface IFileCleanupMessage extends ICleanupMessageBase, IFilePath {}
+
+interface IJSCommand extends ITimeout, IFilePath {
+	data: IDictionary<any>;
+}
+
+interface IJSCleanupMessage extends ICleanupMessageBase {
+	jsCommand: IJSCommand;
+}

package/lib/detached-processes/cleanup-process.js

@@ -0,0 +1,281 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const path = require("path");
+const shelljs = require("shelljs");
+const _ = require("lodash");
+const file_log_service_1 = require("./file-log-service");
+const yok_1 = require("../common/yok");
+const pathToBootstrap = process.argv[2];
+if (!pathToBootstrap || !fs.existsSync(pathToBootstrap)) {
+    throw new Error("Invalid path to bootstrap.");
+}
+const logFile = process.argv[3];
+require(pathToBootstrap);
+const fileLogService = yok_1.injector.resolve(file_log_service_1.FileLogService, {
+    logFile,
+});
+fileLogService.logData({ message: "Initializing Cleanup process." });
+const commandsInfos = [];
+const filesToDelete = [];
+const jsCommands = [];
+const requests = [];
+const executeRequest = (request) => __awaiter(void 0, void 0, void 0, function* () {
+    const $httpClient = yok_1.injector.resolve("httpClient");
+    try {
+        fileLogService.logData({
+            message: `Start executing request: ${request.method} ${request.url}`,
+        });
+        const response = yield $httpClient.httpRequest({
+            url: request.url,
+            method: request.method,
+            headers: request.headers,
+            body: request.body,
+        });
+        const responseStatus = response && response.response && response.response.statusCode;
+        fileLogService.logData({
+            message: `Finished executing request: ${request.method} ${request.url} and got status ${responseStatus}`,
+        });
+    }
+    catch (e) {
+        fileLogService.logData({
+            message: `Unable to execute request: ${request.method} ${request.url}`,
+        });
+    }
+});
+const executeJSCleanup = (jsCommand) => __awaiter(void 0, void 0, void 0, function* () {
+    const $childProcess = yok_1.injector.resolve("childProcess");
+    try {
+        fileLogService.logData({
+            message: `Start executing action for file: ${jsCommand.filePath} and data ${JSON.stringify(jsCommand.data)}`,
+        });
+        yield $childProcess.trySpawnFromCloseEvent(process.execPath, [
+            path.join(__dirname, "cleanup-js-subprocess.js"),
+            pathToBootstrap,
+            logFile,
+            jsCommand.filePath,
+            JSON.stringify(jsCommand.data),
+        ], {}, { throwError: true, timeout: jsCommand.timeout || 3000 });
+        fileLogService.logData({
+            message: `Finished executing action for file: ${jsCommand.filePath} and data ${JSON.stringify(jsCommand.data)}`,
+        });
+    }
+    catch (err) {
+        fileLogService.logData({
+            message: `Unable to execute action for file ${jsCommand.filePath} with data ${JSON.stringify(jsCommand.data)}. Error is: ${err}.`,
+            type: "Error",
+        });
+    }
+});
+const executeCleanup = () => __awaiter(void 0, void 0, void 0, function* () {
+    const $childProcess = yok_1.injector.resolve("childProcess");
+    for (const request of requests) {
+        yield executeRequest(request);
+    }
+    for (const jsCommand of jsCommands) {
+        yield executeJSCleanup(jsCommand);
+    }
+    for (const commandInfo of commandsInfos) {
+        try {
+            fileLogService.logData({
+                message: `Start executing command: ${JSON.stringify(commandInfo)}`,
+            });
+            yield $childProcess.trySpawnFromCloseEvent(commandInfo.command, commandInfo.args, commandInfo.options || {}, { throwError: true, timeout: commandInfo.timeout || 3000 });
+            fileLogService.logData({
+                message: `Successfully executed command: ${JSON.stringify(commandInfo)}`,
+            });
+        }
+        catch (err) {
+            fileLogService.logData({
+                message: `Unable to execute command: ${JSON.stringify(commandInfo)}. Error is: ${err}.`,
+                type: "Error",
+            });
+        }
+    }
+    if (filesToDelete.length) {
+        try {
+            fileLogService.logData({
+                message: `Deleting files ${filesToDelete.join(" ")}`,
+            });
+            shelljs.rm("-Rf", filesToDelete);
+        }
+        catch (err) {
+            fileLogService.logData({
+                message: `Unable to delete files: ${JSON.stringify(filesToDelete)}. Error is: ${err}.`,
+                type: "Error",
+            });
+        }
+    }
+    fileLogService.logData({ message: `cleanup-process finished` });
+    process.exit();
+});
+const addCleanupAction = (commandInfo) => {
+    if (_.some(commandsInfos, (currentCommandInfo) => _.isEqual(currentCommandInfo, commandInfo))) {
+        fileLogService.logData({
+            message: `cleanup-process will not add command for execution as it has been added already: ${JSON.stringify(commandInfo)}`,
+        });
+    }
+    else {
+        fileLogService.logData({
+            message: `cleanup-process added command for execution: ${JSON.stringify(commandInfo)}`,
+        });
+        commandsInfos.push(commandInfo);
+    }
+};
+const removeCleanupAction = (commandInfo) => {
+    if (_.some(commandsInfos, (currentCommandInfo) => _.isEqual(currentCommandInfo, commandInfo))) {
+        _.remove(commandsInfos, (currentCommandInfo) => _.isEqual(currentCommandInfo, commandInfo));
+        fileLogService.logData({
+            message: `cleanup-process removed command for execution: ${JSON.stringify(commandInfo)}`,
+        });
+    }
+    else {
+        fileLogService.logData({
+            message: `cleanup-process cannot remove command for execution as it has not been added before: ${JSON.stringify(commandInfo)}`,
+        });
+    }
+};
+const addRequest = (requestInfo) => {
+    if (_.some(requests, (currentRequestInfo) => _.isEqual(currentRequestInfo, requestInfo))) {
+        fileLogService.logData({
+            message: `cleanup-process will not add request for execution as it has been added already: ${JSON.stringify(requestInfo)}`,
+        });
+    }
+    else {
+        fileLogService.logData({
+            message: `cleanup-process added request for execution: ${JSON.stringify(requestInfo)}`,
+        });
+        requests.push(requestInfo);
+    }
+};
+const removeRequest = (requestInfo) => {
+    if (_.some(requests, (currentRequestInfo) => _.isEqual(currentRequestInfo, currentRequestInfo))) {
+        _.remove(requests, (currentRequestInfo) => _.isEqual(currentRequestInfo, requestInfo));
+        fileLogService.logData({
+            message: `cleanup-process removed request for execution: ${JSON.stringify(requestInfo)}`,
+        });
+    }
+    else {
+        fileLogService.logData({
+            message: `cleanup-process cannot remove request for execution as it has not been added before: ${JSON.stringify(requestInfo)}`,
+        });
+    }
+};
+const addDeleteAction = (filePath) => {
+    const fullPath = path.resolve(filePath);
+    if (_.some(filesToDelete, (f) => f === fullPath)) {
+        fileLogService.logData({
+            message: `cleanup-process will not add ${fullPath} for deletion as it has been added already`,
+        });
+    }
+    else {
+        filesToDelete.push(fullPath);
+        fileLogService.logData({
+            message: `cleanup-process added ${fullPath} for deletion`,
+        });
+    }
+};
+const removeDeleteAction = (filePath) => {
+    const fullPath = path.resolve(filePath);
+    if (_.some(filesToDelete, (f) => f === fullPath)) {
+        _.remove(filesToDelete, (f) => f === fullPath);
+        fileLogService.logData({
+            message: `cleanup-process removed ${fullPath} from the list of files for deletion.`,
+        });
+    }
+    else {
+        fileLogService.logData({
+            message: `cleanup-process cannot remove ${fullPath} for deletion as no such entry is found in the files marked for deletion`,
+        });
+    }
+};
+const addJSFile = (jsCommand) => {
+    const fullPath = path.resolve(jsCommand.filePath);
+    jsCommand.filePath = fullPath;
+    if (_.some(jsCommands, (currentJSCommand) => _.isEqual(currentJSCommand, jsCommand))) {
+        fileLogService.logData({
+            message: `cleanup-process will not add JS file for execution as it has been added already: ${JSON.stringify(jsCommand)}`,
+        });
+    }
+    else {
+        fileLogService.logData({
+            message: `cleanup-process added JS file for execution: ${JSON.stringify(jsCommand)}`,
+        });
+        jsCommands.push(jsCommand);
+    }
+};
+const removeJSFile = (jsCommand) => {
+    const fullPath = path.resolve(jsCommand.filePath);
+    jsCommand.filePath = fullPath;
+    if (_.some(jsCommands, (currentJSCommand) => _.isEqual(currentJSCommand, jsCommand))) {
+        _.remove(jsCommands, (currentJSCommand) => _.isEqual(currentJSCommand, jsCommand));
+        fileLogService.logData({
+            message: `cleanup-process removed JS action for execution: ${JSON.stringify(jsCommand)}`,
+        });
+    }
+    else {
+        fileLogService.logData({
+            message: `cleanup-process cannot remove JS action for execution as it has not been added before: ${JSON.stringify(jsCommand)}`,
+        });
+    }
+};
+process.on("message", (cleanupProcessMessage) => __awaiter(void 0, void 0, void 0, function* () {
+    fileLogService.logData({
+        message: `cleanup-process received message of type: ${JSON.stringify(cleanupProcessMessage)}`,
+    });
+    switch (cleanupProcessMessage.messageType) {
+        case "AddCleanCommand":
+            addCleanupAction(cleanupProcessMessage.commandInfo);
+            break;
+        case "RemoveCleanCommand":
+            removeCleanupAction(cleanupProcessMessage.commandInfo);
+            break;
+        case "AddRequest":
+            addRequest(cleanupProcessMessage.requestInfo);
+            break;
+        case "RemoveRequest":
+            removeRequest(cleanupProcessMessage.requestInfo);
+            break;
+        case "AddDeleteFileAction":
+            addDeleteAction(cleanupProcessMessage.filePath);
+            break;
+        case "RemoveDeleteFileAction":
+            removeDeleteAction(cleanupProcessMessage.filePath);
+            break;
+        case "AddJSFileToRequire":
+            const jsCleanupMessage = cleanupProcessMessage;
+            addJSFile(jsCleanupMessage.jsCommand);
+            break;
+        case "RemoveJSFileToRequire":
+            const msgToRemove = cleanupProcessMessage;
+            removeJSFile(msgToRemove.jsCommand);
+            break;
+        default:
+            fileLogService.logData({
+                message: `Unable to handle message of type ${cleanupProcessMessage.messageType}. Full message is ${JSON.stringify(cleanupProcessMessage)}`,
+                type: "Error",
+            });
+            break;
+    }
+}));
+process.on("disconnect", () => __awaiter(void 0, void 0, void 0, function* () {
+    fileLogService.logData({
+        message: "cleanup-process received process.disconnect event",
+    });
+    yield executeCleanup();
+    yok_1.injector.dispose();
+    process.exit();
+}));
+fileLogService.logData({
+    message: `cleanup-process will send ${"ProcessReadyToReceive"} message`,
+});
+process.send("ProcessReadyToReceive");

package/lib/detached-processes/detached-process-enums.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Defines messages used in communication between CLI's process and analytics subprocesses.
+ */
+declare const enum DetachedProcessMessages {
+	/**
+	 * The detached process is initialized and is ready to receive information for tracking.
+	 */
+	ProcessReadyToReceive = "ProcessReadyToReceive",
+
+	/**
+	 * The detached process finished its tasks and will now exit.
+	 */
+	ProcessFinishedTasks = "ProcessFinishedTasks",
+}
+
+/**
+ * Defines the type of the messages that should be written in the local analyitcs log file (in case such is specified).
+ */
+declare const enum FileLogMessageType {
+	/**
+	 * Information message. This is the default value in case type is not specified.
+	 */
+	Info = "Info",
+
+	/**
+	 * Error message - used to indicate that some action did not succeed.
+	 */
+	Error = "Error",
+}
+
+declare const enum CleanupProcessMessage {
+	/**
+	 * This type of message defines that cleanup procedure should execute specific command.
+	 */
+	AddCleanCommand = "AddCleanCommand",
+
+	/**
+	 * This type of message defines that cleanup procedure should not execute previously defined cleanup command.
+	 */
+	RemoveCleanCommand = "RemoveCleanCommand",
+	/**
+	 * This type of message defines that cleanup procedure should execute specific request.
+	 */
+	AddRequest = "AddRequest",
+
+	/**
+	 * This type of message defines that cleanup procedure should not execute previously defined request.
+	 */
+	RemoveRequest = "RemoveRequest",
+
+	/**
+	 * This type of message defines that cleanup procedure should delete specified files.
+	 */
+	AddDeleteFileAction = "AddDeleteFileAction",
+
+	/**
+	 * This type of message defines that the cleanup procedure should not delete previously specified file.
+	 */
+	RemoveDeleteFileAction = "RemoveDeleteFileAction",
+
+	/**
+	 * This type of message defines that the cleanup procedure will require the specified JS file, which should execute some action.
+	 */
+	AddJSFileToRequire = "AddJSFileToRequire",
+
+	/**
+	 * This type of message defines that the cleanup procedure will not require the previously specified JS file.
+	 */
+	RemoveJSFileToRequire = "RemoveJSFileToRequire",
+}

package/lib/detached-processes/file-log-service.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileLogService = void 0;
+const os_1 = require("os");
+const helpers_1 = require("../common/helpers");
+class FileLogService {
+    constructor($fs, logFile) {
+        this.$fs = $fs;
+        this.logFile = logFile;
+    }
+    logData(fileLoggingMessage) {
+        if (this.logFile && fileLoggingMessage && fileLoggingMessage.message) {
+            fileLoggingMessage.type =
+                fileLoggingMessage.type || "Info";
+            const formattedDate = (0, helpers_1.getFixedLengthDateString)();
+            this.$fs.appendFile(this.logFile, `[${formattedDate}] [${fileLoggingMessage.type}] ${fileLoggingMessage.message}${os_1.EOL}`);
+        }
+    }
+}
+exports.FileLogService = FileLogService;