@nocobase/client 0.7.0-alpha.82 → 0.7.1-alpha.4

package/src/schema-templates/BlockTemplateDetails.tsx

@@ -1,91 +0,0 @@
-import { Input, PageHeader as AntdPageHeader, Spin } from 'antd';
-import React, { useContext, useState } from 'react';
-import { useHistory, useRouteMatch } from 'react-router-dom';
-import { useAPIClient, useRequest, useSchemaTemplateManager } from '..';
-import { RemoteSchemaComponent, SchemaComponentContext } from '../schema-component';
-
-const EditableTitle = (props) => {
-  const [title, setTitle] = useState(props.title);
-  const [visible, setVisible] = useState(false);
-  const { refresh } = useSchemaTemplateManager();
-  const api = useAPIClient();
-  const { run } = useRequest(
-    {
-      resource: 'uiSchemaTemplates',
-      action: 'update',
-      params: {
-        filterByTk: props.filterByTk,
-      },
-    },
-    {
-      manual: true,
-      debounceWait: 500,
-      onSuccess() {
-        refresh();
-      },
-    },
-  );
-  return (
-    <div>
-      {visible ? (
-        <Input
-          defaultValue={title}
-          size={'large'}
-          onBlur={() => {
-            setVisible(false);
-          }}
-          onChange={(e) => {
-            setTitle(e.target.value);
-            run({
-              filterByTk: props.filterByTk,
-              values: {
-                name: e.target.value,
-              },
-            });
-          }}
-        />
-      ) : (
-        <div
-          onClick={() => {
-            setVisible(true);
-          }}
-        >
-          {title || <span style={{ color: '#bbb' }}>未命名</span>}
-        </div>
-      )}
-    </div>
-  );
-};
-
-export const BlockTemplateDetails = () => {
-  const history = useHistory();
-  const match = useRouteMatch<any>();
-  const key = match?.params?.key;
-  const value = useContext(SchemaComponentContext);
-  const { data, loading } = useRequest({
-    resource: 'uiSchemaTemplates',
-    action: 'get',
-    params: {
-      filterByTk: key,
-    },
-  });
-  if (loading) {
-    return <Spin />;
-  }
-  return (
-    <div>
-      <AntdPageHeader
-        onBack={() => {
-          history.push('/admin/plugins/block-templates');
-        }}
-        ghost={false}
-        title={<EditableTitle filterByTk={key} title={data?.data?.name} />}
-      />
-      <div style={{ margin: 24 }}>
-        <SchemaComponentContext.Provider value={{ ...value, designable: true }}>
-          <RemoteSchemaComponent uid={data?.data?.uid} />
-        </SchemaComponentContext.Provider>
-      </div>
-    </div>
-  );
-};

package/src/schema-templates/BlockTemplatePage.tsx

@@ -1,21 +0,0 @@
-import { PageHeader as AntdPageHeader } from 'antd';
-import React from 'react';
-import { useTranslation } from 'react-i18next';
-import { CollectionManagerProvider } from '../collection-manager';
-import { SchemaComponent } from '../schema-component';
-import { uiSchemaTemplatesCollection } from './collections/uiSchemaTemplates';
-import { uiSchemaTemplatesSchema } from './schemas/uiSchemaTemplates';
-
-export const BlockTemplatePage = () => {
-  const { t } = useTranslation();
-  return (
-    <div>
-      <AntdPageHeader ghost={false} title={t('Block templates')} />
-      <div style={{ margin: 24 }}>
-        <CollectionManagerProvider collections={[uiSchemaTemplatesCollection]}>
-          <SchemaComponent schema={uiSchemaTemplatesSchema} />
-        </CollectionManagerProvider>
-      </div>
-    </div>
-  );
-};

package/src/schema-templates/SchemaTemplateManagerProvider.tsx

@@ -1,154 +0,0 @@
-import { ISchema, useFieldSchema } from '@formily/react';
-import { uid } from '@formily/shared';
-import { Spin } from 'antd';
-import { cloneDeep } from 'lodash';
-import React, { createContext, useContext, useMemo } from 'react';
-import { useAPIClient, useRequest } from '../api-client';
-import { RouteSwitchContext } from '../route-switch';
-import { SchemaComponentOptions } from '../schema-component';
-import { BlockTemplate } from './BlockTemplate';
-
-export const SchemaTemplateManagerContext = createContext<any>({});
-
-const SchemaTemplateRouteProvider = (props) => {
-  const { routes, ...others } = useContext(RouteSwitchContext);
-  routes[1].routes.unshift(
-    {
-      type: 'route',
-      path: '/admin/plugins/block-templates/:key',
-      component: 'BlockTemplateDetails',
-    },
-    {
-      type: 'route',
-      path: '/admin/plugins/block-templates',
-      component: 'BlockTemplatePage',
-    },
-  );
-  return <RouteSwitchContext.Provider value={{ ...others, routes }}>{props.children}</RouteSwitchContext.Provider>;
-};
-
-export const SchemaTemplateManagerProvider: React.FC<any> = (props) => {
-  const { templates, refresh } = props;
-  return (
-    <SchemaTemplateManagerContext.Provider value={{ templates, refresh }}>
-      <SchemaTemplateRouteProvider>
-        <SchemaComponentOptions components={{ BlockTemplate }}>{props.children}</SchemaComponentOptions>
-      </SchemaTemplateRouteProvider>
-    </SchemaTemplateManagerContext.Provider>
-  );
-};
-
-const regenerateUid = (s: ISchema) => {
-  s['x-uid'] = uid();
-  Object.keys(s.properties || {}).forEach((key) => {
-    regenerateUid(s.properties[key]);
-  });
-};
-
-export const useSchemaTemplate = () => {
-  const { getTemplateBySchema, templates } = useSchemaTemplateManager();
-  const fieldSchema = useFieldSchema();
-  const schemaId = fieldSchema['x-uid'];
-  const templateKey = fieldSchema['x-template-key'];
-  console.log('templateKey', { schemaId, templateKey })
-  return useMemo(() => getTemplateBySchema(fieldSchema), [schemaId, templateKey]);
-};
-
-export const useSchemaTemplateManager = () => {
-  const { refresh, templates = [] } = useContext(SchemaTemplateManagerContext);
-  const api = useAPIClient();
-  return {
-    templates,
-    refresh,
-    async getTemplateSchemaByMode(options) {
-      const { mode, template } = options;
-      if (mode === 'copy') {
-        const { data } = await api.request({
-          url: `/uiSchemas:getJsonSchema/${template.uid}?includeAsyncNode=true`,
-        });
-        const s = data?.data || {};
-        regenerateUid(s);
-        return cloneDeep(s);
-      } else if (mode === 'reference') {
-        return {
-          type: 'void',
-          'x-component': 'BlockTemplate',
-          'x-component-props': {
-            templateId: template.key,
-          },
-        };
-      }
-    },
-    async copyTemplateSchema(template) {
-      const { data } = await api.request({
-        url: `/uiSchemas:getJsonSchema/${template.uid}?includeAsyncNode=true`,
-      });
-      const s = data?.data || {};
-      regenerateUid(s);
-      return cloneDeep(s);
-    },
-    async saveAsTemplate(values) {
-      const { uid: schemaId } = values;
-      const key = uid();
-      await api.resource('uiSchemas').saveAsTemplate({
-        filterByTk: schemaId,
-        values: {
-          key,
-          ...values,
-        },
-      });
-      await refresh();
-      return { key };
-    },
-    getTemplateBySchema(schema) {
-      const templateKey = schema['x-template-key'];
-      if (templateKey) {
-        return templates?.find((template) => template.key === templateKey);
-      }
-      const schemaId = schema['x-uid'];
-      if (schemaId) {
-        return templates?.find((template) => template.uid === schemaId);
-      }
-    },
-    getTemplateBySchemaId(schemaId) {
-      if (!schemaId) {
-        return null;
-      }
-      return templates?.find((template) => template.uid === schemaId);
-    },
-    getTemplateById(key) {
-      return templates?.find((template) => template.key === key);
-    },
-    getTemplatesByCollection(collectionName: string) {
-      const items = templates?.filter?.((template) => template.collectionName === collectionName);
-      return items || [];
-    },
-  };
-};
-
-export const RemoteSchemaTemplateManagerProvider: React.FC = (props) => {
-  const api = useAPIClient();
-  const options = {
-    resource: 'uiSchemaTemplates',
-    action: 'list',
-    params: {
-      appends: ['collection'],
-      paginate: false,
-    },
-  };
-  const service = useRequest(options);
-  if (service.loading) {
-    return <Spin />;
-  }
-  return (
-    <SchemaTemplateManagerProvider
-      refresh={async () => {
-        const { data } = await api.request(options);
-        service.mutate(data);
-      }}
-      templates={service?.data?.data}
-    >
-      {props.children}
-    </SchemaTemplateManagerProvider>
-  );
-};

package/src/schema-templates/SchemaTemplateShortcut.tsx

@@ -1,19 +0,0 @@
-import { LayoutOutlined } from '@ant-design/icons';
-import React from 'react';
-import { useTranslation } from 'react-i18next';
-import { useHistory } from 'react-router-dom';
-import { PluginManager } from '../plugin-manager';
-
-export const SchemaTemplateShortcut = () => {
-  const { t } = useTranslation();
-  const history = useHistory();
-  return (
-    <PluginManager.Toolbar.Item
-      icon={<LayoutOutlined />}
-      title={t('Block templates')}
-      onClick={() => {
-        history.push('/admin/plugins/block-templates');
-      }}
-    />
-  );
-};

package/src/schema-templates/collections/uiSchemaTemplates.ts

@@ -1,20 +0,0 @@
-import { CollectionOptions } from '../../collection-manager';
-
-export const uiSchemaTemplatesCollection: CollectionOptions = {
-  name: 'uiSchemaTemplates',
-  filterTargetKey: 'key',
-  targetKey: 'key',
-  fields: [
-    {
-      type: 'integer',
-      name: 'name',
-      interface: 'input',
-      uiSchema: {
-        title: '{{ t("Template name") }}',
-        type: 'number',
-        'x-component': 'Input',
-        required: true,
-      },
-    },
-  ],
-};

package/src/schema-templates/index.ts

@@ -1,5 +0,0 @@
-export * from './BlockTemplateDetails';
-export * from './BlockTemplatePage';
-export * from './SchemaTemplateManagerProvider';
-export * from './SchemaTemplateShortcut';
-

package/src/schema-templates/schemas/uiSchemaTemplates.ts

@@ -1,223 +0,0 @@
-import { ISchema } from '@formily/react';
-import { uid } from '@formily/shared';
-import { useUpdateActionProps } from '../../block-provider/hooks';
-import { useSchemaTemplateManager } from '../SchemaTemplateManagerProvider';
-
-const useUpdateSchemaTemplateActionProps = () => {
-  const props = useUpdateActionProps();
-  const { refresh } = useSchemaTemplateManager();
-  return {
-    async onClick() {
-      await props.onClick();
-      refresh();
-    }
-  }
-}
-
-export const uiSchemaTemplatesSchema: ISchema = {
-  type: 'object',
-  properties: {
-    [uid()]: {
-      type: 'void',
-      'x-decorator': 'TableBlockProvider',
-      'x-decorator-props': {
-        collection: 'uiSchemaTemplates',
-        resource: 'uiSchemaTemplates',
-        action: 'list',
-        params: {
-          pageSize: 20,
-          appends: ['collection'],
-          sort: ['-createdAt'],
-        },
-        rowKey: 'key',
-        showIndex: true,
-        dragSort: false,
-      },
-      'x-component': 'CardItem',
-      properties: {
-        actions: {
-          type: 'void',
-          'x-component': 'ActionBar',
-          'x-component-props': {
-            style: {
-              marginBottom: 16,
-            },
-          },
-          properties: {
-            destroy: {
-              title: '{{ t("Delete") }}',
-              'x-action': 'destroy',
-              'x-component': 'Action',
-              'x-designer': 'Action.Designer',
-              'x-component-props': {
-                icon: 'DeleteOutlined',
-                confirm: {
-                  title: "{{t('Delete record')}}",
-                  content: "{{t('Are you sure you want to delete it?')}}",
-                },
-                useProps: '{{ useBulkDestroyActionProps }}',
-              },
-            },
-          },
-        },
-        [uid()]: {
-          type: 'array',
-          'x-component': 'TableV2',
-          'x-component-props': {
-            rowSelection: {
-              type: 'checkbox',
-            },
-            useProps: '{{ useTableBlockProps }}',
-          },
-          properties: {
-            actions: {
-              type: 'void',
-              title: '{{ t("Actions") }}',
-              'x-component': 'TableV2.Column',
-              properties: {
-                actions: {
-                  type: 'void',
-                  'x-decorator': 'DndContext',
-                  'x-component': 'Space',
-                  'x-component-props': {
-                    split: '|',
-                  },
-                  properties: {
-                    // view: {
-                    //   title: '{{ t("View") }}',
-                    //   'x-action': 'view',
-                    //   'x-component': 'RecordLink',
-                    //   'x-component-props': {
-                    //     to: '/admin/plugins/block-templates/${record.key}',
-                    //   },
-                    // },
-                    edit: {
-                      type: 'void',
-                      title: '{{ t("Edit") }}',
-                      'x-action': 'update',
-                      'x-component': 'Action.Link',
-                      'x-component-props': {
-                        openMode: 'drawer',
-                        icon: 'EditOutlined',
-                      },
-                      properties: {
-                        drawer: {
-                          type: 'void',
-                          title: '{{ t("Edit record") }}',
-                          'x-component': 'Action.Container',
-                          'x-component-props': {
-                            className: 'nb-action-popup',
-                          },
-                          properties: {
-                            form: {
-                              type: 'void',
-                              'x-decorator': 'FormBlockProvider',
-                              'x-decorator-props': {
-                                resource: 'uiSchemaTemplates',
-                                collection: 'uiSchemaTemplates',
-                                action: 'get',
-                                useParams: '{{ useParamsFromRecord }}',
-                              },
-                              'x-component': 'CardItem',
-                              properties: {
-                                [uid()]: {
-                                  type: 'void',
-                                  'x-component': 'FormV2',
-                                  'x-component-props': {
-                                    useProps: '{{ useFormBlockProps }}',
-                                  },
-                                  properties: {
-                                    name: {
-                                      type: 'string',
-                                      'x-component': 'CollectionField',
-                                      'x-decorator': 'FormItem',
-                                      'x-collection-field': 'uiSchemaTemplates.name',
-                                      required: true,
-                                    },
-                                    actions: {
-                                      type: 'void',
-                                      'x-component': 'ActionBar',
-                                      'x-component-props': {
-                                        layout: 'one-column',
-                                        style: {
-                                          marginTop: 24,
-                                        },
-                                      },
-                                      properties: {
-                                        submit: {
-                                          title: '{{t("Submit")}}',
-                                          'x-action': 'submit',
-                                          'x-component': 'Action',
-                                          'x-component-props': {
-                                            type: 'primary',
-                                            htmlType: 'submit',
-                                            useProps: useUpdateSchemaTemplateActionProps,
-                                          },
-                                          type: 'void',
-                                        },
-                                      },
-                                    },
-                                  },
-                                },
-                              },
-                            },
-                          },
-                        },
-                      },
-                    },
-                    destroy: {
-                      title: '{{ t("Delete") }}',
-                      'x-action': 'destroy',
-                      'x-component': 'Action.Link',
-                      'x-component-props': {
-                        icon: 'DeleteOutlined',
-                        confirm: {
-                          title: "{{t('Delete record')}}",
-                          content: "{{t('Are you sure you want to delete it?')}}",
-                        },
-                        useProps: '{{ useDestroyActionProps }}',
-                      },
-                    },
-                  },
-                },
-              },
-            },
-            column1: {
-              type: 'void',
-              'x-decorator': 'TableV2.Column.Decorator',
-              'x-component': 'TableV2.Column',
-              properties: {
-                name: {
-                  type: 'string',
-                  'x-collection-field': 'uiSchemaTemplates.name',
-                  'x-component': 'CollectionField',
-                  'x-read-pretty': true,
-                  'x-component-props': {
-                    ellipsis: true,
-                  },
-                },
-              },
-            },
-            column2: {
-              type: 'void',
-              title: '{{t("Collection display name")}}',
-              'x-decorator': 'TableV2.Column.Decorator',
-              'x-component': 'TableV2.Column',
-              properties: {
-                'collection.title': {
-                  type: 'string',
-                  'x-collection-field': 'uiSchemaTemplates.collection',
-                  'x-component': 'Input',
-                  'x-read-pretty': true,
-                  'x-component-props': {
-                    ellipsis: true,
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-    },
-  },
-};