@nocobase/plugin-snapshot-field 0.11.1-alpha.5 → 0.12.0-alpha.2

package/client.d.ts

@@ -1,3 +1,2 @@
-export * from './src/client';
-export { default } from './src/client';
-
+export * from './dist/client';
+export { default } from './dist/client';

package/client.js

@@ -1 +1 @@
-module.exports = require('./lib/client/index.js');
+module.exports = require('./dist/client/index.js');

package/dist/client/index.js

@@ -0,0 +1,510 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@nocobase/client"), require("react"), require("antd"), require("@formily/react"), require("lodash"), require("react-i18next"), require("@ant-design/icons"), require("@formily/shared"), require("@formily/core")) : typeof define === "function" && define.amd ? define(["exports", "@nocobase/client", "react", "antd", "@formily/react", "lodash", "react-i18next", "@ant-design/icons", "@formily/shared", "@formily/core"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["@nocobase/plugin-snapshot-field"] = {}, global["@nocobase/client"], global.react, global.antd, global["@formily/react"], global.lodash, global["react-i18next"], global["@ant-design/icons"], global["@formily/shared"], global["@formily/core"]));
+})(this, function(exports2, client, require$$0, antd, react, lodash, reactI18next, icons, shared, core) {
+  "use strict";
+  var jsxRuntime = { exports: {} };
+  var reactJsxRuntime_production_min = {};
+  /**
+   * @license React
+   * react-jsx-runtime.production.min.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+  var f = require$$0, k = Symbol.for("react.element"), l = Symbol.for("react.fragment"), m = Object.prototype.hasOwnProperty, n = f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, p = { key: true, ref: true, __self: true, __source: true };
+  function q(c, a, g) {
+    var b, d = {}, e = null, h = null;
+    void 0 !== g && (e = "" + g);
+    void 0 !== a.key && (e = "" + a.key);
+    void 0 !== a.ref && (h = a.ref);
+    for (b in a)
+      m.call(a, b) && !p.hasOwnProperty(b) && (d[b] = a[b]);
+    if (c && c.defaultProps)
+      for (b in a = c.defaultProps, a)
+        void 0 === d[b] && (d[b] = a[b]);
+    return { $$typeof: k, type: c, key: e, ref: h, props: d, _owner: n.current };
+  }
+  reactJsxRuntime_production_min.Fragment = l;
+  reactJsxRuntime_production_min.jsx = q;
+  reactJsxRuntime_production_min.jsxs = q;
+  {
+    jsxRuntime.exports = reactJsxRuntime_production_min;
+  }
+  var jsxRuntimeExports = jsxRuntime.exports;
+  const NAMESPACE = "snapshot-field";
+  function useSnapshotTranslation() {
+    return reactI18next.useTranslation(NAMESPACE);
+  }
+  const { defaultProps } = client.interfacesProperties;
+  const APPENDS = "appends";
+  const TARGET_FIELD = "targetField";
+  const useTopRecord = () => {
+    let record = client.useRecord();
+    while (record && Object.keys(record.__parent).length > 0) {
+      record = record.__parent;
+    }
+    return record;
+  };
+  function useRecordCollection() {
+    var _a;
+    const { getCollectionField } = client.useCollectionManager();
+    const record = useTopRecord();
+    const formValues = react.useForm().values;
+    return (_a = getCollectionField(`${record.name}.${formValues.targetField}`)) == null ? void 0 : _a.target;
+  }
+  function MakeFieldsPathOptions(fields, appends = []) {
+    const { getCollection } = client.useCollectionManager();
+    const options = [];
+    fields.forEach((field) => {
+      var _a, _b;
+      if (["belongsTo", "hasOne", "hasMany", "belongsToMany"].includes(field.type)) {
+        const currentAppends = appends.filter((key) => `${key}.`.startsWith(`${field.name}.`));
+        if (currentAppends.length) {
+          const nextCollection = getCollection(field.target);
+          const nextAppends = currentAppends.filter((key) => key !== field.name).map((key) => key.replace(`${field.name}.`, "")).filter((key) => key);
+          options.push({
+            label: ((_a = field.uiSchema) == null ? void 0 : _a.title) ?? field.name,
+            value: field.name,
+            children: MakeFieldsPathOptions(nextCollection.fields, nextAppends)
+          });
+        }
+      } else {
+        options.push({
+          label: ((_b = field.uiSchema) == null ? void 0 : _b.title) ?? field.name,
+          value: field.name
+        });
+      }
+    });
+    return options;
+  }
+  const recordPickerViewer = {
+    type: "void",
+    title: `{{t('View record')}}`,
+    "x-component": "RecordPicker.Viewer",
+    "x-component-props": {
+      className: "nb-action-popup"
+    },
+    properties: {
+      tabs: {
+        type: "void",
+        "x-component": "Tabs",
+        "x-component-props": {},
+        // 'x-initializer': 'TabPaneInitializers',
+        properties: {
+          tab1: {
+            type: "void",
+            title: `{{t('Detail')}}`,
+            "x-component": "Tabs.TabPane",
+            "x-designer": "Tabs.Designer",
+            "x-component-props": {},
+            properties: {
+              grid: {
+                type: "void",
+                "x-component": "Grid",
+                "x-initializer": "SnapshotBlockInitializers",
+                properties: {}
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+  const snapshot = {
+    name: "snapshot",
+    type: "object",
+    group: "advanced",
+    title: `{{t('Snapshot', {ns: '${NAMESPACE}'})}}`,
+    description: `{{t('When adding a new record, create a snapshot for its relational record and save in the current record. The snapshot is not updated when the record is subsequently updated.', {ns: '${NAMESPACE}'})}}`,
+    default: {
+      type: "snapshot",
+      // name,
+      uiSchema: {
+        // title,
+        "x-component": "SnapshotRecordPicker",
+        "x-component-props": {
+          multiple: true,
+          fieldNames: {
+            label: "id",
+            value: "id"
+          }
+        }
+      }
+    },
+    schemaInitialize(schema, { field, readPretty, action, block }) {
+      schema["properties"] = {
+        viewer: lodash.cloneDeep(recordPickerViewer)
+      };
+    },
+    initialize: (values) => {
+    },
+    usePathOptions(field) {
+      const { appends = [], targetCollection } = field;
+      const { getCollection } = client.useCollectionManager();
+      const { fields } = getCollection(targetCollection);
+      const result = MakeFieldsPathOptions(fields, appends);
+      return [
+        {
+          label: `{{t('Snapshot data', { ns: '${NAMESPACE}' })}}`,
+          value: "data",
+          children: result
+        }
+      ];
+    },
+    properties: {
+      ...defaultProps,
+      [TARGET_FIELD]: {
+        type: "string",
+        title: `{{t('The association field to snapshot', {ns: '${NAMESPACE}'})}}`,
+        required: true,
+        "x-decorator": "FormItem",
+        "x-component": "SnapshotOwnerCollectionFieldsSelect",
+        "x-disabled": "{{ !createOnly || isOverride }}",
+        "x-reactions": [
+          {
+            target: APPENDS,
+            when: "{{$self.value != undefined}}",
+            fulfill: {
+              state: {
+                visible: true
+              }
+            },
+            otherwise: {
+              state: {
+                visible: false
+              }
+            }
+          }
+        ]
+      },
+      [APPENDS]: {
+        type: "string",
+        title: `{{t("Snapshot the snapshot's association fields", {ns: "${NAMESPACE}"})}}`,
+        "x-decorator": "FormItem",
+        "x-component": "AppendsTreeSelect",
+        "x-component-props": {
+          useCollection: useRecordCollection
+        },
+        "x-reactions": [
+          {
+            dependencies: [TARGET_FIELD],
+            when: "{{$deps[0]}}",
+            fulfill: {
+              run: "{{$self.setValue($self.value)}}"
+            }
+          }
+        ]
+      }
+    }
+  };
+  const useSnapshotOwnerCollectionFields = () => {
+    const record = useTopRecord();
+    const { getCollection } = client.useCollectionManager();
+    const collection = getCollection(record.name);
+    const compile = client.useCompile();
+    return collection.fields.filter((i) => !!i.target && !!i.interface).map((i) => {
+      var _a;
+      return { ...i, label: compile((_a = i.uiSchema) == null ? void 0 : _a.title), value: i.name };
+    });
+  };
+  const SnapshotOwnerCollectionFieldsSelect = (props) => {
+    const options = useSnapshotOwnerCollectionFields();
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(antd.Select, { popupMatchSelectWidth: false, options, ...props });
+  };
+  const SnapshotBlockInitializers = (props) => {
+    const { t } = useSnapshotTranslation();
+    const { insertPosition, component } = props;
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(
+      client.SchemaInitializer.Button,
+      {
+        wrap: client.gridRowColWrap,
+        insertPosition,
+        component,
+        title: component ? null : t("Add block"),
+        icon: "PlusOutlined",
+        items: [
+          {
+            type: "itemGroup",
+            title: '{{t("Current record blocks")}}',
+            children: [
+              {
+                key: "details",
+                type: "item",
+                title: '{{t("Details")}}',
+                component: "SnapshotBlockInitializersDetailItem",
+                actionInitializers: "CalendarFormActionInitializers"
+              }
+            ]
+          },
+          {
+            type: "itemGroup",
+            title: '{{t("Other blocks")}}',
+            children: [
+              {
+                key: "markdown",
+                type: "item",
+                title: '{{t("Markdown")}}',
+                component: "MarkdownBlockInitializer"
+              }
+            ]
+          }
+        ]
+      }
+    );
+  };
+  const createSnapshotBlockSchema = (options) => {
+    const {
+      formItemInitializers = "ReadPrettyFormItemInitializers",
+      actionInitializers = "ReadPrettyFormActionInitializers",
+      collection,
+      association,
+      resource,
+      template,
+      ...others
+    } = options;
+    const resourceName = resource || association || collection;
+    const schema = {
+      type: "void",
+      "x-acl-action": `${resourceName}:get`,
+      "x-decorator": "SnapshotBlockProvider",
+      "x-decorator-props": {
+        resource: resourceName,
+        collection,
+        association,
+        readPretty: true,
+        action: "get",
+        useParams: "{{ useParamsFromRecord }}",
+        ...others
+      },
+      "x-designer": "FormV2.ReadPrettyDesigner",
+      "x-component": "CardItem",
+      properties: {
+        [shared.uid()]: {
+          type: "void",
+          "x-component": "FormV2",
+          "x-read-pretty": true,
+          "x-component-props": {
+            useProps: "{{ useFormBlockProps }}"
+          },
+          properties: {
+            grid: template || {
+              type: "void",
+              "x-component": "Grid",
+              "x-initializer": formItemInitializers,
+              properties: {}
+            }
+          }
+        }
+      }
+    };
+    console.log(JSON.stringify(schema, null, 2));
+    return schema;
+  };
+  const SnapshotBlockInitializersDetailItem = (props) => {
+    const {
+      onCreateBlockSchema,
+      componentType,
+      createBlockSchema,
+      insert,
+      icon = true,
+      targetCollection,
+      ...others
+    } = props;
+    const { getTemplateSchemaByMode } = client.useSchemaTemplateManager();
+    const collection = targetCollection || client.useCollection();
+    const association = client.useBlockAssociationContext();
+    const { block } = client.useBlockRequestContext();
+    const actionInitializers = block !== "TableField" ? props.actionInitializers || "ReadPrettyFormActionInitializers" : null;
+    return /* @__PURE__ */ require$$0.createElement(
+      client.SchemaInitializer.Item,
+      {
+        icon: icon && /* @__PURE__ */ jsxRuntimeExports.jsx(icons.FormOutlined, {}),
+        ...others,
+        key: "snapshotDetail",
+        onClick: async ({ item }) => {
+          if (item.template) {
+            const s = await getTemplateSchemaByMode(item);
+            if (item.template.componentName === "ReadPrettyFormItem") {
+              const blockSchema = createSnapshotBlockSchema({
+                actionInitializers,
+                association,
+                collection: collection.name,
+                action: "get",
+                useSourceId: "{{ useSourceIdFromParentRecord }}",
+                useParams: "{{ useParamsFromRecord }}",
+                template: s
+              });
+              if (item.mode === "reference") {
+                blockSchema["x-template-key"] = item.template.key;
+              }
+              insert(blockSchema);
+            } else {
+              insert(s);
+            }
+          } else {
+            insert(
+              createSnapshotBlockSchema({
+                actionInitializers,
+                association,
+                collection: collection.name,
+                action: "get",
+                useSourceId: "{{ useSourceIdFromParentRecord }}",
+                useParams: "{{ useParamsFromRecord }}"
+              })
+            );
+          }
+        },
+        items: client.useRecordCollectionDataSourceItems("ReadPrettyFormItem")
+      }
+    );
+  };
+  const InternalFormBlockProvider = (props) => {
+    var _a;
+    const { action, readPretty } = props;
+    const field = react.useField();
+    const form = require$$0.useMemo(
+      () => core.createForm({
+        readPretty
+      }),
+      []
+    );
+    const { resource, service } = client.useBlockRequestContext();
+    const formBlockRef = require$$0.useRef();
+    if (service.loading) {
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(antd.Spin, {});
+    }
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(
+      client.FormBlockContext.Provider,
+      {
+        value: {
+          action,
+          form,
+          field,
+          service,
+          resource,
+          updateAssociationValues: [],
+          formBlockRef
+        },
+        children: readPretty ? /* @__PURE__ */ jsxRuntimeExports.jsx(client.RecordProvider, { record: (_a = service == null ? void 0 : service.data) == null ? void 0 : _a.data, children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { ref: formBlockRef, children: props.children }) }) : /* @__PURE__ */ jsxRuntimeExports.jsx("div", { ref: formBlockRef, children: props.children })
+      }
+    );
+  };
+  const BlockRequestProvider = (props) => {
+    const field = react.useField();
+    const resource = client.useBlockResource();
+    const service = {
+      loading: false,
+      data: {
+        data: client.useRecord()
+      }
+    };
+    const __parent = require$$0.useContext(client.BlockRequestContext);
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(client.BlockRequestContext.Provider, { value: { block: props.block, props, field, service, resource, __parent }, children: props.children });
+  };
+  const BlockProvider = (props) => {
+    const { collection, association } = props;
+    const resource = client.useResource(props);
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(client.MaybeCollectionProvider, { collection, children: /* @__PURE__ */ jsxRuntimeExports.jsx(client.BlockAssociationContext.Provider, { value: association, children: /* @__PURE__ */ jsxRuntimeExports.jsx(client.BlockResourceContext.Provider, { value: resource, children: /* @__PURE__ */ jsxRuntimeExports.jsx(BlockRequestProvider, { ...props, children: props.children }) }) }) });
+  };
+  const SnapshotBlockProvider = (props) => {
+    const record = client.useRecord();
+    const { __tableName } = record;
+    const { getInheritCollections } = client.useCollectionManager();
+    const inheritCollections = getInheritCollections(__tableName);
+    const { designable } = client.useDesignable();
+    const flag = !designable && __tableName && !inheritCollections.includes(props.collection) && __tableName !== props.collection;
+    return !flag && /* @__PURE__ */ jsxRuntimeExports.jsx(BlockProvider, { ...props, children: /* @__PURE__ */ jsxRuntimeExports.jsx(InternalFormBlockProvider, { ...props }) });
+  };
+  const SnapshotHistoryCollectionProvider = (props) => {
+    var _a;
+    const { collectionName } = props;
+    const { collections: allCollections, ...rest } = require$$0.useContext(client.CollectionManagerContext);
+    const snapshotTargetCollection = (_a = client.useHistoryCollectionsByNames([collectionName])) == null ? void 0 : _a[0];
+    const inheritCollections = client.useHistoryCollectionsByNames((snapshotTargetCollection == null ? void 0 : snapshotTargetCollection.inherits) ?? []);
+    const associationFieldTargetCollections = client.useHistoryCollectionsByNames(
+      (snapshotTargetCollection == null ? void 0 : snapshotTargetCollection.fields.filter((i) => i.interface !== "snapshot").map((i) => i.target)) ?? []
+    );
+    const finallyHistoryCollecionts = [
+      snapshotTargetCollection,
+      ...associationFieldTargetCollections,
+      ...inheritCollections
+    ].filter((i) => i);
+    const filterdAllCollection = allCollections.filter(
+      (c) => !finallyHistoryCollecionts.map((i) => i.name).includes(c.name)
+    );
+    const overridedCollections = [...filterdAllCollection, ...finallyHistoryCollecionts];
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(
+      client.CollectionManagerContext.Provider,
+      {
+        value: {
+          ...rest,
+          collections: overridedCollections
+        },
+        children: props.children
+      }
+    );
+  };
+  const ReadPrettyRecordPickerWrapper = (props) => {
+    const fieldSchema = react.useFieldSchema();
+    const { getField } = client.useCollection();
+    const collectionField = getField(fieldSchema.name);
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(SnapshotHistoryCollectionProvider, { collectionName: collectionField == null ? void 0 : collectionField.targetCollection, children: /* @__PURE__ */ jsxRuntimeExports.jsx(client.ReadPrettyRecordPicker, { ...props }) });
+  };
+  const SnapshotRecordPickerInner = react.connect(
+    ReadPrettyRecordPickerWrapper,
+    react.mapReadPretty(ReadPrettyRecordPickerWrapper)
+  );
+  const SnapshotRecordPicker = (props) => {
+    const { value, onChange, ...restProps } = props;
+    const newProps = {
+      ...restProps,
+      value: value == null ? void 0 : value.data,
+      onChange: (value2) => onChange({ data: value2 })
+    };
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(SnapshotRecordPickerInner, { ...newProps });
+  };
+  const SnapshotFieldProvider = require$$0.memo((props) => {
+    require$$0.useEffect(() => {
+      client.registerField(snapshot.group, snapshot.name, snapshot);
+    }, []);
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(
+      client.CollectionManagerProvider,
+      {
+        interfaces: {
+          snapshot
+        },
+        children: /* @__PURE__ */ jsxRuntimeExports.jsx(client.CollectionHistoryProvider, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+          client.SchemaInitializerProvider,
+          {
+            initializers: {
+              SnapshotBlockInitializers
+            },
+            children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+              client.SchemaComponentOptions,
+              {
+                components: {
+                  SnapshotRecordPicker,
+                  SnapshotBlockProvider,
+                  SnapshotBlockInitializersDetailItem,
+                  SnapshotOwnerCollectionFieldsSelect
+                },
+                children: props.children
+              }
+            )
+          }
+        ) })
+      }
+    );
+  });
+  SnapshotFieldProvider.displayName = "SnapshotFieldProvider";
+  class SnapshotFieldPlugin extends client.Plugin {
+    async load() {
+      this.app.use(SnapshotFieldProvider);
+    }
+  }
+  exports2.SnapshotFieldPlugin = SnapshotFieldPlugin;
+  exports2.default = SnapshotFieldPlugin;
+  Object.defineProperties(exports2, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+});

package/{lib → dist}/index.d.ts

@@ -1 +1,2 @@
+export * from './server';
 export { default } from './server';

package/dist/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var server = require('./server');
+
+
+
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () { return server__namespace.default; }
+});
+Object.keys(server).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return server[k]; }
+  });
+});

package/dist/locale/en-US.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var en_US_default = {
+  Detail: "Detail",
+  Snapshot: "Snapshot",
+  "View record": "View record",
+  "Add block": "Add block",
+  "Allow linking to multiple records": "Allow linking to multiple records",
+  "When adding a new record, create a snapshot for its relational record and save in the current record. The snapshot is not updated when the record is subsequently updated.": "When adding a new record, create a snapshot for its relational record and save in the current record. The snapshot is not updated when the record is subsequently updated.",
+  "The association field to snapshot": "The association field to snapshot",
+  "Snapshot the snapshot's association fields": "Snapshot the snapshot's association fields",
+  "Please select": "Please select"
+};
+
+module.exports = en_US_default;

package/dist/locale/es-ES.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var es_ES_default = {
+  "Detail": "Detalle",
+  "Snapshot": "Snapshot",
+  "View record": "Ver registro",
+  "Add block": "A\xF1adir bloque",
+  "Allow linking to multiple records": "Permitir enlace a m\xFAltiples registros",
+  "When adding a new record, create a snapshot for its relational record and save in the current record. The snapshot is not updated when the record is subsequently updated.": "Al a\xF1adir un nuevo registro, crear una snapshot para su registro relacional y guardar en el registro actual. La snapshot no se actualiza cuando el registro se actualiza posteriormente.",
+  "The association field to snapshot": "El campo de asociaci\xF3n a la snapshot",
+  "Snapshot the snapshot's association fields": "Snapshot los campos de asociaci\xF3n de la snapshot",
+  "Please select": "Por favor, seleccione"
+};
+
+module.exports = es_ES_default;

package/dist/locale/fr-FR.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var fr_FR_default = {
+  Detail: "D\xE9tail",
+  Snapshot: "Snapshot",
+  "View record": "Voir l'enregistrement",
+  "Add block": "Ajouter un bloc",
+  "Allow linking to multiple records": "Autoriser la liaison \xE0 plusieurs enregistrements",
+  "When adding a new record, create a snapshot for its relational record and save in the current record. The snapshot is not updated when the record is subsequently updated.": "Lors de l'ajout d'un nouvel enregistrement, cr\xE9ez un snapshot pour son enregistrement relationnel et enregistrez-le dans l'enregistrement actuel. Le snapshot n'est pas mis \xE0 jour lorsque l'enregistrement est ult\xE9rieurement modifi\xE9.",
+  "The association field to snapshot": "Le champ d'association \xE0 un snapshot",
+  "Snapshot the snapshot's association fields": "Snapshot des champs d'association du snapshot",
+  "Please select": "Veuillez s\xE9lectionner"
+};
+
+module.exports = fr_FR_default;

package/dist/locale/ja-JP.js

@@ -0,0 +1,5 @@
+'use strict';
+
+var ja_JP_default = {};
+
+module.exports = ja_JP_default;

package/dist/locale/pt-BR.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var pt_BR_default = {
+  Detail: "Detalhes",
+  Snapshot: "Fotografia",
+  "View record": "Visualizar registro",
+  "Add block": "Adicionar bloco",
+  "Allow linking to multiple records": "Permitir vincula\xE7\xE3o a v\xE1rios registros",
+  "When adding a new record, create a snapshot for its relational record and save in the current record. The snapshot is not updated when the record is subsequently updated.": "Ao adicionar um novo registro, crie uma imagem instant\xE2nea para o registro relacionado e salve no registro atual. A imagem instant\xE2nea n\xE3o \xE9 atualizada quando o registro \xE9 posteriormente atualizado.",
+  "The association field to snapshot": "O campo de associa\xE7\xE3o para criar imagem instant\xE2nea",
+  "Snapshot the snapshot's association fields": "Criar imagem instant\xE2nea para os campos de associa\xE7\xE3o da imagem instant\xE2nea",
+  "Please select": "Por favor, selecione"
+};
+
+module.exports = pt_BR_default;

package/dist/locale/ru-RU.js

@@ -0,0 +1,5 @@
+'use strict';
+
+var ru_RU_default = {};
+
+module.exports = ru_RU_default;

package/dist/locale/tr-TR.js

@@ -0,0 +1,5 @@
+'use strict';
+
+var tr_TR_default = {};
+
+module.exports = tr_TR_default;

package/dist/locale/zh-CN.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var zh_CN_default = {
+  Detail: "\u8BE6\u60C5",
+  Snapshot: "\u5FEB\u7167",
+  "Add block": "\u521B\u5EFA\u533A\u5757",
+  "When adding a new record, create a snapshot for its relational record and save in the current record. The snapshot is not updated when the record is subsequently updated.": "\u5728\u6DFB\u52A0\u6570\u636E\u65F6\uFF0C\u4E3A\u5B83\u7684\u5173\u7CFB\u6570\u636E\u521B\u5EFA\u5FEB\u7167\uFF0C\u5E76\u4FDD\u5B58\u5728\u5F53\u524D\u7684\u6570\u636E\u4E2D\u3002\u540E\u7EED\u66F4\u65B0\u6570\u636E\u65F6\uFF0C\u5FEB\u7167\u4E0D\u518D\u66F4\u65B0\u3002",
+  "View record": "\u67E5\u770B\u6570\u636E",
+  "Allow linking to multiple records": "\u5141\u8BB8\u5173\u8054\u591A\u6761\u8BB0\u5F55",
+  "The association field to snapshot": "\u5FEB\u7167\u76EE\u6807\u5173\u7CFB\u5B57\u6BB5",
+  "Snapshot the snapshot's association fields": "\u4E3A\u5FEB\u7167\u7684\u5173\u7CFB\u6570\u636E\u521B\u5EFA\u5FEB\u7167",
+  "Please select": "\u8BF7\u9009\u62E9",
+  "When a record is created, association data is backed up in a snapshot": "\u521B\u5EFA\u8BB0\u5F55\u65F6\uFF0C\u5173\u7CFB\u6570\u636E\u4F1A\u5907\u4EFD\u5230\u5FEB\u7167\u91CC",
+  "Snapshot data": "\u5FEB\u7167\u6570\u636E"
+};
+
+module.exports = zh_CN_default;