ronds-metadata 1.2.10 → 1.2.12

package/es/framework/metadata/index.js

@@ -0,0 +1,384 @@
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+export var Enum = /*#__PURE__*/function () {
+  function Enum(value) {
+    _classCallCheck(this, Enum);
+
+    this.value = void 0;
+    this.value = value;
+  }
+
+  _createClass(Enum, [{
+    key: "__type__",
+    get: function get() {
+      return {};
+    }
+  }], [{
+    key: "makeEnum",
+    value: function makeEnum(name, _enum) {
+      var result = /*#__PURE__*/function (_Enum) {
+        _inherits(result, _Enum);
+
+        var _super = _createSuper(result);
+
+        function result(value) {
+          _classCallCheck(this, result);
+
+          return _super.call(this, value);
+        }
+
+        _createClass(result, [{
+          key: "__type__",
+          get: function get() {
+            return result;
+          }
+        }]);
+
+        return result;
+      }(Enum);
+
+      result['__name__'] = name;
+      result['__enum__'] = _enum;
+      return result;
+    }
+  }]);
+
+  return Enum;
+}();
+export var Array = function Array(items) {
+  _classCallCheck(this, Array);
+
+  this.items = void 0;
+  this.items = items;
+};
+export var MetaObject = /*#__PURE__*/function () {
+  function MetaObject() {
+    _classCallCheck(this, MetaObject);
+
+    var t = this.__type__;
+
+    var _this = this;
+
+    t.__properties__.forEach(function (v, k) {
+      switch (v) {
+        case Enum:
+        case String:
+          _this[k] = '';
+          break;
+
+        case Number:
+          _this[k] = 0;
+          break;
+
+        case Boolean:
+          _this[k] = false;
+          break;
+
+        case Array:
+          _this[k] = [];
+          break;
+
+        case Object:
+          _this[k] = {};
+          break;
+
+        default:
+          _this[k] = null;
+      }
+    });
+  }
+
+  _createClass(MetaObject, [{
+    key: "__type__",
+    get: function get() {
+      return {};
+    }
+  }], [{
+    key: "makeType",
+    value: function makeType(name) {
+      var result = /*#__PURE__*/function (_MetaObject) {
+        _inherits(result, _MetaObject);
+
+        var _super2 = _createSuper(result);
+
+        function result() {
+          _classCallCheck(this, result);
+
+          return _super2.apply(this, arguments);
+        }
+
+        _createClass(result, [{
+          key: "__type__",
+          get: function get() {
+            return result;
+          }
+        }]);
+
+        return result;
+      }(MetaObject);
+
+      result['__name__'] = name;
+      result['__fields__'] = new Map();
+      result['__properties__'] = new Map();
+      return result;
+    }
+  }, {
+    key: "makeArray",
+    value: function makeArray() {
+      var result = /*#__PURE__*/function (_Array) {
+        _inherits(result, _Array);
+
+        var _super3 = _createSuper(result);
+
+        function result(items) {
+          _classCallCheck(this, result);
+
+          return _super3.call(this, items);
+        }
+
+        _createClass(result, [{
+          key: "type",
+          get: function get() {
+            return result;
+          }
+        }]);
+
+        return result;
+      }(Array);
+
+      return result;
+    }
+  }]);
+
+  return MetaObject;
+}();
+export var MetadataProvider = /*#__PURE__*/function () {
+  function MetadataProvider() {
+    _classCallCheck(this, MetadataProvider);
+
+    this.types = new Map();
+    this.fields = new Map();
+  }
+
+  _createClass(MetadataProvider, [{
+    key: "construct",
+    value: function construct() {}
+  }, {
+    key: "get_type",
+    value: function get_type(id) {
+      return this.types[id];
+    }
+  }, {
+    key: "_add_type",
+    value: function _add_type(typeinfo) {
+      this.types[typeinfo.name] = typeinfo;
+    }
+  }, {
+    key: "_make_type",
+    value: function _make_type(id) {
+      var result = this.get_type(id);
+
+      if (!result) {
+        result = MetaObject.makeType(id);
+        this.types[id] = result;
+      }
+
+      return result;
+    }
+  }, {
+    key: "get_fields",
+    value: function get_fields(id) {
+      return this.fields[id];
+    }
+  }, {
+    key: "_add_fields",
+    value: function _add_fields(fieldsInfo) {
+      this.types[fieldsInfo.name] = fieldsInfo;
+    }
+  }, {
+    key: "_make_array",
+    value: function _make_array(id) {
+      var result = this.get_type("".concat(id));
+
+      if (!result) {
+        this._make_type(id);
+
+        result = Array;
+      }
+
+      return result;
+    }
+  }, {
+    key: "_make_enum",
+    value: function _make_enum(id, _enum) {
+      var result = this.get_type(id);
+
+      if (!result) {
+        result = Enum.makeEnum(id, _enum);
+      }
+
+      return result;
+    }
+  }, {
+    key: "add_types",
+    value: function add_types(typedef) {
+      throw new Error('not implemented error');
+    }
+  }, {
+    key: "get_objects",
+    value: function get_objects(objectdef) {
+      throw new Error('not implemented error');
+    }
+  }]);
+
+  return MetadataProvider;
+}();
+export var JsonMetadataProvider = /*#__PURE__*/function (_MetadataProvider) {
+  _inherits(JsonMetadataProvider, _MetadataProvider);
+
+  var _super4 = _createSuper(JsonMetadataProvider);
+
+  function JsonMetadataProvider() {
+    var _this2;
+
+    _classCallCheck(this, JsonMetadataProvider);
+
+    _this2 = _super4.call(this);
+    _this2.types['str'] = String;
+    _this2.types['int'] = Number;
+    _this2.types['double'] = Number;
+    _this2.types['bool'] = Boolean;
+    _this2.types['object'] = Object;
+    return _this2;
+  }
+
+  _createClass(JsonMetadataProvider, [{
+    key: "__visit_type",
+    value: function __visit_type(id, value) {
+      var _this3 = this;
+
+      var valueType = value['type'];
+
+      if (valueType === 'object') {
+        var typeInfo = this._make_type(id);
+
+        var properties = value.properties || [];
+        properties.forEach(function (p) {
+          var propertyName = "".concat(p['id']);
+
+          var property = _this3.__visit_property(typeInfo, propertyName, p);
+
+          typeInfo.__properties__.set(propertyName, property); // 处理fields
+
+
+          var propertyFields = (p === null || p === void 0 ? void 0 : p.fields) || [];
+          propertyFields.forEach(function (f) {
+            typeInfo.__fields__.set(propertyName, f.value);
+          });
+        });
+        return typeInfo;
+      } else if (valueType === 'array') {
+        var item = value['items'];
+
+        var arrayType = this.__visit_type(item['type'], item);
+
+        return this._make_array(arrayType.__name__);
+      } else if (valueType === 'ref') {
+        var refid = value['refId'] || 'object';
+        return this._make_type("".concat(refid));
+      } else if (valueType === 'number') {
+        var format = value['format'] || 'double';
+        return this.get_type(format);
+      } else if (valueType === 'text') {
+        return this.get_type('str');
+      } else if (valueType == 'enum') {
+        var _value$enum;
+
+        var _enum = [];
+        (_value$enum = value['enum']) === null || _value$enum === void 0 ? void 0 : _value$enum.forEach(function (en) {
+          _enum.push(en['value']);
+        });
+        return this._make_enum(value.id, _enum);
+      } else if (valueType == 'bool') {
+        return this.get_type('bool');
+      } else {
+        throw new Error('invalid type value');
+      }
+    }
+  }, {
+    key: "__visit_property",
+    value: function __visit_property(type, id, value) {
+      var valuetype = value['type'];
+
+      if (valuetype === 'object') {
+        valuetype = this.__visit_type("".concat(type.__name__, "_").concat(id), value);
+        return valuetype;
+      } else {
+        return this.__visit_type(valuetype, value);
+      }
+    }
+  }, {
+    key: "__visit_field",
+    value: function __visit_field(id, value) {
+      return this.__visit_type(id, value);
+    }
+  }, {
+    key: "add_types",
+    value: function add_types(typedef) {
+      var _this4 = this;
+
+      typedef.forEach(function (item) {
+        var typeInfo = _this4.__visit_type("".concat(item['id']), item);
+
+        _this4.types[typeInfo.__name__] = typeInfo;
+      });
+    }
+  }, {
+    key: "get_objects",
+    value: function get_objects(objectdef) {
+      var refid = objectdef['_refId'];
+      var typename = "".concat(refid);
+      var typeinfo = this.get_type(typename);
+      return this.__visit_object(typeinfo, objectdef);
+    }
+  }, {
+    key: "__visit_object",
+    value: function __visit_object(typeinfo, value) {
+      var _this5 = this;
+
+      var result = new typeinfo();
+
+      typeinfo.__properties__.forEach(function (type, name) {
+        var property = value[name];
+
+        if (property) {
+          if (type.prototype instanceof MetaObject) {
+            result[name] = _this5.__visit_object(type, property);
+          }
+        }
+
+        result[name] = _this5.__visit_value(type, property);
+      });
+
+      return result;
+    }
+  }, {
+    key: "__visit_value",
+    value: function __visit_value(valuetype, value) {
+      if (valuetype instanceof Array) {
+        return value;
+      }
+
+      if (valuetype.prototype instanceof Enum) {
+        return new valuetype(value);
+      } else {
+        return value;
+      }
+    }
+  }]);
+
+  return JsonMetadataProvider;
+}(MetadataProvider);
+export default new JsonMetadataProvider();

package/es/framework/rxjs-hooks/useMemoSubject.js

@@ -0,0 +1,16 @@
+/*
+ * @Author: wangxian
+ * @Date: 2022-03-30 10:12:11
+ * @LastEditTime: 2022-04-01 08:15:21
+ */
+import React from 'react';
+import { BehaviorSubject } from 'rxjs';
+
+var useMemoSubject = function useMemoSubject() {
+  var subject$ = React.useMemo(function () {
+    return new BehaviorSubject(undefined);
+  }, []);
+  return subject$;
+};
+
+export default useMemoSubject;

package/es/framework/rxjs-hooks/useObservable.js

@@ -0,0 +1,22 @@
+/*
+ * @Author: wangxian
+ * @Date: 2022-03-30 10:12:11
+ * @LastEditTime: 2022-07-14 08:33:58
+ */
+import React from 'react';
+
+var useObservable = function useObservable(fn) {
+  var dep = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  React.useEffect(function () {
+    var _dep$, _dep$2;
+
+    var subscription = dep[0] && ((_dep$ = dep[0]) === null || _dep$ === void 0 ? void 0 : _dep$.subscribe) && ((_dep$2 = dep[0]) === null || _dep$2 === void 0 ? void 0 : _dep$2.subscribe(function (p) {
+      fn(p);
+    }));
+    return function () {
+      return subscription && subscription.unsubscribe();
+    };
+  }, dep);
+};
+
+export default useObservable;

package/es/framework/rxjs-hooks/useObservableState.js

@@ -0,0 +1,45 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+
+/*
+ * @Author: wangxian
+ * @Date: 2022-05-27 10:32:55
+ * @LastEditTime: 2022-05-27 10:58:18
+ */
+import { useEffect, useMemo, useState } from 'react';
+import { BehaviorSubject } from 'rxjs';
+export var useObservableState = function useObservableState(source$, initialState) {
+  var source = useMemo(function () {
+    if (typeof source$ === 'function') {
+      return source$();
+    }
+
+    return source$;
+  }, [source$]);
+
+  var _useState = useState(function () {
+    if (source instanceof BehaviorSubject) {
+      return source.getValue();
+    }
+
+    return initialState;
+  }),
+      _useState2 = _slicedToArray(_useState, 2),
+      state = _useState2[0],
+      setState = _useState2[1];
+
+  useEffect(function () {
+    if (source) {
+      var sub = source.subscribe(function (v) {
+        if (v) {
+          setState(v);
+        }
+      });
+      return function () {
+        sub.unsubscribe();
+      };
+    }
+
+    return function () {};
+  }, [source]);
+  return [state, setState];
+};

package/es/index.js

@@ -0,0 +1,27 @@
+/*
+ * @Author:wangxian
+ * @Date: 2021-09-18 14:15:04
+ * @LastEditTime: 2023-02-04 13:52:49
+ */
+import './theme.less';
+export { default as MetadataEdit } from './comps/MetadataEdit';
+export { default as MetaPropsEdit } from './comps/MetadataEdit/components/MetaPropsEdit';
+export { default as MetadataEditV2 } from './comps/MetadataEditV2';
+export { default as MetadataForm } from './comps/MetadataForm';
+export { default as JsonView } from './comps/JsonView';
+export { default as JsonEdit } from './comps/JsonEdit';
+export { default as MdEditor } from './comps/MdEdit';
+export { default as MdView } from './comps/MdView';
+export { default as FileView } from './comps/FileView';
+export { default as Editable } from './comps/Editable';
+export { default as FormGenerator } from './comps/FormGenerator';
+export { default as DynamicPorts } from './comps/DynamicPorts';
+export { default as DragNode } from './comps/DynamicPorts/comps/DragNode';
+export { default as Icon } from './comps/Icons';
+export * from './framework/metadata/index';
+export { default as http, addInterceptor } from './framework/http/index';
+export { default as useMemoSubject } from './framework/rxjs-hooks/useMemoSubject';
+export { default as useObservable } from './framework/rxjs-hooks/useObservable';
+export { default as useSyncScroll, useSyncScrollByRefs } from './framework/hooks/use-sync-scroll';
+export { registerMetadataAPI } from './framework/metadata/MetadataService';
+export { globalSettingStream } from './config';

package/es/utils.js

@@ -0,0 +1,138 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+
+/*
+ * @Author: wangxian
+ * @Date: 2021-09-18 14:15:04
+ * @LastEditTime: 2023-02-13 17:02:22
+ */
+import { useCallback, useEffect, useRef } from 'react';
+/** 防抖 */
+
+export function useDebounce(fn, delay) {
+  var dep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+
+  var _useRef = useRef({
+    fn: fn,
+    timer: null
+  }),
+      current = _useRef.current;
+
+  useEffect(function () {
+    current.fn = fn;
+    return function () {
+      if (current.timer) {
+        clearTimeout(current.timer);
+      }
+    }; // eslint-disable-next-line
+  }, [fn]);
+  return useCallback(function f() {
+    var _this = this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    if (current.timer) {
+      clearTimeout(current.timer);
+    }
+
+    current.timer = setTimeout(function () {
+      var _current$fn;
+
+      // @ts-ignore
+      (_current$fn = current.fn).call.apply(_current$fn, [_this].concat(args));
+    }, delay); // eslint-disable-next-line
+  }, dep);
+}
+/**
+ *
+ * 节流
+ * @export
+ * @param {Function} fn
+ * @param {number} delay
+ * @param {DependencyList} [dep=[]]
+ * @returns
+ */
+
+export function useThrottle(fn, delay) {
+  var dep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+
+  var _useRef2 = useRef({
+    fn: fn,
+    timer: null
+  }),
+      current = _useRef2.current;
+
+  useEffect(function () {
+    current.fn = fn; // eslint-disable-next-line
+  }, [fn]);
+  return useCallback(function f() {
+    if (!current.timer) {
+      var _current$fn2;
+
+      current.timer = setTimeout(function () {
+        delete current.timer;
+      }, delay); // @ts-ignore
+
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+
+      (_current$fn2 = current.fn).call.apply(_current$fn2, [this].concat(args));
+    } // eslint-disable-next-line
+
+  }, dep);
+}
+export function deepClone(target) {
+  return JSON.parse(JSON.stringify(target));
+}
+export function guid() {
+  var id = '',
+      i,
+      random,
+      chars = 'abcdef';
+  id += chars[Math.floor(Math.random() * Math.floor(chars.length))];
+
+  for (i = 1; i < 32; i++) {
+    random = Math.random() * 16 | 0;
+
+    if (i == 8 || i == 12 || i == 16 || i == 20) {
+      id += '-';
+    }
+
+    id += (i == 12 ? 4 : i == 16 ? random & 3 | 8 : random).toString(16);
+  }
+
+  return id;
+}
+
+var crypto = require('crypto');
+
+export var md5 = function md5(data) {
+  var digest = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'hex';
+  return crypto.createHash('md5').update(data).digest(digest || 'base64');
+};
+export function arrayMoveMutable(array, fromIndex, toIndex) {
+  var startIndex = fromIndex < 0 ? array.length + fromIndex : fromIndex;
+
+  if (startIndex >= 0 && startIndex < array.length) {
+    var endIndex = toIndex < 0 ? array.length + toIndex : toIndex;
+
+    var _array$splice = array.splice(fromIndex, 1),
+        _array$splice2 = _slicedToArray(_array$splice, 1),
+        item = _array$splice2[0];
+
+    array.splice(endIndex, 0, item);
+  }
+}
+export function arrayMoveImmutable(array, fromIndex, toIndex) {
+  var newArray = _toConsumableArray(array);
+
+  arrayMoveMutable(newArray, fromIndex, toIndex);
+  return newArray;
+}
+export function arrayInsert(array, index, item) {
+  array.splice(index, 0, item);
+  return array;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "public": true,
   "name": "ronds-metadata",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "scripts": {
     "start": "dumi dev",
     "docs:build": "dumi build",