@ui5/webcomponents-localization 1.22.0-rc.1 → 1.22.0-rc.2

package/dist/sap/base/util/deepEqual.js

@@ -1,59 +1,83 @@
-import Log from '../Log.js';
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+/*global Node */
+//@evo-todo check isEqualNode dependency: not yet available...
+//@evo-todo dependency to global name 'Node' contradicts sap/base package
+import Log from "../Log.js";
+/**
+ * Compares the two given values for equality, especially by comparing the content.
+ *
+ * <b>Note:</b> Function does not work with comparing XML objects.
+ *
+ * @function
+ * @since 1.58
+ * @param {any} a A value of any type
+ * @param {any} b A value of any type
+ * @param {int} [maxDepth=10] Maximum recursion depth
+ * @param {boolean} [contains] Whether all existing properties in a are equal as in b
+ * @alias module:sap/base/util/deepEqual
+ * @return {boolean} Whether a and b are equal
+ * @public
+ */
 var fnEqual = function (a, b, maxDepth, contains, depth) {
-    if (typeof maxDepth == 'boolean') {
-        contains = maxDepth;
-        maxDepth = undefined;
-    }
-    if (!depth) {
-        depth = 0;
+  // Optional parameter normalization
+  if (typeof maxDepth == "boolean") {
+    contains = maxDepth;
+    maxDepth = undefined;
+  }
+  if (!depth) {
+    depth = 0;
+  }
+  if (!maxDepth) {
+    maxDepth = 10;
+  }
+  if (depth > maxDepth) {
+    Log.warning("deepEqual comparison exceeded maximum recursion depth of " + maxDepth + ". Treating values as unequal");
+    return false;
+  }
+  if (a === b || Number.isNaN(a) && Number.isNaN(b)) {
+    return true;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (!contains && a.length !== b.length) {
+      return false;
     }
-    if (!maxDepth) {
-        maxDepth = 10;
+    if (a.length > b.length) {
+      return false;
     }
-    if (depth > maxDepth) {
-        Log.warning('deepEqual comparison exceeded maximum recursion depth of ' + maxDepth + '. Treating values as unequal');
+    for (var i = 0; i < a.length; i++) {
+      if (!fnEqual(a[i], b[i], maxDepth, contains, depth + 1)) {
         return false;
+      }
     }
-    if (a === b || Number.isNaN(a) && Number.isNaN(b)) {
-        return true;
-    }
-    if (Array.isArray(a) && Array.isArray(b)) {
-        if (!contains && a.length !== b.length) {
-            return false;
-        }
-        if (a.length > b.length) {
-            return false;
-        }
-        for (var i = 0; i < a.length; i++) {
-            if (!fnEqual(a[i], b[i], maxDepth, contains, depth + 1)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    if (typeof a == 'object' && typeof b == 'object') {
-        if (!a || !b) {
-            return false;
-        }
-        if (a.constructor !== b.constructor) {
-            return false;
-        }
-        if (!contains && Object.keys(a).length !== Object.keys(b).length) {
-            return false;
-        }
-        if (a instanceof Node) {
-            return a.isEqualNode(b);
-        }
-        if (a instanceof Date) {
-            return a.valueOf() === b.valueOf();
-        }
-        for (var i in a) {
-            if (!fnEqual(a[i], b[i], maxDepth, contains, depth + 1)) {
-                return false;
-            }
-        }
-        return true;
+    return true;
+  }
+  if (typeof a == "object" && typeof b == "object") {
+    if (!a || !b) {
+      return false;
     }
-    return false;
+    if (a.constructor !== b.constructor) {
+      return false;
+    }
+    if (!contains && Object.keys(a).length !== Object.keys(b).length) {
+      return false;
+    }
+    if (a instanceof Node) {
+      return a.isEqualNode(b);
+    }
+    if (a instanceof Date) {
+      return a.valueOf() === b.valueOf();
+    }
+    for (var i in a) {
+      if (!fnEqual(a[i], b[i], maxDepth, contains, depth + 1)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
 };
 export default fnEqual;

package/dist/sap/base/util/extend.js

@@ -1,10 +1,61 @@
-import _merge from './_merge.js';
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+import _merge from "./_merge.js";
+/**
+ * Performs object extension by merging source objects into a target object. Generates a shallow copy.
+ *
+ * If during merging a key in the target object exists it is overwritten with the source object's value.
+ * Usage is the same as <code>jQuery.extend(...)</code>.
+ * Values that are <code>undefined</code> are ignored.
+ *
+ * As alternative you may also use <code>Object.assign</code>, but note that <code>Object.assign</code>
+ * only copies enumerable and own properties and doesn't copy properties on the prototype and non-enumerable
+ * properties. Also, values that are <code>undefined</code> are NOT ignored.
+ *
+ * For deep copies, you may use {@link module:sap/base/util/deepExtend sap/base/util/deepExtend}.
+ *
+ * @example
+ * var oResult = extend({}, {
+ *   prop1: {
+ *     prop1a: "1a"
+ *   }
+ * }, {
+ *   prop2: {
+ *     prop2a: "2a"
+ *   }
+ * }, {
+ *   prop1: {
+ *      prop1b: "1b"
+ *   }
+ * }, {
+ *   prop2: undefined
+ * });
+ *
+ *
+ * console.log(oResult);
+ * {
+ *   "prop1": {
+ *     "prop1b": "1b"
+ *   },
+ *   "prop2": {
+ *     "prop2a": "2a"
+ *   }
+ * }
+ *
+ * @function
+ * @alias module:sap/base/util/extend
+ * @param {object} target The object that will receive new properties
+ * @param {...object} [source] One or more objects which get merged into the target object
+ * @return {object} the target object which is the result of the merge
+ * @public
+ * @since 1.71
+ */
 var fnExtend = function () {
-    var args = [
-        false,
-        true
-    ];
-    args.push.apply(args, arguments);
-    return _merge.apply(null, args);
+  var args = [false, true];
+  args.push.apply(args, arguments);
+  return _merge.apply(null, args);
 };
 export default fnExtend;

package/dist/sap/base/util/isEmptyObject.js

@@ -0,0 +1,34 @@
+/**
+ * Validates if the given object is empty, that is that it has no enumerable properties.
+ *
+ * Note that <code>null</code> and <code>undefined</code> comply with this definition of 'empty'.
+ * The behavior for non-object values is undefined and might change in future.
+ *
+ * @example
+ * require(["sap/base/util/isEmptyObject"], function(isEmptyObject){
+ *      isEmptyObject({}); // true
+ *      isEmptyObject({test: '123'}); // false
+ *      isEmptyObject(null); // true
+ *      isEmptyObject(undefined); // true
+ * });
+ *
+ * @function
+ * @since 1.65
+ * @public
+ * @name module:sap/base/util/isEmptyObject
+ * @param {Object} obj the object which is checked
+ * @returns {boolean} whether or not the given object is empty
+ */ /*!
+     * OpenUI5
+     * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+     * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+     */
+
+var fnIsEmptyObject = function isEmptyObject(obj) {
+  // eslint-disable-next-line no-unreachable-loop
+  for (var sName in obj) {
+    return false;
+  }
+  return true;
+};
+export default fnIsEmptyObject;

package/dist/sap/base/util/isPlainObject.js

@@ -1,18 +1,52 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+
 var class2type = {};
 var hasOwn = class2type.hasOwnProperty;
 var toString = class2type.toString;
 var fnToString = hasOwn.toString;
 var ObjectFunctionString = fnToString.call(Object);
+
+/**
+ * Checks whether the object is a plain object (created using "{}" or "new Object").
+ *
+ * @function
+ * @since 1.58
+ * @public
+ * @alias module:sap/base/util/isPlainObject
+ * @param {Object} obj the object which is checked
+ * @returns {boolean} whether or not the object is a plain object (created using "{}" or "new Object").
+ */
 var fnIsPlainObject = function (obj) {
+  /*
+   * The code in this function is taken from jQuery 3.6.0 "jQuery.isPlainObject" and got modified.
+   *
+   * jQuery JavaScript Library v3.6.0
+   * http://jquery.com/
+   *
+   * Copyright OpenJS Foundation and other contributors
+   * Released under the MIT license
+   * http://jquery.org/license
+   */
   var proto, Ctor;
+
+  // Detect obvious negatives
+  // Use toString instead of jQuery.type to catch host objects
   if (!obj || toString.call(obj) !== "[object Object]") {
     return false;
   }
   proto = Object.getPrototypeOf(obj);
+
+  // Objects with no prototype (e.g., `Object.create( null )`) are plain
   if (!proto) {
     return true;
   }
+
+  // Objects with a prototype are considered plain only if they were constructed by a global Object function
   Ctor = hasOwn.call(proto, "constructor") && proto.constructor;
   return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString;
 };
-export default fnIsPlainObject;
+export default fnIsPlainObject;

package/dist/sap/base/util/now.js

@@ -1,7 +1,28 @@
-var fnNow = !(typeof window != "undefined" && window.performance && performance.now && performance.timing) ? Date.now : (function () {
+// @evo-todo window.performance does not exist on node.js, but there is a module performance-now. Maybe use it
+
+/**
+ * Returns a high resolution timestamp in microseconds if supported by the environment, otherwise in milliseconds.
+ * The timestamp is based on 01/01/1970 00:00:00 (UNIX epoch) as float with microsecond precision or
+ * with millisecond precision, if high resolution timestamps are not available.
+ * The fractional part of the timestamp represents fractions of a millisecond.
+ * Converting to a <code>Date</code> is possible by using <code>require(["sap/base/util/now"], function(now){new Date(now());}</code>
+ *
+ * @function
+ * @since 1.58
+ * @public
+ * @alias module:sap/base/util/now
+ * @returns {float} timestamp in microseconds if supported by the environment otherwise in milliseconds
+ */ /*!
+     * OpenUI5
+     * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+     * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+     */
+/*global performance */
+
+var fnNow = !(typeof window != "undefined" && window.performance && performance.now && performance.timing) ? Date.now : function () {
   var iNavigationStart = performance.timing.navigationStart;
   return function perfnow() {
     return iNavigationStart + performance.now();
   };
-})();
-export default fnNow;
+}();
+export default fnNow;

package/dist/sap/base/util/resolveReference.js

@@ -0,0 +1,157 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+import ObjectPath from "./ObjectPath.js";
+// indicator if the reference can't be resolved
+var oNotFound = Object.create(null);
+
+/**
+ * Resolve the path segments under the given root context
+ *
+ * @param {array} aParts The path segments
+ * @param {object} oRoot The root context
+ * @param {object} [mOptions] Options
+ * @param {boolean} [mOptions.bindContext] When the resolved value is a
+ *  function, whether the resolved function is bound to a context
+ * @param {boolean} [mOptions.rootContext] When the resolved value is a
+ *  function and a rootContext is given, the resolved function is bound
+ *  to this context instead of the object to which it belongs. If
+ *  <code>mOptions.bindContext=false</code>, this option has no effect
+ * @return {any} The resolved value. If the value can't be resolved under the
+ *  given root context, it returns <code>oNotFound</code>.
+ */
+function _resolve(aParts, oRoot, mOptions) {
+  var vRef, oContext;
+  if (oRoot && aParts[0] in oRoot) {
+    // the path consists of at least two segments
+    // e.g. key "Module.namespace.function" -> function() {...}
+    oContext = aParts.length > 1 ? ObjectPath.get(aParts.slice(0, -1), oRoot) : oRoot;
+    vRef = oContext && oContext[aParts[aParts.length - 1]];
+    if (typeof vRef === "function" && mOptions.bindContext) {
+      vRef = vRef.bind(mOptions.rootContext || oContext);
+    }
+    return vRef;
+  }
+  return oNotFound;
+}
+
+/**
+ * Returns a value located in the provided path using the given
+ * <code>mVariables</code> object.
+ *
+ * If the provided path cannot be resolved completely, <code>undefined</code> is returned.
+ *
+ * How <code>mVariables</code> are checked for resolving the path depends on
+ * the syntax of the path:
+ * <ul>
+ * <li><i>absolute</i>: paths not starting with a dot ('.') are first checked through
+ *     <code>mVariables</code>.</li>
+ * <li><i>relative</i>: paths starting with a dot ('.') are only checked through the dot variable
+ *     <code>mVariables["."]</code> and not the other variables in <code>mVariables</code>.</li>
+ * <li><i>legacy</i>: when <code>mOptions.preferDotContext=true</code>, paths not starting
+ *     with a dot ('.') are first checked through the dot Variable
+ *     <code>mVariables["."]</code> and then - if nothing is found - through the other
+ *     Variables in <code>mVariables</code>.</li>
+ * </ul>
+ *
+ * For an absolute path, when nothing is found after resolving the value within <code>mVariables</code>,
+ * <code>require</code> is called when <code>mOptions.useProbingRequire=true</code> to retrieve the
+ * module export of the loaded module with the given <code>sPath</code> after replacing '.' with '/' in
+ * the path. If the path can still not be resolved, the last fallback is taken to resolve
+ * <code>sPath</code> within the global scope <code>window</code>.
+ *
+ * When the resolved value is a function, a context may be bound to it with the following
+ * conditions:
+ * <ul>
+ * <li><i>No bound</i>: if the function is resolved from the global scope (not from any
+ *     given variables in <code>mVariables</code>, it's not bound to any context. If the
+ *     function exists directly under <code>mVariables</code>, nothing is bound.</li>
+ * <li><i>Bound</i>: otherwise, the resolved function is bound to the object to which it
+ *     belongs</li>
+ * <li><i>mOptions.bindContext</i>: when this option is set to <code>false</code>, no
+ *     context is bound to the resolved function regardless where the function is resolved
+ *     </li>
+ * <li><i>mOptions.bindDotContext</i>: for paths starting with a dot ('.'),
+ *     <code>mOptions.bindDotContext=false</code> turns off the automatic binding to the
+ *     dot variable <code>mVariables["."]</code>. <code>mOptions.bindDotContext</code> has
+ *     no effect when <code>mOptions.bindContext=false</code>.</li>
+ * </ul>
+ *
+ * @function
+ * @private
+ * @ui5-restricted sap.ui.core
+ * @since 1.69
+ *
+ * @param {string} sPath Path
+ * @param {object} [mVariables] An object containing the mapping of variable name to object or function
+ * @param {object} [mOptions] Options
+ * @param {boolean} [mOptions.preferDotContext=false] Whether the path not starting with a dot ('.') is
+ *  resolved under the dot variable when it can not be resolved through the given variables object.
+ * @param {boolean} [mOptions.bindContext=true] When the resolved value is a function, whether the
+ *  resolved function is bound to a context. When this property is set to false, the
+ *  mOptions.bindDotContext has no effect anymore.
+ * @param {boolean} [mOptions.bindDotContext=true] When the resolved value is a function, whether the
+ *  resolved function from a path which starts with a dot ('.') should be bound to the dot context
+ * @param {boolean} [mOptions.useProbingRequire=false] When the value cannot be resolved by using the
+ *  given <code>mVariables</code>, <code>mOptions.useProbingRequire=true</code> leads to a call of
+ *  <code>require</code> to get the module export of the loaded module under the given
+ *  <code>sPath</code> after replacing the '.' with '/'.
+ * @returns {any} Returns the value located in the provided path, or <code>undefined</code> if the path
+ *  does not exist completely.
+ * @alias module:sap/base/util/resolveReference
+ */
+var resolveReference = function (sPath, mVariables, mOptions) {
+  // fill the default values
+  mVariables = mVariables || {};
+  mOptions = mOptions || {};
+  mOptions.bindContext = mOptions.bindContext !== false;
+  mOptions.bindDotContext = mOptions.bindDotContext !== false;
+  var aParts = sPath.split("."),
+    // if sPath starts with ".", split returns an empty string
+    // at the first position and the dot is used as variable
+    sVariable = aParts.shift() || ".",
+    bDotCase = sVariable === ".",
+    vRef = oNotFound;
+
+  // push the first part back to the array
+  aParts.unshift(sVariable);
+
+  // if preferDotContext, resolve the sPath under the dot context first for sPath which doesn't begin with "."
+  if (mOptions.preferDotContext && !bDotCase) {
+    vRef = _resolve(aParts, mVariables["."], {
+      bindContext: mOptions.bindContext && mOptions.bindDotContext,
+      // resolve function in dot variable should always bind the dot variable
+      rootContext: mVariables["."]
+    });
+  }
+
+  // If sPath isn't resolved yet, resolve the path under mVariables
+  if (vRef === oNotFound) {
+    vRef = _resolve(aParts, mVariables, {
+      bindContext: mOptions.bindContext
+      // dot case: mOptions.bindDotContext determines whether context should be bound
+      // non dot case: bind context if sPath contains more than one segment
+      && (bDotCase ? mOptions.bindDotContext : aParts.length > 1),
+      rootContext: bDotCase ? mVariables["."] : undefined
+    });
+  }
+  if (!bDotCase) {
+    if (vRef === oNotFound && mOptions.useProbingRequire) {
+      vRef = require(sPath.replace(/\./g, "/"));
+      if (vRef === undefined) {
+        vRef = oNotFound;
+      }
+    }
+
+    // resolve the path under global scope, only when it can't be resolved under mVariables
+    if (vRef === oNotFound) {
+      // fallback if no value could be found under the given sPath's first segment
+      // otherwise resolve under global namespace
+      vRef = ObjectPath.get(sPath);
+    }
+  }
+  return vRef === oNotFound ? undefined : vRef;
+};
+export default resolveReference;

package/dist/sap/base/util/uid.js

@@ -0,0 +1,27 @@
+/**
+ * Some private variable used for creation of (pseudo-)unique IDs.
+ * @type int
+ * @private
+ */ /*!
+     * OpenUI5
+     * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+     * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+     */
+
+var iIdCounter = 0;
+
+/**
+ * Creates and returns a pseudo-unique ID.
+ *
+ * No means for detection of overlap with already present or future UIDs.
+ *
+ * @function
+ * @since 1.58
+ * @alias module:sap/base/util/uid
+ * @return {string} A pseudo-unique id.
+ * @public
+ */
+var fnUid = function uid() {
+  return "id-" + new Date().valueOf() + "-" + iIdCounter++;
+};
+export default fnUid;