react-global-comp/lib/es/index.js

A class for create global react component api

/**
 * Bundle of react-global-comp
 * Generated: 2022-04-26
 * Version: 2.1.0
 * License: MIT
 * Author: 2631541504@qq.com
 */

import React from 'react';
import ReactDOM from 'react-dom';

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    if (enumerableOnly) symbols = symbols.filter(function (sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    });
    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(Object(source), true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

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, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  return Constructor;
}

var ReactGlobalComp = /*#__PURE__*/function () {
  function ReactGlobalComp(id, comp) {
    _classCallCheck(this, ReactGlobalComp);

    _defineProperty(this, "id", void 0);

    _defineProperty(this, "comp", void 0);

    _defineProperty(this, "preProps", void 0);

    _defineProperty(this, "ref", void 0);

    this.id = id;
    this.comp = comp;
  }

  _createClass(ReactGlobalComp, [{
    key: "render",
    value: function render(props) {
      var _this = this;

      return new Promise(function (res) {
        var dom = document.getElementById(_this.id);

        if (!dom) {
          dom = document.createElement('div');
          dom.id = _this.id;
          document.body.appendChild(dom);
        }

        var $props = _objectSpread2(_objectSpread2({}, _this.preProps), props);

        ReactDOM.render(React.createElement(_this.comp, _objectSpread2(_objectSpread2({}, $props), {}, {
          ref: function ref(el) {
            _this.ref = el;
            if (typeof $props.ref === 'function') $props.ref(el);else if ($props.ref) $props.ref.current = el;
          }
        })), dom, res);
      });
    }
  }, {
    key: "destroy",
    value: function destroy() {
      var _this2 = this;

      return new Promise(function (res) {
        var dom = document.getElementById(_this2.id);

        if (dom) {
          ReactDOM.render(React.createElement(React.Fragment), dom, res);
        } else {
          console.warn(new Error('Comp did not render yet'));
          res();
        }
      });
    }
  }]);

  return ReactGlobalComp;
}();

export default ReactGlobalComp;