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

package/dist/index.js

@@ -0,0 +1,770 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FormEngine: () => FormEngine,
+  TestRunPipelineEntity: () => TestRunPipelineEntity,
+  connect: () => connect,
+  createTestRunPlugin: () => createTestRunPlugin,
+  useCreateForm: () => useCreateForm2,
+  useTestRunService: () => useTestRunService
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/create-test-run-plugin.ts
+var import_core = require("@flowgram.ai/core");
+
+// src/services/form/form.ts
+var import_react10 = require("react");
+var import_nanoid = require("nanoid");
+var import_inversify = require("inversify");
+var import_utils4 = require("@flowgram.ai/utils");
+
+// src/services/config.ts
+var TestRunConfig = Symbol("TestRunConfig");
+var defineConfig = (config) => {
+  const defaultConfig = {
+    components: {},
+    nodes: {},
+    plugins: []
+  };
+  return {
+    ...defaultConfig,
+    ...config
+  };
+};
+
+// src/form-engine/form/form.tsx
+var import_form3 = require("@flowgram.ai/form");
+
+// src/form-engine/hooks/use-create-form.ts
+var import_react2 = require("react");
+var import_form = require("@flowgram.ai/form");
+
+// src/form-engine/utils.ts
+var import_react = require("react");
+var getUniqueFieldName = (...args) => args.filter((path) => path).join(".");
+var mergeFieldPath = (path, name) => [...path || [], name].filter((i) => Boolean(i));
+var createValidate = (schema) => {
+  const rules = {};
+  visit(schema);
+  return rules;
+  function visit(current, name) {
+    if (name && current["x-validator"]) {
+      rules[name] = current["x-validator"];
+    }
+    if (current.type === "object" && current.properties) {
+      Object.entries(current.properties).forEach(([key, value]) => {
+        visit(value, getUniqueFieldName(name, key));
+      });
+    }
+  }
+};
+var connect = (Component, mapProps) => {
+  const Connected = (props) => {
+    const mappedProps = mapProps(props);
+    return (0, import_react.createElement)(Component, mappedProps, mappedProps.children);
+  };
+  return Connected;
+};
+var isFormEmpty = (schema) => {
+  const isEmpty = (s) => {
+    if (!s.type || s.type === "object" || !s.name) {
+      return Object.entries(schema.properties || {}).map(([key, value]) => ({
+        name: key,
+        ...value
+      })).every(isFormEmpty);
+    }
+    return false;
+  };
+  return isEmpty(schema);
+};
+
+// src/form-engine/model/index.ts
+var import_reactive = require("@flowgram.ai/reactive");
+var FormSchemaModel = class _FormSchemaModel {
+  constructor(json, path = []) {
+    this.path = [];
+    this.state = new import_reactive.ReactiveState({ disabled: false });
+    this.fromJSON(json);
+    this.path = path;
+  }
+  get componentType() {
+    return this["x-component"];
+  }
+  get componentProps() {
+    return this["x-component-props"];
+  }
+  get decoratorType() {
+    return this["x-decorator"];
+  }
+  get decoratorProps() {
+    return this["x-decorator-props"];
+  }
+  get uniqueName() {
+    return getUniqueFieldName(...this.path);
+  }
+  fromJSON(json) {
+    Object.entries(json).forEach(([key, value]) => {
+      this[key] = value;
+    });
+  }
+  getPropertyList() {
+    const orderProperties = [];
+    const unOrderProperties = [];
+    Object.entries(this.properties || {}).forEach(([key, item]) => {
+      const index = item["x-index"];
+      const defaultValues = this.defaultValue;
+      if (typeof defaultValues === "object" && defaultValues !== null && key in defaultValues) {
+        item.defaultValue = defaultValues[key];
+      }
+      const current = new _FormSchemaModel(item, mergeFieldPath(this.path, key));
+      if (index !== void 0 && !isNaN(index)) {
+        orderProperties[index] = current;
+      } else {
+        unOrderProperties.push(current);
+      }
+    });
+    return orderProperties.concat(unOrderProperties).filter((item) => !!item);
+  }
+};
+
+// src/form-engine/hooks/use-create-form.ts
+var useCreateForm = (schema, options = {}) => {
+  const { form, control } = (0, import_react2.useMemo)(
+    () => (0, import_form.createForm)({
+      validate: {
+        ...createValidate(schema),
+        ...options.validate
+      },
+      validateTrigger: options.validateTrigger ?? import_form.ValidateTrigger.onBlur
+    }),
+    [schema]
+  );
+  const model = (0, import_react2.useMemo)(
+    () => new FormSchemaModel({ type: "object", ...schema, defaultValue: options.defaultValues }),
+    [schema]
+  );
+  (0, import_react2.useEffect)(() => {
+    if (options.onMounted) {
+      options.onMounted({ model, form });
+    }
+    const disposable = control._formModel.onFormValuesChange((payload) => {
+      if (options.onFormValuesChange) {
+        options.onFormValuesChange(payload);
+      }
+    });
+    return () => {
+      disposable.dispose();
+      if (options.onUnmounted) {
+        options.onUnmounted();
+      }
+    };
+  }, [control]);
+  return {
+    form,
+    control,
+    model
+  };
+};
+
+// src/form-engine/hooks/use-field.ts
+var import_react4 = require("react");
+var import_reactive2 = require("@flowgram.ai/reactive");
+
+// src/form-engine/contexts.ts
+var import_react3 = require("react");
+var FieldModelContext = (0, import_react3.createContext)({});
+var FormModelContext = (0, import_react3.createContext)({});
+var ComponentsContext = (0, import_react3.createContext)({});
+
+// src/form-engine/hooks/use-field.ts
+var useFieldModel = () => (0, import_react4.useContext)(FieldModelContext);
+var useFieldState = () => (0, import_reactive2.useObserve)(useFieldModel().state.value);
+
+// src/form-engine/hooks/use-form.ts
+var import_react5 = require("react");
+var import_reactive3 = require("@flowgram.ai/reactive");
+var useFormModel = () => (0, import_react5.useContext)(FormModelContext);
+var useFormState = () => (0, import_reactive3.useObserve)(useFormModel().state.value);
+
+// src/form-engine/fields/schema-field.tsx
+var import_react9 = require("react");
+
+// src/form-engine/fields/recursion-field.tsx
+var import_react8 = require("react");
+
+// src/form-engine/fields/reactive-field.tsx
+var import_react6 = require("react");
+var import_react7 = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var ReactiveField = (props) => {
+  const formState = useFormState();
+  const model = useFieldModel();
+  const modelState = useFieldState();
+  const components = (0, import_react6.useContext)(ComponentsContext);
+  const disabled = modelState.disabled || formState.disabled;
+  const componentRender = () => {
+    if (!model.componentType || !components[model.componentType]) {
+      return props.children;
+    }
+    return import_react7.default.createElement(
+      components[model.componentType],
+      {
+        disabled,
+        ...model.componentProps,
+        ...props.componentProps
+      },
+      props.children
+    );
+  };
+  const decoratorRender = (children) => {
+    if (!model.decoratorType || !components[model.decoratorType]) {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
+    }
+    return import_react7.default.createElement(
+      components[model.decoratorType],
+      {
+        type: model.type,
+        required: model.required,
+        ...model.decoratorProps,
+        ...props.decoratorProps
+      },
+      children
+    );
+  };
+  return decoratorRender(componentRender());
+};
+
+// src/form-engine/fields/object-field.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var ObjectField = ({
+  model,
+  children
+}) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(FieldModelContext.Provider, { value: model, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ReactiveField, { children }) });
+
+// src/form-engine/fields/general-field.tsx
+var import_form2 = require("@flowgram.ai/form");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var GeneralField = ({ model }) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(FieldModelContext.Provider, { value: model, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+  import_form2.Field,
+  {
+    name: model.uniqueName,
+    defaultValue: model.defaultValue,
+    render: ({ field, fieldState }) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      ReactiveField,
+      {
+        componentProps: {
+          value: field.value,
+          onChange: field.onChange,
+          onFocus: field.onFocus,
+          onBlur: field.onBlur,
+          ...fieldState
+        },
+        decoratorProps: fieldState
+      }
+    )
+  }
+) });
+
+// src/form-engine/fields/recursion-field.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var RecursionField = ({ model }) => {
+  const properties = (0, import_react8.useMemo)(() => model.getPropertyList(), [model]);
+  if (model.type !== "object") {
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(GeneralField, { model });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ObjectField, { model, children: properties.map((item) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(RecursionField, { model: item }, item.uniqueName)) });
+};
+
+// src/form-engine/fields/schema-field.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var SchemaField = ({
+  components,
+  model,
+  children
+}) => {
+  const [innerComponents] = (0, import_react9.useState)(() => components);
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ComponentsContext.Provider, { value: innerComponents, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(FormModelContext.Provider, { value: model, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(RecursionField, { model }),
+    children
+  ] }) });
+};
+
+// src/form-engine/fields/create-field.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var createSchemaField = (options) => {
+  const InnerSchemaField = ({
+    components,
+    ...props
+  }) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+    SchemaField,
+    {
+      components: {
+        ...options.components,
+        ...components
+      },
+      ...props
+    }
+  );
+  return InnerSchemaField;
+};
+
+// src/form-engine/form/form.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var SchemaField2 = createSchemaField({});
+var FormEngine = ({
+  schema,
+  components,
+  children,
+  ...props
+}) => {
+  const { model, control } = useCreateForm(schema, props);
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_form3.Form, { control, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(SchemaField2, { model, components, children }) });
+};
+
+// src/services/form/form.ts
+var TestRunFormEntity = class {
+  constructor() {
+    this.initialized = false;
+    this.id = (0, import_nanoid.nanoid)();
+    this.form = null;
+    this.onFormMountedEmitter = new import_utils4.Emitter();
+    this.onFormMounted = this.onFormMountedEmitter.event;
+    this.onFormUnmountedEmitter = new import_utils4.Emitter();
+    this.onFormUnmounted = this.onFormUnmountedEmitter.event;
+  }
+  get schema() {
+    return this._schema;
+  }
+  init(options) {
+    if (this.initialized) return;
+    this._schema = options.schema;
+    this.initialized = true;
+  }
+  render(props) {
+    if (!this.initialized) {
+      return null;
+    }
+    const { children, ...restProps } = props || {};
+    return (0, import_react10.createElement)(
+      FormEngine,
+      {
+        schema: this.schema,
+        components: this.config.components,
+        onMounted: (instance) => {
+          this.form = instance;
+          this.onFormMountedEmitter.fire(instance);
+        },
+        onUnmounted: this.onFormUnmountedEmitter.fire.bind(this.onFormUnmountedEmitter),
+        ...restProps
+      },
+      children
+    );
+  }
+  dispose() {
+    this._schema = {};
+    this.form = null;
+    this.onFormMountedEmitter.dispose();
+    this.onFormUnmountedEmitter.dispose();
+  }
+};
+__decorateClass([
+  (0, import_inversify.inject)(TestRunConfig)
+], TestRunFormEntity.prototype, "config", 2);
+TestRunFormEntity = __decorateClass([
+  (0, import_inversify.injectable)()
+], TestRunFormEntity);
+
+// src/services/form/factory.ts
+var TestRunFormFactory = Symbol("TestRunFormFactory");
+
+// src/services/form/manager.ts
+var import_inversify2 = require("inversify");
+var TestRunFormManager = class {
+  constructor() {
+    this.entities = /* @__PURE__ */ new Map();
+  }
+  createForm() {
+    return this.factory();
+  }
+  getForm(id) {
+    return this.entities.get(id);
+  }
+  getAllForm() {
+    return Array.from(this.entities);
+  }
+  disposeForm(id) {
+    const form = this.entities.get(id);
+    if (!form) {
+      return;
+    }
+    form.dispose();
+    this.entities.delete(id);
+  }
+  disposeAllForm() {
+    for (const id of this.entities.keys()) {
+      this.disposeForm(id);
+    }
+  }
+};
+__decorateClass([
+  (0, import_inversify2.inject)(TestRunFormFactory)
+], TestRunFormManager.prototype, "factory", 2);
+TestRunFormManager = __decorateClass([
+  (0, import_inversify2.injectable)()
+], TestRunFormManager);
+
+// src/services/test-run.ts
+var import_inversify3 = require("inversify");
+var import_utils5 = require("@flowgram.ai/utils");
+
+// src/services/pipeline/factory.ts
+var TestRunPipelineFactory = Symbol("TestRunPipelineFactory");
+
+// src/services/test-run.ts
+var TestRunService = class {
+  constructor() {
+    this.pipelineEntities = /* @__PURE__ */ new Map();
+    this.pipelineBindings = /* @__PURE__ */ new Map();
+    this.onPipelineProgressEmitter = new import_utils5.Emitter();
+    this.onPipelineProgress = this.onPipelineProgressEmitter.event;
+    this.onPipelineFinishedEmitter = new import_utils5.Emitter();
+    this.onPipelineFinished = this.onPipelineFinishedEmitter.event;
+  }
+  isEnabled(nodeType) {
+    const config = this.config.nodes[nodeType];
+    return config && config?.enabled !== false;
+  }
+  async toSchema(node) {
+    const nodeType = node.flowNodeType;
+    const config = this.config.nodes[nodeType];
+    if (!this.isEnabled(nodeType)) {
+      return {};
+    }
+    const properties = typeof config.properties === "function" ? await config.properties({ node }) : config.properties;
+    return {
+      type: "object",
+      properties
+    };
+  }
+  createFormWithSchema(schema) {
+    const form = this.formManager.createForm();
+    form.init({ schema });
+    return form;
+  }
+  async createForm(node) {
+    const schema = await this.toSchema(node);
+    return this.createFormWithSchema(schema);
+  }
+  createPipeline(options) {
+    const pipeline = this.pipelineFactory();
+    this.pipelineEntities.set(pipeline.id, pipeline);
+    pipeline.init(options);
+    return pipeline;
+  }
+  connectPipeline(pipeline) {
+    if (this.pipelineBindings.get(pipeline.id)) {
+      return;
+    }
+    const disposable = new import_utils5.DisposableCollection(
+      pipeline.onProgress(this.onPipelineProgressEmitter.fire.bind(this.onPipelineProgressEmitter)),
+      pipeline.onFinished(this.onPipelineFinishedEmitter.fire.bind(this.onPipelineFinishedEmitter))
+    );
+    this.pipelineBindings.set(pipeline.id, disposable);
+  }
+  disconnectPipeline(id) {
+    if (this.pipelineBindings.has(id)) {
+      const disposable = this.pipelineBindings.get(id);
+      disposable?.dispose();
+      this.pipelineBindings.delete(id);
+    }
+  }
+  disconnectAllPipeline() {
+    for (const id of this.pipelineBindings.keys()) {
+      this.disconnectPipeline(id);
+    }
+  }
+};
+__decorateClass([
+  (0, import_inversify3.inject)(TestRunConfig)
+], TestRunService.prototype, "config", 2);
+__decorateClass([
+  (0, import_inversify3.inject)(TestRunPipelineFactory)
+], TestRunService.prototype, "pipelineFactory", 2);
+__decorateClass([
+  (0, import_inversify3.inject)(TestRunFormManager)
+], TestRunService.prototype, "formManager", 2);
+TestRunService = __decorateClass([
+  (0, import_inversify3.injectable)()
+], TestRunService);
+
+// src/services/pipeline/pipeline.ts
+var import_nanoid2 = require("nanoid");
+var import_inversify5 = require("inversify");
+var import_utils6 = require("@flowgram.ai/utils");
+
+// src/services/pipeline/tap.ts
+var Tap = class {
+  constructor() {
+    this.taps = [];
+    this.frozen = false;
+  }
+  tap(name, fn) {
+    this.taps.push({ name, fn });
+  }
+  async call(ctx) {
+    for (const tap of this.taps) {
+      if (this.frozen) {
+        return;
+      }
+      await tap.fn(ctx);
+    }
+  }
+  freeze() {
+    this.frozen = true;
+  }
+};
+
+// src/services/store.ts
+var import_vanilla = require("zustand/vanilla");
+var import_inversify4 = require("inversify");
+var StoreService = class {
+  get getState() {
+    return this.store.getState.bind(this.store);
+  }
+  get setState() {
+    return this.store.setState.bind(this.store);
+  }
+  constructor(stateCreator) {
+    this.store = (0, import_vanilla.createStore)(stateCreator);
+  }
+};
+StoreService = __decorateClass([
+  (0, import_inversify4.injectable)(),
+  __decorateParam(0, (0, import_inversify4.unmanaged)())
+], StoreService);
+
+// src/services/pipeline/pipeline.ts
+var initialState = {
+  status: "idle",
+  data: {}
+};
+var TestRunPipelineEntity = class extends StoreService {
+  constructor() {
+    super((set, get) => ({
+      ...initialState,
+      getData: () => get().data || {},
+      setData: (next) => set((state) => ({ ...state, data: { ...state.data, ...next } }))
+    }));
+    this.id = (0, import_nanoid2.nanoid)();
+    this.prepare = new Tap();
+    this.onProgressEmitter = new import_utils6.Emitter();
+    this.onProgress = this.onProgressEmitter.event;
+    this.onFinishedEmitter = new import_utils6.Emitter();
+    this.onFinished = this.onFinishedEmitter.event;
+  }
+  get status() {
+    return this.getState().status;
+  }
+  set status(next) {
+    this.setState({ status: next });
+  }
+  init(options) {
+    if (!this.container) {
+      return;
+    }
+    const { plugins } = options;
+    for (const PluginClass of plugins) {
+      const plugin = this.container.resolve(PluginClass);
+      plugin.apply(this);
+    }
+  }
+  registerExecute(fn) {
+    this.execute = fn;
+  }
+  registerProgress(fn) {
+    this.progress = fn;
+  }
+  async start(options) {
+    const { data } = options || {};
+    if (this.status !== "idle") {
+      return;
+    }
+    this.setState({ data });
+    const ctx = {
+      id: this.id,
+      store: this.store,
+      operate: {
+        update: this.update.bind(this),
+        cancel: this.cancel.bind(this)
+      }
+    };
+    this.status = "preparing";
+    await this.prepare.call(ctx);
+    if (this.status !== "preparing") {
+      return;
+    }
+    this.status = "executing";
+    if (this.execute) {
+      await this.execute(ctx);
+    }
+    if (this.progress) {
+      await this.progress(ctx);
+    }
+    if (this.status === "executing") {
+      this.status = "finished";
+      this.onFinishedEmitter.fire(this.getState().result);
+    }
+  }
+  update(result) {
+    this.setState({ result });
+    this.onProgressEmitter.fire(result);
+  }
+  cancel() {
+    if (this.status = "preparing") {
+      this.prepare.freeze();
+    }
+    this.status = "canceled";
+  }
+  dispose() {
+  }
+};
+TestRunPipelineEntity = __decorateClass([
+  (0, import_inversify5.injectable)()
+], TestRunPipelineEntity);
+
+// src/create-test-run-plugin.ts
+var createTestRunPlugin = (0, import_core.definePluginCreator)({
+  onBind: ({ bind }, opt) => {
+    bind(TestRunService).toSelf().inSingletonScope();
+    bind(TestRunConfig).toConstantValue(defineConfig(opt));
+    bind(TestRunFormManager).toSelf().inSingletonScope();
+    bind(TestRunFormFactory).toFactory((context) => () => {
+      const e = context.container.resolve(TestRunFormEntity);
+      return e;
+    });
+    bind(TestRunPipelineFactory).toFactory(
+      (context) => () => {
+        const e = context.container.resolve(TestRunPipelineEntity);
+        e.container = context.container.createChild();
+        return e;
+      }
+    );
+  }
+});
+
+// src/reactive/hooks/use-create-form.ts
+var import_react11 = require("react");
+var import_utils7 = require("@flowgram.ai/utils");
+
+// src/reactive/hooks/use-test-run-service.ts
+var import_core2 = require("@flowgram.ai/core");
+var useTestRunService = () => (0, import_core2.useService)(TestRunService);
+
+// src/reactive/hooks/use-create-form.ts
+var useCreateForm2 = ({
+  node,
+  loadingRenderer,
+  emptyRenderer,
+  defaultValues,
+  onMounted,
+  onUnmounted,
+  onFormValuesChange
+}) => {
+  const testRun = useTestRunService();
+  const [loading, setLoading] = (0, import_react11.useState)(false);
+  const [form, setForm] = (0, import_react11.useState)(null);
+  const renderer = (0, import_react11.useMemo)(() => {
+    if (loading || !form) {
+      return loadingRenderer;
+    }
+    const isEmpty = isFormEmpty(form.schema);
+    return form.render({
+      defaultValues,
+      onFormValuesChange,
+      children: isEmpty ? emptyRenderer : null
+    });
+  }, [form, loading]);
+  const compute = async () => {
+    if (!node) {
+      return;
+    }
+    try {
+      setLoading(true);
+      const formEntity = await testRun.createForm(node);
+      setForm(formEntity);
+    } finally {
+      setLoading(false);
+    }
+  };
+  (0, import_react11.useEffect)(() => {
+    compute();
+  }, [node]);
+  (0, import_react11.useEffect)(() => {
+    if (!form) {
+      return;
+    }
+    const disposable = new import_utils7.DisposableCollection(
+      form.onFormMounted((data) => {
+        onMounted?.(data);
+      }),
+      form.onFormUnmounted(() => {
+        onUnmounted?.();
+      })
+    );
+    return () => disposable.dispose();
+  }, [form]);
+  return {
+    renderer,
+    loading,
+    form
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormEngine,
+  TestRunPipelineEntity,
+  connect,
+  createTestRunPlugin,
+  useCreateForm,
+  useTestRunService
+});
+//# sourceMappingURL=index.js.map