@ui5/webcomponents-localization 0.0.0-037d08c67

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

@@ -0,0 +1,89 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+import isPlainObject from "./isPlainObject.js";
+var oToken = Object.create(null);
+
+/**
+ * Performs object extension by merging source objects into a target object.
+ *
+ * @example
+ * var oMerged = _merge(true, false, {}, {prop1:1}, {prop2:2});
+ *
+ * @function
+ * @since 1.71
+ * @private
+ * @alias module:sap/base/util/_merge
+ * @param {boolean} deep Shallow copy or deep merge
+ * @param {boolean} skipUndefined Whether <code>undefined</code> values will be skipped, otherwise <code>undefined</code> values will overwrite existing values
+ * @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
+ */
+var fnMerge = function () {
+  /*
+   * The code in this function is taken from jQuery 3.6.0 "jQuery.extend" and got modified.
+   *
+   * jQuery JavaScript Library v3.6.0
+   * https://jquery.com/
+   *
+   * Copyright OpenJS Foundation and other contributors
+   * Released under the MIT license
+   * https://jquery.org/license
+   */
+  var src,
+    copyIsArray,
+    copy,
+    name,
+    options,
+    clone,
+    target = arguments[2] || {},
+    i = 3,
+    length = arguments.length,
+    deep = arguments[0] || false,
+    skipToken = arguments[1] ? undefined : oToken;
+
+  // Handle case when target is a string or something (possible in deep copy)
+  if (typeof target !== "object" && typeof target !== "function") {
+    target = {};
+  }
+  for (; i < length; i++) {
+    if ((options = arguments[i]) != null) {
+      // Extend the base object
+      for (name in options) {
+        src = target[name];
+        copy = options[name];
+
+        // Prevent never-ending loop
+        // Prevent Object.prototype pollution for $.extend( true, ... )
+        // For further information, please visit https://github.com/jquery/jquery/pull/4333
+        if (name === "__proto__" || target === copy) {
+          continue;
+        }
+
+        // Recurse if we're merging plain objects or arrays
+        if (deep && copy && (isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
+          if (copyIsArray) {
+            copyIsArray = false;
+            clone = src && Array.isArray(src) ? src : [];
+          } else {
+            clone = src && isPlainObject(src) ? src : {};
+          }
+
+          // Never move original objects, clone them
+          target[name] = fnMerge(deep, arguments[1], clone, copy);
+
+          // Don't bring in undefined values
+        } else if (copy !== skipToken) {
+          target[name] = copy;
+        }
+      }
+    }
+  }
+
+  // Return the modified object
+  return target;
+};
+export default fnMerge;

package/dist/sap/base/util/array/uniqueSort.js

@@ -0,0 +1,41 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+import assert from "../../assert.js";
+/**
+ * Sorts the given array in-place and removes any duplicates (identified by "===").
+ *
+ * Uses Array#sort()
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort
+ *
+ * Use <code>jQuery.uniqueSort()</code> for arrays of DOMElements.
+ *
+ * @function
+ * @since 1.58
+ * @param {any[]} aArray An Array of any type
+ * @alias module:sap/base/util/array/uniqueSort
+ * @return {any[]} Same array as given (for chaining)
+ * @public
+ */
+var fnUniqueSort = function (aArray) {
+  assert(Array.isArray(aArray), "uniqueSort: input parameter must be an Array");
+  var iLength = aArray.length;
+  if (iLength > 1) {
+    aArray.sort();
+    var j = 0;
+    for (var i = 1; i < iLength; i++) {
+      // invariant: i is the entry to check, j is the last unique entry known so far
+      if (aArray.indexOf(aArray[i]) === i) {
+        aArray[++j] = aArray[i];
+      }
+    }
+    // cut off the rest - if any
+    if (++j < iLength) {
+      aArray.splice(j, iLength - j);
+    }
+  }
+  return aArray;
+};
+export default fnUniqueSort;

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

@@ -0,0 +1,102 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+import isPlainObject from "./isPlainObject.js";
+/**
+ * Creates a deep clone of the source value.
+ *
+ * Only arrays, JavaScript Date objects and objects that pass the {@link module:sap/base/util/isPlainObject isPlainObject}
+ * check will be cloned. For other object types, a <code>TypeError</code> will be thrown as there's no standard way
+ * to clone them. Primitive values (boolean, number, string) as well as <code>null</code> and <code>undefined</code>
+ * will be copied, they have value semantics anyhow.
+ *
+ * <code>deepClone</code> is designed to match the semantics of {@link module:sap/base/util/deepEqual deepEqual}.
+ * Any deeply cloned object should be deep-equal to the source. However, not every object that can be handled
+ * by <code>deepEqual</code> can also be deeply cloned (e.g. <code>deepClone</code> fails on non-plain objects).
+ *
+ * To limit the time needed for a deep clone and to avoid endless recursion in case of cyclic structures, the
+ * recursion depth is limited by the parameter <code>maxDepth</code>, which defaults to 10. When the recursion
+ * depth exceeds the given limit, a <code>TypeError</code> is thrown.
+ *
+ * Note that object identities are not honored by the clone operation. If the original source contained multiple
+ * references to the same plain object instance, the clone will contain a different clone for each reference.
+ *
+ * @example <caption>Simple operation</caption>
+ * var oSource = { a: 1, b: { x: "test", y : 5.0 }, c: new Date(), d: null };
+ * var oClone = deepClone(oValue);
+ *
+ * deepEqual(oClone, oSource); // true
+ * oClone !== oSource; // true
+ * oClone.b !== oSource.b; // true
+ * oClone.c !== oSource.c; // true
+ *
+ * @example <caption>Object Identities</caption>
+ * var oCommon = { me: "unique" };
+ * var oValue = { a: oCommon, b: oCommon };
+ * var oClone = deepClone(oValue);
+ *
+ * deepEqual(oClone, oSource); // true
+ * oSource.a === oSource.b; // true
+ * oClone.a === oClone.b; // false
+ * deepEqual(oClone.a, oClone.b); // true
+ *
+ * @since 1.63
+ * @public
+ * @alias module:sap/base/util/deepClone
+ * @param {any} src Source value that shall be cloned
+ * @param {int} [maxDepth=10] Maximum recursion depth for the clone operation, deeper structures will throw an error
+ * @returns {any} A clone of the source value
+ * @throws {TypeError} When a non-plain object is encountered or when the max structure depth is exceeded
+ */
+var fnDeepClone = function (src, maxDepth) {
+  if (!maxDepth) {
+    maxDepth = 10;
+  }
+  return clone(src, 0, maxDepth);
+};
+function clone(src, depth, maxDepth) {
+  // avoid endless recursion due to cyclic structures
+  if (depth > maxDepth) {
+    throw new TypeError("The structure depth of the source exceeds the maximum depth (" + maxDepth + ")");
+  }
+  if (src == null) {
+    return src;
+  } else if (src instanceof Date) {
+    if (src.clone) {
+      // sap.ui.core.date.UI5Date
+      return src.clone();
+    }
+
+    // clone date object using #getTime(). Officially the date constructor does not support parameter Date.
+    return new Date(src.getTime());
+  } else if (Array.isArray(src)) {
+    return cloneArray(src, depth, maxDepth);
+  } else if (typeof src === "object") {
+    return cloneObject(src, depth, maxDepth);
+  } else {
+    return src;
+  }
+}
+function cloneArray(src, depth, maxDepth) {
+  var aClone = [];
+  for (var i = 0; i < src.length; i++) {
+    aClone.push(clone(src[i], depth + 1, maxDepth));
+  }
+  return aClone;
+}
+function cloneObject(src, depth, maxDepth) {
+  if (!isPlainObject(src)) {
+    throw new TypeError("Cloning is only supported for plain objects");
+  }
+  var oClone = {};
+  for (var key in src) {
+    if (key === "__proto__") {
+      continue;
+    }
+    oClone[key] = clone(src[key], depth + 1, maxDepth);
+  }
+  return oClone;
+}
+export default fnDeepClone;

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

@@ -0,0 +1,83 @@
+/*!
+ * 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) {
+  // 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 (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 false;
+};
+export default fnEqual;

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

@@ -0,0 +1,61 @@
+/*!
+ * 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);
+};
+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
+ * sap.ui.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

@@ -0,0 +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;

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

@@ -0,0 +1,28 @@
+// @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;

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

@@ -0,0 +1,3 @@
+export default (function () {
+  throw new Error("not implemented");
+});

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;