@flowgram.ai/test-run-plugin 0.1.0-alpha.20

package/dist/index.d.ts

@@ -0,0 +1,314 @@
+import * as _flowgram_ai_core from '@flowgram.ai/core';
+import { FlowNodeType, FlowNodeEntity } from '@flowgram.ai/document';
+import * as React$1 from 'react';
+import React__default, { ReactNode } from 'react';
+import { Validate, FieldState, ValidateTrigger, IForm } from '@flowgram.ai/form';
+import * as _flowgram_ai_utils from '@flowgram.ai/utils';
+import { Emitter, Disposable } from '@flowgram.ai/utils';
+import { StoreApi, StateCreator } from 'zustand';
+import { interfaces } from 'inversify';
+import { OnFormValuesChangePayload } from '@flowgram.ai/form-core';
+import { ReactiveState } from '@flowgram.ai/reactive';
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/** field type */
+type FormSchemaType = 'string' | 'number' | 'boolean' | 'object' | string;
+type FormSchemaValidate = Validate;
+interface FormSchema {
+    /** core */
+    name?: string;
+    type?: FormSchemaType;
+    defaultValue?: any;
+    /** children */
+    properties?: Record<string, FormSchema>;
+    /** ui */
+    title?: string | React__default.ReactNode;
+    description?: string | React__default.ReactNode;
+    ['x-index']?: number;
+    ['x-visible']?: boolean;
+    ['x-hidden']?: boolean;
+    ['x-component']?: string;
+    ['x-component-props']?: Record<string, unknown>;
+    ['x-decorator']?: string;
+    ['x-decorator-props']?: Record<string, unknown>;
+    /** rule */
+    required?: boolean;
+    ['x-validator']?: FormSchemaValidate;
+    /** custom */
+    [key: string]: any;
+}
+type FormComponentProps = {
+    type?: FormSchemaType;
+    disabled?: boolean;
+    [key: string]: any;
+} & FormSchema['x-component-props'] & FormSchema['x-decorator-props'] & Partial<FieldState>;
+type FormComponent = React__default.FunctionComponent<any>;
+type FormComponents = Record<string, FormComponent>;
+/** ui state */
+interface FormSchemaModelState {
+    disabled: boolean;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+declare class FormSchemaModel implements FormSchema {
+    name?: string;
+    type?: FormSchemaType;
+    defaultValue?: any;
+    properties?: Record<string, FormSchema>;
+    ['x-index']?: number;
+    ['x-component']?: string;
+    ['x-component-props']?: Record<string, unknown>;
+    ['x-decorator']?: string;
+    ['x-decorator-props']?: Record<string, unknown>;
+    [key: string]: any;
+    path: string[];
+    state: ReactiveState<FormSchemaModelState>;
+    get componentType(): string | undefined;
+    get componentProps(): Record<string, unknown> | undefined;
+    get decoratorType(): string | undefined;
+    get decoratorProps(): Record<string, unknown> | undefined;
+    get uniqueName(): string;
+    constructor(json: FormSchema, path?: string[]);
+    private fromJSON;
+    getPropertyList(): FormSchemaModel[];
+}
+
+interface FormInstance {
+    model: FormSchemaModel;
+    form: IForm;
+}
+interface UseCreateFormOptions {
+    defaultValues?: any;
+    validate?: Record<string, FormSchemaValidate>;
+    validateTrigger?: ValidateTrigger;
+    onMounted?: (form: FormInstance) => void;
+    onFormValuesChange?: (payload: OnFormValuesChangePayload) => void;
+    onUnmounted?: () => void;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+type FormEngineProps = React.PropsWithChildren<{
+    /** Form schema */
+    schema: FormSchema;
+    /** form material map */
+    components?: FormComponents;
+} & UseCreateFormOptions>;
+declare const FormEngine: React.FC<FormEngineProps>;
+
+declare const connect: <T = any>(Component: React.FunctionComponent<any>, mapProps: (p: FormComponentProps) => T) => (props: FormComponentProps) => React$1.FunctionComponentElement<any>;
+
+type FormRenderProps = Omit<FormEngineProps, 'schema' | 'components' | 'onMounted' | 'onUnmounted'>;
+declare class TestRunFormEntity {
+    private readonly config;
+    private _schema;
+    private initialized;
+    id: string;
+    form: FormInstance | null;
+    onFormMountedEmitter: Emitter<FormInstance>;
+    onFormMounted: _flowgram_ai_utils.Event<FormInstance>;
+    onFormUnmountedEmitter: Emitter<void>;
+    onFormUnmounted: _flowgram_ai_utils.Event<void>;
+    get schema(): FormSchema;
+    init(options: {
+        schema: FormSchema;
+    }): void;
+    render(props?: FormRenderProps): ReactNode;
+    dispose(): void;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+declare class TestRunFormManager {
+    private readonly factory;
+    private entities;
+    createForm(): TestRunFormEntity;
+    getForm(id: string): TestRunFormEntity | undefined;
+    getAllForm(): [string, TestRunFormEntity][];
+    disposeForm(id: string): void;
+    disposeAllForm(): void;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+type MaybePromise<T> = T | Promise<T>;
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+interface TapValue<T> {
+    name: string;
+    fn: (arg: T) => MaybePromise<void>;
+}
+declare class Tap<T> {
+    private taps;
+    private frozen;
+    tap(name: string, fn: TapValue<T>['fn']): void;
+    call(ctx: T): Promise<void>;
+    freeze(): void;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+interface TestRunPipelinePlugin {
+    name: string;
+    apply(pipeline: TestRunPipelineEntity): void;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * 包含 Store 的 Service
+ */
+declare class StoreService<State> {
+    store: StoreApi<State>;
+    get getState(): () => State;
+    get setState(): {
+        (partial: State | Partial<State> | ((state: State) => State | Partial<State>), replace?: false): void;
+        (state: State | ((state: State) => State), replace: true): void;
+    };
+    constructor(stateCreator: StateCreator<State>);
+}
+
+interface TestRunPipelineEntityOptions {
+    plugins: (new () => TestRunPipelinePlugin)[];
+}
+interface TestRunPipelineEntityState<T = any> {
+    status: 'idle' | 'preparing' | 'executing' | 'canceled' | 'finished';
+    data?: T;
+    result?: any;
+    getData: () => T;
+    setData: (next: any) => void;
+}
+interface TestRunPipelineEntityCtx<T = any> {
+    id: string;
+    store: StoreApi<TestRunPipelineEntityState<T>>;
+    operate: {
+        update: (data: any) => void;
+        cancel: () => void;
+    };
+}
+declare class TestRunPipelineEntity extends StoreService<TestRunPipelineEntityState> {
+    container: interfaces.Container | undefined;
+    id: string;
+    prepare: Tap<TestRunPipelineEntityCtx<any>>;
+    private execute?;
+    private progress?;
+    get status(): TestRunPipelineEntityState["status"];
+    set status(next: TestRunPipelineEntityState['status']);
+    onProgressEmitter: Emitter<any>;
+    onProgress: _flowgram_ai_utils.Event<any>;
+    onFinishedEmitter: Emitter<any>;
+    onFinished: _flowgram_ai_utils.Event<any>;
+    constructor();
+    init(options: TestRunPipelineEntityOptions): void;
+    registerExecute(fn: (ctx: TestRunPipelineEntityCtx) => Promise<void> | void): void;
+    registerProgress(fn: (ctx: TestRunPipelineEntityCtx) => Promise<void> | void): void;
+    start<T>(options?: {
+        data: T;
+    }): Promise<void>;
+    update(result: any): void;
+    cancel(): void;
+    dispose(): void;
+}
+
+declare class TestRunService {
+    private readonly config;
+    private readonly pipelineFactory;
+    readonly formManager: TestRunFormManager;
+    pipelineEntities: Map<string, TestRunPipelineEntity>;
+    pipelineBindings: Map<string, Disposable>;
+    onPipelineProgressEmitter: Emitter<any>;
+    onPipelineProgress: _flowgram_ai_utils.Event<any>;
+    onPipelineFinishedEmitter: Emitter<any>;
+    onPipelineFinished: _flowgram_ai_utils.Event<any>;
+    isEnabled(nodeType: FlowNodeType): boolean;
+    toSchema(node: FlowNodeEntity): Promise<{
+        type?: undefined;
+        properties?: undefined;
+    } | {
+        type: string;
+        properties: Record<string, FormSchema> | undefined;
+    }>;
+    createFormWithSchema(schema: FormSchema): TestRunFormEntity;
+    createForm(node: FlowNodeEntity): Promise<TestRunFormEntity>;
+    createPipeline(options: TestRunPipelineEntityOptions): TestRunPipelineEntity;
+    connectPipeline(pipeline: TestRunPipelineEntity): void;
+    disconnectPipeline(id: string): void;
+    disconnectAllPipeline(): void;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+type PropertiesFunctionParams = {
+    node: FlowNodeEntity;
+};
+type NodeMap = Record<FlowNodeType, NodeTestConfig>;
+interface NodeTestConfig {
+    /** Enable node TestRun */
+    enabled?: boolean;
+    /** Input schema properties */
+    properties?: Record<string, FormSchema> | ((params: PropertiesFunctionParams) => MaybePromise<Record<string, FormSchema>>);
+}
+interface TestRunConfig {
+    components: FormComponents;
+    nodes: NodeMap;
+    plugins: (new () => TestRunPipelinePlugin)[];
+}
+declare const TestRunConfig: unique symbol;
+
+declare const createTestRunPlugin: _flowgram_ai_core.PluginCreator<Partial<TestRunConfig>>;
+
+interface UseFormOptions {
+    node?: FlowNodeEntity;
+    /** form loading */
+    loadingRenderer?: React.ReactNode;
+    /** form empty */
+    emptyRenderer?: React.ReactNode;
+    defaultValues?: FormEngineProps['defaultValues'];
+    onMounted?: FormEngineProps['onMounted'];
+    onUnmounted?: FormEngineProps['onUnmounted'];
+    onFormValuesChange?: FormEngineProps['onFormValuesChange'];
+}
+declare const useCreateForm: ({ node, loadingRenderer, emptyRenderer, defaultValues, onMounted, onUnmounted, onFormValuesChange, }: UseFormOptions) => {
+    renderer: React$1.ReactNode;
+    loading: boolean;
+    form: TestRunFormEntity | null;
+};
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+declare const useTestRunService: () => TestRunService;
+
+export { type FormComponentProps, FormEngine, type FormEngineProps, type FormInstance, type FormSchema, TestRunPipelineEntity, type TestRunPipelineEntityCtx, type TestRunPipelinePlugin, connect, createTestRunPlugin, useCreateForm, useTestRunService };