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

package/Distributable/cjs/AJAX/AJAX_Service.js

@@ -139,7 +139,7 @@ class AJAX_Service {
                 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."
+                            "\"API_SERVER_URI_CONSTANT_PART__WITHOUT_TRAILING_SLASH\" has not been set."
                     }),
                     title: InvalidConfigError_1.default.localization.defaultTitle,
                     occurrenceLocation: "AJAX_Service.normalizeURI_UntilPath(URI_PathRawDefinition)"

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

@@ -12,7 +12,7 @@ function getLastElementOfArray(targetArray, options) {
     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."),
+                errorInstance: new UnexpectedEventError_1.default("Contrary to expectations, target array is empty thus there is no the last element can be accessed."),
                 title: UnexpectedEventError_1.default.localization.defaultTitle,
                 occurrenceLocation: "getLastElementOfArray(targetArray, options)"
             });

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

@@ -27,8 +27,8 @@ function getIndexOfArrayElementSatisfiesThePredicateIfSuchElementIsExactlyOne(ta
     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."),
+                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)"

package/Distributable/cjs/Arrays/05-ReplacingOfElements/replaceArrayElementsByIndexesImmutably.js

@@ -27,11 +27,11 @@ function replaceArrayElementsByIndexesImmutably(sourceDataAndOptions) {
                     "● The combination of:\n " +
                     "○ \"index\": must the either natural number or 0\n" +
                     "○ \"newElement\": must corresponding to type of elements of the target array\n" +
-                    "● \"replacements\": The array of objects with above \"index\" and \"newElement\" properties and same " +
+                    "● \"replacements\": the array of objects with above \"index\" and \"newElement\" properties and same " +
                     "limitations"
             }),
             title: InvalidParameterValueError_1.default.localization.defaultTitle,
-            occurrenceLocation: "addElementsToArray(compoundParameter)"
+            occurrenceLocation: "replaceArrayElementsByIndexesImmutably(sourceDataAndOptions)"
         });
     }
     for (const replacement of replacements) {

package/Distributable/cjs/Arrays/06-PermutationsOfElements/ObjectTypeElementsArrayOrdererByMultipleFields.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectTypeElementsArrayOrdererByMultipleFields = void 0;
+class ObjectTypeElementsArrayOrdererByMultipleFields {
+    static order({ targetArray, mutably, elementsComparers, finalElementsStableComparer }) {
+        const arrayWorkpiece = mutably ? targetArray : [...targetArray];
+        if (arrayWorkpiece.length < 2 || elementsComparers.length === 0) {
+            return arrayWorkpiece;
+        }
+        let similarElementsGroups = ObjectTypeElementsArrayOrdererByMultipleFields.assignMultipleElementsToGroups(arrayWorkpiece, elementsComparers[0]);
+        for (const compareElements of elementsComparers.slice(1)) {
+            similarElementsGroups =
+                ObjectTypeElementsArrayOrdererByMultipleFields.updateGroups(similarElementsGroups, compareElements);
+        }
+        similarElementsGroups =
+            ObjectTypeElementsArrayOrdererByMultipleFields.updateGroups(similarElementsGroups, finalElementsStableComparer);
+        return similarElementsGroups.flatMap((group) => group.elements);
+    }
+    static updateGroups(groups, compareElements) {
+        const updatedGroups = [];
+        for (const group of groups) {
+            if (group.elements.length === 1) {
+                updatedGroups.push({ elements: [...group.elements] });
+                continue;
+            }
+            updatedGroups.push(...ObjectTypeElementsArrayOrdererByMultipleFields.assignMultipleElementsToGroups(group.elements, compareElements));
+        }
+        return updatedGroups;
+    }
+    static assignMultipleElementsToGroups(elementsOfParentGroup, compareElements) {
+        const groups = [{ elements: [elementsOfParentGroup[0]] }];
+        for (let index = 1; index < elementsOfParentGroup.length; index++) {
+            const targetElement = elementsOfParentGroup[index];
+            let hasCurrentElementBeenAssignedToGroup = false;
+            let wasFirstElementGreaterThanSecondOne = false;
+            for (const [groupIndex, group] of groups.entries()) {
+                const comparisonResult = compareElements(targetElement, group.elements[0]);
+                if (Reflect.get(comparisonResult, "firstElementIsStrictlyGreater") === true) {
+                    wasFirstElementGreaterThanSecondOne = true;
+                }
+                else if ("elementsAreEquals" in comparisonResult) {
+                    group.elements.push(targetElement);
+                    hasCurrentElementBeenAssignedToGroup = true;
+                    break;
+                }
+                else {
+                    if (wasFirstElementGreaterThanSecondOne) {
+                        groups.splice(groupIndex, 0, { elements: [targetElement] });
+                        hasCurrentElementBeenAssignedToGroup = true;
+                        break;
+                    }
+                }
+            }
+            if (!hasCurrentElementBeenAssignedToGroup) {
+                if (wasFirstElementGreaterThanSecondOne) {
+                    groups.push({ elements: [targetElement] });
+                }
+                else {
+                    groups.unshift({ elements: [targetElement] });
+                }
+            }
+        }
+        return groups;
+    }
+}
+exports.ObjectTypeElementsArrayOrdererByMultipleFields = ObjectTypeElementsArrayOrdererByMultipleFields;
+exports.default = ObjectTypeElementsArrayOrdererByMultipleFields.order;

package/Distributable/cjs/Arrays/06-PermutationsOfElements/moveArrayElementToOnePosition.js

@@ -15,7 +15,7 @@ function moveArrayElementToOnePosition({ mutably, targetArray, toLeft, errorMust
                 errorInstance: new InvalidParameterValueError_1.default({
                     parameterNumber: 1,
                     parameterName: "sourceDataAndOptions",
-                    messageSpecificPart: `Target array must contain at least 2 elements while actually contains ${targetArray.length}. ` +
+                    messageSpecificPart: `Target array must contain at least 2 elements while actually contains ${targetArray.length} ones. ` +
                         "This case is being considered as an error when \"errorMustBeThrownIf.elementsCountIsLessThan2\" " +
                         "flag has been set to \"true\"."
                 }),

package/Distributable/cjs/Arrays/08-Restructuring/twoDimensionalizeArray.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = twoDimensionalizeArray;
-function twoDimensionalizeArray(sourceData) {
+function twoDimensionalizeArray({ targetFlatArray, elementsCountPerNestedArray }) {
     const twoDimensionalArray = [];
-    const elementsCountInTargetFlatArray = sourceData.targetFlatArray.length;
+    const elementsCountInTargetFlatArray = targetFlatArray.length;
     let nestedArray = [];
-    for (const [index, arrayElement] of sourceData.targetFlatArray.entries()) {
+    for (const [index, arrayElement] of targetFlatArray.entries()) {
         nestedArray.push(arrayElement);
         const hasNextElement = index !== elementsCountInTargetFlatArray - 1;
         if (hasNextElement) {
-            if (nestedArray.length === sourceData.elementsCountPerNestedArray) {
+            if (nestedArray.length === elementsCountPerNestedArray) {
                 twoDimensionalArray.push(nestedArray);
                 nestedArray = [];
             }

package/Distributable/cjs/DataMocking/LocalizableMocking/LocalizableEntitiesByIDsMap.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class LocalizableEntitiesByIDsMap extends Map {
+    getEntityID;
+    constructor({ initialEntitiesWithLocalizations, getEntityID }) {
+        super((initialEntitiesWithLocalizations ?? []).
+            map(({ entity, localizations }) => [
+            getEntityID(entity),
+            {
+                entity,
+                localizations
+            }
+        ]));
+        this.getEntityID = getEntityID;
+    }
+    addEntityWithLocalization({ entity, localizations }) {
+        super.set(this.getEntityID(entity), {
+            entity,
+            localizations
+        });
+    }
+    addEntitiesWithLocalizations(entitiesWithLocalization) {
+        for (const { entity, localizations } of entitiesWithLocalization) {
+            this.set(this.getEntityID(entity), { entity, localizations });
+        }
+    }
+}
+(function (LocalizableEntitiesByIDsMap) {
+    let EntityWithLocalizations;
+    (function (EntityWithLocalizations) {
+        function createLocalizations(localizationsKeysEnumeration, createLocalization) {
+            return Object.values(localizationsKeysEnumeration).reduce((interimLocalizations, localizationKey) => {
+                interimLocalizations[localizationKey] = createLocalization(localizationKey);
+                return interimLocalizations;
+            }, {});
+        }
+        EntityWithLocalizations.createLocalizations = createLocalizations;
+    })(EntityWithLocalizations = LocalizableEntitiesByIDsMap.EntityWithLocalizations || (LocalizableEntitiesByIDsMap.EntityWithLocalizations = {}));
+})(LocalizableEntitiesByIDsMap || (LocalizableEntitiesByIDsMap = {}));
+exports.default = LocalizableEntitiesByIDsMap;

package/Distributable/cjs/DataMocking/LocalizableMocking/LocalizableSampleDataRepository.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const LocalizableEntitiesByIDsMap_1 = __importDefault(require("./LocalizableEntitiesByIDsMap"));
+const Logger_1 = __importDefault(require("../../Logging/Logger"));
+const UnexpectedEventError_1 = __importDefault(require("../../Errors/UnexpectedEvent/UnexpectedEventError"));
+const isUndefined_1 = __importDefault(require("../../TypeGuards/EmptyTypes/isUndefined"));
+const getEntriesOfObjectWithFixedKeysSetAndUniformValues_1 = __importDefault(require("../../Objects/getEntriesOfObjectWithFixedKeysSetAndUniformValues"));
+class LocalizableSampleDataRepository {
+    cachedSamplesWithLocalizationsByHumanFriendlyIDs;
+    get entitiesCount() {
+        return Object.entries(this.workpieces).length;
+    }
+    assignIDsAndGetLocalizableEntitiesMap({ preGeneratedIDs, mustCacheGeneratedSamples }) {
+        let samplesWithLocalizationsByHumanFriendlyIDs;
+        if ((0, isUndefined_1.default)(this.cachedSamplesWithLocalizationsByHumanFriendlyIDs)) {
+            const iterativelyGeneratedSamplesWithLocalizationByHumanFriendlyIDs = (0, getEntriesOfObjectWithFixedKeysSetAndUniformValues_1.default)(this.workpieces).
+                reduce((interimSamplesWithLocalizationByHumanFriendlyIDs, [humanReadableIDs, workpiece], index) => {
+                interimSamplesWithLocalizationByHumanFriendlyIDs[humanReadableIDs] =
+                    this.completeWorkpiece(preGeneratedIDs[index], workpiece);
+                return interimSamplesWithLocalizationByHumanFriendlyIDs;
+            }, {});
+            samplesWithLocalizationsByHumanFriendlyIDs =
+                iterativelyGeneratedSamplesWithLocalizationByHumanFriendlyIDs;
+        }
+        else {
+            samplesWithLocalizationsByHumanFriendlyIDs = this.cachedSamplesWithLocalizationsByHumanFriendlyIDs;
+        }
+        if (mustCacheGeneratedSamples) {
+            this.cachedSamplesWithLocalizationsByHumanFriendlyIDs = samplesWithLocalizationsByHumanFriendlyIDs;
+        }
+        return new LocalizableEntitiesByIDsMap_1.default({
+            getEntityID: this.getEntityID.bind(this),
+            initialEntitiesWithLocalizations: Object.values(samplesWithLocalizationsByHumanFriendlyIDs)
+        });
+    }
+    getExpectedBeInitializedSamplesWithLocalizationsByHumanFriendlyIDs() {
+        return this.cachedSamplesWithLocalizationsByHumanFriendlyIDs ??
+            Logger_1.default.throwErrorWithFormattedMessage({
+                errorInstance: new UnexpectedEventError_1.default("Contrary to expectations, the samples with localizations by human friendly IDs map has not been initialized."),
+                title: UnexpectedEventError_1.default.localization.defaultTitle,
+                occurrenceLocation: "InheritorOf<LocalizableSamplesRepository>." +
+                    "getExpectedBeInitializedSamplesWithLocalizationsByHumanFriendlyIDs(compoundParameter)"
+            });
+    }
+    static createLocalizations(workpiece, getLocaleDependentFields, composeLocalization) {
+        return (0, getEntriesOfObjectWithFixedKeysSetAndUniformValues_1.default)(getLocaleDependentFields(workpiece)).reduce((interimLocalizations, [languageBCP_47_Subtag, localeDependentFields]) => {
+            interimLocalizations[languageBCP_47_Subtag] = composeLocalization(languageBCP_47_Subtag, localeDependentFields);
+            return interimLocalizations;
+        }, {});
+    }
+}
+exports.default = LocalizableSampleDataRepository;

package/Distributable/cjs/Maps/getOneEntryOfMap.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getOneEntryOfMap;
+function getOneEntryOfMap(targetMap) {
+    return Array.from(targetMap.entries())[0];
+}

package/Distributable/cjs/Numbers/isStringifiedNonNegativeIntegerOfRegularNotation.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = isStringifiedNonNegativeIntegerOfRegularNotation;
 function isStringifiedNonNegativeIntegerOfRegularNotation(value) {
-    return (/^[1-9]\d*$/u).test(value);
+    return (/^(?:0|^[1-9]\d*)$/u).test(value);
 }

package/Distributable/cjs/Objects/getEntriesOfObjectWithFixedKeysSetAndUniformValues.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getEntriesOfObjectWithFixedKeysSetAndUniformValues;
+function getEntriesOfObjectWithFixedKeysSetAndUniformValues(targetObject) {
+    return Object.entries(targetObject);
+}

package/Distributable/cjs/Objects/getObjectPropertySafely.js

@@ -9,44 +9,46 @@ const Logger_1 = __importDefault(require("../Logging/Logger"));
 const InvalidParameterValueError_1 = __importDefault(require("../Errors/InvalidParameterValue/InvalidParameterValueError"));
 const isNonEmptyString_1 = __importDefault(require("../TypeGuards/Strings/isNonEmptyString"));
 const isArbitraryObject_1 = __importDefault(require("../TypeGuards/Objects/isArbitraryObject"));
+const isNaturalNumberOrZero_1 = __importDefault(require("../TypeGuards/Numbers/isNaturalNumberOrZero"));
 function getObjectPropertySafely(targetObject, dotSeparatedOrArrayedPathToTargetProperty) {
-    if (!(0, isNonEmptyString_1.default)(dotSeparatedOrArrayedPathToTargetProperty) &&
-        (!Array.isArray(dotSeparatedOrArrayedPathToTargetProperty) ||
-            dotSeparatedOrArrayedPathToTargetProperty.some((key) => !(0, isNonEmptyString_1.default)(key)))) {
-        Logger_1.default.logError({
-            errorType: InvalidParameterValueError_1.default.NAME,
-            title: InvalidParameterValueError_1.default.localization.defaultTitle,
-            description: InvalidParameterValueError_1.default.localization.generateDescription({
-                parameterNumber: 2,
-                parameterName: "dotSeparatedOrArrayedPathToTargetProperty",
-                messageSpecificPart: "This parameter must be either non-empty string or array of non-empty strings."
-            }),
-            occurrenceLocation: "getObjectPropertySafely(targetObject, dotSeparatedOrArrayedPathToTargetProperty)"
-        });
-        return;
-    }
     if (!(0, isArbitraryObject_1.default)(targetObject)) {
         return;
     }
     let targetPropertyPathSegments;
-    if (Array.isArray(dotSeparatedOrArrayedPathToTargetProperty)) {
+    if (Array.isArray(dotSeparatedOrArrayedPathToTargetProperty) &&
+        dotSeparatedOrArrayedPathToTargetProperty.length > 0 &&
+        dotSeparatedOrArrayedPathToTargetProperty.
+            every((key) => (0, isNonEmptyString_1.default)(key) || (0, isNaturalNumberOrZero_1.default)(key))) {
         targetPropertyPathSegments = dotSeparatedOrArrayedPathToTargetProperty;
     }
-    else {
+    else if ((0, isNaturalNumberOrZero_1.default)(dotSeparatedOrArrayedPathToTargetProperty)) {
+        targetPropertyPathSegments = [String(dotSeparatedOrArrayedPathToTargetProperty)];
+    }
+    else if ((0, isNonEmptyString_1.default)(dotSeparatedOrArrayedPathToTargetProperty)) {
         targetPropertyPathSegments = (0, splitString_1.default)(dotSeparatedOrArrayedPathToTargetProperty, ".");
     }
-    if (targetPropertyPathSegments.length === 0) {
+    else {
+        Logger_1.default.throwErrorWithFormattedMessage({
+            errorInstance: new InvalidParameterValueError_1.default({
+                parameterNumber: 2,
+                parameterName: "dotSeparatedOrArrayedPathToTargetProperty",
+                messageSpecificPart: "This parameter must be either a non-empty string, or a non-negative integer, or a non-empty array " +
+                    "of strings and/or non-negative integers."
+            }),
+            title: InvalidParameterValueError_1.default.localization.defaultTitle,
+            occurrenceLocation: "getObjectPropertySafely(targetObject, dotSeparatedOrArrayedPathToTargetProperty)"
+        });
         return;
     }
     let objectOfCurrentDepthLevel = targetObject;
-    for (let depthLevel = 1; depthLevel <= targetPropertyPathSegments.length; depthLevel++) {
-        const isLastDepthLevel = depthLevel === targetPropertyPathSegments.length;
-        const valueOfNextDepthLevel = objectOfCurrentDepthLevel[targetPropertyPathSegments[depthLevel - 1]];
+    for (let depthLevel__numerationFrom1 = 1; depthLevel__numerationFrom1 <= targetPropertyPathSegments.length; depthLevel__numerationFrom1++) {
+        const isLastDepthLevel = depthLevel__numerationFrom1 === targetPropertyPathSegments.length;
+        const valueOfCurrentDepthLevel = objectOfCurrentDepthLevel[targetPropertyPathSegments[depthLevel__numerationFrom1 - 1]];
         if (isLastDepthLevel) {
-            return valueOfNextDepthLevel;
+            return valueOfCurrentDepthLevel;
         }
-        else if ((0, isArbitraryObject_1.default)(valueOfNextDepthLevel)) {
-            objectOfCurrentDepthLevel = valueOfNextDepthLevel;
+        else if ((0, isArbitraryObject_1.default)(valueOfCurrentDepthLevel)) {
+            objectOfCurrentDepthLevel = valueOfCurrentDepthLevel;
         }
         else {
             return;

package/Distributable/cjs/Objects/setObjectProperties.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = setObjectProperties;
+const splitString_1 = __importDefault(require("../Strings/splitString"));
+const isNonNullObject_1 = __importDefault(require("../TypeGuards/Objects/isNonNullObject"));
+const isUndefined_1 = __importDefault(require("../TypeGuards/EmptyTypes/isUndefined"));
+const isStringifiedNonNegativeIntegerOfRegularNotation_1 = __importDefault(require("../Numbers/isStringifiedNonNegativeIntegerOfRegularNotation"));
+function setObjectProperties(targetObject, order) {
+    for (const [fullyQualifiedName, propertyDescriptor] of Object.entries(order)) {
+        const targetPropertyPathSegments = (0, splitString_1.default)(fullyQualifiedName, ".");
+        let objectOfCurrentDepthLevel = targetObject;
+        for (let depthLevel__numerationFrom1 = 1; depthLevel__numerationFrom1 <= targetPropertyPathSegments.length; depthLevel__numerationFrom1++) {
+            const isLastDepthLevel = depthLevel__numerationFrom1 === targetPropertyPathSegments.length;
+            const propertyKeyForCurrentDepthLevel = targetPropertyPathSegments[depthLevel__numerationFrom1 - 1];
+            let valueOfNextDepthLevel = Reflect.get(objectOfCurrentDepthLevel, propertyKeyForCurrentDepthLevel);
+            if (isLastDepthLevel) {
+                if ((0, isNonNullObject_1.default)(objectOfCurrentDepthLevel)) {
+                    Object.defineProperty(objectOfCurrentDepthLevel, propertyKeyForCurrentDepthLevel, {
+                        value: propertyDescriptor.value,
+                        enumerable: propertyDescriptor.enumerable ?? true,
+                        configurable: propertyDescriptor.configurable ?? true,
+                        writable: propertyDescriptor.writable ?? true
+                    });
+                }
+                else {
+                    return;
+                }
+            }
+            else if ((0, isNonNullObject_1.default)(valueOfNextDepthLevel)) {
+                objectOfCurrentDepthLevel = valueOfNextDepthLevel;
+            }
+            else if ((0, isUndefined_1.default)(valueOfNextDepthLevel) && propertyDescriptor.mustCreateParentsObjectsIfNotPresent === true) {
+                const propertyKeyForNextDepthLevel = targetPropertyPathSegments[depthLevel__numerationFrom1];
+                valueOfNextDepthLevel = (0, isStringifiedNonNegativeIntegerOfRegularNotation_1.default)(propertyKeyForNextDepthLevel) ? [] : {};
+                Object.defineProperty(objectOfCurrentDepthLevel, propertyKeyForCurrentDepthLevel, {
+                    value: valueOfNextDepthLevel,
+                    enumerable: true,
+                    configurable: true,
+                    writable: true
+                });
+                objectOfCurrentDepthLevel = valueOfNextDepthLevel;
+            }
+            else {
+                return;
+            }
+        }
+    }
+}