@cgeui/business-components 0.0.1 → 0.0.3

package/dist/esm/utils/formAdapter/BasicAdapter.js

@@ -0,0 +1,71 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { cloneDeep, merge as _merge } from 'lodash';
+import { useIntl as _useIntl } from 'react-intl';
+export var BasicAdapter = /*#__PURE__*/function () {
+  function BasicAdapter(data) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, BasicAdapter);
+    _defineProperty(this, "data", void 0);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "intl", void 0);
+    this.data = cloneDeep(data);
+    this.options = options;
+    this.key();
+    if (options !== null && options !== void 0 && options.useIntl) {
+      this.useIntl();
+    }
+  }
+  _createClass(BasicAdapter, [{
+    key: "key",
+    value: function key(_key) {
+      this.data.key = _key || this.data.dataIndex || this.data.key || new Date().getTime();
+    }
+  }, {
+    key: "useIntl",
+    value: function useIntl() {
+      if (!this.intl) {
+        var _this$options;
+        this.intl = ((_this$options = this.options) === null || _this$options === void 0 ? void 0 : _this$options.customIntl) || _useIntl();
+      }
+      if (this.data.title) {
+        this.data.title = this.intl.formatMessage({
+          id: this.data.title
+        });
+      }
+      return this;
+    }
+  }, {
+    key: "sorter",
+    value: function sorter() {
+      var fn = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      this.data.sorter = fn;
+      return this;
+    }
+  }, {
+    key: "assign",
+    value: function assign(params) {
+      Object.assign(this.data, params);
+      return this;
+    }
+  }, {
+    key: "merge",
+    value: function merge(params) {
+      _merge(this.data, params);
+      return this;
+    }
+  }, {
+    key: "useEnum",
+    value: function useEnum(valueEnum) {
+      return this.assign({
+        enum: valueEnum
+      });
+    }
+  }]);
+  return BasicAdapter;
+}();

package/dist/esm/utils/formAdapter/FormSchemaAdapter.js

@@ -0,0 +1,149 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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 _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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 _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+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 _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 _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import { isFunction } from 'lodash';
+import { BasicAdapter } from "./BasicAdapter";
+import { jsx as _jsx } from "react/jsx-runtime";
+export var FormSchemaAdapter = /*#__PURE__*/function (_BasicAdapter) {
+  _inherits(FormSchemaAdapter, _BasicAdapter);
+  var _super = _createSuper(FormSchemaAdapter);
+  function FormSchemaAdapter(data) {
+    var _this;
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      useIntl: true,
+      colon: false,
+      customIntl: null
+    };
+    _classCallCheck(this, FormSchemaAdapter);
+    _this = _super.call(this, data, options);
+    if (!options.colon) {
+      _this.colon(false);
+    }
+    return _this;
+  }
+  _createClass(FormSchemaAdapter, [{
+    key: "required",
+    value: function required() {
+      var _required = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      return this.assign({
+        required: _required
+      });
+    }
+  }, {
+    key: "useDecorator",
+    value: function useDecorator() {
+      var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'FormItem';
+      var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      var schema = {};
+      schema['x-decorator'] = name;
+      if (props) {
+        schema['x-decorator-props'] = props;
+      }
+      return this.merge(schema);
+    }
+  }, {
+    key: "useDecoratorProps",
+    value: function useDecoratorProps(props) {
+      return this.merge({
+        'x-decorator-props': props
+      });
+    }
+  }, {
+    key: "useDirection",
+    value: function useDirection(direction) {
+      return this.useDecoratorProps({
+        className: "flex-".concat(direction)
+      });
+    }
+  }, {
+    key: "useLabel",
+    value: function useLabel(labelRender) {
+      var labelJsx = labelRender;
+      if (isFunction(labelRender)) {
+        labelJsx = labelRender(this.data);
+      }
+      var Label = function Label() {
+        return labelJsx;
+      };
+      return this.useDecorator('FormItem', {
+        label: /*#__PURE__*/_jsx(Label, {})
+      });
+    }
+  }, {
+    key: "colon",
+    value: function colon() {
+      var _colon = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      return this.useDecoratorProps({
+        colon: _colon
+      });
+    }
+  }, {
+    key: "readOnly",
+    value: function readOnly() {
+      return this.assign({
+        readOnly: true
+      });
+    }
+  }, {
+    key: "readPretty",
+    value: function readPretty() {
+      return this.assign({
+        'x-read-pretty': true
+      });
+    }
+  }, {
+    key: "useComponent",
+    value: function useComponent() {
+      var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Input';
+      var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      var componentSchema = {};
+      componentSchema['x-component'] = name;
+      if (props) {
+        componentSchema['x-component-props'] = props;
+      }
+      return this.assign(componentSchema);
+    }
+  }, {
+    key: "useProperties",
+    value: function useProperties() {
+      var properties = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      return this.assign({
+        properties: properties
+      });
+    }
+  }, {
+    key: "useValidator",
+    value: function useValidator(validator) {
+      return this.assign({
+        'x-validator': validator
+      });
+    }
+  }, {
+    key: "useReactions",
+    value: function useReactions(fulfill) {
+      return this.merge({
+        'x-reactions': fulfill
+      });
+    }
+  }, {
+    key: "useDependencies",
+    value: function useDependencies(dependencies) {
+      return this.merge({
+        'x-reactions': {
+          dependencies: dependencies
+        }
+      });
+    }
+  }]);
+  return FormSchemaAdapter;
+}(BasicAdapter);

package/dist/esm/utils/index.js

@@ -0,0 +1,5 @@
+export * from "./constants/battery";
+export * from "./formAdapter/FormSchemaAdapter";
+export * from "./locale";
+export * from "./tableAdapter/table";
+export * from "./time";

package/dist/esm/utils/locale.js

@@ -0,0 +1,10 @@
+export var getLocale = function getLocale() {
+  var lang = navigator.cookieEnabled && typeof localStorage !== 'undefined' ? window.localStorage.getItem('locale') : '';
+  // support baseNavigator, default true
+  var isNavigatorLanguageValid = typeof navigator !== 'undefined' && typeof navigator.language === 'string';
+  var browserLang = isNavigatorLanguageValid ? navigator.language.split('-').join('-') : '';
+  return lang || browserLang || 'zh-CN';
+};
+export var getInfoByLocales = function getInfoByLocales(info, val) {
+  return info.replace('{n}', val);
+};

package/dist/esm/utils/store/action.js

@@ -0,0 +1,316 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import ENV from "../constants/env";
+import { debounce, isEqual, isFunction, set } from 'lodash';
+import { makeObservable, observable, action as mAction } from 'mobx';
+export var Action = /*#__PURE__*/_createClass(function Action(action) {
+  _classCallCheck(this, Action);
+  /**action的名字 */
+  _defineProperty(this, "title", void 0);
+  /**action对象的名字，即组件名 默认window */
+  // targetName: string;
+  /**执行action的对象 */
+  _defineProperty(this, "target", void 0);
+  /**action的方法 */
+  _defineProperty(this, "fn", void 0);
+  /**action提供外部访问的数据 */
+  _defineProperty(this, "data", void 0);
+  /**action类型 */
+  _defineProperty(this, "type", void 0);
+  /**对应target dataSet中的字段 */
+  _defineProperty(this, "dataKey", void 0);
+  /**处理params的方法 */
+  _defineProperty(this, "handlerParamsFn", void 0);
+  _defineProperty(this, "throttle", void 0);
+  _defineProperty(this, "debounced", void 0);
+  this.title = action.title;
+  // this.targetName = action.targetName || 'window';
+  this.target = action.target || window;
+  this.dataKey = action.dataKey;
+  this.type = action.type;
+  this.throttle = action === null || action === void 0 ? void 0 : action.throttle;
+  this.debounced = action.debounced;
+  this.fn = action.fn;
+  this.handlerParamsFn = action.handlerParamsFn;
+  if (this.debounced) {
+    this.fn = debounce(this.fn, this.debounced.waitTime);
+  }
+  this.data = action.data;
+  /**TODO
+      // this.when = action.when || null;
+      // this.on = action.on;
+      // this.target=action.target
+      // this.type=ation.type
+      // this.beforeComplete = action.beforeComplete;
+      // this.callback = action.callback;
+      // this.isCompleted = action.isCompleted || false;
+      // this.isStart = false;
+      // this.status = null;
+      // makeObservable(this, {
+      //   title: observable,
+      //   data: observable,
+      //   // setData: mAction,
+      //   // ref: observable,
+      //   // isCompleted: observable,
+      //   // isEditing: observable,
+      // });
+      */
+}
+
+// handlerParams(params) {
+//   switch (this.type) {
+//     case 'setDataSet':
+//       return [this.dataKey, params];
+//     default:
+//       return this.handlerParamsFn?.(params) || params;
+//   }
+// }
+
+// setData(data) {
+//   this.data = data;
+// }
+// run(params) {
+//   let res;
+//   if (this.fn) {
+//     res = this.fn.call(this.target, params);
+//   } else {
+//     res = this.target[this.type](params);
+//   }
+//   this.setData(res);
+//   if (this.dataKey) {
+//     this.target.setDataSet(this.dataKey, res);
+//   }
+//   return res;
+// }
+);
+export var ActionTarget = /*#__PURE__*/function () {
+  function ActionTarget(parmas) {
+    _classCallCheck(this, ActionTarget);
+    /**action对象的名字，即组件名 默认window */
+    _defineProperty(this, "targetName", void 0);
+    /**执行action的对象 */
+    // _target: any;
+    // targets: ActionTargetsType | undefined;
+    /**action主体类型 window/scope */
+    _defineProperty(this, "type", void 0);
+    /**actions */
+    _defineProperty(this, "actions", {});
+    /**数据集 */
+    _defineProperty(this, "dataSet", void 0);
+    this.targetName = parmas.targetName;
+    this.type = parmas.type || 'scope';
+    this.dataSet = parmas.dataSet || {};
+    this.initActions(parmas.actionList);
+    makeObservable(this, {
+      actions: observable,
+      dataSet: observable,
+      register: mAction,
+      // target: computed,
+      // actionStore: computed,
+      setDataSet: mAction
+    });
+  }
+  _createClass(ActionTarget, [{
+    key: "initActions",
+    value: function initActions() {
+      var _this = this;
+      var actionList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      if (actionList) {
+        actionList.forEach(function (element) {
+          if (!element.type) {
+            throw Error("element.type is required");
+          }
+          if (!_this.getActionFun(element)) {
+            throw Error("element.type ".concat(element.type, " and element.fn is invalid"));
+          }
+          _this.actions[element.type] = new Action({
+            targetName: _this.targetName,
+            dataKey: element.dataKey,
+            // target: this,
+            type: element.type,
+            fn: element.fn
+          });
+        });
+      }
+    }
+  }, {
+    key: "getActionFun",
+    value: function getActionFun(action) {
+      var _this2 = this;
+      if (this.targetName === 'window') {
+        if (!window[action.type]) {
+          throw Error("window function ".concat(action.type, " is not exist"));
+        }
+        return window[action.type];
+      }
+      if (this[action.type]) {
+        return this[action.type];
+      }
+      if (action.fn) return action.fn;
+      // debugger;
+      return function () {
+        for (var _len = arguments.length, arg = new Array(_len), _key = 0; _key < _len; _key++) {
+          arg[_key] = arguments[_key];
+        }
+        return _this2.setDataSet.apply(_this2, [action.dataKey].concat(arg));
+      };
+      // throw Error(`${this.targetName}'s action ${action.type} is invalid`);
+    }
+    // get actionStore() {
+    //   return getActionStore();
+    // }
+
+    // get target() {
+    //   if (this.targetName === 'window') {
+    //     return window;
+    //   }
+    //   if (this.actionStore) {
+    //     return this.actionStore.getTarget(this.targetName);
+    //   }
+    // }
+  }, {
+    key: "setDataSet",
+    value: function setDataSet() {
+      for (var _len2 = arguments.length, arg = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        arg[_key2] = arguments[_key2];
+      }
+      if (arg.length === 1) {
+        var _arg$ = arg[0],
+          dataKey = _arg$.dataKey,
+          value = _arg$.value;
+        if (dataKey) {
+          if (isEqual(value, this.dataSet[dataKey])) {
+            console.log("".concat(dataKey, " value no change"), value);
+            return;
+          }
+          set(this.dataSet, dataKey, value);
+        } else {
+          this.dataSet = arg[0];
+        }
+      } else if (arg.length === 2) {
+        if (arg[0] === undefined) {
+          this.dataSet = arg[1];
+        } else {
+          set(this.dataSet, arg[0], arg[1]);
+        }
+      } else {
+        throw Error("setDataSet params error.".concat(arg));
+      }
+    }
+  }, {
+    key: "register",
+    value: function register(action) {
+      if (!action.type) {
+        throw Error('register action error');
+      }
+      if (!this.actions[action.type]) {
+        this.actions[action.type] = new Action(action);
+      }
+    }
+  }, {
+    key: "getAction",
+    value: function getAction(type) {
+      if (this.actions[type]) {
+        return this.actions[type];
+      }
+      throw Error("action name ".concat(type, " is not exist"));
+    }
+  }, {
+    key: "runAction",
+    value: function runAction(actionParmas, params) {
+      var paramsHandler = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+      var action = actionParmas.type ? actionParmas : this.getAction(actionParmas);
+      var arg = [isFunction(paramsHandler) ? paramsHandler(params) : params];
+      if (action.type !== 'setDataSet' && action.fn) {
+        arg.push({
+          actionTarget: this,
+          action: action
+        });
+      }
+      return this.getActionFun(action).apply(this, arg);
+    }
+  }]);
+  return ActionTarget;
+}();
+export var ActionStore = /*#__PURE__*/function () {
+  function ActionStore() {
+    _classCallCheck(this, ActionStore);
+    _defineProperty(this, "targets", void 0);
+    this.targets = _defineProperty({
+      window: new ActionTarget({
+        targetName: 'window',
+        // target: this,
+        actionList: [{
+          title: '打开窗口',
+          type: 'open'
+        }]
+        // ajax、link、url、drawer、dialog、confirm、cancel、prev、next、copy、close
+      })
+    }, ENV.namespace, new ActionTarget({
+      targetName: ENV.namespace,
+      actionList: [{
+        title: '打开详情',
+        type: 'lookUp',
+        fn: function fn(url) {
+          window.location.href = url;
+          // history.push(url);
+        }
+      }, {
+        title: '数据导出',
+        type: 'export',
+        fn: function fn() {}
+      }]
+    }));
+    makeObservable(this, {
+      targets: observable,
+      register: mAction
+    });
+  }
+  _createClass(ActionStore, [{
+    key: "register",
+    value: function register(actionTarget) {
+      if (!actionTarget.targetName) {
+        throw Error('register action error');
+      }
+      if (!this.targets[actionTarget.targetName]) {
+        // this.targets[action.name] = {};
+        this.targets[actionTarget.targetName] = new ActionTarget(_objectSpread(_objectSpread({}, actionTarget), {}, {
+          actionList: [{
+            type: 'setDataSet'
+          }].concat(actionTarget.actionList || [])
+
+          // targets: this,
+        }));
+      }
+    }
+  }, {
+    key: "getTarget",
+    value: function getTarget(targetName) {
+      if (this.targets[targetName]) {
+        return this.targets[targetName];
+      }
+      throw Error("action name ".concat(targetName, " is not exist"));
+    }
+  }, {
+    key: "runTargetAction",
+    value: function runTargetAction(_ref) {
+      var _ref$targetName = _ref.targetName,
+        targetName = _ref$targetName === void 0 ? 'window' : _ref$targetName,
+        actionName = _ref.actionName,
+        params = _ref.params,
+        paramsHandler = _ref.paramsHandler;
+      var target = this.getTarget(targetName);
+      return target === null || target === void 0 ? void 0 : target.runAction(actionName, params, paramsHandler);
+    }
+  }]);
+  return ActionStore;
+}();
+// export const actionStore = new ActionStore();
+// const getActionStore = () => actionStore;

package/dist/esm/utils/store/index.js

@@ -0,0 +1,44 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { createContext, useContext } from 'react';
+import { ActionStore } from "./action";
+import { jsx as _jsx } from "react/jsx-runtime";
+var RootStore = /*#__PURE__*/_createClass(function RootStore(initStore) {
+  _classCallCheck(this, RootStore);
+  _defineProperty(this, "actionStore", void 0);
+  Object.assign(this, initStore);
+});
+var rootStore = new RootStore({
+  actionStore: new ActionStore()
+});
+var RootStoreContext = /*#__PURE__*/createContext(rootStore);
+export var RootStoreProvider = function RootStoreProvider(_ref) {
+  var children = _ref.children;
+  return /*#__PURE__*/_jsx(RootStoreContext.Provider, {
+    value: rootStore,
+    children: children
+  });
+};
+export var useRootStore = function useRootStore() {
+  return useContext(RootStoreContext);
+};
+export var useActionStore = function useActionStore(actionTarget) {
+  var _useContext = useContext(RootStoreContext),
+    actionStore = _useContext.actionStore;
+  if (actionTarget) {
+    actionStore.register(actionTarget);
+  }
+  return actionStore;
+};
+export var useActionTargets = function useActionTargets(targetName) {
+  var actionStore = useActionStore();
+  if (targetName) {
+    return actionStore.getTarget(targetName);
+  }
+  return actionStore.targets;
+};