@aneuhold/core-ts-lib 1.0.17 → 1.1.3

package/lib/index.d.ts

@@ -1,17 +1,10 @@
 import datesAreOnSameDay from './helperFunctions/dateFunctions';
 import sleep from './helperFunctions/sleep';
-import ChromeService from './services/applications/ChromeService';
-import DockerService from './services/applications/DockerService';
-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 DependencyService from './services/DependencyService';
 import DOFunctionService, { DOFunction } from './services/DOFunctionService/DOFunctionService';
 import { DOAuthCheckPasswordInput, DOAuthCheckPasswordOutput, DOAuthCheckPasswordRawOutput } from './services/DOFunctionService/functionsInfo/authCheckPassword';
 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, ITermService, ConfigService, DOFunctionService, DependencyService };
-export type { DOAuthCheckPasswordRawOutput, DOAuthCheckPasswordInput, DOAuthCheckPasswordOutput, DOFunction };
+export { datesAreOnSameDay, DependencyService, DOFunctionService, Logger, sleep, StringService };
+export type { DOAuthCheckPasswordInput, DOAuthCheckPasswordOutput, DOAuthCheckPasswordRawOutput, DOFunction };
 //# 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,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,iBAAiB,EAAE,EACxB,UAAU,EACX,MAAM,gDAAgD,CAAC;AACxD,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EACzB,4BAA4B,EAC7B,MAAM,8DAA8D,CAAC;AACtE,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,EACjB,iBAAiB,EAClB,CAAC;AAGF,YAAY,EACV,4BAA4B,EAC5B,wBAAwB,EACxB,yBAAyB,EACzB,UAAU,EACX,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,iBAAiB,MAAM,8BAA8B,CAAC;AAC7D,OAAO,iBAAiB,EAAE,EACxB,UAAU,EACX,MAAM,gDAAgD,CAAC;AACxD,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EACzB,4BAA4B,EAC7B,MAAM,8DAA8D,CAAC;AACtE,OAAO,aAAa,MAAM,0BAA0B,CAAC;AACrD,OAAO,MAAM,MAAM,gBAAgB,CAAC;AAGpC,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,MAAM,EACN,KAAK,EACL,aAAa,EACd,CAAC;AAGF,YAAY,EACV,wBAAwB,EACxB,yBAAyB,EACzB,4BAA4B,EAC5B,UAAU,EACX,CAAC"}

package/lib/index.js

@@ -1,58 +1,18 @@
 "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 });
-exports.DependencyService = 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;
+exports.StringService = exports.sleep = exports.Logger = exports.DOFunctionService = exports.DependencyService = exports.datesAreOnSameDay = 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 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/FileSystemService"));
-exports.FileSystemService = FileSystemService_1.default;
-const ITermService_1 = __importDefault(require("./services/applications/ITermService"));
-exports.ITermService = ITermService_1.default;
-const CLIService_1 = __importDefault(require("./services/CLIService"));
-exports.CLIService = CLIService_1.default;
-const ConfigService_1 = __importDefault(require("./services/ConfigService/ConfigService"));
-exports.ConfigService = ConfigService_1.default;
 const DependencyService_1 = __importDefault(require("./services/DependencyService"));
 exports.DependencyService = DependencyService_1.default;
 const DOFunctionService_1 = __importDefault(require("./services/DOFunctionService/DOFunctionService"));
 exports.DOFunctionService = DOFunctionService_1.default;
 const StringService_1 = __importDefault(require("./services/StringService"));
 exports.StringService = StringService_1.default;
-const CurrentEnv_1 = __importStar(require("./utils/CurrentEnv"));
-exports.CurrentEnv = CurrentEnv_1.default;
-Object.defineProperty(exports, "OperatingSystemType", { enumerable: true, get: function () { return CurrentEnv_1.OperatingSystemType; } });
-Object.defineProperty(exports, "ShellType", { enumerable: true, get: function () { return CurrentEnv_1.ShellType; } });
-Object.defineProperty(exports, "TerminalType", { enumerable: true, get: function () { return CurrentEnv_1.TerminalType; } });
 const Logger_1 = __importDefault(require("./utils/Logger"));
 exports.Logger = Logger_1.default;

package/lib/services/DependencyService.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const promises_1 = require("fs/promises");
 const path_1 = __importDefault(require("path"));
-const FileSystemService_1 = __importDefault(require("./applications/FileSystemService/FileSystemService"));
+const FileSystemService_1 = __importDefault(require("./FileSystemService/FileSystemService"));
 /**
  * A service which can be used to manage dependencies in the current project
  * in various ways.

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

@@ -0,0 +1,42 @@
+/**
+ * A service which can be used to interact with the file system, only in build
+ * steps.
+ */
+export default class FileSystemService {
+    /**
+     * 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[]>;
+}
+//# sourceMappingURL=FileSystemService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileSystemService.d.ts","sourceRoot":"","sources":["../../../src/services/FileSystemService/FileSystemService.ts"],"names":[],"mappings":"AAeA;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,iBAAiB;IACpC;;;;;;;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;CAMzE"}

package/lib/services/FileSystemService/FileSystemService.js

@@ -0,0 +1,128 @@
+"use strict";
+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 Logger_1 = __importDefault(require("../../utils/Logger"));
+const StringService_1 = __importDefault(require("../StringService"));
+/**
+ * A service which can be used to interact with the file system, only in build
+ * steps.
+ */
+class FileSystemService {
+    /**
+     * 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, '');
+        });
+    }
+}
+exports.default = FileSystemService;

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

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

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

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

package/lib/services/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.17",
+  "version": "1.1.3",
   "description": "A core library for all of my TypeScript projects",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -31,11 +31,6 @@
   "files": [
     "lib/**/*"
   ],
-  "dependencies": {
-    "dotenv": "^16.3.1",
-    "node-fetch": "^2",
-    "octokit": "^3.1.2"
-  },
   "devDependencies": {
     "@types/jest": "^29.5.8",
     "@types/node": "^18.15.0",