@nocobase/client 0.7.4-alpha.7 → 0.7.5-alpha.1

package/lib/collection-manager/interfaces/properties/index.js

@@ -5,7 +5,7 @@ function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" =
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.type = exports.relationshipType = exports.recordPickerViewer = exports.recordPickerSelector = exports.operators = exports.defaultProps = exports.dateTimeProps = exports.dataSource = void 0;
+exports.unique = exports.type = exports.reverseFieldProperties = exports.relationshipType = exports.recordPickerViewer = exports.recordPickerSelector = exports.operators = exports.defaultProps = exports.dateTimeProps = exports.dataSource = void 0;
 
 var _shared = require("@formily/shared");
 
@@ -17,6 +17,12 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+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; }
+
 var type = {
   type: 'string',
   title: '{{t("Storage type")}}',
@@ -39,6 +45,9 @@ var type = {
   }, {
     label: 'Float',
     value: 'float'
+  }, {
+    label: 'Double',
+    value: 'double'
   }, {
     label: 'Decimal',
     value: 'decimal'
@@ -75,6 +84,13 @@ var type = {
   }]
 };
 exports.type = type;
+var unique = {
+  type: 'boolean',
+  'x-content': '{{t("Unique")}}',
+  'x-decorator': 'FormItem',
+  'x-component': 'Checkbox'
+};
+exports.unique = unique;
 var relationshipType = {
   type: 'string',
   title: '{{t("Relationship type")}}',
@@ -97,6 +113,83 @@ var relationshipType = {
   }]
 };
 exports.relationshipType = relationshipType;
+var reverseFieldProperties = {
+  reverse: {
+    type: 'void',
+    'x-component': 'div',
+    'x-hidden': '{{ !showReverseFieldConfig }}',
+    properties: {
+      autoCreateReverseField: {
+        type: 'boolean',
+        default: true,
+        'x-decorator': 'FormItem',
+        'x-component': 'Checkbox',
+        'x-content': '{{t("Create inverse field in the target collection")}}',
+        'x-reactions': [{
+          target: 'reverseField.type',
+          when: '{{!!$self.value}}',
+          fulfill: {
+            state: {
+              hidden: false
+            }
+          },
+          otherwise: {
+            state: {
+              hidden: true
+            }
+          }
+        }, {
+          target: 'reverseField.uiSchema.title',
+          when: '{{!!$self.value}}',
+          fulfill: {
+            state: {
+              hidden: false
+            }
+          },
+          otherwise: {
+            state: {
+              hidden: true
+            }
+          }
+        }, {
+          target: 'reverseField.name',
+          when: '{{!!$self.value}}',
+          fulfill: {
+            state: {
+              hidden: false
+            }
+          },
+          otherwise: {
+            state: {
+              hidden: true
+            }
+          }
+        }]
+      },
+      'reverseField.type': _objectSpread(_objectSpread({}, relationshipType), {}, {
+        title: '{{t("Inverse relationship type")}}'
+      }),
+      'reverseField.uiSchema.title': {
+        type: 'string',
+        title: '{{t("Inverse field display name")}}',
+        default: '{{record.title}}',
+        required: true,
+        'x-decorator': 'FormItem',
+        'x-component': 'Input'
+      },
+      'reverseField.name': {
+        type: 'string',
+        title: '{{t("Inverse field name")}}',
+        required: true,
+        'x-decorator': 'FormItem',
+        'x-component': 'Input',
+        'x-validator': 'uid',
+        description: "{{t('Randomly generated and can be modified. Support letters, numbers and underscores, must start with an letter.')}}"
+      }
+    }
+  }
+};
+exports.reverseFieldProperties = reverseFieldProperties;
 var dateTimeProps = {
   'uiSchema.x-component-props.dateFormat': {
     type: 'string',

package/lib/collection-manager/interfaces/sequence.d.ts

@@ -0,0 +1,2 @@
+import { IField } from './types';
+export declare const sequence: IField;

package/lib/collection-manager/interfaces/sequence.js

@@ -0,0 +1,455 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sequence = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _antd = require("antd");
+
+var _core = require("@formily/core");
+
+var _react2 = require("@formily/react");
+
+var _antd2 = require("@formily/antd");
+
+var _reactI18next = require("react-i18next");
+
+var _css = require("@emotion/css");
+
+var _schemaComponent = require("../../schema-component");
+
+var _properties = require("./properties");
+
+var _templateObject, _templateObject2, _templateObject3, _cycle, _templateObject4, _templateObject5;
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+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 RuleTypeSelect(props) {
+  var compile = (0, _schemaComponent.useCompile)();
+
+  var _useForm = (0, _react2.useForm)(),
+      setValuesIn = _useForm.setValuesIn;
+
+  var index = _antd2.ArrayTable.useIndex();
+
+  (0, _react2.useFormEffects)(function () {
+    (0, _core.onFieldValueChange)("patterns.".concat(index, ".type"), function (field) {
+      setValuesIn("patterns.".concat(index, ".options"), {});
+    });
+  });
+  return /*#__PURE__*/_react.default.createElement(_antd.Select, _objectSpread({}, props), Object.keys(RuleTypes).map(function (key) {
+    return /*#__PURE__*/_react.default.createElement(_antd.Select.Option, {
+      key: key,
+      value: key
+    }, compile(RuleTypes[key].title));
+  }));
+}
+
+function RuleOptions() {
+  var _ArrayTable$useRecord = _antd2.ArrayTable.useRecord(),
+      type = _ArrayTable$useRecord.type,
+      options = _ArrayTable$useRecord.options;
+
+  var ruleType = RuleTypes[type];
+  var compile = (0, _schemaComponent.useCompile)();
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: (0, _css.css)(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n      display: flex;\n      gap: 1em;\n      flex-wrap: wrap;\n    "])))
+  }, Object.keys(options).filter(function (key) {
+    return typeof options[key] !== 'undefined';
+  }).map(function (key) {
+    var Component = ruleType.optionRenders[key];
+    var title = ruleType.fieldset[key].title;
+    return Component ? /*#__PURE__*/_react.default.createElement("dl", {
+      key: key,
+      className: (0, _css.css)(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n                margin: 0;\n                padding: 0;\n              "])))
+    }, /*#__PURE__*/_react.default.createElement("dt", null, compile(title)), /*#__PURE__*/_react.default.createElement("dd", {
+      className: (0, _css.css)(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n                  margin-bottom: 0;\n                "])))
+    }, /*#__PURE__*/_react.default.createElement(Component, {
+      key: key,
+      value: options[key]
+    }))) : null;
+  }));
+}
+
+;
+var RuleTypes = {
+  string: {
+    title: '{{t("Fixed text")}}',
+    optionRenders: {
+      value: function value() {
+        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+          value: ''
+        };
+        return /*#__PURE__*/_react.default.createElement("code", null, options.value);
+      }
+    },
+    fieldset: {
+      value: {
+        type: 'string',
+        title: '{{t("Text content")}}',
+        'x-decorator': 'FormItem',
+        'x-component': 'Input'
+      }
+    }
+  },
+  integer: {
+    title: '{{t("Autoincrement")}}',
+    optionRenders: {
+      digits: function digits(_ref) {
+        var value = _ref.value;
+
+        var _useTranslation = (0, _reactI18next.useTranslation)(),
+            t = _useTranslation.t;
+
+        return /*#__PURE__*/_react.default.createElement("span", null, t('{{value}} Digits', {
+          value: value
+        }));
+      },
+      start: function start(_ref2) {
+        var value = _ref2.value;
+
+        var _useTranslation2 = (0, _reactI18next.useTranslation)(),
+            t = _useTranslation2.t;
+
+        return /*#__PURE__*/_react.default.createElement("span", null, t('Starts from {{value}}', {
+          value: value
+        }));
+      },
+      cycle: function cycle(_ref3) {
+        var value = _ref3.value;
+        return /*#__PURE__*/_react.default.createElement(_schemaComponent.SchemaComponent, {
+          schema: {
+            type: 'string',
+            name: 'cycle',
+            'x-component': 'Cron',
+            'x-read-pretty': true
+          }
+        });
+      }
+    },
+    fieldset: {
+      digits: {
+        type: 'number',
+        title: '{{t("Digits")}}',
+        'x-decorator': 'FormItem',
+        'x-component': 'InputNumber',
+        'x-component-props': {
+          min: 1,
+          max: 10
+        },
+        required: true,
+        default: 1
+      },
+      start: {
+        type: 'number',
+        title: '{{t("Start from")}}',
+        'x-decorator': 'FormItem',
+        'x-component': 'InputNumber',
+        'x-component-props': {
+          min: 0
+        },
+        required: true,
+        default: 0
+      },
+      cycle: (_cycle = {
+        type: 'string',
+        title: '{{t("Reset cycle")}}',
+        'x-decorator': 'FormItem'
+      }, _defineProperty(_cycle, 'x-component', function xComponent(_ref4) {
+        var value = _ref4.value,
+            _onChange = _ref4.onChange;
+        var shortValues = [{
+          label: '不重置',
+          value: 0
+        }, {
+          label: '每天',
+          value: 1,
+          cron: '0 0 * * *'
+        }, {
+          label: '每周一',
+          value: 2,
+          cron: '0 0 * * 1'
+        }, {
+          label: '每月',
+          value: 3,
+          cron: '0 0 1 * *'
+        }, {
+          label: '每年',
+          value: 4,
+          cron: '0 0 1 1 *'
+        }, {
+          label: '自定义',
+          value: 5,
+          cron: '* * * * *'
+        }];
+        var option = typeof value === 'undefined' ? shortValues[0] : shortValues.find(function (item) {
+          return item.cron == value;
+        }) || shortValues[5];
+        return /*#__PURE__*/_react.default.createElement("fieldset", null, /*#__PURE__*/_react.default.createElement(_antd.Select, {
+          value: option.value,
+          onChange: function onChange(v) {
+            return _onChange(shortValues[v].cron);
+          }
+        }, shortValues.map(function (item) {
+          return /*#__PURE__*/_react.default.createElement(_antd.Select.Option, {
+            key: item.value,
+            value: item.value
+          }, item.label);
+        })), option.value === 5 ? /*#__PURE__*/_react.default.createElement(_schemaComponent.Cron, {
+          value: value,
+          setValue: _onChange,
+          clearButton: false
+        }) : null);
+      }), _defineProperty(_cycle, "default", null), _cycle)
+    }
+  },
+  date: {
+    title: '{{t("Date")}}',
+    optionRenders: {
+      format: function format() {
+        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+          value: 'YYYYMMDD'
+        };
+        return /*#__PURE__*/_react.default.createElement("code", null, options.value);
+      }
+    }
+  }
+};
+
+function RuleConfigForm() {
+  var _useTranslation3 = (0, _reactI18next.useTranslation)(),
+      t = _useTranslation3.t;
+
+  var compile = (0, _schemaComponent.useCompile)();
+  var schemaOptions = (0, _react.useContext)(_react2.SchemaOptionsContext);
+  var form = (0, _react2.useForm)();
+
+  var _ArrayTable$useRecord2 = _antd2.ArrayTable.useRecord(),
+      type = _ArrayTable$useRecord2.type,
+      options = _ArrayTable$useRecord2.options;
+
+  var index = _antd2.ArrayTable.useIndex();
+
+  var ruleType = RuleTypes[type];
+  return (ruleType === null || ruleType === void 0 ? void 0 : ruleType.fieldset) ? /*#__PURE__*/_react.default.createElement(_antd.Button, {
+    type: "link",
+    onClick: function onClick() {
+      (0, _antd2.FormDrawer)(compile(ruleType.title), function () {
+        return /*#__PURE__*/_react.default.createElement(_antd2.FormLayout, {
+          layout: "vertical"
+        }, /*#__PURE__*/_react.default.createElement(_schemaComponent.SchemaComponentOptions, {
+          scope: schemaOptions.scope,
+          components: schemaOptions.components
+        }, /*#__PURE__*/_react.default.createElement(_schemaComponent.SchemaComponent, {
+          schema: {
+            type: 'object',
+            'x-component': 'fieldset',
+            properties: ruleType.fieldset
+          }
+        })), /*#__PURE__*/_react.default.createElement(_antd2.FormDrawer.Footer, null, /*#__PURE__*/_react.default.createElement(_antd2.FormButtonGroup, {
+          className: (0, _css.css)(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n                    justify-content: flex-end;\n                  "])))
+        }, /*#__PURE__*/_react.default.createElement(_antd2.Submit, {
+          onSubmit: function onSubmit(values) {
+            return values;
+          }
+        }, t('Submit')))));
+      }).open({
+        initialValues: options
+      }).then(function (values) {
+        form.setValuesIn("patterns.".concat(index), {
+          type: type,
+          options: _objectSpread({}, values)
+        });
+      });
+    }
+  }, t('Configure')) : null;
+}
+
+var sequence = {
+  name: 'sequence',
+  type: 'object',
+  group: 'advanced',
+  order: 2,
+  title: '{{t("Sequence")}}',
+  sortable: true,
+  default: {
+    type: 'sequence',
+    uiSchema: {
+      type: 'string',
+      'x-component': 'Input',
+      'x-component-props': {
+        readOnly: true,
+        disabled: true
+      },
+      'x-read-pretty': true
+    }
+  },
+  hasDefaultValue: false,
+  properties: _objectSpread(_objectSpread({}, _properties.defaultProps), {}, {
+    unique: _properties.unique,
+    patterns: {
+      type: 'array',
+      title: '{{t("Sequence rules")}}',
+      required: true,
+      'x-decorator': 'FormItem',
+      'x-component': 'ArrayTable',
+      items: {
+        type: 'object',
+        properties: {
+          sort: {
+            type: 'void',
+            'x-component': 'ArrayTable.Column',
+            'x-component-props': {
+              width: 50,
+              title: '',
+              align: 'center'
+            },
+            properties: {
+              sort: {
+                type: 'void',
+                'x-component': 'ArrayTable.SortHandle'
+              }
+            }
+          },
+          type: {
+            type: 'void',
+            'x-component': 'ArrayTable.Column',
+            'x-component-props': {
+              title: '{{t("Type")}}'
+            },
+            // 'x-hidden': true,
+            properties: {
+              type: {
+                type: 'string',
+                name: 'type',
+                required: true,
+                'x-decorator': 'FormItem',
+                'x-component': RuleTypeSelect
+              }
+            }
+          },
+          options: {
+            type: 'void',
+            'x-component': 'ArrayTable.Column',
+            'x-component-props': {
+              title: '{{t("Rule content")}}'
+            },
+            properties: {
+              options: {
+                type: 'object',
+                name: 'options',
+                'x-component': RuleOptions
+              }
+            }
+          },
+          operations: {
+            type: 'void',
+            'x-component': 'ArrayTable.Column',
+            'x-component-props': {
+              title: '{{t("Operations")}}',
+              dataIndex: 'operations',
+              fixed: 'right',
+              className: (0, _css.css)(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n                > *:not(:last-child){\n                  margin-right: .5em;\n                }\n                button{\n                  padding: 0;\n                }\n              "])))
+            },
+            properties: {
+              config: {
+                type: 'void',
+                // 'x-component': 'span',
+                properties: {
+                  options: {
+                    type: 'object',
+                    'x-component': RuleConfigForm
+                  }
+                }
+              },
+              // configure: {
+              //   type: 'void',
+              //   title: '{{t("Configure")}}',
+              //   'x-component': 'Action.Link',
+              //   properties: {
+              //     drawer: {
+              //       type: 'void',
+              //       'x-component': 'Action.Drawer',
+              //       'x-decorator': 'Form',
+              //       'x-decorator-props': {
+              //         useValues: useRowOptions
+              //       },
+              //       title: '{{t("Configure")}}',
+              //       properties: {
+              //         options: {
+              //           type: 'void',
+              //           'x-component': RuleConfig
+              //         },
+              //         actions: {
+              //           type: 'void',
+              //           'x-component': 'Action.Drawer.Footer',
+              //           properties: {
+              //             cancel: {
+              //               title: '{{t("Cancel")}}',
+              //               'x-component': 'Action',
+              //               'x-component-props': {
+              //                 // useAction: '{{ cm.useCancelAction }}',
+              //               },
+              //             },
+              //             submit: {
+              //               title: '{{t("Submit")}}',
+              //               'x-component': 'Action',
+              //               'x-component-props': {
+              //                 type: 'primary',
+              //                 async useAction() {
+              //                   const form = useForm();
+              //                   const ctx = useActionContext();
+              //                   await form.submit();
+              //                   console.log(form);
+              //                   ctx.setVisible(false);
+              //                 }
+              //               }
+              //             }
+              //           }
+              //         }
+              //       }
+              //     },
+              //   },
+              // },
+              remove: {
+                type: 'void',
+                'x-component': 'ArrayTable.Remove'
+              }
+            }
+          }
+        }
+      },
+      properties: {
+        add: {
+          type: 'void',
+          'x-component': 'ArrayTable.Addition',
+          'x-component-props': {
+            defaultValue: {
+              type: 'integer'
+            }
+          },
+          title: "{{t('Add rule')}}"
+        }
+      }
+    }
+  }),
+  filterable: {
+    operators: _properties.operators.string
+  }
+};
+exports.sequence = sequence;

package/lib/locale/en_US.d.ts

@@ -555,5 +555,6 @@ declare const _default: {
     "View all plugins": string;
     Print: string;
     'Single select and radio fields can be used as the grouping field': string;
+    'Sign up successfully, and automatically jump to the sign in page': string;
 };
 export default _default;

package/lib/locale/en_US.js

@@ -560,6 +560,7 @@ var _default = {
   "Enabled languages": "Enabled languages",
   "View all plugins": "View all plugins",
   "Print": "Print",
-  'Single select and radio fields can be used as the grouping field': 'Single select and radio fields can be used as the grouping field'
+  'Single select and radio fields can be used as the grouping field': 'Single select and radio fields can be used as the grouping field',
+  'Sign up successfully, and automatically jump to the sign in page': 'Sign up successfully, and automatically jump to the sign in page'
 };
 exports.default = _default;

package/lib/locale/index.js

@@ -7,12 +7,20 @@ exports.default = void 0;
 
 var _en_US = _interopRequireDefault(require("antd/lib/locale/en_US"));
 
+var _ja_JP = _interopRequireDefault(require("antd/lib/locale/ja_JP"));
+
 var _zh_CN = _interopRequireDefault(require("antd/lib/locale/zh_CN"));
 
+var _ru_RU = _interopRequireDefault(require("antd/lib/locale/ru_RU"));
+
 var _en_US2 = _interopRequireDefault(require("./en_US"));
 
+var _ja_JP2 = _interopRequireDefault(require("./ja_JP"));
+
 var _zh_CN2 = _interopRequireDefault(require("./zh_CN"));
 
+var _ru_RU2 = _interopRequireDefault(require("./ru_RU"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
@@ -32,6 +40,16 @@ var _default = {
       client: _objectSpread({}, _en_US2.default)
     }
   },
+  'ja-JP': {
+    label: '日本語',
+    // https://github.com/moment/moment/blob/develop/locale/ja.js
+    moment: 'ja',
+    // https://github.com/ant-design/ant-design/tree/master/components/locale/ja_JP
+    antd: _ja_JP.default,
+    resources: {
+      client: _objectSpread({}, _ja_JP2.default)
+    }
+  },
   'zh-CN': {
     label: '简体中文',
     // https://github.com/moment/moment/blob/develop/locale/zh-cn.js
@@ -42,6 +60,16 @@ var _default = {
     resources: {
       client: _objectSpread({}, _zh_CN2.default)
     }
+  },
+  'ru-RU': {
+    label: 'Русский',
+    // https://github.com/moment/moment/blob/develop/locale/ru.js
+    moment: 'ru',
+    // https://github.com/ant-design/ant-design/tree/master/components/locale/ru_RU
+    antd: _ru_RU.default,
+    resources: {
+      client: _objectSpread({}, _ru_RU2.default)
+    }
   }
 };
 exports.default = _default;