@aneuhold/core-ts-lib 1.0.13 → 1.0.14

package/lib/index.d.ts

@@ -1,15 +1,14 @@
 import datesAreOnSameDay from './helperFunctions/dateFunctions';
 import sleep from './helperFunctions/sleep';
-import getFileNameExtension from './helperFunctions/stringFunctions';
 import ChromeService from './services/applications/ChromeService';
 import DockerService from './services/applications/DockerService';
-import FileSystemService from './services/applications/FileSystemService';
+import FileSystemService from './services/applications/FileSystemService/FileSystemService';
 import ITermService from './services/applications/ITermService';
 import CLIService from './services/CLIService';
 import ConfigService from './services/ConfigService/ConfigService';
-import DOFunctionService, { DOFunctionOutput } from './services/DOFunctionService';
+import DOFunctionService from './services/DOFunctionService';
 import StringService from './services/StringService';
 import CurrentEnv, { OperatingSystemType, ShellType, TerminalType } from './utils/CurrentEnv';
 import Logger from './utils/Logger';
-export { CLIService, StringService, CurrentEnv, ChromeService, DockerService, FileSystemService, sleep, OperatingSystemType, ShellType, Logger, TerminalType, datesAreOnSameDay, getFileNameExtension, ITermService, ConfigService, DOFunctionService, DOFunctionOutput };
+export { CLIService, StringService, CurrentEnv, ChromeService, DockerService, FileSystemService, sleep, OperatingSystemType, ShellType, Logger, TerminalType, datesAreOnSameDay, ITermService, ConfigService, DOFunctionService };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,iBAAiB,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,MAAM,yBAAyB,CAAC;AAC5C,OAAO,oBAAoB,MAAM,mCAAmC,CAAC;AACrE,OAAO,aAAa,MAAM,uCAAuC,CAAC;AAClE,OAAO,aAAa,MAAM,uCAAuC,CAAC;AAClE,OAAO,iBAAiB,MAAM,2CAA2C,CAAC;AAC1E,OAAO,YAAY,MAAM,sCAAsC,CAAC;AAChE,OAAO,UAAU,MAAM,uBAAuB,CAAC;AAC/C,OAAO,aAAa,MAAM,wCAAwC,CAAC;AACnE,OAAO,iBAAiB,EAAE,EACxB,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,aAAa,MAAM,0BAA0B,CAAC;AACrD,OAAO,UAAU,EAAE,EACjB,mBAAmB,EACnB,SAAS,EACT,YAAY,EACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,MAAM,MAAM,gBAAgB,CAAC;AAGpC,OAAO,EACL,UAAU,EACV,aAAa,EACb,UAAU,EACV,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,KAAK,EACL,mBAAmB,EACnB,SAAS,EACT,MAAM,EACN,YAAY,EACZ,iBAAiB,EACjB,oBAAoB,EACpB,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EACjB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,iBAAiB,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,MAAM,yBAAyB,CAAC;AAC5C,OAAO,aAAa,MAAM,uCAAuC,CAAC;AAClE,OAAO,aAAa,MAAM,uCAAuC,CAAC;AAClE,OAAO,iBAAiB,MAAM,6DAA6D,CAAC;AAC5F,OAAO,YAAY,MAAM,sCAAsC,CAAC;AAChE,OAAO,UAAU,MAAM,uBAAuB,CAAC;AAC/C,OAAO,aAAa,MAAM,wCAAwC,CAAC;AACnE,OAAO,iBAAiB,MAAM,8BAA8B,CAAC;AAC7D,OAAO,aAAa,MAAM,0BAA0B,CAAC;AACrD,OAAO,UAAU,EAAE,EACjB,mBAAmB,EACnB,SAAS,EACT,YAAY,EACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,MAAM,MAAM,gBAAgB,CAAC;AAGpC,OAAO,EACL,UAAU,EACV,aAAa,EACb,UAAU,EACV,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,KAAK,EACL,mBAAmB,EACnB,SAAS,EACT,MAAM,EACN,YAAY,EACZ,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,iBAAiB,EAClB,CAAC"}

package/lib/index.js

@@ -26,18 +26,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DOFunctionService = exports.ConfigService = exports.ITermService = exports.getFileNameExtension = exports.datesAreOnSameDay = exports.TerminalType = exports.Logger = exports.ShellType = exports.OperatingSystemType = exports.sleep = exports.FileSystemService = exports.DockerService = exports.ChromeService = exports.CurrentEnv = exports.StringService = exports.CLIService = void 0;
+exports.DOFunctionService = exports.ConfigService = exports.ITermService = exports.datesAreOnSameDay = exports.TerminalType = exports.Logger = exports.ShellType = exports.OperatingSystemType = exports.sleep = exports.FileSystemService = exports.DockerService = exports.ChromeService = exports.CurrentEnv = exports.StringService = exports.CLIService = void 0;
 const dateFunctions_1 = __importDefault(require("./helperFunctions/dateFunctions"));
 exports.datesAreOnSameDay = dateFunctions_1.default;
 const sleep_1 = __importDefault(require("./helperFunctions/sleep"));
 exports.sleep = sleep_1.default;
-const stringFunctions_1 = __importDefault(require("./helperFunctions/stringFunctions"));
-exports.getFileNameExtension = stringFunctions_1.default;
 const ChromeService_1 = __importDefault(require("./services/applications/ChromeService"));
 exports.ChromeService = ChromeService_1.default;
 const DockerService_1 = __importDefault(require("./services/applications/DockerService"));
 exports.DockerService = DockerService_1.default;
-const FileSystemService_1 = __importDefault(require("./services/applications/FileSystemService"));
+const FileSystemService_1 = __importDefault(require("./services/applications/FileSystemService/FileSystemService"));
 exports.FileSystemService = FileSystemService_1.default;
 const ITermService_1 = __importDefault(require("./services/applications/ITermService"));
 exports.ITermService = ITermService_1.default;

package/lib/services/ConfigService/ConfigService.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ConfigService.spec.d.ts.map

package/lib/services/ConfigService/ConfigService.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigService.spec.d.ts","sourceRoot":"","sources":["../../../src/services/ConfigService/ConfigService.spec.ts"],"names":[],"mappings":""}

package/lib/services/ConfigService/ConfigService.spec.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const console_1 = require("console");
+const ConfigService_1 = __importDefault(require("./ConfigService"));
+const TestUtils_1 = __importDefault(require("../../utils/TestUtils"));
+describe('ConfigService', () => {
+    describe('useConfig', () => {
+        /**
+         * Depends upon a GitHub token being available in the local environment.
+         * This will be a local `.env` file with the CONFIG_GITHUB_TOKEN variable
+         * set.
+         */
+        it('should load configuration from GitHub', async () => {
+            const env = 'local';
+            await ConfigService_1.default.useConfig(env);
+            (0, console_1.assert)(process.env.SOME_KEY === 'SOME_VALUE');
+        });
+        it('should throw an error when loading configuration fails', async () => {
+            const env = 'invalid_env';
+            TestUtils_1.default.suppressConsole();
+            await expect(ConfigService_1.default.useConfig(env)).rejects.toThrow();
+            TestUtils_1.default.restoreConsole();
+        });
+    });
+});

package/lib/services/DOFunctionService.d.ts

@@ -1,13 +1,3 @@
-/**
- * Output from a Digital Ocean function must always be an object.
- */
-export type DOFunctionOutput<TOutput extends object> = {
-    /**
-     * The body is an object, which means it will automatically be serialized to
-     * JSON and the Content-Type header will be set to application/json.
-     */
-    body: TOutput;
-};
 /**
  * A service to provide some utility common to multiple Digital Ocean functions.
  */

package/lib/services/DOFunctionService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DOFunctionService.d.ts","sourceRoot":"","sources":["../../src/services/DOFunctionService.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,OAAO,SAAS,MAAM,IAAI;IACrD;;;OAGG;IACH,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,iBAAiB;CAAG"}
+{"version":3,"file":"DOFunctionService.d.ts","sourceRoot":"","sources":["../../src/services/DOFunctionService.ts"],"names":[],"mappings":"AAWA;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,iBAAiB;CAAG"}

package/lib/services/applications/FileSystemService/FileSystemService.d.ts

@@ -0,0 +1,45 @@
+/**
+ * A service which can be used to interact with the file system application on
+ * the current system.
+ */
+export default class FileSystemService {
+    static openNugetCache(): Promise<void>;
+    /**
+     * Tries to add the provided snippet of text to the path provided. If the file
+     * doesn't exist, it creates it. If the folders to the file don't exist, it
+     * creates those. If the text already exists in the file, it does nothing.
+     *
+     * @param folderPath the path to the folder which contains the file that should
+     * be updated
+     */
+    static findAndInsertText(folderPath: string, fileName: string, textToInsert: string): Promise<void>;
+    /**
+     * Copies the contents of one folder to another folder.
+     *
+     * @param ignoreExtensions is an array with extensions that should be
+     * ignored. For example, if you want to ignore all .ts files, you would pass
+     * in ['ts'].
+     */
+    static copyFolderContents(sourceFolderPath: string, targetFolderPath: string, ignoreExtensions?: string[]): Promise<void>;
+    static checkOrCreateFolder(folderPath: string): Promise<void>;
+    static deleteFolder(folderPath: string): Promise<void>;
+    /**
+     * Gets all the file paths in the directory provided, including all
+     * subdirectories, as an array of strings. The returned result will include
+     * the directory path provided.
+     *
+     * If only relative file paths are needed, use {@link getAllFilePathsRelative}.
+     */
+    static getAllFilePaths(dirPath: string): Promise<string[]>;
+    /**
+     * Gets all the file paths in the directory provided, including all
+     * subdirectories, as an array of strings. The returned result will not
+     * include the directory path provided.
+     *
+     * If absolute file paths are needed, use {@link getAllFilePaths}.
+     */
+    static getAllFilePathsRelative(dirPath: string): Promise<string[]>;
+    private static openWindowsNugetCache;
+    private static openMacNugetCache;
+}
+//# sourceMappingURL=FileSystemService.d.ts.map

package/lib/services/applications/FileSystemService/FileSystemService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileSystemService.d.ts","sourceRoot":"","sources":["../../../../src/services/applications/FileSystemService/FileSystemService.ts"],"names":[],"mappings":"AAiBA;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,iBAAiB;WACvB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAY5C;;;;;;;OAOG;WACU,iBAAiB,CAC5B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC;IAsBhB;;;;;;OAMG;WACU,kBAAkB,CAC7B,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,CAAC,EAAE,MAAM,EAAE,GAC1B,OAAO,CAAC,IAAI,CAAC;WAoCH,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAWtD,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAU5D;;;;;;OAMG;WACU,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAoBhE;;;;;;OAMG;WACU,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;mBAOnD,qBAAqB;mBAOrB,iBAAiB;CAMvC"}

package/lib/services/applications/FileSystemService/FileSystemService.js

@@ -0,0 +1,176 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+const CurrentEnv_1 = __importStar(require("../../../utils/CurrentEnv"));
+const Logger_1 = __importDefault(require("../../../utils/Logger"));
+const CLIService_1 = __importDefault(require("../../CLIService"));
+const StringService_1 = __importDefault(require("../../StringService"));
+/**
+ * A service which can be used to interact with the file system application on
+ * the current system.
+ */
+class FileSystemService {
+    static async openNugetCache() {
+        if (CurrentEnv_1.default.os === CurrentEnv_1.OperatingSystemType.Windows) {
+            await FileSystemService.openWindowsNugetCache();
+            return;
+        }
+        if (CurrentEnv_1.default.os === CurrentEnv_1.OperatingSystemType.MacOSX) {
+            await FileSystemService.openMacNugetCache();
+            return;
+        }
+        Logger_1.default.error('Not implemented for this OS yet.');
+    }
+    /**
+     * Tries to add the provided snippet of text to the path provided. If the file
+     * doesn't exist, it creates it. If the folders to the file don't exist, it
+     * creates those. If the text already exists in the file, it does nothing.
+     *
+     * @param folderPath the path to the folder which contains the file that should
+     * be updated
+     */
+    static async findAndInsertText(folderPath, fileName, textToInsert) {
+        const filePath = path_1.default.join(folderPath, fileName);
+        await FileSystemService.checkOrCreateFolder(folderPath);
+        try {
+            await (0, promises_1.access)(filePath);
+            const fileContents = await (0, promises_1.readFile)(filePath);
+            if (!fileContents.includes(textToInsert)) {
+                await (0, promises_1.appendFile)(filePath, `\n${textToInsert}`);
+                Logger_1.default.info(`Added "${textToInsert}" to "${filePath}"`);
+            }
+            else {
+                Logger_1.default.info(`"${textToInsert}" already exists in "${filePath}"`);
+            }
+        }
+        catch {
+            Logger_1.default.info(`File at "${filePath}" didn't exist. Creating it now and adding "${textToInsert}" to it.`);
+            await (0, promises_1.writeFile)(filePath, textToInsert);
+        }
+    }
+    /**
+     * Copies the contents of one folder to another folder.
+     *
+     * @param ignoreExtensions is an array with extensions that should be
+     * ignored. For example, if you want to ignore all .ts files, you would pass
+     * in ['ts'].
+     */
+    static async copyFolderContents(sourceFolderPath, targetFolderPath, ignoreExtensions) {
+        // Check if the source directory exists first
+        try {
+            await (0, promises_1.access)(sourceFolderPath);
+        }
+        catch {
+            Logger_1.default.error(`Source directory "${sourceFolderPath}" does not exist.`);
+            return;
+        }
+        await FileSystemService.checkOrCreateFolder(targetFolderPath);
+        // Get the files in the source directory
+        const sourceFilePaths = await FileSystemService.getAllFilePathsRelative(sourceFolderPath);
+        // console.log(sourceFilePaths);
+        await Promise.all(sourceFilePaths.map(async (sourceFilePath) => {
+            const sourceFile = path_1.default.join(sourceFolderPath, sourceFilePath);
+            const targetFile = path_1.default.join(targetFolderPath, sourceFilePath);
+            const sourceFileExtension = StringService_1.default.getFileNameExtension(sourceFile);
+            if (sourceFileExtension &&
+                ignoreExtensions?.includes(sourceFileExtension)) {
+                return;
+            }
+            await (0, promises_1.cp)(sourceFile, targetFile, { recursive: true });
+        }));
+    }
+    static async checkOrCreateFolder(folderPath) {
+        try {
+            await (0, promises_1.access)(folderPath);
+        }
+        catch {
+            Logger_1.default.verbose.info(`Directory "${folderPath}" does not exist. Creating it now...`);
+            await (0, promises_1.mkdir)(folderPath, { recursive: true });
+        }
+    }
+    static async deleteFolder(folderPath) {
+        try {
+            await (0, promises_1.access)(folderPath);
+        }
+        catch {
+            Logger_1.default.error(`Directory "${folderPath}" does not exist.`);
+            return;
+        }
+        await (0, promises_1.rm)(folderPath, { recursive: true });
+    }
+    /**
+     * Gets all the file paths in the directory provided, including all
+     * subdirectories, as an array of strings. The returned result will include
+     * the directory path provided.
+     *
+     * If only relative file paths are needed, use {@link getAllFilePathsRelative}.
+     */
+    static async getAllFilePaths(dirPath) {
+        const filePaths = [];
+        const fileOrFolderNames = await (0, promises_1.readdir)(dirPath);
+        await Promise.all(fileOrFolderNames.map(async (fileOrFolder) => {
+            const absolutePath = path_1.default.join(dirPath, fileOrFolder);
+            const fileStat = await (0, promises_1.stat)(absolutePath);
+            if (fileStat.isDirectory()) {
+                filePaths.push(...(await this.getAllFilePaths(absolutePath)));
+            }
+            else {
+                filePaths.push(absolutePath);
+            }
+        }));
+        return filePaths;
+    }
+    /**
+     * Gets all the file paths in the directory provided, including all
+     * subdirectories, as an array of strings. The returned result will not
+     * include the directory path provided.
+     *
+     * If absolute file paths are needed, use {@link getAllFilePaths}.
+     */
+    static async getAllFilePathsRelative(dirPath) {
+        const filePaths = await this.getAllFilePaths(dirPath);
+        return filePaths.map((filePath) => {
+            return filePath.replace(dirPath, '');
+        });
+    }
+    static async openWindowsNugetCache() {
+        await Promise.all([
+            CLIService_1.default.execCmd(`ii $HOME/localNuget`),
+            CLIService_1.default.execCmd(`ii $HOME/.nuget/packages`)
+        ]);
+    }
+    static async openMacNugetCache() {
+        await Promise.all([
+            CLIService_1.default.execCmd(`open $HOME/localNuget`),
+            CLIService_1.default.execCmd(`open $HOME/.nuget/packages`)
+        ]);
+    }
+}
+exports.default = FileSystemService;

package/lib/services/applications/FileSystemService/FileSystemService.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=FileSystemService.spec.d.ts.map

package/lib/services/applications/FileSystemService/FileSystemService.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileSystemService.spec.d.ts","sourceRoot":"","sources":["../../../../src/services/applications/FileSystemService/FileSystemService.spec.ts"],"names":[],"mappings":""}

package/lib/services/applications/FileSystemService/FileSystemService.spec.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const promises_1 = require("fs/promises");
+const FileSystemService_1 = __importDefault(require("./FileSystemService"));
+const TEST_FOLDER_NAME = '__fileSystemService-tests__';
+describe('FileSystemService', () => {
+    afterAll(async () => {
+        await deleteTestFolder();
+    });
+    describe('copyFolderContents', () => {
+        it('should successfully copy all contents when target folder doesnt exist', async () => {
+            // Make a test folder with a folder and a couple files in it
+            const testName = 'copyFolderContents-1';
+            const sourceFolderName = `${testName}-source`;
+            const sourceFolderPath = await createTestFolder(sourceFolderName);
+            await createTestFiles(sourceFolderPath, {
+                'file1.txt': 'test text',
+                'file2.txt': 'test text',
+                subFolder: {
+                    'subFile1.txt': 'sub test text',
+                    'subFile2.txt': 'sub test text'
+                }
+            });
+            const targetFolderPath = path_1.default.join(TEST_FOLDER_NAME, `${testName}-target`);
+            // Execute
+            await FileSystemService_1.default.copyFolderContents(sourceFolderPath, targetFolderPath);
+            // Assert
+            const expectedContents = await FileSystemService_1.default.getAllFilePathsRelative(sourceFolderPath);
+            const actualContents = await FileSystemService_1.default.getAllFilePathsRelative(targetFolderPath);
+            expect(actualContents).toEqual(expectedContents);
+        });
+        it('should successfully copy only files that arent ignored', async () => {
+            // Make a test folder with a folder and a couple files in it
+            const testName = 'copyFolderContents-2';
+            const sourceFolderName = `${testName}-source`;
+            const sourceFolderPath = await createTestFolder(sourceFolderName);
+            await createTestFiles(sourceFolderPath, {
+                'file1.txt': 'test text',
+                'file2.txt': 'test text',
+                subFolder: {
+                    'subFile1.txt': 'sub test text',
+                    'subFile2.txt': 'sub test text'
+                },
+                javascript: {
+                    'file1.js': 'test text',
+                    'file2.js': 'test text'
+                },
+                typescript: {
+                    'file1.ts': 'test text',
+                    'file2.ts': 'test text'
+                }
+            });
+            const targetFolderPath = path_1.default.join(TEST_FOLDER_NAME, `${testName}-target`);
+            // Execute
+            await FileSystemService_1.default.copyFolderContents(sourceFolderPath, targetFolderPath, ['ts']);
+            // Assert
+            const expectedContents = (await FileSystemService_1.default.getAllFilePathsRelative(sourceFolderPath)).filter((sourceFilePath) => !sourceFilePath.endsWith('.ts'));
+            const actualContents = await FileSystemService_1.default.getAllFilePathsRelative(targetFolderPath);
+            expect(actualContents).toEqual(expectedContents);
+        });
+    });
+});
+async function createTestFiles(folderPath, fileStructure) {
+    await FileSystemService_1.default.checkOrCreateFolder(folderPath);
+    await Promise.all(Object.entries(fileStructure).map(async ([key, value]) => {
+        if (typeof value === 'string') {
+            await (0, promises_1.writeFile)(path_1.default.join(folderPath, key), value);
+        }
+        else if (typeof value === 'object') {
+            await createTestFiles(path_1.default.join(folderPath, key), value);
+        }
+    }));
+}
+async function createTestFolder(folderName) {
+    const testFolderPath = path_1.default.join(TEST_FOLDER_NAME, folderName);
+    await FileSystemService_1.default.checkOrCreateFolder(testFolderPath);
+    return testFolderPath;
+}
+async function deleteTestFolder() {
+    await FileSystemService_1.default.deleteFolder(TEST_FOLDER_NAME);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aneuhold/core-ts-lib",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "A core library for all of my TypeScript projects",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",