@yamato-daiwa/es-extensions 0.6.2 → 0.9.0-alpha.0

package/Distributable/cjs/AJAX/AJAX_Service.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fundamental_constants_1 = require("fundamental-constants");
+const RawObjectDataProcessor_1 = __importDefault(require("../RawObjectDataProcessor/RawObjectDataProcessor"));
+const Logger_1 = __importDefault(require("../Logging/Logger"));
+const InvalidParameterValueError_1 = __importDefault(require("../Errors/InvalidParameterValue/InvalidParameterValueError"));
+const DataSubmittingFailedError_1 = __importDefault(require("../Errors/DataSubmittingFailed/DataSubmittingFailedError"));
+const DataRetrievingFailedError_1 = __importDefault(require("../Errors/DataRetrievingFailed/DataRetrievingFailedError"));
+const InvalidExternalDataError_1 = __importDefault(require("../Errors/InvalidExternalData/InvalidExternalDataError"));
+const InvalidConfigError_1 = __importDefault(require("../Errors/InvalidConfig/InvalidConfigError"));
+const removeSpecificCharacterFromCertainPosition_1 = __importDefault(require("../Strings/removeSpecificCharacterFromCertainPosition"));
+const insertSubstring_1 = __importDefault(require("../Strings/insertSubstring"));
+const serializeURI_QueryParameters_1 = __importDefault(require("./serializeURI_QueryParameters"));
+const isNonEmptyString_1 = __importDefault(require("../TypeGuards/Strings/isNonEmptyString"));
+const isNull_1 = __importDefault(require("../TypeGuards/EmptyTypes/isNull"));
+const isUndefined_1 = __importDefault(require("../TypeGuards/EmptyTypes/isUndefined"));
+const isNotUndefined_1 = __importDefault(require("../TypeGuards/EmptyTypes/isNotUndefined"));
+class AJAX_Service {
+    static implementation = null;
+    static API_SERVER_URI_CONSTANT_PART__WITHOUT_TRAILING_SLASH = null;
+    static URI_QueryParametersSerializer = serializeURI_QueryParameters_1.default;
+    static set API_SERVER_URI_CONSTANT_PART(value) {
+        AJAX_Service.API_SERVER_URI_CONSTANT_PART__WITHOUT_TRAILING_SLASH = (0, removeSpecificCharacterFromCertainPosition_1.default)({
+            targetString: value,
+            targetCharacter: "/",
+            fromLastPosition: true
+        });
+    }
+    static setup(properties) {
+        if ((0, isNotUndefined_1.default)(properties.implementation)) {
+            AJAX_Service.implementation = properties.implementation;
+        }
+        if ((0, isNotUndefined_1.default)(properties.API_ServerURI_ConstantPart)) {
+            AJAX_Service.API_SERVER_URI_CONSTANT_PART = properties.API_ServerURI_ConstantPart;
+        }
+        if ((0, isNotUndefined_1.default)(properties.URI_QueryParametersSerializer)) {
+            AJAX_Service.URI_QueryParametersSerializer = properties.URI_QueryParametersSerializer;
+        }
+    }
+    static async retrieveData(compoundParameter) {
+        return AJAX_Service.getExpectedToBeInitializedImplementation().retrieveData(compoundParameter);
+    }
+    static async submitData(compoundParameter) {
+        return AJAX_Service.getExpectedToBeInitializedImplementation().submitData(compoundParameter);
+    }
+    static async retrieveText(compoundParameter) {
+        return AJAX_Service.getExpectedToBeInitializedImplementation().retrieveText(compoundParameter);
+    }
+    async retrieveData(compoundParameter) {
+        let rawObjectDataResponse;
+        try {
+            rawObjectDataResponse = await this.retrieveResponseWithRawObjectData({
+                URI: this.normalizeURI(compoundParameter),
+                HTTP_Method: compoundParameter.HTTP_Method ?? fundamental_constants_1.HTTP_Methods.get,
+                HTTP_Headers: compoundParameter.HTTP_Headers ?? {},
+                mustIncludeCookiesAndAuthenticationHeadersToRequest: compoundParameter.mustIncludeCookiesAndAuthenticationHeadersToRequest === true
+            });
+        }
+        catch (error) {
+            Logger_1.default.throwErrorWithFormattedMessage({
+                errorInstance: new DataRetrievingFailedError_1.default({
+                    customMessage: "The retrieving data by AJAX has failed."
+                }),
+                title: DataRetrievingFailedError_1.default.localization.defaultTitle,
+                occurrenceLocation: "AJAX_Service.retrieveData(compoundParameter)",
+                innerError: error
+            });
+        }
+        return AJAX_Service.normalizeRawObjectDataResponse(rawObjectDataResponse, compoundParameter.validResponseDataSpecification);
+    }
+    async submitData(compoundParameter) {
+        let rawObjectDataResponse;
+        try {
+            rawObjectDataResponse = await this.submitAndGetRawResponseDataIfAvailable({
+                URI: this.normalizeURI(compoundParameter),
+                HTTP_Method: compoundParameter.HTTP_Method ?? fundamental_constants_1.HTTP_Methods.get,
+                HTTP_Headers: compoundParameter.HTTP_Headers ?? {},
+                requestData: compoundParameter.requestData,
+                mustExpectResponseData: (0, isNotUndefined_1.default)(compoundParameter.validResponseDataSpecification),
+                mustIncludeCookiesAndAuthenticationHeadersToRequest: compoundParameter.mustIncludeCookiesAndAuthenticationHeadersToRequest === true
+            });
+        }
+        catch (error) {
+            Logger_1.default.throwErrorWithFormattedMessage({
+                errorInstance: new DataSubmittingFailedError_1.default({
+                    customMessage: "The submitting of the data by AJAX has failed."
+                }),
+                title: DataSubmittingFailedError_1.default.localization.defaultTitle,
+                occurrenceLocation: "AJAX_Service.submitData(compoundParameter)",
+                innerError: error
+            });
+        }
+        if ((0, isUndefined_1.default)(compoundParameter.validResponseDataSpecification)) {
+            return {
+                ...rawObjectDataResponse.isSuccessful ?
+                    {
+                        isSuccessful: true,
+                        data: rawObjectDataResponse.data
+                    } :
+                    {
+                        isSuccessful: false,
+                        ..."errorObjectPayload" in rawObjectDataResponse ?
+                            { errorObjectPayload: rawObjectDataResponse.errorObjectPayload } :
+                            { errorTextPayload: rawObjectDataResponse.errorTextPayload }
+                    },
+                HTTP_Headers: rawObjectDataResponse.HTTP_Headers,
+                HTTP_Status: rawObjectDataResponse.HTTP_Status
+            };
+        }
+        return AJAX_Service.normalizeRawObjectDataResponse(rawObjectDataResponse, compoundParameter.validResponseDataSpecification);
+    }
+    async retrieveText(compoundParameter) {
+        return this.retrieveResponseWithTextData({
+            URI: this.normalizeURI(compoundParameter),
+            HTTP_Method: compoundParameter.HTTP_Method ?? fundamental_constants_1.HTTP_Methods.get,
+            HTTP_Headers: compoundParameter.HTTP_Headers ?? {},
+            ...(0, isNotUndefined_1.default)(compoundParameter.requestData) ? { requestData: compoundParameter.requestData } : null,
+            mustIncludeCookiesAndAuthenticationHeadersToRequest: compoundParameter.mustIncludeCookiesAndAuthenticationHeadersToRequest === true
+        });
+    }
+    normalizeURI(compoundParameter) {
+        const targetURI_PartUntilPath = this.normalizeURI_UntilPath(compoundParameter);
+        const URI_QueryParameters = compoundParameter.URI_QueryParameters ?? {};
+        let serializedQueryParameters;
+        if (Object.entries(URI_QueryParameters).length > 0) {
+            serializedQueryParameters =
+                compoundParameter.URI_QueryParametersSerializer?.(URI_QueryParameters) ??
+                    AJAX_Service.URI_QueryParametersSerializer(URI_QueryParameters);
+        }
+        return targetURI_PartUntilPath +
+            (0, insertSubstring_1.default)(serializedQueryParameters, { modifier: (nonEmptySerializedQueryParameters) => `?${nonEmptySerializedQueryParameters}` });
+    }
+    normalizeURI_UntilPath(URI_PathRawDefinition) {
+        if ((0, isNonEmptyString_1.default)(URI_PathRawDefinition.alternatingURI_PathPart)) {
+            if ((0, isNull_1.default)(AJAX_Service.API_SERVER_URI_CONSTANT_PART__WITHOUT_TRAILING_SLASH)) {
+                Logger_1.default.throwErrorWithFormattedMessage({
+                    errorInstance: new InvalidConfigError_1.default({
+                        customMessage: "The \"alternatingURI_PathPart\" has been specified while the static field " +
+                            "\"API_SERVER_URI_CONSTANT_PART\" has not been set."
+                    }),
+                    title: InvalidConfigError_1.default.localization.defaultTitle,
+                    occurrenceLocation: "AJAX_Service.normalizeURI_UntilPath(URI_PathRawDefinition)"
+                });
+            }
+            return encodeURI(`${AJAX_Service.API_SERVER_URI_CONSTANT_PART__WITHOUT_TRAILING_SLASH}/` +
+                (0, removeSpecificCharacterFromCertainPosition_1.default)({
+                    targetString: URI_PathRawDefinition.alternatingURI_PathPart,
+                    targetCharacter: "/",
+                    fromFirstPosition: true
+                }));
+        }
+        if ((0, isNonEmptyString_1.default)(URI_PathRawDefinition.specificURI_UntilPath)) {
+            return encodeURI(URI_PathRawDefinition.specificURI_UntilPath);
+        }
+        Logger_1.default.throwErrorWithFormattedMessage({
+            errorInstance: new InvalidParameterValueError_1.default({
+                customMessage: "Either \"alternatingURI_PathPart\" or \"specificURI_UntilPath\" must be specified with non-empty " +
+                    "strings while neither has been."
+            }),
+            title: InvalidParameterValueError_1.default.localization.defaultTitle,
+            occurrenceLocation: "AJAX_Service.normalizeURI_UntilPath(URI_PathRawDefinition)"
+        });
+    }
+    static normalizeRawObjectDataResponse(rawObjectDataResponse, validResponseDataSpecification) {
+        if (rawObjectDataResponse.isSuccessful) {
+            const responseRawDataProcessingResult = RawObjectDataProcessor_1.default.process(rawObjectDataResponse.data, validResponseDataSpecification);
+            if (responseRawDataProcessingResult.isRawDataInvalid) {
+                Logger_1.default.throwErrorWithFormattedMessage({
+                    errorInstance: new InvalidExternalDataError_1.default({
+                        mentionToExpectedData: "HTTP_ResponseData",
+                        messageSpecificPart: RawObjectDataProcessor_1.default.formatValidationErrorsList(responseRawDataProcessingResult.validationErrorsMessages)
+                    }),
+                    title: InvalidExternalDataError_1.default.localization.defaultTitle,
+                    occurrenceLocation: "AJAX_Service.normalizeRawObjectDataResponse(rawObjectDataResponse, validResponseDataSpecification)"
+                });
+            }
+            return {
+                isSuccessful: true,
+                data: responseRawDataProcessingResult.processedData,
+                HTTP_Headers: rawObjectDataResponse.HTTP_Headers,
+                HTTP_Status: rawObjectDataResponse.HTTP_Status
+            };
+        }
+        return {
+            isSuccessful: false,
+            ..."errorObjectPayload" in rawObjectDataResponse ?
+                { errorObjectPayload: rawObjectDataResponse.errorObjectPayload } :
+                { errorTextPayload: rawObjectDataResponse.errorTextPayload },
+            HTTP_Headers: rawObjectDataResponse.HTTP_Headers,
+            HTTP_Status: rawObjectDataResponse.HTTP_Status
+        };
+    }
+    static getExpectedToBeInitializedImplementation() {
+        if ((0, isNull_1.default)(AJAX_Service.implementation)) {
+            Logger_1.default.throwErrorWithFormattedMessage({
+                errorType: "ImplementationHasNotBeenSetError",
+                title: "Implementation has not been set",
+                description: "To use the static methods of \"AJAX_Service\" class and its inheritors, it is required to set " +
+                    "the \"implementation\" public static field first or use \"setup\" static method.",
+                occurrenceLocation: "AJAX_Service.getExpectedToBeInitializedImplementation()"
+            });
+        }
+        return AJAX_Service.implementation;
+    }
+}
+exports.default = AJAX_Service;

package/Distributable/cjs/AJAX/FetchAPI_Service.js

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AJAX_Service_1 = __importDefault(require("./AJAX_Service"));
+const Logger_1 = __importDefault(require("../Logging/Logger"));
+const DataRetrievingFailedError_1 = __importDefault(require("../Errors/DataRetrievingFailed/DataRetrievingFailedError"));
+const DataSubmittingFailedError_1 = __importDefault(require("../Errors/DataSubmittingFailed/DataSubmittingFailedError"));
+const UnsupportedScenarioError_1 = __importDefault(require("../Errors/UnsupportedScenario/UnsupportedScenarioError"));
+const isPossiblyReadonlyParsedJSON_1 = __importDefault(require("../TypeGuards/ParsedJSON/isPossiblyReadonlyParsedJSON"));
+const HTTP_ResponseBodyParsingFailureError_1 = __importDefault(require("../Errors/HTTP/ResponseBodyParsingFailure/HTTP_ResponseBodyParsingFailureError"));
+const isNotUndefined_1 = __importDefault(require("../TypeGuards/EmptyTypes/isNotUndefined"));
+class FetchAPI_Service extends AJAX_Service_1.default {
+    async retrieveResponseWithRawObjectData(compoundParameter) {
+        let response;
+        try {
+            response = await fetch(compoundParameter.URI, {
+                method: compoundParameter.HTTP_Method,
+                headers: { ...compoundParameter.HTTP_Headers },
+                ...compoundParameter.mustIncludeCookiesAndAuthenticationHeadersToRequest ? { credentials: "include" } : null
+            });
+        }
+        catch (error) {
+            Logger_1.default.throwErrorWithFormattedMessage({
+                errorInstance: new DataRetrievingFailedError_1.default({
+                    customMessage: "The error has occurred before response has been retrieved."
+                }),
+                title: DataRetrievingFailedError_1.default.localization.defaultTitle,
+                occurrenceLocation: "FetchAPI_Service.retrieveResponseWithRawData(compoundParameter)",
+                innerError: error
+            });
+        }
+        return {
+            ...response.ok ?
+                {
+                    isSuccessful: true,
+                    data: await FetchAPI_Service.extractRawObjectDataFromResponse(response)
+                } :
+                {
+                    isSuccessful: false,
+                    ...await FetchAPI_Service.extractErrorPayloadFromResponse(response)
+                },
+            HTTP_Headers: Array.from(response.headers).reduce((HTTP_Headers, [key, value]) => {
+                HTTP_Headers[key] = value;
+                return HTTP_Headers;
+            }, {}),
+            HTTP_Status: response.status
+        };
+    }
+    async submitAndGetRawResponseDataIfAvailable(compoundParameter) {
+        let response;
+        try {
+            response = await fetch(compoundParameter.URI, {
+                method: compoundParameter.HTTP_Method,
+                headers: {
+                    "Content-Type": "application/json; charset=UTF-8",
+                    ...compoundParameter.HTTP_Headers
+                },
+                body: JSON.stringify(compoundParameter.requestData),
+                ...compoundParameter.mustIncludeCookiesAndAuthenticationHeadersToRequest ? { credentials: "include" } : null
+            });
+        }
+        catch (error) {
+            Logger_1.default.throwErrorWithFormattedMessage({
+                errorInstance: new DataSubmittingFailedError_1.default({
+                    customMessage: "The error has occurred before server response has been retrieved."
+                }),
+                title: DataSubmittingFailedError_1.default.localization.defaultTitle,
+                occurrenceLocation: "FetchAPI_Service.submitAndGetRawResponseDataIfAvailable(compoundParameter)",
+                innerError: error
+            });
+        }
+        return {
+            ...response.ok ?
+                {
+                    isSuccessful: true,
+                    data: compoundParameter.mustExpectResponseData ?
+                        await FetchAPI_Service.extractRawObjectDataFromResponse(response) : {}
+                } :
+                {
+                    isSuccessful: false,
+                    ...await FetchAPI_Service.extractErrorPayloadFromResponse(response)
+                },
+            HTTP_Headers: Array.from(response.headers).reduce((HTTP_Headers, [key, value]) => {
+                HTTP_Headers[key] = value;
+                return HTTP_Headers;
+            }, {}),
+            HTTP_Status: response.status
+        };
+    }
+    async retrieveResponseWithTextData(compoundParameter) {
+        let response;
+        try {
+            response = await fetch(compoundParameter.URI, {
+                method: compoundParameter.HTTP_Method,
+                headers: {
+                    ...(0, isNotUndefined_1.default)(compoundParameter.requestData) ? { "Content-Type": "application/json; charset=UTF-8" } : null,
+                    ...compoundParameter.HTTP_Headers
+                },
+                ...(0, isNotUndefined_1.default)(compoundParameter.requestData) ? { body: JSON.stringify(compoundParameter.requestData) } : null,
+                ...compoundParameter.mustIncludeCookiesAndAuthenticationHeadersToRequest ? { credentials: "include" } : null
+            });
+        }
+        catch (error) {
+            Logger_1.default.throwErrorWithFormattedMessage({
+                errorInstance: new DataRetrievingFailedError_1.default({
+                    customMessage: "The error has occurred before response has been retrieved."
+                }),
+                title: DataRetrievingFailedError_1.default.localization.defaultTitle,
+                occurrenceLocation: "FetchAPI_Service.retrieveResponseWithTextData(compoundParameter)",
+                innerError: error
+            });
+        }
+        let decodedText;
+        if (response.ok) {
+            try {
+                decodedText = await response.text();
+            }
+            catch (error) {
+                Logger_1.default.throwErrorWithFormattedMessage({
+                    errorInstance: new HTTP_ResponseBodyParsingFailureError_1.default("The HTTP response body could not be represented as text."),
+                    title: HTTP_ResponseBodyParsingFailureError_1.default.localization.defaultTitle,
+                    occurrenceLocation: "FetchAPI_Service.retrieveResponseWithTextData(compoundParameter)",
+                    innerError: error
+                });
+            }
+        }
+        return {
+            ...(0, isNotUndefined_1.default)(decodedText) ?
+                {
+                    isSuccessful: true,
+                    text: decodedText
+                } : {
+                isSuccessful: false,
+                ...await FetchAPI_Service.extractErrorPayloadFromResponse(response)
+            },
+            HTTP_Headers: Array.from(response.headers).reduce((HTTP_Headers, [key, value]) => {
+                HTTP_Headers[key] = value;
+                return HTTP_Headers;
+            }, {}),
+            HTTP_Status: response.status
+        };
+    }
+    static async extractRawObjectDataFromResponse(response) {
+        let responseRawData;
+        try {
+            responseRawData = await response.json();
+        }
+        catch (error) {
+            Logger_1.default.throwErrorWithFormattedMessage({
+                errorInstance: new HTTP_ResponseBodyParsingFailureError_1.default("The HTTP response body could not be represented as JSON."),
+                title: HTTP_ResponseBodyParsingFailureError_1.default.localization.defaultTitle,
+                occurrenceLocation: "FetchAPI_Service.extractRawObjectDataFromResponse(response)",
+                innerError: error
+            });
+        }
+        if (!(0, isPossiblyReadonlyParsedJSON_1.default)(responseRawData)) {
+            Logger_1.default.throwErrorWithFormattedMessage({
+                errorInstance: new UnsupportedScenarioError_1.default(`The data has type "${typeof responseRawData}" while currently non-object data in not supported.`),
+                title: UnsupportedScenarioError_1.default.localization.defaultTitle,
+                occurrenceLocation: "FetchAPI_Service.extractRawObjectDataFromResponse(response)"
+            });
+        }
+        return responseRawData;
+    }
+    static async extractErrorPayloadFromResponse(response) {
+        const contentType = response.headers.get("content-type");
+        if (contentType?.includes("application/json") === true) {
+            let objectTypeData;
+            try {
+                objectTypeData = await response.json();
+            }
+            catch (error) {
+                Logger_1.default.throwErrorWithFormattedMessage({
+                    errorInstance: new HTTP_ResponseBodyParsingFailureError_1.default("The HTTP response body could not be represented as JSON while \"content-type\" HTTP header is includes " +
+                        "\"application/json\"."),
+                    title: HTTP_ResponseBodyParsingFailureError_1.default.localization.defaultTitle,
+                    occurrenceLocation: "FetchAPI_Service.extractErrorPayloadFromResponse(response)",
+                    innerError: error
+                });
+            }
+            if (!(0, isPossiblyReadonlyParsedJSON_1.default)(objectTypeData)) {
+                Logger_1.default.throwErrorWithFormattedMessage({
+                    errorInstance: new UnsupportedScenarioError_1.default(`The data has type "${typeof objectTypeData}" while currently non-object data in not supported.`),
+                    title: UnsupportedScenarioError_1.default.localization.defaultTitle,
+                    occurrenceLocation: "FetchAPI_Service.extractRawObjectDataFromResponse(response)"
+                });
+            }
+            return { errorObjectPayload: objectTypeData };
+        }
+        if (contentType?.includes("text") === true) {
+            let decodedText;
+            try {
+                decodedText = await response.text();
+            }
+            catch (error) {
+                Logger_1.default.throwErrorWithFormattedMessage({
+                    errorInstance: new HTTP_ResponseBodyParsingFailureError_1.default("The HTTP response body could not be represented as text while \"content-type\" HTTP header is includes " +
+                        "\"text\"."),
+                    title: HTTP_ResponseBodyParsingFailureError_1.default.localization.defaultTitle,
+                    occurrenceLocation: "FetchAPI_Service.extractRawObjectDataFromResponse(compoundParameter)",
+                    innerError: error
+                });
+            }
+            return { errorTextPayload: decodedText };
+        }
+        return { errorObjectPayload: {} };
+    }
+}
+exports.default = FetchAPI_Service;

package/Distributable/cjs/AJAX/URI_QueryParametersSerializer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/Distributable/cjs/AJAX/serializeURI_QueryParameters.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isString_1 = __importDefault(require("../TypeGuards/Strings/isString"));
+const index_1 = require("../index");
+const serializeURI_QueryParameters = (URI_QueryParameters) => {
+    const stringifiedKeysAndValueParis = [];
+    for (const [key, value] of Object.entries(URI_QueryParameters)) {
+        if ((0, isString_1.default)(value) || (0, index_1.isNumber)(value, { mustConsiderNaN_AsNumber: true }) || (0, index_1.isBoolean)(value)) {
+            stringifiedKeysAndValueParis.push(`${key}=${value}`);
+        }
+    }
+    return stringifiedKeysAndValueParis.join("&");
+};
+exports.default = serializeURI_QueryParameters;

package/Distributable/cjs/Arrays/00-Creating/createArrayOfNaturalNumbers.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createArrayOfNaturalNumbers;
+const isNaturalNumberOrZero_1 = __importDefault(require("../../TypeGuards/Numbers/isNaturalNumberOrZero"));
+const isNaturalNumber_1 = __importDefault(require("../../TypeGuards/Numbers/isNaturalNumber"));
+const Logger_1 = __importDefault(require("../../Logging/Logger"));
+const InvalidParameterValueError_1 = __importDefault(require("../../Errors/InvalidParameterValue/InvalidParameterValueError"));
+function createArrayOfNaturalNumbers({ elementsCount, isDescendingOrder = false, startingNumber = isDescendingOrder ? (elementsCount === 0 ? 1 : elementsCount) : 1 }) {
+    if (!(0, isNaturalNumberOrZero_1.default)(elementsCount)) {
+        Logger_1.default.throwErrorWithFormattedMessage({
+            errorInstance: new InvalidParameterValueError_1.default({
+                parameterNumber: 1,
+                parameterName: "options",
+                messageSpecificPart: `The \`elementsCount\` must be the natural number or zero while ${elementsCount} has been specified.`
+            }),
+            title: InvalidParameterValueError_1.default.localization.defaultTitle,
+            occurrenceLocation: "createArrayOfNaturalNumbers(options)"
+        });
+    }
+    if (!(0, isNaturalNumber_1.default)(startingNumber)) {
+        Logger_1.default.throwErrorWithFormattedMessage({
+            errorInstance: new InvalidParameterValueError_1.default({
+                parameterNumber: 1,
+                parameterName: "options",
+                messageSpecificPart: `The \`startingNumber\` must the natural number while ${elementsCount} has been specified.`
+            }),
+            title: InvalidParameterValueError_1.default.localization.defaultTitle,
+            occurrenceLocation: "createArrayOfNaturalNumbers(options)"
+        });
+    }
+    if (isDescendingOrder && startingNumber < elementsCount) {
+        Logger_1.default.throwErrorWithFormattedMessage({
+            errorInstance: new InvalidParameterValueError_1.default({
+                parameterNumber: 1,
+                parameterName: "options",
+                messageSpecificPart: `The specified \`startingNumber\` ${startingNumber} is smaller than requested ${elementsCount} ` +
+                    "elements count. " +
+                    "The monotonically decreasing array of natural numbers could not be created with such conditions."
+            }),
+            title: InvalidParameterValueError_1.default.localization.defaultTitle,
+            occurrenceLocation: "createArrayOfNaturalNumbers(options)"
+        });
+    }
+    return Array.from(new Array(elementsCount).keys()).
+        map((elementAsIndex) => startingNumber + (isDescendingOrder ? -elementAsIndex : elementAsIndex));
+}

package/Distributable/cjs/Arrays/01-RetrievingOfElements/getArrayElementSatisfiesThePredicateIfSuchElementIsExactlyOne.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getArrayElementSatisfiesThePredicateIfSuchElementIsExactlyOne;
+const Logger_1 = __importDefault(require("../../Logging/Logger"));
+const UnexpectedEventError_1 = __importDefault(require("../../Errors/UnexpectedEvent/UnexpectedEventError"));
+function getArrayElementSatisfiesThePredicateIfSuchElementIsExactlyOne(targetArray, predicate, options = {}) {
+    const allElementsMatchingWithPredicate = targetArray.filter(predicate);
+    if (allElementsMatchingWithPredicate.length === 0) {
+        if (options.mustThrowErrorIfElementNotFoundOrMatchesAreMultiple === true) {
+            Logger_1.default.throwErrorWithFormattedMessage({
+                errorInstance: new UnexpectedEventError_1.default("Array element satisfies the specified predicate not found."),
+                title: UnexpectedEventError_1.default.localization.defaultTitle,
+                occurrenceLocation: "getArrayElementSatisfiesThePredicateIfSuchElementIsExactlyOne(targetArray, predicate, options)"
+            });
+        }
+        return null;
+    }
+    if (allElementsMatchingWithPredicate.length > 1) {
+        if (options.mustThrowErrorIfElementNotFoundOrMatchesAreMultiple === true) {
+            Logger_1.default.throwErrorWithFormattedMessage({
+                errorInstance: new UnexpectedEventError_1.default("There are multiple elements satisfies the predicate. " +
+                    "As it follows from the function name, two or more matches case is being considered as the unexpected event."),
+                title: UnexpectedEventError_1.default.localization.defaultTitle,
+                occurrenceLocation: "getArrayElementSatisfiesThePredicateIfSuchElementIsExactlyOne(targetArray, predicate, options)"
+            });
+        }
+        return null;
+    }
+    return allElementsMatchingWithPredicate[0];
+}

package/Distributable/cjs/Arrays/01-RetrievingOfElements/getLastElementOfArray.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getLastElementOfArray;
+const isUndefined_1 = __importDefault(require("../../TypeGuards/EmptyTypes/isUndefined"));
+const Logger_1 = __importDefault(require("../../Logging/Logger"));
+const UnexpectedEventError_1 = __importDefault(require("../../Errors/UnexpectedEvent/UnexpectedEventError"));
+function getLastElementOfArray(targetArray, options) {
+    const lastElementOfTargetArray = targetArray[targetArray.length - 1];
+    if ((0, isUndefined_1.default)(lastElementOfTargetArray)) {
+        if (options?.mustThrowErrorIfArrayIsEmpty === true) {
+            Logger_1.default.throwErrorWithFormattedMessage({
+                errorInstance: new UnexpectedEventError_1.default("Contrary to expectations, target array is empty thus there is no the last element could be accessed."),
+                title: UnexpectedEventError_1.default.localization.defaultTitle,
+                occurrenceLocation: "getLastElementOfArray(targetArray, options)"
+            });
+        }
+        return null;
+    }
+    return lastElementOfTargetArray;
+}

package/Distributable/cjs/Arrays/02-RetrievingOfIndexes/getIndexOfArrayElementSatisfiesThePredicateIfSuchElementIsExactlyOne.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getIndexOfArrayElementSatisfiesThePredicateIfSuchElementIsExactlyOne;
+const Logger_1 = __importDefault(require("../../Logging/Logger"));
+const UnexpectedEventError_1 = __importDefault(require("../../Errors/UnexpectedEvent/UnexpectedEventError"));
+function getIndexOfArrayElementSatisfiesThePredicateIfSuchElementIsExactlyOne(targetArray, predicate, options = {}) {
+    const indexesOfAllElementsSatisfiesThePredicate = [];
+    for (const [index, element] of targetArray.entries()) {
+        if (predicate(element)) {
+            indexesOfAllElementsSatisfiesThePredicate.push(index);
+        }
+    }
+    if (indexesOfAllElementsSatisfiesThePredicate.length === 0) {
+        if (options.mustThrowErrorIfElementNotFoundOrMatchesAreMultiple === true) {
+            Logger_1.default.throwErrorWithFormattedMessage({
+                errorInstance: new UnexpectedEventError_1.default("Array element satisfies to specified predicate not found."),
+                title: UnexpectedEventError_1.default.localization.defaultTitle,
+                occurrenceLocation: "getIndexOfArrayElementSatisfiesThePredicateIfSuchElementIsExactlyOne" +
+                    "(targetArray, predicate, options)"
+            });
+        }
+        return null;
+    }
+    if (indexesOfAllElementsSatisfiesThePredicate.length > 1) {
+        if (options.mustThrowErrorIfElementNotFoundOrMatchesAreMultiple === true) {
+            Logger_1.default.throwErrorWithFormattedMessage({
+                errorInstance: new UnexpectedEventError_1.default("There are multiple elements satisfies the predicate. As it follows from the function name, two or more " +
+                    "matches case is being considered as unexpected event."),
+                title: UnexpectedEventError_1.default.localization.defaultTitle,
+                occurrenceLocation: "getIndexOfArrayElementSatisfiesThePredicateIfSuchElementIsExactlyOne" +
+                    "(targetArray, predicate, options)"
+            });
+        }
+        return null;
+    }
+    return indexesOfAllElementsSatisfiesThePredicate[0];
+}

package/Distributable/cjs/Arrays/02-RetrievingOfIndexes/getIndexesOfSatisfiesThePredicateArrayElements.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getIndexesOfSatisfiesThePredicateArrayElements;
+function getIndexesOfSatisfiesThePredicateArrayElements(targetArray, predicate) {
+    return targetArray.flatMap((arrayElement, index) => (predicate(arrayElement) ? index : []));
+}