@yamato-daiwa/es-extensions-nodejs 0.0.2 → 0.10.0-alpha.0

package/Distributable/ConsoleCommandsParser/ConsoleCommandsParserLocalization.english.d.ts

@@ -0,0 +1,4 @@
+import ConsoleCommandsParser from "./ConsoleCommandsParser";
+import Localization = ConsoleCommandsParser.Localization;
+declare const consoleCommandsParserLocalization__english: Localization;
+export default consoleCommandsParserLocalization__english;

package/Distributable/ConsoleCommandsParser/ConsoleCommandsParserLocalization.english.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+const consoleCommandsParserLocalization__english = {
+    helpReference: {
+        defaultCommandPhrase__parenthetical: "(default command phrase)",
+        options: "Options",
+        shortcut: "Shortcut",
+        type: "Type",
+        isRequired: "Is Required",
+        defaultValue: "Default Value",
+        yes: "Yes",
+        no: "No",
+        allowedAlternatives: "Allowed Alternatives",
+        numbersSet: {
+            key: "Numbers Set",
+            generateValue: es_extensions_1.rawObjectDataProcessorLocalization__english.getLocalizedNumbersSet
+        },
+        minimalValue: "Minimal Value",
+        maximalValue: "Maximal Value",
+        objectTypeValuePropertiesSpecification: "Properties Specification"
+    },
+    generateCheckTheCommandReferenceAsking: (commandReference) => `Please check the reference for this command:\n${commandReference}`,
+    errorsMessages: {
+        argumentsVectorIsNotArray: {
+            generate: ({ stringifiedActualValueOfArgumentsVector }) => "Expected that the arguments vector be an array while actually it is not and actually has the value:\n" +
+                stringifiedActualValueOfArgumentsVector
+        },
+        argumentsVectorHasNotEnoughElements: {
+            generate: ({ minimalElementsCountInArgumentsVector, actualElementsCountInArgumentsVector, stringifiedArgumentsVector }) => `The valid arguments vector must be an array of at least ${minimalElementsCountInArgumentsVector} elements ` +
+                `while actually is has ${actualElementsCountInArgumentsVector} elements and value:\n` +
+                stringifiedArgumentsVector
+        },
+        argumentsVectorHasNonStringElements: {
+            generate: ({ stringifiedFormattedNonStringArguments }) => "The valid arguments vector must be an array of the strings while below arguments are not strings:\n" +
+                stringifiedFormattedNonStringArguments
+        },
+        moreThanOneCommandPhrasesMarkedAsDefault: {
+            generate: ({ formattedListOfCommandsPhrasesMarkedAsDefault }) => "More than one commands phrases has been marked as default. " +
+                "If you are the developer of the this console application, leave the \"default\" flag only on one of below " +
+                "command phrases:\n" +
+                `${formattedListOfCommandsPhrasesMarkedAsDefault}\n` +
+                "If you are the user of this console application, please consider the reporting about this issue to the " +
+                "developers."
+        },
+        noDefaultCommandPhraseAvailable: {
+            generate: (templateVariables) => "This application has no the default command. " +
+                "Please specify explicitly one of mentioned below command phrases.\n" +
+                templateVariables.helpReference
+        },
+        firstParameterLooksLikeCommandPhraseWhileNoCommandPhrasesAvailable: {
+            generate: ({ commandPhraseLikeArgument, helpReference }) => `"${commandPhraseLikeArgument}" seems like the command phrase while there is only the default command available ` +
+                "for this application:\n" +
+                helpReference
+        },
+        unknownCommandPhrase: {
+            generate: ({ inputtedCommandPhrase, helpReference }) => `The command phrase "${inputtedCommandPhrase}" is unknown. ` +
+                "Please input one of below available command phrases:" +
+                `\n${helpReference}`
+        },
+        requiredOptionKeyIsMissing: {
+            generate: ({ missingOptionKey, commandPhrase, isDefaultCommandPhrase, commandHelpReference }) => `The option "${missingOptionKey}" is required for the command "${commandPhrase}"` +
+                `${(0, es_extensions_1.insertSubstringIf)(" (default command phrase)", isDefaultCommandPhrase)}. ` +
+                consoleCommandsParserLocalization__english.generateCheckTheCommandReferenceAsking(commandHelpReference)
+        },
+        noValueFollowingTheKeyOfNonBooleanOption: {
+            generate: ({ targetOptionKey, commandHelpReference }) => `No value following the key "${targetOptionKey}" of non-boolean option has been specified. ` +
+                consoleCommandsParserLocalization__english.generateCheckTheCommandReferenceAsking(commandHelpReference)
+        },
+        invalidCommandOptionTypeAtSpecification: {
+            generate: ({ optionName, typeName }) => "Most likely, it is the bug from the side of the console application. " +
+                `The type "${typeName}" specified for the option "${optionName}" in the console command specification ` +
+                " is invalid. " +
+                "It is possible only when the console application has been written by JavaScript or the TypeScript type checking " +
+                "has been disabled. " +
+                "There is nothing you must to correct; however it is recommended to report about this issue to the developers " +
+                "of this application."
+        },
+        unknownOptionsFoundForSpecificCommand: {
+            generate: ({ commandPhrase, formattedUnknownOptions, commandHelpReference }) => "Below options are unknown for the " +
+                `${(0, es_extensions_1.isNotUndefined)(commandPhrase) ? `command "${commandPhrase}"` : "default command"}:\n` +
+                `${formattedUnknownOptions}\n` +
+                consoleCommandsParserLocalization__english.generateCheckTheCommandReferenceAsking(commandHelpReference)
+        },
+        optionValueIsNotAmongAllowedAlternatives: {
+            generate: ({ targetOptionKey, actualOptionValue, commandHelpReference }) => `The value "${actualOptionValue}" of the option "${targetOptionKey}" is not among allowed alternatives. ` +
+                consoleCommandsParserLocalization__english.generateCheckTheCommandReferenceAsking(commandHelpReference)
+        },
+        unparsableNumericOptionValue: {
+            generate: ({ actualOptionValue, targetOptionKey, commandHelpReference }) => `The value "${actualOptionValue}" of the numeric option "${targetOptionKey}" is not the valid numeric value.\n` +
+                consoleCommandsParserLocalization__english.generateCheckTheCommandReferenceAsking(commandHelpReference)
+        },
+        numericOptionValueIsNotBelongToExpectedNumbersSet: {
+            generate: ({ targetOptionKey, expectedNumbersSet, actualOptionValue, commandHelpReference }) => `The value "${actualOptionValue}" of the numeric option "${targetOptionKey}" is not belong to ` +
+                `"${es_extensions_1.rawObjectDataProcessorLocalization__english.getLocalizedNumbersSet(expectedNumbersSet)}" numbers set.\n` +
+                consoleCommandsParserLocalization__english.generateCheckTheCommandReferenceAsking(commandHelpReference)
+        },
+        numericValueIsSmallerThanRequiredMinimum: {
+            generate: ({ targetOptionKey, requiredMinimum, actualOptionValue, commandHelpReference }) => `The value "${actualOptionValue}" of the numeric option "${targetOptionKey}" is smaller than required ` +
+                `minimal value ${requiredMinimum}.\n` +
+                consoleCommandsParserLocalization__english.generateCheckTheCommandReferenceAsking(commandHelpReference)
+        },
+        numericValueIsGreaterThanAllowedMaximum: {
+            generate: ({ targetOptionKey, allowedMaximum, actualOptionValue, commandHelpReference }) => `The value "${actualOptionValue}" of the numeric option "${targetOptionKey}" is greater that allowed ` +
+                `maximal value ${allowedMaximum}.\n` +
+                consoleCommandsParserLocalization__english.generateCheckTheCommandReferenceAsking(commandHelpReference)
+        },
+        malformedJSON5_Option: {
+            generate: ({ targetOptionKey, commandHelpReference }) => `The value of the option "${targetOptionKey}" is not valid JSON5 string. ` +
+                consoleCommandsParserLocalization__english.generateCheckTheCommandReferenceAsking(commandHelpReference)
+        },
+        JSON5_OptionDoesNotMatchWithValidDataSchema: {
+            generate: ({ targetOptionKey, formattedValidationErrorsMessages }) => `The JSON5-type value of the option "${targetOptionKey}" does not match with valid data schema:\n` +
+                formattedValidationErrorsMessages
+        }
+    }
+};
+exports.default = consoleCommandsParserLocalization__english;

package/Distributable/DateTime/NodeJS_Timer.d.ts

@@ -1,7 +1,21 @@
-import { Timer } from "@yamato-daiwa/es-extensions";
-export default class NodeJS_Timer extends Timer {
-    private timeout;
-    start(): void;
-    stop(): void;
-    restart(): void;
-}
+import { Timer } from "@yamato-daiwa/es-extensions";
+export default class NodeJS_Timer extends Timer {
+    #private;
+    constructor(compoundParameter: Readonly<{
+        period__seconds: number;
+        onElapsed?: (outcome: Timer.Outcomes) => void;
+    }>);
+    countDown(compoundParameter?: Readonly<{
+        asynchronousCompletion?: Timer.AsynchronousCompletions.promise;
+    }>): Promise<Timer.Outcomes>;
+    countDown(compoundParameter: Readonly<{
+        asynchronousCompletion: Timer.AsynchronousCompletions.callback;
+    }>): void;
+    resetAndRestart(compoundParameter?: Readonly<{
+        asynchronousCompletion: Timer.AsynchronousCompletions.promise;
+    }>): Promise<Timer.Outcomes>;
+    resetAndRestart(compoundParameter: Readonly<{
+        asynchronousCompletion: Timer.AsynchronousCompletions.callback;
+    }>): void;
+    get isActive(): boolean;
+}

package/Distributable/DateTime/NodeJS_Timer.js

@@ -1,13 +1,61 @@
-import { Timer, secondsToMilliseconds } from "@yamato-daiwa/es-extensions";
-export default class NodeJS_Timer extends Timer {
-    start() {
-        this.timeout = setTimeout(this.onElapsed.bind(this), secondsToMilliseconds(this.period__seconds));
-    }
-    stop() {
-        clearTimeout(this.timeout);
-    }
-    restart() {
-        this.stop();
-        this.start();
-    }
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+class NodeJS_Timer extends es_extensions_1.Timer {
+    #nativeTimeout;
+    #secondsLeft = this.period__seconds;
+    #isActive = false;
+    constructor(compoundParameter) {
+        super(compoundParameter);
+    }
+    countDown({ asynchronousCompletion = es_extensions_1.Timer.AsynchronousCompletions.promise } = {}) {
+        if (this.isActive) {
+            return;
+        }
+        this.#isActive = true;
+        const promise = new Promise((resolve) => {
+            this.#nativeTimeout = setInterval(() => {
+                if (this.mustStop) {
+                    this.#isActive = false;
+                    window.clearInterval(this.#nativeTimeout);
+                    resolve(es_extensions_1.Timer.Outcomes.stopped);
+                    return;
+                }
+                this.#secondsLeft = this.#secondsLeft - 1;
+                if (this.#secondsLeft === 0) {
+                    this.#isActive = false;
+                    this.#secondsLeft = this.period__seconds;
+                    clearInterval(this.#nativeTimeout);
+                    resolve(es_extensions_1.Timer.Outcomes.elapsed);
+                }
+            }, (0, es_extensions_1.secondsToMilliseconds)(1));
+        });
+        if (asynchronousCompletion === es_extensions_1.Timer.AsynchronousCompletions.promise) {
+            return promise;
+        }
+        promise.
+            then((outcome) => { this.onElapsed?.(outcome); }).
+            catch((error) => {
+            es_extensions_1.Logger.logError({
+                errorType: es_extensions_1.AlgorithmMismatchError.NAME,
+                title: es_extensions_1.AlgorithmMismatchError.localization.defaultTitle,
+                description: "Error occurred before times has elapsed.",
+                occurrenceLocation: "browserJS_Timer.countDown(parametersObject)",
+                caughtError: error
+            });
+        });
+    }
+    resetAndRestart({ asynchronousCompletion = es_extensions_1.Timer.AsynchronousCompletions.promise } = {}) {
+        clearInterval(this.#nativeTimeout);
+        this.#isActive = false;
+        this.#secondsLeft = this.period__seconds;
+        if (asynchronousCompletion === es_extensions_1.Timer.AsynchronousCompletions.promise) {
+            return this.countDown({ asynchronousCompletion: es_extensions_1.Timer.AsynchronousCompletions.promise });
+        }
+        this.countDown({ asynchronousCompletion: es_extensions_1.Timer.AsynchronousCompletions.callback });
+    }
+    get isActive() {
+        return this.#isActive;
+    }
+}
+exports.default = NodeJS_Timer;

package/Distributable/DotEnvFilesGenerator.d.ts

@@ -0,0 +1,13 @@
+declare abstract class DotEnvFilesGenerator {
+    static generate(order: DotEnvFilesGenerator.Order): typeof DotEnvFilesGenerator;
+}
+declare namespace DotEnvFilesGenerator {
+    type Order = Readonly<{
+        fileName: string;
+        directory: string;
+        variables: Readonly<{
+            [name: string]: string | number;
+        }>;
+    }>;
+}
+export default DotEnvFilesGenerator;

package/Distributable/DotEnvFilesGenerator.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ImprovedFileSystem_1 = __importDefault(require("./ImprovedFileSystem"));
+const path_1 = __importDefault(require("path"));
+class DotEnvFilesGenerator {
+    static generate(order) {
+        const fileContent = Object.entries(order.variables).
+            reduce((previousValue, [key, value]) => `${previousValue}${key}="${value}"\n`, "# [ Attention ] DON'T EDIT THIS FILE MANUALLY!!! \n" +
+            "# This file intended to be generated repeatedly thus the manual changes WILL BE LOST.\n\n");
+        ImprovedFileSystem_1.default.writeFileToPossiblyNotExistingDirectory({
+            content: fileContent,
+            filePath: path_1.default.join(order.directory, order.fileName),
+            synchronously: true
+        });
+        return DotEnvFilesGenerator;
+    }
+}
+exports.default = DotEnvFilesGenerator;

package/Distributable/Errors/FileNotFoundError/FileNotFoundError.d.ts

@@ -0,0 +1,25 @@
+declare class FileNotFoundError extends Error {
+    static readonly NAME: string;
+    static localization: FileNotFoundError.Localization;
+    constructor(constructorParameter: FileNotFoundError.ConstructorParameter);
+}
+declare namespace FileNotFoundError {
+    type ConstructorParameter = Readonly<{
+        filePath: string;
+        messageSpecificPart?: string;
+    } | {
+        customMessage: string;
+    }>;
+    type Localization = Readonly<{
+        defaultTitle: string;
+        generateDescriptionCommonPart: (templateVariables: Localization.CommonDescription.TemplateVariables) => string;
+    }>;
+    namespace Localization {
+        namespace CommonDescription {
+            type TemplateVariables = Readonly<{
+                filePath: string;
+            }>;
+        }
+    }
+}
+export default FileNotFoundError;

package/Distributable/Errors/FileNotFoundError/FileNotFoundError.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const FileNotFoundErrorLocalization_english_1 = __importDefault(require("./FileNotFoundErrorLocalization.english"));
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+class FileNotFoundError extends Error {
+    static NAME = "FileNotFoundError";
+    static localization = FileNotFoundErrorLocalization_english_1.default;
+    constructor(constructorParameter) {
+        super();
+        this.name = FileNotFoundError.NAME;
+        this.message =
+            "customMessage" in constructorParameter ?
+                constructorParameter.customMessage :
+                FileNotFoundError.localization.generateDescriptionCommonPart(constructorParameter) +
+                    (0, es_extensions_1.insertSubstring)(constructorParameter.messageSpecificPart, { modifier: (messageSpecificPart) => ` ${messageSpecificPart}` });
+    }
+}
+exports.default = FileNotFoundError;

package/Distributable/Errors/FileNotFoundError/FileNotFoundErrorLocalization.english.d.ts

@@ -0,0 +1,3 @@
+import type FileNotFoundError from "./FileNotFoundError";
+declare const fileNotFoundErrorLocalization__english: FileNotFoundError.Localization;
+export default fileNotFoundErrorLocalization__english;

package/Distributable/Errors/FileNotFoundError/FileNotFoundErrorLocalization.english.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fileNotFoundErrorLocalization__english = {
+    defaultTitle: "File Not Found",
+    generateDescriptionCommonPart: ({ filePath }) => `File with path "${filePath}" not found.`
+};
+exports.default = fileNotFoundErrorLocalization__english;

package/Distributable/Errors/InvalidConsoleCommand/InvalidConsoleCommandError.d.ts

@@ -0,0 +1,25 @@
+declare class InvalidConsoleCommandError extends Error {
+    static readonly NAME: string;
+    static localization: InvalidConsoleCommandError.Localization;
+    constructor(constructorParameter: InvalidConsoleCommandError.ConstructorParameter);
+}
+declare namespace InvalidConsoleCommandError {
+    type ConstructorParameter = Readonly<{
+        applicationName: string;
+        messageSpecificPart?: string;
+    } | {
+        customMessage: string;
+    }>;
+    type Localization = Readonly<{
+        defaultTitle: string;
+        generateDescriptionCommonPart: (templateVariables: Localization.CommonDescription.TemplateVariables) => string;
+    }>;
+    namespace Localization {
+        namespace CommonDescription {
+            type TemplateVariables = Readonly<{
+                applicationName: string;
+            }>;
+        }
+    }
+}
+export default InvalidConsoleCommandError;

package/Distributable/Errors/InvalidConsoleCommand/InvalidConsoleCommandError.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const InvalidConsoleCommandErrorLocalization_english_1 = __importDefault(require("./InvalidConsoleCommandErrorLocalization.english"));
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+class InvalidConsoleCommandError extends Error {
+    static NAME = "InvalidConsoleCommandError";
+    static localization = InvalidConsoleCommandErrorLocalization_english_1.default;
+    constructor(constructorParameter) {
+        super();
+        this.name = InvalidConsoleCommandError.NAME;
+        this.message =
+            "customMessage" in constructorParameter ?
+                constructorParameter.customMessage :
+                InvalidConsoleCommandError.localization.generateDescriptionCommonPart(constructorParameter) +
+                    (0, es_extensions_1.insertSubstring)(constructorParameter.messageSpecificPart, { modifier: (messageSpecificPart) => ` ${messageSpecificPart}` });
+    }
+}
+exports.default = InvalidConsoleCommandError;

package/Distributable/Errors/InvalidConsoleCommand/InvalidConsoleCommandErrorLocalization.english.d.ts

@@ -0,0 +1,3 @@
+import type InvalidConsoleCommandError from "./InvalidConsoleCommandError";
+declare const invalidConsoleCommandErrorLocalization__english: InvalidConsoleCommandError.Localization;
+export default invalidConsoleCommandErrorLocalization__english;

package/Distributable/Errors/InvalidConsoleCommand/InvalidConsoleCommandErrorLocalization.english.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const invalidConsoleCommandErrorLocalization__english = {
+    defaultTitle: "Invalid Console Command",
+    generateDescriptionCommonPart: ({ applicationName }) => `Invalid console command for the application "${applicationName}".`
+};
+exports.default = invalidConsoleCommandErrorLocalization__english;

package/Distributable/Errors/PathRefersToDirectoryNotFileError/PathRefersToDirectoryNotFileError.d.ts

@@ -0,0 +1,25 @@
+declare class PathRefersToDirectoryNotFileError extends Error {
+    static readonly NAME: string;
+    static localization: PathRefersToDirectoryNotFileError.Localization;
+    constructor(constructorParameter: PathRefersToDirectoryNotFileError.ConstructorParameter);
+}
+declare namespace PathRefersToDirectoryNotFileError {
+    type ConstructorParameter = Readonly<{
+        targetPath: string;
+        messageSpecificPart?: string;
+    } | {
+        customMessage: string;
+    }>;
+    type Localization = Readonly<{
+        defaultTitle: string;
+        genericDescription: (templateVariables: Localization.CommonDescription.TemplateVariables) => string;
+    }>;
+    namespace Localization {
+        namespace CommonDescription {
+            type TemplateVariables = Readonly<{
+                targetPath: string;
+            }>;
+        }
+    }
+}
+export default PathRefersToDirectoryNotFileError;

package/Distributable/Errors/PathRefersToDirectoryNotFileError/PathRefersToDirectoryNotFileError.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PathRefersToDirectoryNotFileErrorLocalization_english_1 = __importDefault(require("./PathRefersToDirectoryNotFileErrorLocalization.english"));
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+class PathRefersToDirectoryNotFileError extends Error {
+    static NAME = "PathRefersToDirectoryNotFileError";
+    static localization = PathRefersToDirectoryNotFileErrorLocalization_english_1.default;
+    constructor(constructorParameter) {
+        super();
+        this.name = PathRefersToDirectoryNotFileError.NAME;
+        this.message =
+            "customMessage" in constructorParameter ?
+                constructorParameter.customMessage :
+                PathRefersToDirectoryNotFileError.localization.genericDescription(constructorParameter) +
+                    (0, es_extensions_1.insertSubstring)(constructorParameter.messageSpecificPart, { modifier: (messageSpecificPart) => ` ${messageSpecificPart}` });
+    }
+}
+exports.default = PathRefersToDirectoryNotFileError;

package/Distributable/Errors/PathRefersToDirectoryNotFileError/PathRefersToDirectoryNotFileErrorLocalization.english.d.ts

@@ -0,0 +1,3 @@
+import type PathRefersToDirectoryNotFileError from "./PathRefersToDirectoryNotFileError";
+declare const pathRefersToDirectoryNotFileErrorLocalization__english: PathRefersToDirectoryNotFileError.Localization;
+export default pathRefersToDirectoryNotFileErrorLocalization__english;

package/Distributable/Errors/PathRefersToDirectoryNotFileError/PathRefersToDirectoryNotFileErrorLocalization.english.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pathRefersToDirectoryNotFileErrorLocalization__english = {
+    defaultTitle: "Desired File Actually is the Directory",
+    genericDescription: ({ targetPath }) => `Contrary to expectations, path "${targetPath}" refers to directory, not file.`
+};
+exports.default = pathRefersToDirectoryNotFileErrorLocalization__english;

package/Distributable/ImprovedFileSystem.d.ts

@@ -0,0 +1,43 @@
+export default class ImprovedFileSystem {
+    static isFileOrDirectoryExists(compoundParameter: Readonly<{
+        targetPath: string;
+        synchronously: false;
+    }>): Promise<boolean>;
+    static isFileOrDirectoryExists(compoundParameter: Readonly<{
+        targetPath: string;
+        synchronously: true;
+    }>): boolean;
+    static createDirectory(compoundParameter: Readonly<{
+        targetPath: string;
+        mustThrowErrorIfTargetDirectoryExists: boolean;
+        synchronously: false;
+    }>): Promise<void>;
+    static createDirectory(compoundParameter: Readonly<{
+        targetPath: string;
+        mustThrowErrorIfTargetDirectoryExists: boolean;
+        synchronously: true;
+    }>): void;
+    static ensureDirectoriesCreated(targetDirectoryPathOrMultipleOfThem: string | ReadonlyArray<string>): void;
+    static removeDirectoryWithFiles(compoundParameter: Readonly<{
+        targetPath: string;
+        mustThrowErrorIfOneOrMoreFilesCouldNotBeDeleted: boolean;
+    }>): void;
+    static removeFilesFromDirectory(compoundParameter: Readonly<{
+        directoryPath__absoluteOrRelative: string;
+        synchronously: true;
+    }>): void;
+    static removeFilesFromDirectory(compoundParameter: Readonly<{
+        directoryPath__absoluteOrRelative: string;
+        synchronously: false;
+    }>): Promise<void>;
+    static writeFileToPossiblyNotExistingDirectory(compoundParameter: Readonly<{
+        filePath: string;
+        content: string;
+        synchronously: true;
+    }>): void;
+    static writeFileToPossiblyNotExistingDirectory(compoundParameter: Readonly<{
+        filePath: string;
+        content: string;
+        synchronously: false;
+    }>): Promise<void>;
+}

package/Distributable/ImprovedFileSystem.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const ImprovedPath_1 = __importDefault(require("./ImprovedPath/ImprovedPath"));
+const isErrnoException_1 = __importDefault(require("./isErrnoException"));
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+class ImprovedFileSystem {
+    static isFileOrDirectoryExists({ targetPath, synchronously }) {
+        if (synchronously) {
+            return fs_1.default.existsSync(targetPath);
+        }
+        return new Promise((resolve, reject) => {
+            promises_1.default.access(targetPath).
+                then(() => { resolve(true); }).
+                catch((error) => {
+                if ((0, isErrnoException_1.default)(error) && error.code === "ENOENT") {
+                    resolve(false);
+                }
+                reject(error);
+            });
+        });
+    }
+    static createDirectory({ targetPath, mustThrowErrorIfTargetDirectoryExists, synchronously }) {
+        if (synchronously) {
+            if (ImprovedFileSystem.isFileOrDirectoryExists({ targetPath, synchronously: true })) {
+                if (mustThrowErrorIfTargetDirectoryExists) {
+                    es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                        errorType: "DirectoryAlreadyExistsError",
+                        title: "Directory already exists",
+                        description: `The directory "${targetPath}" is already exists.`,
+                        occurrenceLocation: "ImprovedFileSystem.createDirectory(compoundParameter)"
+                    });
+                }
+                return;
+            }
+            fs_1.default.mkdirSync(targetPath, { recursive: true });
+            return;
+        }
+        return ImprovedFileSystem.isFileOrDirectoryExists({ targetPath, synchronously: false }).
+            then(async (isTargetDirectoryAlreadyExists) => {
+            if (isTargetDirectoryAlreadyExists) {
+                if (mustThrowErrorIfTargetDirectoryExists) {
+                    es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                        errorType: "DirectoryAlreadyExistsError",
+                        title: "Directory already exists",
+                        description: `The directory "${targetPath}" is already exists.`,
+                        occurrenceLocation: "ImprovedFileSystem.createDirectory(compoundParameter)"
+                    });
+                }
+                return;
+            }
+            await promises_1.default.mkdir(targetPath, { recursive: true });
+        });
+    }
+    static ensureDirectoriesCreated(targetDirectoryPathOrMultipleOfThem) {
+        for (const targetDirectory of Array.isArray(targetDirectoryPathOrMultipleOfThem) ?
+            targetDirectoryPathOrMultipleOfThem : [targetDirectoryPathOrMultipleOfThem]) {
+            ImprovedFileSystem.createDirectory({
+                targetPath: targetDirectory,
+                synchronously: true,
+                mustThrowErrorIfTargetDirectoryExists: false
+            });
+        }
+    }
+    static removeDirectoryWithFiles(compoundParameter) {
+        const targetDirectoryPath = compoundParameter.targetPath;
+        if (!fs_1.default.existsSync(targetDirectoryPath)) {
+            return;
+        }
+        for (const fileOrDirectoryPathRelativeToTargetDirectory of fs_1.default.readdirSync(targetDirectoryPath)) {
+            const fileOrChildDirectoryAbsolutePath = path_1.default.join(targetDirectoryPath, fileOrDirectoryPathRelativeToTargetDirectory);
+            if (fs_1.default.lstatSync(fileOrChildDirectoryAbsolutePath).isDirectory()) {
+                ImprovedFileSystem.removeDirectoryWithFiles({
+                    targetPath: fileOrChildDirectoryAbsolutePath,
+                    mustThrowErrorIfOneOrMoreFilesCouldNotBeDeleted: compoundParameter.mustThrowErrorIfOneOrMoreFilesCouldNotBeDeleted
+                });
+            }
+            else {
+                fs_1.default.unlinkSync(fileOrChildDirectoryAbsolutePath);
+            }
+        }
+        fs_1.default.rmdirSync(targetDirectoryPath);
+    }
+    static removeFilesFromDirectory({ directoryPath__absoluteOrRelative, synchronously }) {
+        if (synchronously) {
+            fs_1.default.rmSync(directoryPath__absoluteOrRelative, { recursive: true, force: true });
+            return;
+        }
+        return promises_1.default.rm(directoryPath__absoluteOrRelative, { recursive: true, force: true });
+    }
+    static writeFileToPossiblyNotExistingDirectory({ filePath, content, synchronously }) {
+        if (synchronously) {
+            try {
+                fs_1.default.writeFileSync(filePath, content);
+            }
+            catch (error) {
+                if ((0, isErrnoException_1.default)(error) && error.code === "ENOENT") {
+                    ImprovedFileSystem.createDirectory({
+                        targetPath: ImprovedPath_1.default.extractDirectoryFromFilePath({
+                            targetPath: filePath,
+                            ambiguitiesResolution: {
+                                mustConsiderLastSegmentWithoutDotsAsFileNameWithoutExtension: true,
+                                mustConsiderLastSegmentWithNonLeadingDotAsDirectory: false,
+                                mustConsiderLastSegmentStartingWithDotAsDirectory: false
+                            }
+                        }),
+                        synchronously: true,
+                        mustThrowErrorIfTargetDirectoryExists: true
+                    });
+                    fs_1.default.writeFileSync(filePath, content);
+                }
+            }
+            return;
+        }
+        return promises_1.default.
+            writeFile(filePath, content).
+            catch(async (error) => {
+            if ((0, isErrnoException_1.default)(error) && error.code === "ENOENT") {
+                ImprovedFileSystem.createDirectory({
+                    targetPath: ImprovedPath_1.default.extractDirectoryFromFilePath({
+                        targetPath: filePath,
+                        ambiguitiesResolution: {
+                            mustConsiderLastSegmentWithoutDotsAsFileNameWithoutExtension: true,
+                            mustConsiderLastSegmentWithNonLeadingDotAsDirectory: false,
+                            mustConsiderLastSegmentStartingWithDotAsDirectory: false
+                        }
+                    }),
+                    synchronously: true,
+                    mustThrowErrorIfTargetDirectoryExists: true
+                });
+                return promises_1.default.writeFile(filePath, content);
+            }
+            throw error;
+        });
+    }
+}
+exports.default = ImprovedFileSystem;