@nocobase/client-v2 2.1.0-alpha.22 → 2.1.0-alpha.24

package/es/Application.d.ts

@@ -6,119 +6,41 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import { FlowEngine, FlowEngineContext, FlowModel } from '@nocobase/flow-engine';
 import { APIClient, type APIClientOptions } from '@nocobase/sdk';
 import { type i18n as i18next } from 'i18next';
-import React, { ComponentType, ReactElement, ReactNode } from 'react';
-import type { Plugin } from './Plugin';
-import { PluginManager, type PluginType } from './PluginManager';
-import { type PluginSettingOptions, PluginSettingsManager } from './PluginSettingsManager';
-import { type ComponentTypeAndString, RouterManager, type RouterOptions } from './RouterManager';
-import { WebSocketClient, type WebSocketClientOptions } from './WebSocketClient';
-import type { RequireJS } from './utils/requirejs';
-declare global {
-    interface Window {
-        define: RequireJS['define'];
-    }
-}
-export type DevDynamicImport = (packageName: string) => Promise<{
-    default: typeof Plugin;
-}>;
-export type ComponentAndProps<T = any> = [ComponentType, T];
-export interface ApplicationOptions {
-    name?: string;
-    publicPath?: string;
+import { BaseApplication, type BaseApplicationOptions } from './BaseApplication';
+import type { PluginType } from './PluginManager';
+import { PluginManager } from './PluginManager';
+import { PluginSettingsManager } from './PluginSettingsManager';
+import type { RouterOptions } from './RouterManager';
+import { RouterManager } from './RouterManager';
+import type { WebSocketClientOptions } from './WebSocketClient';
+export type { DevDynamicImport, ComponentAndProps } from './BaseApplication';
+export { ApplicationModel } from './BaseApplication';
+export interface ApplicationOptions extends BaseApplicationOptions<PluginType> {
     apiClient?: APIClientOptions;
     ws?: WebSocketClientOptions | boolean;
     i18n?: i18next;
-    providers?: (ComponentType | ComponentAndProps)[];
     plugins?: PluginType[];
-    components?: Record<string, ComponentType>;
-    scopes?: Record<string, any>;
+    components?: BaseApplicationOptions<PluginType>['components'];
     router?: RouterOptions;
-    pluginSettings?: Record<string, PluginSettingOptions>;
-    designable?: boolean;
-    loadRemotePlugins?: boolean;
-    devDynamicImport?: DevDynamicImport;
-    disableAcl?: boolean;
 }
-export declare class Application {
-    protected options: ApplicationOptions;
-    eventBus: EventTarget;
-    providers: ComponentAndProps[];
-    router: RouterManager;
-    scopes: Record<string, any>;
-    i18n: i18next;
-    ws: WebSocketClient;
-    apiClient: APIClient;
-    components: Record<string, ComponentType<any> | any>;
-    pluginManager: PluginManager;
-    pluginSettingsManager: PluginSettingsManager;
-    devDynamicImport: DevDynamicImport;
-    requirejs: RequireJS;
-    name: string;
-    favicon: string;
-    flowEngine: FlowEngine;
-    context: FlowEngineContext & {
-        pluginSettingsRouter: PluginSettingsManager;
-        pluginManager: PluginManager;
-    };
-    maintained: boolean;
-    maintaining: boolean;
-    error: any;
-    model: ApplicationModel;
-    private wsAuthorized;
-    apps: {
-        Component?: ComponentType;
-    };
-    get pm(): PluginManager;
-    get disableAcl(): boolean;
-    get isWsAuthorized(): boolean;
-    updateFavicon(favicon?: string): void;
-    setWsAuthorized(authorized: boolean): void;
-    constructor(options?: ApplicationOptions);
-    private initListeners;
-    protected setTokenInWebSocket(options: {
-        token: string;
-        authenticator: string;
-    }): void;
-    setMaintaining(maintaining: boolean): void;
-    private initRequireJs;
-    private addDefaultProviders;
-    private addReactRouterComponents;
-    private addRoutes;
-    getOptions(): ApplicationOptions;
-    getName(): string;
-    getPublicPath(): string;
-    getApiUrl(pathname?: string): string;
-    getRouteUrl(pathname: string): string;
-    getHref(pathname: string): string;
-    /**
-     * @internal
-     */
-    getComposeProviders(): React.FC;
-    use<T = any>(component: ComponentType, props?: T): number;
-    addProvider<T = any>(component: ComponentType, props?: T): number;
-    addProviders(providers: (ComponentType | [ComponentType, any])[]): void;
+export declare class Application extends BaseApplication<ApplicationOptions, PluginManager, RouterManager, APIClient, PluginSettingsManager> {
+    dataSourceManager: any;
+    protected createApiClient(options: ApplicationOptions): APIClient;
+    protected configureRuntimeAdapters(): void;
+    protected createI18n(options: ApplicationOptions): i18next;
+    protected createRouterManager(options: ApplicationOptions): RouterManager<this>;
+    protected createPluginManager(options: ApplicationOptions): PluginManager;
+    protected createPluginSettingsManager(_options: ApplicationOptions): PluginSettingsManager;
     load(): Promise<void>;
     loadWebSocket(): Promise<void>;
-    getComponent<T = any>(Component: ComponentTypeAndString<T>, isShowError?: boolean): ComponentType<T> | undefined;
-    renderComponent<T extends {}>(Component: ComponentTypeAndString, props?: T, children?: ReactNode): ReactElement;
-    private addComponent;
-    addComponents(components: Record<string, ComponentType>): void;
-    getRootComponent(): React.FC<{
-        children?: React.ReactNode;
-    }>;
-    mount(containerOrSelector: Element | ShadowRoot | string): import("react-dom/client").Root;
-}
-declare class ApplicationModel extends FlowModel {
-    #private;
-    get app(): Application;
-    getProviders(): React.FunctionComponent<{}>;
-    getRouter(): any;
-    render(): React.JSX.Element;
-    renderMaintaining(): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
-    renderError(): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
-    renderContent(): React.JSX.Element;
+    protected addCustomProviders(): void;
+    addFieldInterfaces(fieldInterfaceClasses?: any[]): any;
+    addFieldInterfaceGroups(groups: Record<string, {
+        label: string;
+        order?: number;
+    }>): any;
+    addFieldInterfaceComponentOption(fieldName: string, componentOption: any): any;
+    addFieldInterfaceOperator(name: string, operatorOption: any): any;
 }
-export {};

package/es/BaseApplication.d.ts

@@ -0,0 +1,176 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { FlowEngine, FlowEngineContext, FlowModel } from '@nocobase/flow-engine';
+import { APIClient } from '@nocobase/sdk';
+import type { i18n as i18next } from 'i18next';
+import React, { ReactElement, ReactNode } from 'react';
+import { AIManager } from './ai';
+import { SystemSettingsSource } from './flow/system-settings';
+import type { PluginClass, PluginManager, PluginType } from './PluginManager';
+import { RouteRepository } from './RouteRepository';
+import type { ComponentTypeAndString, RenderableComponentType, RouterComponentType, RouterManager, RouterOptions } from './RouterManager';
+import { WebSocketClient, type WebSocketClientOptions } from './WebSocketClient';
+import type { RequireJS } from './utils/requirejs';
+declare global {
+    interface Window {
+        requirejs?: RequireJS;
+        define: RequireJS['define'];
+    }
+}
+type AnyComponent = RenderableComponentType<any>;
+type AuthTokenPayload = {
+    token: string;
+    authenticator: string | null;
+};
+export type DevDynamicImport = (packageName: string) => Promise<{
+    default: PluginClass;
+}>;
+export type ComponentAndProps<T = any> = [AnyComponent, T];
+export interface BaseApplicationOptions<TPluginType> {
+    name?: string;
+    publicPath?: string;
+    apiClient?: any;
+    ws?: WebSocketClientOptions | boolean;
+    i18n?: i18next;
+    providers?: (AnyComponent | ComponentAndProps)[];
+    plugins?: TPluginType[];
+    components?: Record<string, AnyComponent>;
+    scopes?: Record<string, any>;
+    router?: RouterOptions;
+    designable?: boolean;
+    loadRemotePlugins?: boolean;
+    devDynamicImport?: DevDynamicImport;
+    disableAcl?: boolean;
+}
+/**
+ * 共享的应用运行时基类。
+ *
+ * 该类只负责承接 client 与 client-v2 共用的 Application 骨架，
+ * 具体产品行为通过子类钩子补齐。
+ */
+export declare abstract class BaseApplication<TOptions extends BaseApplicationOptions<any> = BaseApplicationOptions<PluginType>, TPluginManager extends PluginManager<any> = PluginManager<any>, TRouterManager extends RouterManager<any> = RouterManager<any>, TApiClient extends APIClient = APIClient, TPluginSettingsManager = any> {
+    protected options: TOptions;
+    eventBus: EventTarget;
+    providers: ComponentAndProps[];
+    router: TRouterManager;
+    scopes: Record<string, any>;
+    i18n: i18next;
+    ws: WebSocketClient;
+    apiClient: TApiClient;
+    components: Record<string, AnyComponent>;
+    pluginManager: TPluginManager;
+    pluginSettingsManager: TPluginSettingsManager;
+    aiManager: AIManager;
+    devDynamicImport?: DevDynamicImport;
+    requirejs: RequireJS;
+    name: string;
+    favicon: string;
+    flowEngine: FlowEngine;
+    dataSourceManager: any;
+    context: FlowEngineContext & {
+        routeRepository: RouteRepository;
+        appInfo: Promise<Record<string, any>>;
+        pageInfo: {
+            version?: 'v1' | 'v2';
+        };
+        systemSettings: SystemSettingsSource;
+        acl?: {
+            data: Record<string, any>;
+            meta: Record<string, any>;
+            setData: (data: Record<string, any>) => void;
+            setMeta: (meta: Record<string, any>) => void;
+        };
+        pluginManager: TPluginManager;
+    };
+    systemSettings: SystemSettingsSource;
+    maintained: boolean;
+    maintaining: boolean;
+    error: any;
+    model: ApplicationModel;
+    private wsAuthorized;
+    apps: {
+        Component?: AnyComponent | null;
+    };
+    get pm(): TPluginManager;
+    get disableAcl(): boolean;
+    get isWsAuthorized(): boolean;
+    constructor(options?: TOptions);
+    /**
+     * 注册共享 observable 状态。
+     */
+    protected defineObservableState(): void;
+    protected initializeExtendedState(): void;
+    protected afterManagersInitialized(): void;
+    protected configureContext(): void;
+    protected configureRuntimeAdapters(): void;
+    protected addCustomProviders(): void;
+    protected initListeners(): void;
+    protected setTokenInWebSocket(options: AuthTokenPayload): void;
+    protected initRequireJs(): void;
+    /**
+     * 注入两边共享的基础 context。
+     */
+    protected configureBaseContext(): void;
+    /**
+     * 注册两边共享的默认 providers。
+     */
+    protected addBaseProviders(): void;
+    addReactRouterComponents(): void;
+    addRoutes(): void;
+    updateFavicon(favicon?: string): void;
+    setWsAuthorized(authorized: boolean): void;
+    setMaintaining(maintaining: boolean): void;
+    getOptions(): TOptions;
+    getName(): string;
+    getPublicPath(): string;
+    getApiUrl(pathname?: string): string;
+    getRouteUrl(pathname: string): string;
+    getHref(pathname: string): string;
+    getComposeProviders(): React.FC;
+    use<T = any>(component: AnyComponent, props?: T): number;
+    addProvider<T = any>(component: AnyComponent, props?: T): number;
+    addProviders(providers: (AnyComponent | ComponentAndProps)[]): void;
+    getComponent<T = any>(Component: ComponentTypeAndString<T>, isShowError?: boolean): AnyComponent | undefined;
+    renderComponent<T extends {}>(Component: ComponentTypeAndString, props?: T, children?: ReactNode): ReactElement | null;
+    /**
+     * @internal
+     */
+    protected addComponent(component: AnyComponent, name?: string): void;
+    addComponents(components: Record<string, AnyComponent>): void;
+    protected getRootFallback(): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+    getRootComponent(): React.FC<{
+        children?: React.ReactNode;
+    }>;
+    mount(containerOrSelector: Element | ShadowRoot | string): import("react-dom/client").Root;
+    protected abstract createApiClient(options: TOptions): TApiClient;
+    protected abstract createI18n(options: TOptions): i18next;
+    protected abstract createRouterManager(options: TOptions): TRouterManager;
+    protected abstract createPluginManager(options: TOptions): TPluginManager;
+    protected abstract createPluginSettingsManager(options: TOptions): TPluginSettingsManager;
+    protected createWebSocketClient(options: TOptions): WebSocketClient;
+    protected getDefaultComponents(): Record<string, AnyComponent>;
+    abstract load(): Promise<void>;
+    abstract loadWebSocket(): Promise<void>;
+}
+/**
+ * Application 共享根模型。
+ *
+ * 该模型统一承接 app.load、错误态、维护态和主内容渲染。
+ */
+export declare class ApplicationModel extends FlowModel {
+    #private;
+    get app(): BaseApplication<BaseApplicationOptions<PluginType>, PluginManager<any>, RouterManager<any>, APIClient, any>;
+    getProviders(): AnyComponent;
+    getRouter(): RouterComponentType;
+    render(): React.JSX.Element;
+    renderMaintaining(): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+    renderError(): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+    renderContent(): React.JSX.Element;
+}
+export {};

package/es/PinnedPluginListContext.d.ts

@@ -0,0 +1,22 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+/// <reference types="react" />
+import type { ComponentTypeAndString } from './RouterManager';
+export type PinnedPluginListItem = {
+    component: ComponentTypeAndString;
+    order?: number;
+    pin?: boolean;
+    snippet?: string;
+};
+export type PinnedPluginListItems = Record<string, PinnedPluginListItem>;
+export type PinnedPluginListContextValue = {
+    items: PinnedPluginListItems;
+};
+export declare const getPinnedPluginListKeys: (items?: PinnedPluginListItems) => string[];
+export declare const PinnedPluginListContext: import("react").Context<PinnedPluginListContextValue>;

package/es/Plugin.d.ts

@@ -7,25 +7,51 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import type { TFuncKey, TOptions } from 'i18next';
-import type { Application } from './Application';
-export declare class Plugin<T = any> {
+import type { BaseApplication } from './BaseApplication';
+import { Application } from './Application';
+/**
+ * 插件配置选项。
+ *
+ * 作为 Plugin 类的泛型参数，描述插件注册时可接收的配置项。
+ *
+ * @template T 插件自定义配置类型
+ */
+export interface PluginOptions<T = any> {
+    name?: string;
+    packageName?: string;
+    options?: any;
+    config?: T;
+    [key: string]: any;
+}
+export declare class Plugin<T extends PluginOptions<any> = PluginOptions, TApp extends BaseApplication<any> = Application> {
     options: T;
-    protected app: Application;
-    constructor(options: T, app: Application);
-    get pluginManager(): import("./PluginManager").PluginManager;
+    protected app: TApp;
+    constructor(options: T, app: TApp);
+    get pluginManager(): import("./PluginManager").PluginManager<any>;
     get context(): import("@nocobase/flow-engine").FlowEngineContext & {
-        pluginSettingsRouter: import("./PluginSettingsManager").PluginSettingsManager;
-        pluginManager: import("./PluginManager").PluginManager;
+        routeRepository: import("./RouteRepository").RouteRepository;
+        appInfo: Promise<Record<string, any>>;
+        pageInfo: {
+            version?: "v1" | "v2";
+        };
+        systemSettings: import("./flow").SystemSettingsSource;
+        acl?: {
+            data: Record<string, any>;
+            meta: Record<string, any>;
+            setData: (data: Record<string, any>) => void;
+            setMeta: (meta: Record<string, any>) => void;
+        };
+        pluginManager: import("./PluginManager").PluginManager<any>;
     };
     get flowEngine(): import("@nocobase/flow-engine").FlowEngine;
     get engine(): import("@nocobase/flow-engine").FlowEngine;
-    get pm(): import("./PluginManager").PluginManager;
-    get router(): import("./RouterManager").RouterManager;
-    get pluginSettingsManager(): import("./PluginSettingsManager").PluginSettingsManager;
-    get pluginSettingsRouter(): import("./PluginSettingsManager").PluginSettingsManager;
+    get pm(): import("./PluginManager").PluginManager<any>;
+    get router(): import("./RouterManager").RouterManager<any>;
+    get pluginSettingsManager(): any;
     get schemaInitializerManager(): any;
     get schemaSettingsManager(): any;
     get dataSourceManager(): any;
+    get ai(): import("./ai").AIManager;
     afterAdd(): Promise<void>;
     beforeLoad(): Promise<void>;
     load(): Promise<void>;

package/es/PluginManager.d.ts

@@ -6,14 +6,12 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import type { Application } from './Application';
-import type { Plugin } from './Plugin';
-export type PluginOptions<T = any> = {
-    name?: string;
-    packageName?: string;
-    config?: T;
-};
-export type PluginType<Opts = any> = typeof Plugin | [typeof Plugin<Opts>, PluginOptions<Opts>];
+import type { BaseApplication } from './BaseApplication';
+import type { Plugin, PluginOptions } from './Plugin';
+export type PluginClass<Opts = any, TApp extends BaseApplication<any> = BaseApplication<any>> = new (options: PluginOptions<Opts>, app: TApp) => Plugin<PluginOptions<Opts>, TApp>;
+export type PluginType<Opts = any, TApp extends BaseApplication<any> = BaseApplication<any>> = PluginClass<Opts, TApp> | [PluginClass<Opts, TApp>, PluginOptions<Opts>];
+export type PluginClassLike<TApp extends BaseApplication<any> = BaseApplication<any>> = PluginClass<any, TApp>;
+export type PluginTypeLike<TApp extends BaseApplication<any> = BaseApplication<any>> = PluginType<any, TApp>;
 export type PluginData = {
     name: string;
     packageName: string;
@@ -21,24 +19,25 @@ export type PluginData = {
     url: string;
     type: 'local' | 'upload' | 'npm';
 };
-export declare class PluginManager {
-    protected _plugins: PluginType[];
-    protected loadRemotePlugins: boolean;
-    protected app: Application;
-    protected pluginInstances: Map<typeof Plugin, Plugin>;
-    protected pluginsAliases: Record<string, Plugin>;
+export declare class PluginManager<TApp extends BaseApplication<any> = BaseApplication<any>> {
+    protected _plugins: PluginType<any, TApp>[] | undefined;
+    protected loadRemotePlugins: boolean | undefined;
+    protected app: TApp;
+    protected pluginInstances: Map<PluginClass<any, TApp>, Plugin<any, TApp>>;
+    protected pluginsAliases: Record<string, Plugin<any, TApp>>;
     private initPlugins;
-    constructor(_plugins: PluginType[], loadRemotePlugins: boolean, app: Application);
+    constructor(_plugins: PluginType<any, TApp>[] | undefined, loadRemotePlugins: boolean | undefined, app: TApp);
     /**
      * @internal
      */
-    init(_plugins: PluginType[]): Promise<void>;
+    init(_plugins: PluginType<any, TApp>[]): Promise<void>;
+    protected getRemotePluginsRequestUrl(): string;
     private initStaticPlugins;
-    private initRemotePlugins;
-    add<T = any>(plugin: typeof Plugin, opts?: PluginOptions<T>): Promise<void>;
-    get<T extends typeof Plugin>(PluginClass: T): InstanceType<T>;
+    protected initRemotePlugins(): Promise<void>;
+    add<T = any>(plugin: PluginClass<T, TApp>, opts?: PluginOptions<T>): Promise<void>;
+    get<T extends PluginClass<any, TApp>>(PluginClass: T): InstanceType<T>;
     get<T extends {}>(name: string): T;
-    private getInstance;
+    protected getInstance<T>(plugin: PluginClass<T, TApp>, opts?: PluginOptions<T>): Plugin<PluginOptions<T>, TApp>;
     /**
      * @internal
      */