@dbmx/toasts 0.0.18 → 0.0.19

package/cjs/_virtual/_rollupPluginBabelHelpers.cjs

@@ -379,6 +379,28 @@ function _asyncToGenerator(fn) {
     });
   };
 }
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
 function _defineProperty(obj, key, value) {
   key = _toPropertyKey(key);
   if (key in obj) {
@@ -393,6 +415,122 @@ function _defineProperty(obj, key, value) {
   }
   return obj;
 }
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct.bind();
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _isNativeFunction(fn) {
+  try {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+  } catch (e) {
+    return typeof fn === "function";
+  }
+}
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+      _cache.set(Class, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+  return _wrapNativeSuper(Class);
+}
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _possibleConstructorReturn(self, call) {
+  if (call && (typeof call === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized(self);
+}
+function _createSuper(Derived) {
+  var hasNativeReflectConstruct = _isNativeReflectConstruct();
+  return function _createSuperInternal() {
+    var Super = _getPrototypeOf(Derived),
+      result;
+    if (hasNativeReflectConstruct) {
+      var NewTarget = _getPrototypeOf(this).constructor;
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+    return _possibleConstructorReturn(this, result);
+  };
+}
 function _slicedToArray(arr, i) {
   return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
 }
@@ -496,17 +634,29 @@ function _toPropertyKey(arg) {
 exports.arrayLikeToArray = _arrayLikeToArray;
 exports.arrayWithHoles = _arrayWithHoles;
 exports.arrayWithoutHoles = _arrayWithoutHoles;
+exports.assertThisInitialized = _assertThisInitialized;
 exports.asyncToGenerator = _asyncToGenerator;
+exports.classCallCheck = _classCallCheck;
+exports.construct = _construct;
+exports.createClass = _createClass;
 exports.createForOfIteratorHelper = _createForOfIteratorHelper;
+exports.createSuper = _createSuper;
 exports.defineProperty = _defineProperty;
+exports.getPrototypeOf = _getPrototypeOf;
+exports.inherits = _inherits;
+exports.isNativeFunction = _isNativeFunction;
+exports.isNativeReflectConstruct = _isNativeReflectConstruct;
 exports.iterableToArray = _iterableToArray;
 exports.iterableToArrayLimit = _iterableToArrayLimit;
 exports.nonIterableRest = _nonIterableRest;
 exports.nonIterableSpread = _nonIterableSpread;
 exports.objectSpread2 = _objectSpread2;
+exports.possibleConstructorReturn = _possibleConstructorReturn;
 exports.regeneratorRuntime = _regeneratorRuntime;
+exports.setPrototypeOf = _setPrototypeOf;
 exports.slicedToArray = _slicedToArray;
 exports.toConsumableArray = _toConsumableArray;
 exports.toPrimitive = _toPrimitive;
 exports.toPropertyKey = _toPropertyKey;
 exports.unsupportedIterableToArray = _unsupportedIterableToArray;
+exports.wrapNativeSuper = _wrapNativeSuper;

package/cjs/index.cjs

@@ -14,6 +14,7 @@ var toasts = [{
   type: type,
   tag: tag,
   name: 'SDMX Datagrid',
+  tech: 'react',
   description: 'SDMX, which stands for Statistical Data and Metadata eXchange, is an international initiative that aims at standardising and modernising ("industrialising") the mechanisms and processes for the exchange of statistical data and metadata among international organisations and their member countries.',
   component: /*#__PURE__*/React.lazy( /*#__PURE__*/_rollupPluginBabelHelpers.asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers.regeneratorRuntime().mark(function _callee() {
     var obj;
@@ -68,6 +69,25 @@ var toasts = [{
       defaultValue: '~'
     }
   }
+}, {
+  id: 'helloWorld',
+  importPath: '@dbmx/webComponents',
+  type: '@dbmx/webComponents',
+  tag: 'hello-world',
+  name: 'Hello World',
+  tech: 'web-component',
+  description: 'web component demonstration',
+  component: function component() {
+    return Promise.resolve().then(function () { return require('./webComponents/HelloWorld/index.cjs'); });
+  },
+  image: 'https://ui.mantine.dev/_next/static/media/comments-light.9c0747c0.svg',
+  props: {
+    name: {
+      type: 'string',
+      required: true,
+      "default": 'test'
+    }
+  }
 }];
 
 module.exports = toasts;

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/webComponents/HelloWorld/index.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.cjs');
+var React = require('react');
+var client = require('../../node_modules/react-dom/client.cjs');
+
+var Component = function Component(_ref) {
+  var name = _ref.name;
+  return /*#__PURE__*/React.createElement("div", {
+    style: {
+      backgroundColor: '#cfe8ff60',
+      padding: 15
+    }
+  }, /*#__PURE__*/React.createElement("h2", null, "testing react component"), /*#__PURE__*/React.createElement("p", null, "Your name is: ", /*#__PURE__*/React.createElement("i", {
+    style: {
+      color: '#9c9c9c'
+    }
+  }, name)), /*#__PURE__*/React.createElement("input", {
+    type: "text",
+    placeholder: "filter"
+  }));
+};
+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), "setName", void 0);
+    _rollupPluginBabelHelpers.defineProperty(_rollupPluginBabelHelpers.assertThisInitialized(_this), "HelloWorldContainer", function () {
+      var _useState = React.useState(_this.getAttribute('name')),
+        _useState2 = _rollupPluginBabelHelpers.slicedToArray(_useState, 2),
+        name = _useState2[0],
+        updateName = _useState2[1];
+      _this.setName = updateName;
+      return /*#__PURE__*/React.createElement(Component, {
+        name: name
+      });
+    });
+    return _this;
+  }
+  _rollupPluginBabelHelpers.createClass(HelloWorld, [{
+    key: "connectedCallback",
+    value: function connectedCallback() {
+      var mountPoint = document.createElement('div');
+      this.attachShadow({
+        mode: 'open'
+      }).appendChild(mountPoint);
+      var root = client.createRoot(mountPoint);
+      root.render( /*#__PURE__*/React.createElement(this.HelloWorldContainer, null));
+    }
+  }, {
+    key: "attributeChangedCallback",
+    value: function attributeChangedCallback(attrName, oldValue, newValue) {
+      if (attrName === 'name') {
+        if (typeof this.setName === 'function') {
+          this.setName(newValue);
+        }
+      }
+    }
+  }], [{
+    key: "observedAttributes",
+    get: function get() {
+      return ['name'];
+    }
+  }]);
+  return HelloWorld;
+}( /*#__PURE__*/_rollupPluginBabelHelpers.wrapNativeSuper(HTMLElement));
+customElements.define('hello-world', HelloWorld);