@yamato-daiwa/es-extensions 1.9.0-alpha.2 → 1.9.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/DataMocking/LocalizableMocking/LocalizableEntitiesByIDsMap.js

@@ -1,12 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class LocalizableEntitiesByIDsMap extends Map {
-    constructor(entries) {
-        super(entries);
+    getEntityID;
+    constructor({ initialEntitiesWithLocalizations, getEntityID }) {
+        super((initialEntitiesWithLocalizations ?? []).
+            map(({ entity, localizations }) => [
+            getEntityID(entity),
+            {
+                entity,
+                localizations
+            }
+        ]));
+        this.getEntityID = getEntityID;
     }
-    addEntries(entries) {
-        for (const [key, value] of entries) {
-            this.set(key, value);
+    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 });
         }
     }
 }

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

@@ -31,12 +31,10 @@ class LocalizableSampleDataRepository {
         if (mustCacheGeneratedSamples) {
             this.cachedSamplesWithLocalizationsByHumanFriendlyIDs = samplesWithLocalizationsByHumanFriendlyIDs;
         }
-        return new LocalizableEntitiesByIDsMap_1.default(Object.
-            values(samplesWithLocalizationsByHumanFriendlyIDs).
-            map((entityWithLocalization) => [
-            this.getEntityID(entityWithLocalization.entity),
-            entityWithLocalization
-        ]));
+        return new LocalizableEntitiesByIDsMap_1.default({
+            getEntityID: this.getEntityID.bind(this),
+            initialEntitiesWithLocalizations: Object.values(samplesWithLocalizationsByHumanFriendlyIDs)
+        });
     }
     getExpectedBeInitializedSamplesWithLocalizationsByHumanFriendlyIDs() {
         return this.cachedSamplesWithLocalizationsByHumanFriendlyIDs ??

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/getObjectPropertySafely.js

@@ -9,44 +9,47 @@ 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)))) {
+    if (!(0, isArbitraryObject_1.default)(targetObject)) {
+        return;
+    }
+    let targetPropertyPathSegments;
+    if (Array.isArray(dotSeparatedOrArrayedPathToTargetProperty) &&
+        dotSeparatedOrArrayedPathToTargetProperty.length > 0 &&
+        dotSeparatedOrArrayedPathToTargetProperty.
+            every((key) => (0, isNonEmptyString_1.default)(key) || (0, isNaturalNumberOrZero_1.default)(key))) {
+        targetPropertyPathSegments = dotSeparatedOrArrayedPathToTargetProperty;
+    }
+    else if ((0, isNaturalNumberOrZero_1.default)(dotSeparatedOrArrayedPathToTargetProperty)) {
+        targetPropertyPathSegments = [String(dotSeparatedOrArrayedPathToTargetProperty)];
+    }
+    else if ((0, isNonEmptyString_1.default)(dotSeparatedOrArrayedPathToTargetProperty)) {
+        targetPropertyPathSegments = (0, splitString_1.default)(dotSeparatedOrArrayedPathToTargetProperty, ".");
+    }
+    else {
         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."
+                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."
             }),
             occurrenceLocation: "getObjectPropertySafely(targetObject, dotSeparatedOrArrayedPathToTargetProperty)"
         });
         return;
     }
-    if (!(0, isArbitraryObject_1.default)(targetObject)) {
-        return;
-    }
-    let targetPropertyPathSegments;
-    if (Array.isArray(dotSeparatedOrArrayedPathToTargetProperty)) {
-        targetPropertyPathSegments = dotSeparatedOrArrayedPathToTargetProperty;
-    }
-    else {
-        targetPropertyPathSegments = (0, splitString_1.default)(dotSeparatedOrArrayedPathToTargetProperty, ".");
-    }
-    if (targetPropertyPathSegments.length === 0) {
-        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;
+            }
+        }
+    }
+}