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

package/Distributable/ImprovedGlob.d.ts

@@ -0,0 +1,57 @@
+export default class ImprovedGlob {
+    static getFilesAbsolutePathsSynchronously(globSelectors: ReadonlyArray<string>, options?: Readonly<{
+        alwaysForwardSlashSeparators?: boolean;
+    }>): Array<string>;
+    static isFilePathMatchingWithGlobSelector(compoundParameter: Readonly<{
+        filePath: string;
+        globSelector: string;
+    }>): boolean;
+    static isFilePathMatchingWithAllGlobSelectors(compoundParameter: Readonly<{
+        filePath: string;
+        globSelectors: ReadonlyArray<string> | string;
+    }>): boolean;
+    static isFilePathMatchingWithAtLeastOneGlobSelector({ filePath, globSelectors }: Readonly<{
+        filePath: string;
+        globSelectors: ReadonlyArray<string> | ReadonlySet<string>;
+    }>): boolean;
+    static isExcludingGlobSelector(globSelector: string): boolean;
+    static buildAllFilesInCurrentDirectoryButNotBelowGlobSelector(compoundParameter: {
+        basicDirectoryPath: string;
+        fileNamesExtensions?: ReadonlyArray<string> | ReadonlySet<string>;
+    }): string;
+    static buildAllFilesInCurrentDirectoryAndBelowGlobSelector(polymorphicParameter: string | Readonly<{
+        basicDirectoryPath: string;
+        fileNamesPostfixes?: ReadonlyArray<string> | ReadonlySet<string>;
+        fileNamesExtensions?: ReadonlyArray<string> | ReadonlySet<string>;
+        penultimateFileNamesExtensions?: ReadonlyArray<string> | ReadonlySet<string>;
+    }>): string;
+    static buildExcludingOfDirectoryWithSubdirectoriesGlobSelector(polymorphicParameter: string | Readonly<{
+        targetDirectoryPath: string;
+        fileNamesPostfixes?: ReadonlyArray<string> | ReadonlySet<string>;
+        fileNamesExtensions?: ReadonlyArray<string> | ReadonlySet<string>;
+        penultimateFileNamesExtensions?: ReadonlyArray<string> | ReadonlySet<string>;
+    }>): string;
+    static buildExcludingOfFilesWithSpecificPrefixesGlobSelector(compoundParameter: Readonly<{
+        basicDirectoryPath: string;
+        filesNamesPrefixes: ReadonlyArray<string> | ReadonlySet<string>;
+        filesNamesExtensions: ReadonlyArray<string> | ReadonlySet<string>;
+    }>): string;
+    static buildExcludingOfFilesInSubdirectoriesWithSpecificPrefixesGlobSelector(compoundParameter: Readonly<{
+        basicDirectoryPath: string;
+        subdirectoriesPrefixes: ReadonlyArray<string> | ReadonlySet<string>;
+        filesNamesExtensions?: ReadonlyArray<string> | ReadonlySet<string>;
+    }>): string;
+    static buildExcludingOfFilesInSpecificSubdirectoriesGlobSelector(compoundParameter: Readonly<{
+        basicDirectoryPath: string;
+        subdirectoriesNames: ReadonlyArray<string> | ReadonlySet<string>;
+        filesNamesExtensions?: ReadonlyArray<string> | ReadonlySet<string>;
+    }>): string;
+    static createMultipleFilenameExtensionsGlobPostfix(fileNamesExtensions: ReadonlyArray<string> | ReadonlySet<string>): string;
+    static buildAbsolutePathBasedGlob(compoundParameter: Readonly<{
+        basicDirectoryPath: string;
+        relativePathBasedGlob: string;
+        isExclusive?: boolean;
+    }>): string;
+    static includingGlobSelectorToExcludingOne(targetIncludingGlobSelector: string): string;
+    static includingGlobSelectorsToExcludingOnes(targetIncludingGlobSelectors: ReadonlyArray<string>): Array<string>;
+}

package/Distributable/ImprovedGlob.js

@@ -0,0 +1,275 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const glob_1 = require("glob");
+const minimatch_1 = require("minimatch");
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+const appendCharacterIfItDoesNotPresentInLastPosition_1 = __importDefault(require("./Temporary/appendCharacterIfItDoesNotPresentInLastPosition"));
+class ImprovedGlob {
+    static getFilesAbsolutePathsSynchronously(globSelectors, options = {}) {
+        const inclusiveGlobSelectors = [];
+        const exclusiveGlobSelectors = [];
+        for (const globSelector of globSelectors) {
+            (ImprovedGlob.isExcludingGlobSelector(globSelector) ? exclusiveGlobSelectors : inclusiveGlobSelectors).
+                push((0, es_extensions_1.replaceDoubleBackslashesWithForwardSlashes)(globSelector));
+        }
+        const matchingFilesAbsolutePaths = [];
+        for (const inclusiveGlobSelector of inclusiveGlobSelectors) {
+            matchingFilesAbsolutePaths.push(...glob_1.glob.sync(inclusiveGlobSelector, {
+                ignore: exclusiveGlobSelectors.map((globSelector) => (0, es_extensions_1.removeSpecificCharacterFromCertainPosition)({
+                    targetString: globSelector,
+                    fromFirstPosition: true,
+                    targetCharacter: "!"
+                })),
+                nodir: true,
+                dot: true
+            }));
+        }
+        if (options.alwaysForwardSlashSeparators !== true) {
+            return matchingFilesAbsolutePaths;
+        }
+        return matchingFilesAbsolutePaths.map((fileAbsolutePath) => (0, es_extensions_1.replaceDoubleBackslashesWithForwardSlashes)(fileAbsolutePath));
+    }
+    static isFilePathMatchingWithGlobSelector(compoundParameter) {
+        return (0, minimatch_1.minimatch)(compoundParameter.filePath, compoundParameter.globSelector);
+    }
+    static isFilePathMatchingWithAllGlobSelectors(compoundParameter) {
+        return (Array.isArray(compoundParameter.globSelectors) ?
+            compoundParameter.globSelectors : [compoundParameter.globSelectors]).
+            every((globSelector) => (0, minimatch_1.minimatch)(compoundParameter.filePath, globSelector));
+    }
+    static isFilePathMatchingWithAtLeastOneGlobSelector({ filePath, globSelectors }) {
+        return (Array.isArray(globSelectors) ? globSelectors : [...globSelectors]).
+            some((globSelector) => (0, minimatch_1.minimatch)(filePath, globSelector));
+    }
+    static isExcludingGlobSelector(globSelector) {
+        return globSelector.startsWith("!");
+    }
+    static buildAllFilesInCurrentDirectoryButNotBelowGlobSelector(compoundParameter) {
+        let fileNamesExtensions;
+        if ((0, es_extensions_1.isUndefined)(compoundParameter.fileNamesExtensions)) {
+            fileNamesExtensions = new Set();
+        }
+        else if (compoundParameter.fileNamesExtensions instanceof Set) {
+            fileNamesExtensions = compoundParameter.fileNamesExtensions;
+        }
+        else {
+            fileNamesExtensions = new Set(compoundParameter.fileNamesExtensions);
+        }
+        return [
+            (0, appendCharacterIfItDoesNotPresentInLastPosition_1.default)({
+                targetString: (0, es_extensions_1.replaceDoubleBackslashesWithForwardSlashes)(compoundParameter.basicDirectoryPath),
+                trailingCharacter: "/"
+            }),
+            "*",
+            ...fileNamesExtensions.size > 0 ?
+                [ImprovedGlob.createMultipleFilenameExtensionsGlobPostfix(fileNamesExtensions)] : []
+        ].join("");
+    }
+    static buildAllFilesInCurrentDirectoryAndBelowGlobSelector(polymorphicParameter) {
+        let basicDirectoryPath;
+        let fileNamesPostfixes = new Set();
+        let fileNamesExtensions = new Set();
+        let penultimateFileNamesExtensions = new Set();
+        if ((0, es_extensions_1.isString)(polymorphicParameter)) {
+            basicDirectoryPath = polymorphicParameter;
+        }
+        else {
+            basicDirectoryPath = polymorphicParameter.basicDirectoryPath;
+            if (polymorphicParameter.fileNamesPostfixes instanceof Set) {
+                fileNamesPostfixes = polymorphicParameter.fileNamesPostfixes;
+            }
+            else if (Array.isArray(polymorphicParameter.fileNamesPostfixes)) {
+                fileNamesPostfixes = new Set(polymorphicParameter.fileNamesPostfixes);
+            }
+            if (polymorphicParameter.fileNamesExtensions instanceof Set) {
+                fileNamesExtensions = polymorphicParameter.fileNamesExtensions;
+            }
+            else if (Array.isArray(polymorphicParameter.fileNamesExtensions)) {
+                fileNamesExtensions = new Set(polymorphicParameter.fileNamesExtensions);
+            }
+            if (polymorphicParameter.penultimateFileNamesExtensions instanceof Set) {
+                penultimateFileNamesExtensions = polymorphicParameter.penultimateFileNamesExtensions;
+            }
+            else if (Array.isArray(polymorphicParameter.penultimateFileNamesExtensions)) {
+                penultimateFileNamesExtensions = new Set(polymorphicParameter.penultimateFileNamesExtensions);
+            }
+        }
+        return [
+            (0, appendCharacterIfItDoesNotPresentInLastPosition_1.default)({
+                targetString: (0, es_extensions_1.replaceDoubleBackslashesWithForwardSlashes)(basicDirectoryPath),
+                trailingCharacter: "/"
+            }),
+            "**/*",
+            ...fileNamesPostfixes.size > 0 ?
+                [
+                    `@(${Array.from(fileNamesPostfixes).
+                        join("|").
+                        replace(/\./gu, "")})`
+                ] :
+                [],
+            ...penultimateFileNamesExtensions.size > 0 ?
+                [
+                    `.@(${Array.from(penultimateFileNamesExtensions).
+                        map((penultimateFilenameExtension) => (0, es_extensions_1.removeSpecificCharacterFromCertainPosition)({
+                        targetString: penultimateFilenameExtension,
+                        targetCharacter: ".",
+                        fromFirstPosition: true
+                    })).
+                        join("|")})`
+                ] :
+                [],
+            ...fileNamesExtensions.size > 0 ?
+                [ImprovedGlob.createMultipleFilenameExtensionsGlobPostfix(fileNamesExtensions)] :
+                penultimateFileNamesExtensions.size > 0 ? ["/*"] : []
+        ].join("");
+    }
+    static buildExcludingOfDirectoryWithSubdirectoriesGlobSelector(polymorphicParameter) {
+        if ((0, es_extensions_1.isString)(polymorphicParameter)) {
+            return ImprovedGlob.includingGlobSelectorToExcludingOne(ImprovedGlob.buildAllFilesInCurrentDirectoryAndBelowGlobSelector(polymorphicParameter));
+        }
+        const { targetDirectoryPath, ...options } = polymorphicParameter;
+        return ImprovedGlob.includingGlobSelectorToExcludingOne(ImprovedGlob.buildAllFilesInCurrentDirectoryAndBelowGlobSelector({
+            basicDirectoryPath: targetDirectoryPath,
+            ...options
+        }));
+    }
+    static buildExcludingOfFilesWithSpecificPrefixesGlobSelector(compoundParameter) {
+        const filesNamesPrefixes = compoundParameter.filesNamesPrefixes instanceof Set ?
+            compoundParameter.filesNamesPrefixes : new Set(compoundParameter.filesNamesPrefixes);
+        if (filesNamesPrefixes.size === 0) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new es_extensions_1.InvalidParameterValueError({
+                    parameterName: "compoundParameter.filesNamesPrefixes",
+                    parameterNumber: 1,
+                    messageSpecificPart: "At least one file name prefix must be specified."
+                }),
+                title: es_extensions_1.InvalidParameterValueError.localization.defaultTitle,
+                occurrenceLocation: "ImprovedGlob.buildExcludingOfFilesWithSpecificPrefixesGlobSelector(compoundParameter)"
+            });
+        }
+        const filesNamesExtensions = compoundParameter.filesNamesExtensions instanceof Set ?
+            compoundParameter.filesNamesExtensions : new Set(compoundParameter.filesNamesExtensions);
+        if (filesNamesExtensions.size === 0) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new es_extensions_1.InvalidParameterValueError({
+                    parameterName: "compoundParameter.filesNamesExtensions",
+                    parameterNumber: 1,
+                    messageSpecificPart: "At least on file name extension must be specified."
+                }),
+                title: es_extensions_1.InvalidParameterValueError.localization.defaultTitle,
+                occurrenceLocation: "ImprovedGlob.buildExcludingOfFilesWithSpecificPrefixesGlobSelector(compoundParameter)"
+            });
+        }
+        return [
+            "!",
+            (0, appendCharacterIfItDoesNotPresentInLastPosition_1.default)({
+                targetString: (0, es_extensions_1.replaceDoubleBackslashesWithForwardSlashes)(compoundParameter.basicDirectoryPath),
+                trailingCharacter: "/"
+            }),
+            "**/",
+            `@(${Array.from(filesNamesPrefixes).join("|")})*`,
+            ImprovedGlob.createMultipleFilenameExtensionsGlobPostfix(compoundParameter.filesNamesExtensions)
+        ].join("");
+    }
+    static buildExcludingOfFilesInSubdirectoriesWithSpecificPrefixesGlobSelector(compoundParameter) {
+        const subdirectoriesPrefixes = compoundParameter.subdirectoriesPrefixes instanceof Set ?
+            compoundParameter.subdirectoriesPrefixes : new Set(compoundParameter.subdirectoriesPrefixes);
+        let filesNamesExtensions;
+        if ((0, es_extensions_1.isUndefined)(compoundParameter.filesNamesExtensions)) {
+            filesNamesExtensions = new Set();
+        }
+        else if (compoundParameter.filesNamesExtensions instanceof Set) {
+            filesNamesExtensions = compoundParameter.filesNamesExtensions;
+        }
+        else {
+            filesNamesExtensions = new Set(compoundParameter.filesNamesExtensions);
+        }
+        if (filesNamesExtensions.size === 0) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new es_extensions_1.InvalidParameterValueError({
+                    parameterName: "compoundParameter.subdirectoriesPrefixes",
+                    parameterNumber: 1,
+                    messageSpecificPart: "The property \"subdirectoriesPrefixes\" must be defined with non-empty array."
+                }),
+                title: es_extensions_1.InvalidParameterValueError.localization.defaultTitle,
+                occurrenceLocation: "ImprovedGlob." +
+                    "buildExcludingOfFilesInSubdirectoriesWithSpecificPrefixesGlobSelector(compoundParameter)"
+            });
+        }
+        return [
+            "!",
+            (0, appendCharacterIfItDoesNotPresentInLastPosition_1.default)({
+                targetString: (0, es_extensions_1.replaceDoubleBackslashesWithForwardSlashes)(compoundParameter.basicDirectoryPath),
+                trailingCharacter: "/"
+            }),
+            "**/",
+            `@(${Array.from(subdirectoriesPrefixes).join("|")})*/**/*`,
+            ...(0, es_extensions_1.isNonEmptyArray)(compoundParameter.filesNamesExtensions) ?
+                [ImprovedGlob.createMultipleFilenameExtensionsGlobPostfix(compoundParameter.filesNamesExtensions)] : []
+        ].join("");
+    }
+    static buildExcludingOfFilesInSpecificSubdirectoriesGlobSelector(compoundParameter) {
+        const subdirectoriesNames = compoundParameter.subdirectoriesNames instanceof Set ?
+            compoundParameter.subdirectoriesNames : new Set(compoundParameter.subdirectoriesNames);
+        if (subdirectoriesNames.size === 0) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new es_extensions_1.InvalidParameterValueError({
+                    parameterName: "compoundParameter.subdirectoriesNames",
+                    parameterNumber: 1,
+                    messageSpecificPart: "The property \"subdirectoriesNames\" must be defined with non-empty array."
+                }),
+                title: es_extensions_1.InvalidParameterValueError.localization.defaultTitle,
+                occurrenceLocation: "ImprovedGlob.buildExcludingOfFilesInSpecificSubdirectoriesGlobSelector(compoundParameter)"
+            });
+        }
+        let filesNamesExtensions;
+        if ((0, es_extensions_1.isUndefined)(compoundParameter.filesNamesExtensions)) {
+            filesNamesExtensions = new Set();
+        }
+        else if (compoundParameter.filesNamesExtensions instanceof Set) {
+            filesNamesExtensions = compoundParameter.filesNamesExtensions;
+        }
+        else {
+            filesNamesExtensions = new Set(compoundParameter.filesNamesExtensions);
+        }
+        return [
+            "!",
+            (0, appendCharacterIfItDoesNotPresentInLastPosition_1.default)({
+                targetString: (0, es_extensions_1.replaceDoubleBackslashesWithForwardSlashes)(compoundParameter.basicDirectoryPath),
+                trailingCharacter: "/"
+            }),
+            `**/@(${Array.from(subdirectoriesNames).join("|")})/**/*`,
+            ...filesNamesExtensions.size > 0 ?
+                [ImprovedGlob.createMultipleFilenameExtensionsGlobPostfix(filesNamesExtensions)] : []
+        ].join("");
+    }
+    static createMultipleFilenameExtensionsGlobPostfix(fileNamesExtensions) {
+        return `.@(${(Array.isArray(fileNamesExtensions) ?
+            fileNamesExtensions :
+            Array.from(fileNamesExtensions)).join("|").replace(/\./gu, "")})`;
+    }
+    static buildAbsolutePathBasedGlob(compoundParameter) {
+        return [
+            compoundParameter.isExclusive === true ? ["!"] : [],
+            (0, appendCharacterIfItDoesNotPresentInLastPosition_1.default)({
+                targetString: (0, es_extensions_1.replaceDoubleBackslashesWithForwardSlashes)(compoundParameter.basicDirectoryPath),
+                trailingCharacter: "/"
+            }),
+            (0, es_extensions_1.removeSpecificCharacterFromCertainPosition)({
+                targetString: (0, es_extensions_1.replaceDoubleBackslashesWithForwardSlashes)(compoundParameter.relativePathBasedGlob),
+                targetCharacter: "/",
+                fromLastPosition: true
+            })
+        ].join("");
+    }
+    static includingGlobSelectorToExcludingOne(targetIncludingGlobSelector) {
+        return targetIncludingGlobSelector.startsWith("!") ? targetIncludingGlobSelector : `!${targetIncludingGlobSelector}`;
+    }
+    static includingGlobSelectorsToExcludingOnes(targetIncludingGlobSelectors) {
+        return targetIncludingGlobSelectors.map((targetIncludingGlobSelector) => ImprovedGlob.includingGlobSelectorToExcludingOne(targetIncludingGlobSelector));
+    }
+}
+exports.default = ImprovedGlob;

package/Distributable/ImprovedPath/ImprovedPath.d.ts

@@ -0,0 +1,59 @@
+import Path from "path";
+declare abstract class ImprovedPath {
+    static joinPathSegments(pathSegments: ReadonlyArray<string>, options?: Readonly<{
+        alwaysForwardSlashSeparators: boolean;
+    }>): string;
+    static buildAbsolutePathFromCurrentWorkingDirectory(pathSegments: ReadonlyArray<string>, options?: Readonly<{
+        alwaysForwardSlashSeparators: boolean;
+    }>): string;
+    static computeRelativePath(namedParameters: Readonly<{
+        basePath: string;
+        comparedPath: string;
+        alwaysForwardSlashSeparators?: boolean;
+    }>): string;
+    static parsePath(targetPath: string): ImprovedPath.ParsingResult;
+    static replacePathSeparatorsToForwardSlashes(targetPath: string): string;
+    static explodePathToSegments(targetPath: string): Array<string>;
+    static doesPathEndWithFileNameExtension(namedParameters: Readonly<{
+        targetPath: string;
+        mustConsiderLasPathSegmentBeginsFromDotAsTheFileNameWithoutExtension: boolean;
+    }>): boolean;
+    static extractFileNameWithoutExtensionFromPath(namedParameters: Readonly<{
+        targetPath: string;
+        mustThrowErrorIfLastPathSegmentHasNoDots: false;
+    }>): string | null;
+    static extractFileNameWithoutExtensionFromPath(namedParameters: Readonly<{
+        targetPath: string;
+        mustThrowErrorIfLastPathSegmentHasNoDots: true;
+    }>): string;
+    static extractDirectoryFromFilePath(compoundParameter: Readonly<{
+        targetPath: string;
+        ambiguitiesResolution: Readonly<{
+            mustConsiderLastSegmentStartingWithDotAsDirectory: boolean;
+            mustConsiderLastSegmentWithNonLeadingDotAsDirectory: boolean;
+            mustConsiderLastSegmentWithoutDotsAsFileNameWithoutExtension: boolean;
+        }>;
+        alwaysForwardSlashSeparators?: boolean;
+    }>): string;
+}
+declare namespace ImprovedPath {
+    class ParsingResult {
+        #private;
+        constructor(namedParameters: Readonly<{
+            rawPath: string;
+            nativeParsedPath: Path.ParsedPath;
+        }>);
+        get root(): string | null;
+        get root__forwardSlashesSeparators(): string | null;
+        getRootExpectedToExist(namedParameters?: Readonly<{
+            alwaysForwardSlashesSeparators: boolean;
+        }>): string;
+        get directory(): string | null;
+        get directory__forwardSlashesSeparators(): string | null;
+        getDirectoryExpectedToExist(namedParameters?: Readonly<{
+            alwaysForwardSlashesSeparators: boolean;
+        }>): string;
+        get directoryExplodedToPathSegments(): ReadonlyArray<string>;
+    }
+}
+export default ImprovedPath;

package/Distributable/ImprovedPath/ImprovedPath.js

@@ -0,0 +1,224 @@
+"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 es_extensions_1 = require("@yamato-daiwa/es-extensions");
+class ImprovedPath {
+    static joinPathSegments(pathSegments, options) {
+        try {
+            return options?.alwaysForwardSlashSeparators === true ?
+                (0, es_extensions_1.replaceDoubleBackslashesWithForwardSlashes)(path_1.default.join(...pathSegments)) :
+                path_1.default.join(...pathSegments);
+        }
+        catch (error) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new es_extensions_1.InvalidParameterValueError({ parameterName: "pathSegments", parameterNumber: 1 }),
+                title: es_extensions_1.InvalidParameterValueError.localization.defaultTitle,
+                occurrenceLocation: "ImprovedPath.joinPathSegments(pathSegments, options)",
+                innerError: error
+            });
+        }
+    }
+    static buildAbsolutePathFromCurrentWorkingDirectory(pathSegments, options) {
+        const segmentsIncludingAbsolutePaths = pathSegments.
+            filter((pathSegment) => path_1.default.isAbsolute(pathSegment));
+        if (segmentsIncludingAbsolutePaths.length > 0) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new es_extensions_1.InvalidParameterValueError({
+                    parameterName: "pathSegments",
+                    parameterNumber: 1,
+                    messageSpecificPart: `${segmentsIncludingAbsolutePaths.length} path segment(s) including absolute path:\n` +
+                        `${(0, es_extensions_1.stringifyAndFormatArbitraryValue)(segmentsIncludingAbsolutePaths)}\n` +
+                        "As it follows from the method name, it builds absolute path from current working directory thus " +
+                        "does not require the implicit absolute path. If you want join the arbitrary absolute path with other path " +
+                        "segments, use 'joinPathSegments' method instead."
+                }),
+                title: es_extensions_1.InvalidParameterValueError.localization.defaultTitle,
+                occurrenceLocation: "ImprovedPath.buildAbsolutePathFromCurrentWorkingDirectory(pathSegments, options)"
+            });
+        }
+        try {
+            return options?.alwaysForwardSlashSeparators === true ?
+                (0, es_extensions_1.replaceDoubleBackslashesWithForwardSlashes)(path_1.default.resolve(...pathSegments)) :
+                path_1.default.resolve(...pathSegments);
+        }
+        catch (error) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new es_extensions_1.InvalidParameterValueError({ parameterName: "pathSegments", parameterNumber: 1 }),
+                title: es_extensions_1.InvalidParameterValueError.localization.defaultTitle,
+                occurrenceLocation: "ImprovedPath.buildAbsolutePathFromCurrentWorkingDirectory(pathSegments, options)",
+                innerError: error
+            });
+        }
+    }
+    static computeRelativePath(namedParameters) {
+        let operationingSystemDependentRelativePath;
+        try {
+            operationingSystemDependentRelativePath = path_1.default.relative(namedParameters.basePath, namedParameters.comparedPath);
+        }
+        catch (error) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new es_extensions_1.InvalidParameterValueError({ parameterName: "namedParameters", parameterNumber: 1 }),
+                title: es_extensions_1.InvalidParameterValueError.localization.defaultTitle,
+                occurrenceLocation: "ImprovedPath.computeRelativePath(namedParameters)",
+                innerError: error
+            });
+        }
+        return namedParameters.alwaysForwardSlashSeparators === true ?
+            (0, es_extensions_1.replaceDoubleBackslashesWithForwardSlashes)(operationingSystemDependentRelativePath) :
+            operationingSystemDependentRelativePath;
+    }
+    static parsePath(targetPath) {
+        const nativeParsedPath = path_1.default.parse(targetPath);
+        return new ImprovedPath.ParsingResult({
+            rawPath: targetPath,
+            nativeParsedPath
+        });
+    }
+    static replacePathSeparatorsToForwardSlashes(targetPath) {
+        return (0, es_extensions_1.replaceDoubleBackslashesWithForwardSlashes)(targetPath);
+    }
+    static explodePathToSegments(targetPath) {
+        const normalizedPath = ImprovedPath.replacePathSeparatorsToForwardSlashes(path_1.default.normalize(targetPath));
+        return [
+            ...normalizedPath.startsWith("/") ? ["/"] : [],
+            ...(0, es_extensions_1.splitString)(normalizedPath, "/").filter((pathSegment) => pathSegment.length > 0)
+        ];
+    }
+    static doesPathEndWithFileNameExtension(namedParameters) {
+        const lastPathSegment = ImprovedPath.explodePathToSegments(namedParameters.targetPath).at(-1);
+        if ((0, es_extensions_1.isUndefined)(lastPathSegment)) {
+            return false;
+        }
+        if (!lastPathSegment.includes(".") || lastPathSegment.endsWith(".")) {
+            return false;
+        }
+        if (lastPathSegment.startsWith(".")) {
+            return namedParameters.mustConsiderLasPathSegmentBeginsFromDotAsTheFileNameWithoutExtension;
+        }
+        return true;
+    }
+    static extractFileNameWithoutExtensionFromPath(namedParameters) {
+        let targetPathExplodedToSegments = ImprovedPath.explodePathToSegments(namedParameters.targetPath);
+        if (targetPathExplodedToSegments.length > 1 && targetPathExplodedToSegments[0] === ".") {
+            targetPathExplodedToSegments = [""];
+        }
+        const lastPathSegment = (0, es_extensions_1.getLastElementOfArray)(targetPathExplodedToSegments, { mustThrowErrorIfArrayIsEmpty: true });
+        const dotSeparatedSubsegmentsOfLastSegment = (0, es_extensions_1.splitString)(lastPathSegment, ".");
+        if (dotSeparatedSubsegmentsOfLastSegment[0].length > 0) {
+            return dotSeparatedSubsegmentsOfLastSegment[0];
+        }
+        if (namedParameters.mustThrowErrorIfLastPathSegmentHasNoDots) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new es_extensions_1.UnexpectedEventError(`Contrary to expectations, the last segment of '${namedParameters.targetPath}' does not look like the ` +
+                    "file name with extension."),
+                title: es_extensions_1.UnexpectedEventError.localization.defaultTitle,
+                occurrenceLocation: "ImprovedPath.extractFileNameWithoutExtensionFromPath(namedParameters)"
+            });
+        }
+        return null;
+    }
+    static extractDirectoryFromFilePath(compoundParameter) {
+        const targetPath = ImprovedPath.replacePathSeparatorsToForwardSlashes(compoundParameter.targetPath);
+        const pathSegments = ImprovedPath.explodePathToSegments(targetPath);
+        if (pathSegments.length === 1 && pathSegments[0] === ".") {
+            return "/";
+        }
+        const lastPathSegment = (0, es_extensions_1.getLastElementOfArray)(pathSegments, { mustThrowErrorIfArrayIsEmpty: true });
+        if (lastPathSegment.startsWith(".")) {
+            if (compoundParameter.ambiguitiesResolution.mustConsiderLastSegmentStartingWithDotAsDirectory) {
+                return compoundParameter.alwaysForwardSlashSeparators === true ?
+                    targetPath : path_1.default.normalize(targetPath);
+            }
+            return ImprovedPath.joinPathSegments(pathSegments.slice(0, -1), { alwaysForwardSlashSeparators: compoundParameter.alwaysForwardSlashSeparators === true });
+        }
+        if (lastPathSegment.includes(".")) {
+            if (compoundParameter.ambiguitiesResolution.mustConsiderLastSegmentWithNonLeadingDotAsDirectory) {
+                return compoundParameter.alwaysForwardSlashSeparators === true ? targetPath : path_1.default.normalize(targetPath);
+            }
+            return ImprovedPath.joinPathSegments(pathSegments.slice(0, -1), { alwaysForwardSlashSeparators: compoundParameter.alwaysForwardSlashSeparators === true });
+        }
+        if (compoundParameter.ambiguitiesResolution.mustConsiderLastSegmentWithoutDotsAsFileNameWithoutExtension) {
+            return ImprovedPath.joinPathSegments(pathSegments.slice(0, -1), { alwaysForwardSlashSeparators: compoundParameter.alwaysForwardSlashSeparators === true });
+        }
+        return compoundParameter.alwaysForwardSlashSeparators === true ? targetPath : path_1.default.normalize(targetPath);
+    }
+}
+(function (ImprovedPath) {
+    class ParsingResult {
+        #rawPath;
+        #root;
+        #root__forwardSlashesSeparators;
+        #directory;
+        #directory__forwardSlashesSeparators;
+        #directoryExplodedToPathSegments;
+        constructor(namedParameters) {
+            this.#rawPath = namedParameters.rawPath;
+            if (namedParameters.nativeParsedPath.root.length > 0) {
+                this.#root = namedParameters.nativeParsedPath.root;
+                this.#root__forwardSlashesSeparators = (0, es_extensions_1.replaceDoubleBackslashesWithForwardSlashes)(this.#root);
+            }
+            else {
+                this.#root = null;
+                this.#root__forwardSlashesSeparators = null;
+            }
+            if (namedParameters.nativeParsedPath.dir.length > 0) {
+                this.#directory = namedParameters.nativeParsedPath.dir;
+                this.#directory__forwardSlashesSeparators = (0, es_extensions_1.replaceDoubleBackslashesWithForwardSlashes)(this.#directory);
+                this.#directoryExplodedToPathSegments = [
+                    ...this.#directory__forwardSlashesSeparators.startsWith("/") ? ["/"] : [],
+                    ...(0, es_extensions_1.splitString)(this.#directory__forwardSlashesSeparators, "/").
+                        filter((pathSegment) => pathSegment.length > 0)
+                ];
+            }
+            else {
+                this.#directory = null;
+                this.#directory__forwardSlashesSeparators = null;
+                this.#directoryExplodedToPathSegments = [];
+            }
+        }
+        get root() {
+            return this.#root;
+        }
+        get root__forwardSlashesSeparators() {
+            return this.#root__forwardSlashesSeparators;
+        }
+        getRootExpectedToExist(namedParameters) {
+            const root = namedParameters?.alwaysForwardSlashesSeparators === true ?
+                this.#root__forwardSlashesSeparators : this.#root;
+            if ((0, es_extensions_1.isNull)(root)) {
+                es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                    errorInstance: new es_extensions_1.UnexpectedEventError(`Contrary to expectations, the root is not exists on path '${this.#rawPath}'.`),
+                    title: es_extensions_1.UnexpectedEventError.localization.defaultTitle,
+                    occurrenceLocation: "ImprovedPath.ParsedPath.getRootExpectedToBeExists(namedParameters)"
+                });
+            }
+            return root;
+        }
+        get directory() {
+            return this.#directory;
+        }
+        get directory__forwardSlashesSeparators() {
+            return this.#directory__forwardSlashesSeparators;
+        }
+        getDirectoryExpectedToExist(namedParameters) {
+            const directory = namedParameters?.alwaysForwardSlashesSeparators === true ?
+                this.#directory__forwardSlashesSeparators : this.#directory;
+            if ((0, es_extensions_1.isNull)(directory)) {
+                es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                    errorInstance: new es_extensions_1.UnexpectedEventError(`Contrary to expectations, the directory is not exists on path '${this.#rawPath}'.`),
+                    title: es_extensions_1.UnexpectedEventError.localization.defaultTitle,
+                    occurrenceLocation: "ImprovedPath.ParsedPath.getDirectoryExpectedToExist(namedParameters)"
+                });
+            }
+            return directory;
+        }
+        get directoryExplodedToPathSegments() {
+            return this.#directoryExplodedToPathSegments;
+        }
+    }
+    ImprovedPath.ParsingResult = ParsingResult;
+})(ImprovedPath || (ImprovedPath = {}));
+exports.default = ImprovedPath;