@dbmx/toasts 0.0.121 → 0.0.123

package/cjs/node_modules/react/jsx-runtime.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var jsxRuntime = require('../../_virtual/jsx-runtime.cjs');
+var reactJsxRuntime_development = require('./cjs/react-jsx-runtime.development.cjs');
+require('react');
+
+{
+  jsxRuntime.__module.exports = reactJsxRuntime_development.__require();
+}
+
+var jsxRuntimeExports = jsxRuntime.__module.exports;
+
+exports.jsxRuntimeExports = jsxRuntimeExports;

package/cjs/node_modules/react-dom/client.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var require$$0 = require('react-dom');
+
+exports.createRoot = void 0;
+
+var m = require$$0;
+{
+  var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+  exports.createRoot = function (c, o) {
+    i.usingClientEntryPoint = true;
+    try {
+      return m.createRoot(c, o);
+    } finally {
+      i.usingClientEntryPoint = false;
+    }
+  };
+}

package/cjs/node_modules/yallist/iterator.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var iterator;
+var hasRequiredIterator;
+
+function requireIterator () {
+	if (hasRequiredIterator) return iterator;
+	hasRequiredIterator = 1;
+
+	iterator = function (Yallist) {
+	  Yallist.prototype[Symbol.iterator] = function* () {
+	    for (let walker = this.head; walker; walker = walker.next) {
+	      yield walker.value;
+	    }
+	  };
+	};
+	return iterator;
+}
+
+exports.__require = requireIterator;

package/cjs/node_modules/yallist/yallist.cjs

@@ -0,0 +1,370 @@
+'use strict';
+
+var iterator = require('./iterator.cjs');
+
+var yallist = Yallist;
+Yallist.Node = Node;
+Yallist.create = Yallist;
+function Yallist(list) {
+  var self = this;
+  if (!(self instanceof Yallist)) {
+    self = new Yallist();
+  }
+  self.tail = null;
+  self.head = null;
+  self.length = 0;
+  if (list && typeof list.forEach === 'function') {
+    list.forEach(function (item) {
+      self.push(item);
+    });
+  } else if (arguments.length > 0) {
+    for (var i = 0, l = arguments.length; i < l; i++) {
+      self.push(arguments[i]);
+    }
+  }
+  return self;
+}
+Yallist.prototype.removeNode = function (node) {
+  if (node.list !== this) {
+    throw new Error('removing node which does not belong to this list');
+  }
+  var next = node.next;
+  var prev = node.prev;
+  if (next) {
+    next.prev = prev;
+  }
+  if (prev) {
+    prev.next = next;
+  }
+  if (node === this.head) {
+    this.head = next;
+  }
+  if (node === this.tail) {
+    this.tail = prev;
+  }
+  node.list.length--;
+  node.next = null;
+  node.prev = null;
+  node.list = null;
+  return next;
+};
+Yallist.prototype.unshiftNode = function (node) {
+  if (node === this.head) {
+    return;
+  }
+  if (node.list) {
+    node.list.removeNode(node);
+  }
+  var head = this.head;
+  node.list = this;
+  node.next = head;
+  if (head) {
+    head.prev = node;
+  }
+  this.head = node;
+  if (!this.tail) {
+    this.tail = node;
+  }
+  this.length++;
+};
+Yallist.prototype.pushNode = function (node) {
+  if (node === this.tail) {
+    return;
+  }
+  if (node.list) {
+    node.list.removeNode(node);
+  }
+  var tail = this.tail;
+  node.list = this;
+  node.prev = tail;
+  if (tail) {
+    tail.next = node;
+  }
+  this.tail = node;
+  if (!this.head) {
+    this.head = node;
+  }
+  this.length++;
+};
+Yallist.prototype.push = function () {
+  for (var i = 0, l = arguments.length; i < l; i++) {
+    push(this, arguments[i]);
+  }
+  return this.length;
+};
+Yallist.prototype.unshift = function () {
+  for (var i = 0, l = arguments.length; i < l; i++) {
+    unshift(this, arguments[i]);
+  }
+  return this.length;
+};
+Yallist.prototype.pop = function () {
+  if (!this.tail) {
+    return undefined;
+  }
+  var res = this.tail.value;
+  this.tail = this.tail.prev;
+  if (this.tail) {
+    this.tail.next = null;
+  } else {
+    this.head = null;
+  }
+  this.length--;
+  return res;
+};
+Yallist.prototype.shift = function () {
+  if (!this.head) {
+    return undefined;
+  }
+  var res = this.head.value;
+  this.head = this.head.next;
+  if (this.head) {
+    this.head.prev = null;
+  } else {
+    this.tail = null;
+  }
+  this.length--;
+  return res;
+};
+Yallist.prototype.forEach = function (fn, thisp) {
+  thisp = thisp || this;
+  for (var walker = this.head, i = 0; walker !== null; i++) {
+    fn.call(thisp, walker.value, i, this);
+    walker = walker.next;
+  }
+};
+Yallist.prototype.forEachReverse = function (fn, thisp) {
+  thisp = thisp || this;
+  for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
+    fn.call(thisp, walker.value, i, this);
+    walker = walker.prev;
+  }
+};
+Yallist.prototype.get = function (n) {
+  for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
+    // abort out of the list early if we hit a cycle
+    walker = walker.next;
+  }
+  if (i === n && walker !== null) {
+    return walker.value;
+  }
+};
+Yallist.prototype.getReverse = function (n) {
+  for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
+    // abort out of the list early if we hit a cycle
+    walker = walker.prev;
+  }
+  if (i === n && walker !== null) {
+    return walker.value;
+  }
+};
+Yallist.prototype.map = function (fn, thisp) {
+  thisp = thisp || this;
+  var res = new Yallist();
+  for (var walker = this.head; walker !== null;) {
+    res.push(fn.call(thisp, walker.value, this));
+    walker = walker.next;
+  }
+  return res;
+};
+Yallist.prototype.mapReverse = function (fn, thisp) {
+  thisp = thisp || this;
+  var res = new Yallist();
+  for (var walker = this.tail; walker !== null;) {
+    res.push(fn.call(thisp, walker.value, this));
+    walker = walker.prev;
+  }
+  return res;
+};
+Yallist.prototype.reduce = function (fn, initial) {
+  var acc;
+  var walker = this.head;
+  if (arguments.length > 1) {
+    acc = initial;
+  } else if (this.head) {
+    walker = this.head.next;
+    acc = this.head.value;
+  } else {
+    throw new TypeError('Reduce of empty list with no initial value');
+  }
+  for (var i = 0; walker !== null; i++) {
+    acc = fn(acc, walker.value, i);
+    walker = walker.next;
+  }
+  return acc;
+};
+Yallist.prototype.reduceReverse = function (fn, initial) {
+  var acc;
+  var walker = this.tail;
+  if (arguments.length > 1) {
+    acc = initial;
+  } else if (this.tail) {
+    walker = this.tail.prev;
+    acc = this.tail.value;
+  } else {
+    throw new TypeError('Reduce of empty list with no initial value');
+  }
+  for (var i = this.length - 1; walker !== null; i--) {
+    acc = fn(acc, walker.value, i);
+    walker = walker.prev;
+  }
+  return acc;
+};
+Yallist.prototype.toArray = function () {
+  var arr = new Array(this.length);
+  for (var i = 0, walker = this.head; walker !== null; i++) {
+    arr[i] = walker.value;
+    walker = walker.next;
+  }
+  return arr;
+};
+Yallist.prototype.toArrayReverse = function () {
+  var arr = new Array(this.length);
+  for (var i = 0, walker = this.tail; walker !== null; i++) {
+    arr[i] = walker.value;
+    walker = walker.prev;
+  }
+  return arr;
+};
+Yallist.prototype.slice = function (from, to) {
+  to = to || this.length;
+  if (to < 0) {
+    to += this.length;
+  }
+  from = from || 0;
+  if (from < 0) {
+    from += this.length;
+  }
+  var ret = new Yallist();
+  if (to < from || to < 0) {
+    return ret;
+  }
+  if (from < 0) {
+    from = 0;
+  }
+  if (to > this.length) {
+    to = this.length;
+  }
+  for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
+    walker = walker.next;
+  }
+  for (; walker !== null && i < to; i++, walker = walker.next) {
+    ret.push(walker.value);
+  }
+  return ret;
+};
+Yallist.prototype.sliceReverse = function (from, to) {
+  to = to || this.length;
+  if (to < 0) {
+    to += this.length;
+  }
+  from = from || 0;
+  if (from < 0) {
+    from += this.length;
+  }
+  var ret = new Yallist();
+  if (to < from || to < 0) {
+    return ret;
+  }
+  if (from < 0) {
+    from = 0;
+  }
+  if (to > this.length) {
+    to = this.length;
+  }
+  for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
+    walker = walker.prev;
+  }
+  for (; walker !== null && i > from; i--, walker = walker.prev) {
+    ret.push(walker.value);
+  }
+  return ret;
+};
+Yallist.prototype.splice = function (start, deleteCount, ...nodes) {
+  if (start > this.length) {
+    start = this.length - 1;
+  }
+  if (start < 0) {
+    start = this.length + start;
+  }
+  for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
+    walker = walker.next;
+  }
+  var ret = [];
+  for (var i = 0; walker && i < deleteCount; i++) {
+    ret.push(walker.value);
+    walker = this.removeNode(walker);
+  }
+  if (walker === null) {
+    walker = this.tail;
+  }
+  if (walker !== this.head && walker !== this.tail) {
+    walker = walker.prev;
+  }
+  for (var i = 0; i < nodes.length; i++) {
+    walker = insert(this, walker, nodes[i]);
+  }
+  return ret;
+};
+Yallist.prototype.reverse = function () {
+  var head = this.head;
+  var tail = this.tail;
+  for (var walker = head; walker !== null; walker = walker.prev) {
+    var p = walker.prev;
+    walker.prev = walker.next;
+    walker.next = p;
+  }
+  this.head = tail;
+  this.tail = head;
+  return this;
+};
+function insert(self, node, value) {
+  var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self);
+  if (inserted.next === null) {
+    self.tail = inserted;
+  }
+  if (inserted.prev === null) {
+    self.head = inserted;
+  }
+  self.length++;
+  return inserted;
+}
+function push(self, item) {
+  self.tail = new Node(item, self.tail, null, self);
+  if (!self.head) {
+    self.head = self.tail;
+  }
+  self.length++;
+}
+function unshift(self, item) {
+  self.head = new Node(item, null, self.head, self);
+  if (!self.tail) {
+    self.tail = self.head;
+  }
+  self.length++;
+}
+function Node(value, prev, next, list) {
+  if (!(this instanceof Node)) {
+    return new Node(value, prev, next, list);
+  }
+  this.list = list;
+  this.value = value;
+  if (prev) {
+    prev.next = this;
+    this.prev = prev;
+  } else {
+    this.prev = null;
+  }
+  if (next) {
+    next.prev = this;
+    this.next = next;
+  } else {
+    this.next = null;
+  }
+}
+try {
+  // add if support for Symbol.iterator is present
+  iterator.__require()(Yallist);
+} catch (er) {}
+
+exports.yallist = yallist;

package/cjs/webComponents/HelloWorld/index.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.cjs');
+var React = require('react');
+var client = require('../../node_modules/react-dom/client.cjs');
+var index = require('../../components/HelloWorld/index.cjs');
+var style = require('../../components/HelloWorld/style.css.cjs');
+
+var HelloWorld = /*#__PURE__*/function (_HTMLElement) {
+  _rollupPluginBabelHelpers.inherits(HelloWorld, _HTMLElement);
+  var _super = _rollupPluginBabelHelpers.createSuper(HelloWorld);
+  function HelloWorld() {
+    var _this;
+    _rollupPluginBabelHelpers.classCallCheck(this, HelloWorld);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _rollupPluginBabelHelpers.defineProperty(_rollupPluginBabelHelpers.assertThisInitialized(_this), "forceUpdateComponent", void 0);
+    _rollupPluginBabelHelpers.defineProperty(_rollupPluginBabelHelpers.assertThisInitialized(_this), "container", function () {
+      var forceUpdate = React.useReducer(function () {
+        return {};
+      }, {})[1];
+      _this.forceUpdateComponent = forceUpdate;
+      var name = _this.getAttribute('name');
+      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("style", null, style), ",", /*#__PURE__*/React.createElement(index, {
+        name: name
+      }));
+    });
+    return _this;
+  }
+  _rollupPluginBabelHelpers.createClass(HelloWorld, [{
+    key: "connectedCallback",
+    value: function connectedCallback() {
+      var mountPoint = document.createElement('div');
+      var shadowRoot = this.attachShadow({
+        mode: 'open'
+      });
+      shadowRoot.appendChild(mountPoint);
+      var root = client.createRoot(mountPoint);
+      root.render( /*#__PURE__*/React.createElement(this.container, null));
+    }
+  }, {
+    key: "attributeChangedCallback",
+    value: function attributeChangedCallback() {
+      if (typeof this.forceUpdateComponent === 'function') this.forceUpdateComponent();
+    }
+  }], [{
+    key: "observedAttributes",
+    get: function get() {
+      return ['name'];
+    }
+  }]);
+  return HelloWorld;
+}( /*#__PURE__*/_rollupPluginBabelHelpers.wrapNativeSuper(HTMLElement));
+customElements.define('hello-world', HelloWorld);

package/cjs/webComponents/SDMXDatagrid/index.cjs

@@ -0,0 +1,88 @@
+'use strict';
+
+var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.cjs');
+var React = require('react');
+var client = require('../../node_modules/react-dom/client.cjs');
+var index = require('../../components/SdmxDatagrid/index.cjs');
+var emotionCache_esm = require('../../node_modules/@emotion/cache/dist/emotion-cache.esm.cjs');
+var react = require('@emotion/react');
+var reactIntl = require('react-intl');
+var styles = require('@mui/styles');
+var jss = require('jss');
+var createTheme = require('../../node_modules/@mui/material/styles/createTheme.cjs');
+var ThemeProvider = require('../../node_modules/@mui/material/styles/ThemeProvider.cjs');
+
+var SDMXDatagrid = /*#__PURE__*/function (_HTMLElement) {
+  _rollupPluginBabelHelpers.inherits(SDMXDatagrid, _HTMLElement);
+  var _super = _rollupPluginBabelHelpers.createSuper(SDMXDatagrid);
+  function SDMXDatagrid() {
+    var _this;
+    _rollupPluginBabelHelpers.classCallCheck(this, SDMXDatagrid);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _rollupPluginBabelHelpers.defineProperty(_rollupPluginBabelHelpers.assertThisInitialized(_this), "forceUpdateComponent", void 0);
+    _rollupPluginBabelHelpers.defineProperty(_rollupPluginBabelHelpers.assertThisInitialized(_this), "container", function () {
+      var forceUpdate = React.useReducer(function () {
+        return {};
+      }, {})[1];
+      _this.forceUpdateComponent = forceUpdate;
+      var props = {
+        endpoint: _this.getAttribute('endpoint'),
+        resourceType: _this.getAttribute('resourceType'),
+        agencyID: _this.getAttribute('agencyID'),
+        id: _this.getAttribute('id'),
+        version: _this.getAttribute('version')
+      };
+      var containerProps = _this.getAttribute('containerProps') || {};
+      var containerPropsValue = typeof containerProps === 'string' ? JSON.parse(containerProps) : {};
+      return /*#__PURE__*/React.createElement("div", containerPropsValue, /*#__PURE__*/React.createElement(index, props));
+    });
+    return _this;
+  }
+  _rollupPluginBabelHelpers.createClass(SDMXDatagrid, [{
+    key: "connectedCallback",
+    value: function connectedCallback() {
+      var shadowContainer = this.attachShadow({
+        mode: 'open'
+      });
+      var emotionRoot = document.createElement('style');
+      var shadowRootElement = document.createElement('div');
+      shadowContainer.appendChild(emotionRoot);
+      shadowContainer.appendChild(shadowRootElement);
+      var cache = emotionCache_esm({
+        key: 'css-shadow-dom',
+        prepend: true,
+        container: emotionRoot
+      });
+      var shadowTheme = createTheme({});
+      var jss$1 = jss.create(_rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, styles.jssPreset()), {}, {
+        insertionPoint: shadowRootElement
+      }));
+      client.createRoot(shadowRootElement).render( /*#__PURE__*/React.createElement(React.StrictMode, null, /*#__PURE__*/React.createElement(styles.StylesProvider, {
+        jss: jss$1
+      }, /*#__PURE__*/React.createElement(react.CacheProvider, {
+        value: cache
+      }, /*#__PURE__*/React.createElement(ThemeProvider, {
+        theme: shadowTheme
+      }, /*#__PURE__*/React.createElement(reactIntl.IntlProvider, {
+        defaultLocale: "en",
+        locale: "en",
+        messages: {}
+      }, /*#__PURE__*/React.createElement(this.container, null)))))));
+    }
+  }, {
+    key: "attributeChangedCallback",
+    value: function attributeChangedCallback() {
+      if (typeof this.forceUpdateComponent === 'function') this.forceUpdateComponent();
+    }
+  }], [{
+    key: "observedAttributes",
+    get: function get() {
+      return ['endpoint', 'resourceType', 'agencyID', 'id', 'version'];
+    }
+  }]);
+  return SDMXDatagrid;
+}( /*#__PURE__*/_rollupPluginBabelHelpers.wrapNativeSuper(HTMLElement));
+customElements.define('sdmx-datagrid', SDMXDatagrid);

package/esm/_virtual/_commonjsHelpers.js

@@ -0,0 +1,31 @@
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+export { getAugmentedNamespace, getDefaultExportFromCjs };
+//# sourceMappingURL=_commonjsHelpers.js.map

package/esm/_virtual/_commonjsHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_commonjsHelpers.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}