@nocobase/client 0.21.0-alpha.6 → 0.21.0-alpha.7

package/es/application/Application.d.ts

@@ -1,6 +1,6 @@
 import { APIClientOptions } from '@nocobase/sdk';
 import { i18n as i18next } from 'i18next';
-import React, { ComponentType, ReactElement } from 'react';
+import React, { ComponentType, ReactElement, ReactNode } from 'react';
 import { APIClient } from '../api-client';
 import { PluginManager, PluginType } from './PluginManager';
 import { PluginSettingOptions, PluginSettingsManager } from './PluginSettingsManager';
@@ -69,6 +69,7 @@ export declare class Application {
     private addRoutes;
     getOptions(): ApplicationOptions;
     getPublicPath(): string;
+    getApiUrl(pathname?: string): string;
     getRouteUrl(pathname: string): string;
     getCollectionManager(dataSource?: string): import("..").CollectionManager;
     /**
@@ -80,13 +81,15 @@ export declare class Application {
     addProviders(providers: (ComponentType | [ComponentType, any])[]): void;
     load(): Promise<void>;
     getComponent<T = any>(Component: ComponentTypeAndString<T>, isShowError?: boolean): ComponentType<T> | undefined;
-    renderComponent<T extends {}>(Component: ComponentTypeAndString, props?: T): ReactElement;
+    renderComponent<T extends {}>(Component: ComponentTypeAndString, props?: T, children?: ReactNode): ReactElement;
     /**
      * @internal use addComponents({ SomeComponent }) instead
      */
     protected addComponent(component: ComponentType, name?: string): void;
     addComponents(components: Record<string, ComponentType>): void;
     addScopes(scopes: Record<string, any>): void;
-    getRootComponent(): React.FC;
+    getRootComponent(): React.FC<{
+        children?: React.ReactNode;
+    }>;
     mount(containerOrSelector: Element | ShadowRoot | string): any;
 }

package/es/application/RouterManager.d.ts

@@ -34,7 +34,7 @@ export declare class RouterManager {
     /**
      * @internal
      */
-    getRouterComponent(): React.FC<{
+    getRouterComponent(children?: React.ReactNode): React.FC<{
         BaseLayout?: ComponentType;
     }>;
     add(name: string, route: RouteType): void;

package/es/application/components/MainComponent.d.ts

@@ -1,2 +1,2 @@
 import React from 'react';
-export declare const MainComponent: React.MemoExoticComponent<() => React.JSX.Element>;
+export declare const MainComponent: React.NamedExoticComponent<object>;

package/es/application/components/defaultComponents.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 export declare const defaultAppComponents: {
-    AppMain: React.MemoExoticComponent<() => React.JSX.Element>;
+    AppMain: React.NamedExoticComponent<object>;
     AppSpin: React.FC;
     AppError: React.FC<{
         error: Error;

package/es/application/schema-initializer/components/SchemaInitializerActionModal.d.ts

@@ -6,6 +6,7 @@ export interface SchemaInitializerActionModalProps {
     onSubmit?: (values: any) => void;
     buttonText?: any;
     component?: any;
+    isItem?: boolean;
 }
 export declare const SchemaInitializerActionModal: FC<SchemaInitializerActionModalProps>;
 export declare const SchemaInitializerActionModalInternal: () => React.JSX.Element;

package/es/application/schema-initializer/components/SchemaInitializerItem.d.ts

@@ -11,4 +11,7 @@ export interface SchemaInitializerItemProps {
     children?: ReactNode;
 }
 export declare const SchemaInitializerItem: React.MemoExoticComponent<React.ForwardRefExoticComponent<SchemaInitializerItemProps & React.RefAttributes<any>>>;
+/**
+ * @internal
+ */
 export declare const SchemaInitializerItemInternal: () => React.JSX.Element;

package/es/application/schema-initializer/components/SchemaInitializerItemGroup.d.ts

@@ -3,7 +3,11 @@ import { SchemaInitializerOptions } from '../types';
 export interface SchemaInitializerItemGroupProps {
     title: string;
     children?: SchemaInitializerOptions['items'];
+    items?: SchemaInitializerOptions['items'];
     divider?: boolean;
 }
 export declare const SchemaInitializerItemGroup: FC<SchemaInitializerItemGroupProps>;
+/**
+ * @internal
+ */
 export declare const SchemaInitializerItemGroupInternal: () => React.JSX.Element;

package/es/application/schema-initializer/components/SchemaInitializerSelect.d.ts

@@ -8,4 +8,7 @@ export interface SchemaInitializerSelectItemProps extends SchemaInitializerItemP
     openOnHover?: boolean;
 }
 export declare const SchemaInitializerSelect: FC<SchemaInitializerSelectItemProps>;
+/**
+ * @internal
+ */
 export declare const SchemaInitializerSelectInternal: () => React.JSX.Element;

package/es/application/schema-initializer/components/SchemaInitializerSubMenu.d.ts

@@ -2,16 +2,24 @@ import { MenuProps } from 'antd';
 import React, { FC, ReactNode } from 'react';
 import { SchemaInitializerOptions } from '../types';
 export interface SchemaInitializerSubMenuProps {
-    name: string;
+    name?: string;
     title?: string;
     onClick?: (args: any) => void;
     onOpenChange?: (openKeys: string[]) => void;
     icon?: string | ReactNode;
     children?: SchemaInitializerOptions['items'];
+    items?: SchemaInitializerOptions['items'];
 }
+/**
+ * @internal
+ */
+export declare const SchemaInitializerMenuProvider: (props: any) => React.JSX.Element;
 export declare const useSchemaInitializerSubMenuContext: () => {
     isInMenu?: true;
 };
 export declare const SchemaInitializerMenu: FC<MenuProps>;
 export declare const SchemaInitializerSubMenu: FC<SchemaInitializerSubMenuProps>;
+/**
+ * @internal
+ */
 export declare const SchemaInitializerSubMenuInternal: () => React.JSX.Element;

package/es/application/schema-initializer/components/SchemaInitializerSwitch.d.ts

@@ -5,4 +5,7 @@ export interface SchemaInitializerSwitchItemProps extends SchemaInitializerItemP
     disabled?: boolean;
 }
 export declare const SchemaInitializerSwitch: FC<SchemaInitializerSwitchItemProps>;
+/**
+ * @internal
+ */
 export declare const SchemaInitializerSwitchInternal: () => React.JSX.Element;

package/es/application/schema-initializer/hooks/index.d.ts

@@ -1,19 +1,3 @@
-import { ButtonProps } from 'antd';
-import React from 'react';
-import { SchemaInitializerOptions } from '../types';
 export * from './useAriaAttributeOfMenuItem';
-/**
- * @internal
- */
-export declare function useSchemaInitializerMenuItems(items: any[], name?: string, onClick?: (args: any) => void): any;
-/**
- * @internal
- */
-export declare function useGetSchemaInitializerMenuItems(onClick?: (args: any) => void): any;
-export declare function useSchemaInitializerRender<P1 = ButtonProps, P2 = {}>(name: string, options?: Omit<SchemaInitializerOptions<P1, P2>, 'name'>): {
-    exists: boolean;
-    render: () => any;
-} | {
-    exists: boolean;
-    render: (props?: Omit<SchemaInitializerOptions<P1, P2>, 'name'>) => React.FunctionComponentElement<any> | React.FunctionComponentElement<SchemaInitializerOptions<any, any>>;
-};
+export * from './useSchemaInitializerRender';
+export * from './useGetSchemaInitializerMenuItems';

package/es/application/schema-initializer/hooks/useGetSchemaInitializerMenuItems.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @internal
+ */
+export declare function useSchemaInitializerMenuItems(items: any[], name?: string, onClick?: (args: any) => void): any;
+/**
+ * @internal
+ */
+export declare function useGetSchemaInitializerMenuItems(onClick?: (args: any) => void): any;

package/es/application/schema-initializer/hooks/useSchemaInitializerRender.d.ts

@@ -0,0 +1,10 @@
+import { ButtonProps } from 'antd';
+import React from 'react';
+import { SchemaInitializerOptions } from '../types';
+export declare function useSchemaInitializerRender<P1 = ButtonProps, P2 = {}>(name: string, options?: Omit<SchemaInitializerOptions<P1, P2>, 'name'>): {
+    exists: boolean;
+    render: () => any;
+} | {
+    exists: boolean;
+    render: (props?: Omit<SchemaInitializerOptions<P1, P2>, 'name'>) => React.FunctionComponentElement<SchemaInitializerOptions<any, any>>;
+};

package/es/application/schema-initializer/index.d.ts

@@ -1,4 +1,4 @@
-export * from './hoc';
+export * from './withInitializer';
 export * from './hooks';
 export * from './types';
 export * from './context';

package/es/application/schema-initializer/{hoc/index.d.ts → withInitializer.d.ts}

@@ -1,3 +1,3 @@
 import React, { ComponentType } from 'react';
-import { SchemaInitializerOptions } from '../types';
+import { SchemaInitializerOptions } from './types';
 export declare function withInitializer<T>(C: ComponentType<T>): React.MemoExoticComponent<import("@formily/react").ReactFC<Omit<SchemaInitializerOptions<T, {}>, "ref">>>;

package/es/application/schema-settings/context/SchemaSettingItemContext.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { SchemaSettingsItemType } from '../types';
+export declare const SchemaSettingItemContext: import("react").Context<SchemaSettingsItemType>;
+export declare function useSchemaSettingsItem<T = {}>(): T;

package/es/application/schema-settings/context/index.d.ts

@@ -1,4 +1 @@
-/// <reference types="react" />
-import { SchemaSettingsItemType } from '../types';
-export declare const SchemaSettingItemContext: import("react").Context<SchemaSettingsItemType>;
-export declare function useSchemaSettingsItem(): SchemaSettingsItemType;
+export * from './SchemaSettingItemContext';

package/es/application/schema-settings/hooks/index.d.ts

@@ -1,19 +1 @@
-import { SchemaSettingOptions } from '../types';
-import React from 'react';
-import { SchemaSettingsProps } from '../../../schema-settings';
-import { Schema } from '@formily/json-schema';
-import { GeneralField } from '@formily/core';
-import { Designable } from '../../../schema-component';
-type UseSchemaSettingsRenderOptions<T = {}> = Omit<SchemaSettingOptions<T>, 'name' | 'items'> & Omit<SchemaSettingsProps, 'title' | 'children'> & {
-    fieldSchema?: Schema;
-    field?: GeneralField;
-    dn?: Designable;
-};
-export declare function useSchemaSettingsRender<T = {}>(name: string, options?: UseSchemaSettingsRenderOptions<T>): {
-    exists: boolean;
-    render: () => any;
-} | {
-    exists: boolean;
-    render: (options2?: UseSchemaSettingsRenderOptions) => React.FunctionComponentElement<any> | React.FunctionComponentElement<SchemaSettingOptions<any>>;
-};
-export {};
+export * from './useSchemaSettingsRender';

package/es/application/schema-settings/hooks/useSchemaSettingsRender.d.ts

@@ -0,0 +1,19 @@
+import { SchemaSettingOptions } from '../types';
+import React from 'react';
+import { SchemaSettingsProps } from '../../../schema-settings';
+import { Schema } from '@formily/json-schema';
+import { GeneralField } from '@formily/core';
+import { Designable } from '../../../schema-component';
+type UseSchemaSettingsRenderOptions<T = {}> = Omit<SchemaSettingOptions<T>, 'name' | 'items'> & Omit<SchemaSettingsProps, 'title' | 'children'> & {
+    fieldSchema?: Schema;
+    field?: GeneralField;
+    dn?: Designable;
+};
+export declare function useSchemaSettingsRender<T = {}>(name: string, options?: UseSchemaSettingsRenderOptions<T>): {
+    exists: boolean;
+    render: () => any;
+} | {
+    exists: boolean;
+    render: (options2?: UseSchemaSettingsRenderOptions) => React.FunctionComponentElement<SchemaSettingOptions<any>>;
+};
+export {};

package/es/data-source/collection/AssociationProvider.d.ts

@@ -7,3 +7,4 @@ export interface AssociationProviderProps {
 }
 export declare const useParentCollection: () => Collection;
 export declare const AssociationProvider: FC<AssociationProviderProps>;
+export declare const useAssociationName: () => string;

package/es/data-source/collection/CollectionManager.d.ts

@@ -32,7 +32,7 @@ export declare class CollectionManager {
      */
     getCollectionField(path: SchemaKey | CollectionFieldOptions): any;
     getCollectionFields(collectionName: string, predicate?: GetCollectionFieldPredicate): CollectionFieldOptions[];
-    getSourceKeyByAssocation(associationName: string): any;
+    getSourceKeyByAssociation(associationName: string): any;
     /**
      * @internal
      */

package/es/data-source/components/CollectionDeletedPlaceholder.d.ts

@@ -1,6 +1,6 @@
 import { FC } from 'react';
 export interface CollectionDeletedPlaceholderProps {
-    type: 'Collection' | 'Field' | 'DataSource';
+    type: 'Collection' | 'Field' | 'Data Source' | 'Block template';
     name?: string | number;
     message?: string;
 }

package/es/data-source/data-source/DataSourceManager.d.ts

@@ -26,7 +26,7 @@ export declare class DataSourceManager {
     collectionFieldInterfaceManager: CollectionFieldInterfaceManager;
     constructor(options: DataSourceManagerOptions, app: Application);
     addCollectionMixins(mixins?: (typeof Collection)[]): void;
-    getDataSources(filterCollection?: (dataSource: DataSource) => boolean): DataSource[];
+    getDataSources(filterDataSource?: (dataSource: DataSource) => boolean): DataSource[];
     getDataSource(key?: string): DataSource;
     removeDataSources(keys: string[]): void;
     addDataSource(DataSource: DataSourceFactory, options: DataSourceOptions): DataSource;

package/es/index.d.ts

@@ -24,7 +24,6 @@ export * from './data-source';
 export * from './document-title';
 export * from './filter-provider';
 export * from './flag-provider';
-export * from './formula';
 export * from './global-theme';
 export * from './hooks';
 export * from './i18n';