@dbmx/toasts 0.0.122 → 0.0.124

package/cjs/node_modules/@dbmx/sdmx/esm/dependencyResolver.cjs

@@ -0,0 +1,68 @@
+'use strict';
+
+var index_esm = require('../../semver/dist/index.esm.cjs');
+
+// TODO: remove resourceType from comparaison
+const matchRefVersionLess = (ref, resource) =>
+  ((ref.resourceType && resource.resourceType && ref.resourceType === resource.resourceType) ||
+    !ref.resourceType ||
+    !resource.resourceType) &&
+  ref.id === resource.id &&
+  ref.agencyID === resource.agencyID;
+
+const getOne = (ref, range, resources) => {
+  for (const resource of resources) {
+    if (matchRefVersionLess(ref, resource) && range.test(resource.version)) return resource
+  }
+};
+
+const getLatest = (ref, range, resources) => {
+  let res = [];
+  if (resources.length === 1 && range.raw === '~') return resources[0]
+  for (const resource of resources) {
+    if (!matchRefVersionLess(ref, resource)) continue
+    const semver = index_esm.SemVer(resource.version);
+    if (semver.isNonVersioned()) continue
+    if (range.test(semver)) {
+      if (!res[0]) res = [resource, semver];
+      else if (semver.compare(res[1]) === 1) res = [resource, semver];
+    }
+  }
+  return res[0]
+};
+
+/**
+ * Resolves a dependency by finding the appropriate resource based on a version range and returns an external resource from the input
+ *
+ * @function resolveDependency
+ * @tag dependency
+ * @param {array} - Array of all possible resources
+ * @param {object} - Source object representing the dependency source
+ * @param {object} - Reference object representing the target version
+ * @param {object} - Options object (optional)
+ * @param {boolean} - Flag to indicate whether to suppress errors ([noError=false])
+ * @return {object | undefined} - The resolved resource that matches the reference and version range, or undefined if not found (depending on the 'noError' flag)
+ * @throws {Error} - Throws an error if 'noError' flag is not set and resolution fails
+ *
+ * @example
+ *
+ *   const resources = [
+ *      { agencyID: 'A', id: 'ID1', version: '1.0.0' },
+ *      { agencyID: 'A', id: 'ID2', version: '1.0.1' },
+ *      { agencyID: 'A', id: 'ID3', version: '1.1.1' },
+ *   ]
+ *   const ref = resolveDependency(resources, { version: 1.0.0 }, { resourceType, agencyID, id, version: '1.1+.0' }
+ *   expect(ref.id}.toEqual('ID3')
+ */
+const resolveDependency = (resources, source, ref, { noError } = {}) => {
+  try {
+    const range = index_esm.Dependency(source, ref.version).range;
+    if (range.type === index_esm.RANGE_TYPE.LATEST) return getLatest(ref, range, resources)
+    return getOne(ref, range, resources)
+  } catch (err) {
+    if (noError) return
+    throw err
+  }
+};
+
+exports.resolveDependency = resolveDependency;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/bind.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var _arity = require('./internal/_arity.cjs');
+var _curry2 = require('./internal/_curry2.cjs');
+
+/**
+ * Creates a function that is bound to a context.
+ * Note: `R.bind` does not provide the additional argument-binding capabilities of
+ * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).
+ *
+ * @func
+ * @memberOf R
+ * @since v0.6.0
+ * @category Function
+ * @category Object
+ * @sig (* -> *) -> {*} -> (* -> *)
+ * @param {Function} fn The function to bind to context
+ * @param {Object} thisObj The context to bind `fn` to
+ * @return {Function} A function that will execute in the context of `thisObj`.
+ * @see R.partial
+ * @example
+ *
+ *      const log = R.bind(console.log, console);
+ *      R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3}
+ *      // logs {a: 2}
+ * @symb R.bind(f, o)(a, b) = f.call(o, a, b)
+ */
+
+var bind =
+/*#__PURE__*/
+_curry2(function bind(fn, thisObj) {
+  return _arity(fn.length, function () {
+    return fn.apply(thisObj, arguments);
+  });
+});
+
+var bind$1 = bind;
+
+module.exports = bind$1;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/compose.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var pipe = require('./pipe.cjs');
+var reverse = require('./reverse.cjs');
+
+/**
+ * Performs right-to-left function composition. The last argument may have
+ * any arity; the remaining arguments must be unary.
+ *
+ * **Note:** The result of compose is not automatically curried.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> ((a, b, ..., n) -> z)
+ * @param {...Function} ...functions The functions to compose
+ * @return {Function}
+ * @see R.pipe
+ * @example
+ *
+ *      const classyGreeting = (firstName, lastName) => "The name's " + lastName + ", " + firstName + " " + lastName
+ *      const yellGreeting = R.compose(R.toUpper, classyGreeting);
+ *      yellGreeting('James', 'Bond'); //=> "THE NAME'S BOND, JAMES BOND"
+ *
+ *      R.compose(Math.abs, R.add(1), R.multiply(2))(-4) //=> 7
+ *
+ * @symb R.compose(f, g, h)(a, b) = f(g(h(a, b)))
+ * @symb R.compose(f, g, h)(a)(b) = f(g(h(a)))(b)
+ */
+
+function compose() {
+  if (arguments.length === 0) {
+    throw new Error('compose requires at least one argument');
+  }
+
+  return pipe.apply(this, reverse(arguments));
+}
+
+module.exports = compose;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/curryN.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+var _arity = require('./internal/_arity.cjs');
+var _curry1 = require('./internal/_curry1.cjs');
+var _curry2 = require('./internal/_curry2.cjs');
+var _curryN = require('./internal/_curryN.cjs');
+
+/**
+ * Returns a curried equivalent of the provided function, with the specified
+ * arity. The curried function has two unusual capabilities. First, its
+ * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the
+ * following are equivalent:
+ *
+ *   - `g(1)(2)(3)`
+ *   - `g(1)(2, 3)`
+ *   - `g(1, 2)(3)`
+ *   - `g(1, 2, 3)`
+ *
+ * Secondly, the special placeholder value [`R.__`](#__) may be used to specify
+ * "gaps", allowing partial application of any combination of arguments,
+ * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),
+ * the following are equivalent:
+ *
+ *   - `g(1, 2, 3)`
+ *   - `g(_, 2, 3)(1)`
+ *   - `g(_, _, 3)(1)(2)`
+ *   - `g(_, _, 3)(1, 2)`
+ *   - `g(_, 2)(1)(3)`
+ *   - `g(_, 2)(1, 3)`
+ *   - `g(_, 2)(_, 3)(1)`
+ *
+ * @func
+ * @memberOf R
+ * @since v0.5.0
+ * @category Function
+ * @sig Number -> (* -> a) -> (* -> a)
+ * @param {Number} length The arity for the returned function.
+ * @param {Function} fn The function to curry.
+ * @return {Function} A new, curried function.
+ * @see R.curry
+ * @example
+ *
+ *      const sumArgs = (...args) => R.sum(args);
+ *
+ *      const curriedAddFourNumbers = R.curryN(4, sumArgs);
+ *      const f = curriedAddFourNumbers(1, 2);
+ *      const g = f(3);
+ *      g(4); //=> 10
+ */
+
+var curryN =
+/*#__PURE__*/
+_curry2(function curryN(length, fn) {
+  if (length === 1) {
+    return _curry1(fn);
+  }
+
+  return _arity(length, _curryN(length, [], fn));
+});
+
+var curryN$1 = curryN;
+
+module.exports = curryN$1;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/defaultTo.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var _curry2 = require('./internal/_curry2.cjs');
+
+/**
+ * Returns the second argument if it is not `null`, `undefined` or `NaN`;
+ * otherwise the first argument is returned.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.10.0
+ * @category Logic
+ * @sig a -> b -> a | b
+ * @param {a} default The default value.
+ * @param {b} val `val` will be returned instead of `default` unless `val` is `null`, `undefined` or `NaN`.
+ * @return {*} The second value if it is not `null`, `undefined` or `NaN`, otherwise the default value
+ * @example
+ *
+ *      const defaultTo42 = R.defaultTo(42);
+ *
+ *      defaultTo42(null);  //=> 42
+ *      defaultTo42(undefined);  //=> 42
+ *      defaultTo42(false);  //=> false
+ *      defaultTo42('Ramda');  //=> 'Ramda'
+ *      // parseInt('string') results in NaN
+ *      defaultTo42(parseInt('string')); //=> 42
+ */
+
+var defaultTo =
+/*#__PURE__*/
+_curry2(function defaultTo(d, v) {
+  return v == null || v !== v ? d : v;
+});
+
+var defaultTo$1 = defaultTo;
+
+module.exports = defaultTo$1;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/forEach.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+var _checkForMethod = require('./internal/_checkForMethod.cjs');
+var _curry2 = require('./internal/_curry2.cjs');
+
+/**
+ * Iterate over an input `list`, calling a provided function `fn` for each
+ * element in the list.
+ *
+ * `fn` receives one argument: *(value)*.
+ *
+ * Note: `R.forEach` does not skip deleted or unassigned indices (sparse
+ * arrays), unlike the native `Array.prototype.forEach` method. For more
+ * details on this behavior, see:
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description
+ *
+ * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns
+ * the original array. In some libraries this function is named `each`.
+ *
+ * Dispatches to the `forEach` method of the second argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.1
+ * @category List
+ * @sig (a -> *) -> [a] -> [a]
+ * @param {Function} fn The function to invoke. Receives one argument, `value`.
+ * @param {Array} list The list to iterate over.
+ * @return {Array} The original list.
+ * @see R.addIndex
+ * @example
+ *
+ *      const printXPlusFive = x => console.log(x + 5);
+ *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]
+ *      // logs 6
+ *      // logs 7
+ *      // logs 8
+ * @symb R.forEach(f, [a, b, c]) = [a, b, c]
+ */
+
+var forEach =
+/*#__PURE__*/
+_curry2(
+/*#__PURE__*/
+_checkForMethod('forEach', function forEach(fn, list) {
+  var len = list.length;
+  var idx = 0;
+
+  while (idx < len) {
+    fn(list[idx]);
+    idx += 1;
+  }
+
+  return list;
+}));
+
+var forEach$1 = forEach;
+
+module.exports = forEach$1;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/identity.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var _curry1 = require('./internal/_curry1.cjs');
+var _identity = require('./internal/_identity.cjs');
+
+/**
+ * A function that does nothing but return the parameter supplied to it. Good
+ * as a default or placeholder function.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig a -> a
+ * @param {*} x The value to return.
+ * @return {*} The input value, `x`.
+ * @example
+ *
+ *      R.identity(1); //=> 1
+ *
+ *      const obj = {};
+ *      R.identity(obj) === obj; //=> true
+ * @symb R.identity(a) = a
+ */
+
+var identity =
+/*#__PURE__*/
+_curry1(_identity);
+
+var identity$1 = identity;
+
+module.exports = identity$1;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/internal/_arity.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+function _arity(n, fn) {
+  /* eslint-disable no-unused-vars */
+  switch (n) {
+    case 0:
+      return function () {
+        return fn.apply(this, arguments);
+      };
+
+    case 1:
+      return function (a0) {
+        return fn.apply(this, arguments);
+      };
+
+    case 2:
+      return function (a0, a1) {
+        return fn.apply(this, arguments);
+      };
+
+    case 3:
+      return function (a0, a1, a2) {
+        return fn.apply(this, arguments);
+      };
+
+    case 4:
+      return function (a0, a1, a2, a3) {
+        return fn.apply(this, arguments);
+      };
+
+    case 5:
+      return function (a0, a1, a2, a3, a4) {
+        return fn.apply(this, arguments);
+      };
+
+    case 6:
+      return function (a0, a1, a2, a3, a4, a5) {
+        return fn.apply(this, arguments);
+      };
+
+    case 7:
+      return function (a0, a1, a2, a3, a4, a5, a6) {
+        return fn.apply(this, arguments);
+      };
+
+    case 8:
+      return function (a0, a1, a2, a3, a4, a5, a6, a7) {
+        return fn.apply(this, arguments);
+      };
+
+    case 9:
+      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {
+        return fn.apply(this, arguments);
+      };
+
+    case 10:
+      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+        return fn.apply(this, arguments);
+      };
+
+    default:
+      throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
+  }
+}
+
+module.exports = _arity;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/internal/_arrayReduce.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+function _arrayReduce(reducer, acc, list) {
+  var index = 0;
+  var length = list.length;
+
+  while (index < length) {
+    acc = reducer(acc, list[index]);
+    index += 1;
+  }
+
+  return acc;
+}
+
+module.exports = _arrayReduce;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/internal/_checkForMethod.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var _isArray = require('./_isArray.cjs');
+
+/**
+ * This checks whether a function has a [methodname] function. If it isn't an
+ * array it will execute that function otherwise it will default to the ramda
+ * implementation.
+ *
+ * @private
+ * @param {Function} fn ramda implementation
+ * @param {String} methodname property to check for a custom implementation
+ * @return {Object} Whatever the return value of the method is.
+ */
+
+function _checkForMethod(methodname, fn) {
+  return function () {
+    var length = arguments.length;
+
+    if (length === 0) {
+      return fn();
+    }
+
+    var obj = arguments[length - 1];
+    return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1));
+  };
+}
+
+module.exports = _checkForMethod;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/internal/_createReduce.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var _isArrayLike = require('./_isArrayLike.cjs');
+
+var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';
+function _createReduce(arrayReduce, methodReduce, iterableReduce) {
+  return function _reduce(xf, acc, list) {
+    if (_isArrayLike(list)) {
+      return arrayReduce(xf, acc, list);
+    }
+
+    if (list == null) {
+      return acc;
+    }
+
+    if (typeof list['fantasy-land/reduce'] === 'function') {
+      return methodReduce(xf, acc, list, 'fantasy-land/reduce');
+    }
+
+    if (list[symIterator] != null) {
+      return iterableReduce(xf, acc, list[symIterator]());
+    }
+
+    if (typeof list.next === 'function') {
+      return iterableReduce(xf, acc, list);
+    }
+
+    if (typeof list.reduce === 'function') {
+      return methodReduce(xf, acc, list, 'reduce');
+    }
+
+    throw new TypeError('reduce: list must be array or iterable');
+  };
+}
+
+module.exports = _createReduce;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/internal/_curry1.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+var _isPlaceholder = require('./_isPlaceholder.cjs');
+
+/**
+ * Optimized internal one-arity curry function.
+ *
+ * @private
+ * @category Function
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+
+function _curry1(fn) {
+  return function f1(a) {
+    if (arguments.length === 0 || _isPlaceholder(a)) {
+      return f1;
+    } else {
+      return fn.apply(this, arguments);
+    }
+  };
+}
+
+module.exports = _curry1;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/internal/_curry2.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var _curry1 = require('./_curry1.cjs');
+var _isPlaceholder = require('./_isPlaceholder.cjs');
+
+/**
+ * Optimized internal two-arity curry function.
+ *
+ * @private
+ * @category Function
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+
+function _curry2(fn) {
+  return function f2(a, b) {
+    switch (arguments.length) {
+      case 0:
+        return f2;
+
+      case 1:
+        return _isPlaceholder(a) ? f2 : _curry1(function (_b) {
+          return fn(a, _b);
+        });
+
+      default:
+        return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function (_a) {
+          return fn(_a, b);
+        }) : _isPlaceholder(b) ? _curry1(function (_b) {
+          return fn(a, _b);
+        }) : fn(a, b);
+    }
+  };
+}
+
+module.exports = _curry2;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/internal/_curry3.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+var _curry1 = require('./_curry1.cjs');
+var _curry2 = require('./_curry2.cjs');
+var _isPlaceholder = require('./_isPlaceholder.cjs');
+
+/**
+ * Optimized internal three-arity curry function.
+ *
+ * @private
+ * @category Function
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+
+function _curry3(fn) {
+  return function f3(a, b, c) {
+    switch (arguments.length) {
+      case 0:
+        return f3;
+
+      case 1:
+        return _isPlaceholder(a) ? f3 : _curry2(function (_b, _c) {
+          return fn(a, _b, _c);
+        });
+
+      case 2:
+        return _isPlaceholder(a) && _isPlaceholder(b) ? f3 : _isPlaceholder(a) ? _curry2(function (_a, _c) {
+          return fn(_a, b, _c);
+        }) : _isPlaceholder(b) ? _curry2(function (_b, _c) {
+          return fn(a, _b, _c);
+        }) : _curry1(function (_c) {
+          return fn(a, b, _c);
+        });
+
+      default:
+        return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3 : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function (_a, _b) {
+          return fn(_a, _b, c);
+        }) : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function (_a, _c) {
+          return fn(_a, b, _c);
+        }) : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function (_b, _c) {
+          return fn(a, _b, _c);
+        }) : _isPlaceholder(a) ? _curry1(function (_a) {
+          return fn(_a, b, c);
+        }) : _isPlaceholder(b) ? _curry1(function (_b) {
+          return fn(a, _b, c);
+        }) : _isPlaceholder(c) ? _curry1(function (_c) {
+          return fn(a, b, _c);
+        }) : fn(a, b, c);
+    }
+  };
+}
+
+module.exports = _curry3;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/internal/_curryN.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var _arity = require('./_arity.cjs');
+var _isPlaceholder = require('./_isPlaceholder.cjs');
+
+/**
+ * Internal curryN function.
+ *
+ * @private
+ * @category Function
+ * @param {Number} length The arity of the curried function.
+ * @param {Array} received An array of arguments received thus far.
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+
+function _curryN(length, received, fn) {
+  return function () {
+    var combined = [];
+    var argsIdx = 0;
+    var left = length;
+    var combinedIdx = 0;
+    var hasPlaceholder = false;
+
+    while (combinedIdx < received.length || argsIdx < arguments.length) {
+      var result;
+
+      if (combinedIdx < received.length && (!_isPlaceholder(received[combinedIdx]) || argsIdx >= arguments.length)) {
+        result = received[combinedIdx];
+      } else {
+        result = arguments[argsIdx];
+        argsIdx += 1;
+      }
+
+      combined[combinedIdx] = result;
+
+      if (!_isPlaceholder(result)) {
+        left -= 1;
+      } else {
+        hasPlaceholder = true;
+      }
+
+      combinedIdx += 1;
+    }
+
+    return !hasPlaceholder && left <= 0 ? fn.apply(this, combined) : _arity(Math.max(0, left), _curryN(length, combined, fn));
+  };
+}
+
+module.exports = _curryN;