@flowgram.ai/form-core 0.1.0

package/dist/index.js

@@ -0,0 +1,909 @@
+"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;
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DecoratorAbility: () => DecoratorAbility,
+  DefaultAbility: () => DefaultAbility,
+  EffectAbility: () => EffectAbility,
+  ErrorContainerModule: () => ErrorContainerModule,
+  FORM_VOID: () => FORM_VOID,
+  FlowNodeErrorData: () => FlowNodeErrorData,
+  FlowNodeFormData: () => FlowNodeFormData,
+  FormAbilityExtensionRegistry: () => FormAbilityExtensionRegistry,
+  FormContextMaker: () => FormContextMaker,
+  FormContribution: () => FormContribution,
+  FormCoreContainerModule: () => FormCoreContainerModule,
+  FormItem: () => FormItem,
+  FormItemEventName: () => FormItemEventName,
+  FormManager: () => FormManager,
+  FormMeta: () => FormMeta,
+  FormModel: () => FormModel,
+  FormModelEntity: () => FormModelEntity,
+  FormModelFactory: () => FormModelFactory,
+  FormPathService: () => FormPathService,
+  MATERIAL_KEY: () => MATERIAL_KEY,
+  MaterialRenderKey: () => MaterialRenderKey,
+  NodeContainerModule: () => NodeContainerModule,
+  NodeContribution: () => NodeContribution,
+  NodeEngine: () => NodeEngine,
+  NodeEngineContext: () => NodeEngineContext,
+  NodeEngineReactContext: () => NodeEngineReactContext,
+  NodeManager: () => NodeManager,
+  NodeRender: () => NodeRender,
+  PLUGIN_KEY: () => PLUGIN_KEY,
+  SetterAbility: () => SetterAbility,
+  ValidationAbility: () => ValidationAbility,
+  VisibilityAbility: () => VisibilityAbility,
+  createNodeContainerModules: () => createNodeContainerModules,
+  createNodeEntityDatas: () => createNodeEntityDatas,
+  getFormModel: () => getFormModel,
+  getNodeError: () => getNodeError,
+  isNodeFormReady: () => isNodeFormReady,
+  registerNodeErrorRender: () => registerNodeErrorRender,
+  registerNodePlaceholderRender: () => registerNodePlaceholderRender,
+  useFormItem: () => useFormItem,
+  useNodeEngineContext: () => useNodeEngineContext
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/node/node-contribution.ts
+var NodeContribution = Symbol("NodeContribution");
+
+// src/node/node-container-module.ts
+var import_inversify4 = require("inversify");
+
+// src/node/node-manager.ts
+var import_lodash = require("lodash");
+var import_inversify = require("inversify");
+var MaterialRenderKey = /* @__PURE__ */ ((MaterialRenderKey2) => {
+  MaterialRenderKey2["CustomNodeError"] = "Material_CustomNodeError";
+  return MaterialRenderKey2;
+})(MaterialRenderKey || {});
+var NodeManager = class {
+  constructor() {
+    this.materialRenderRegistry = /* @__PURE__ */ new Map();
+    this.pluginRenderRegistry = /* @__PURE__ */ new Map();
+    this.nodeRenderHocs = [];
+    this.nodeContributions = [];
+  }
+  registerMaterialRender(key, render) {
+    this.materialRenderRegistry.set(key, render);
+  }
+  getMaterialRender(key) {
+    return this.materialRenderRegistry.get(key);
+  }
+  registerPluginRender(key, render) {
+    this.pluginRenderRegistry.set(key, render);
+  }
+  getPluginRender(key) {
+    return this.pluginRenderRegistry.get(key);
+  }
+  registerNodeErrorRender(render) {
+    this.registerMaterialRender("Material_CustomNodeError" /* CustomNodeError */, render);
+  }
+  get nodeRenderHoc() {
+    return (0, import_lodash.flow)(this.nodeRenderHocs);
+  }
+  registerNodeRenderHoc(hoc) {
+    this.nodeRenderHocs.push(hoc);
+  }
+  get nodeErrorRender() {
+    return this.materialRenderRegistry.get("Material_CustomNodeError" /* CustomNodeError */);
+  }
+  init() {
+    this.nodeContributions.forEach((contrib) => contrib.onRegister?.(this));
+  }
+};
+__decorateClass([
+  (0, import_inversify.multiInject)(NodeContribution),
+  (0, import_inversify.optional)()
+], NodeManager.prototype, "nodeContributions", 2);
+__decorateClass([
+  (0, import_inversify.postConstruct)()
+], NodeManager.prototype, "init", 1);
+NodeManager = __decorateClass([
+  (0, import_inversify.injectable)()
+], NodeManager);
+
+// src/node/node-engine-context.ts
+var import_inversify2 = require("inversify");
+var import_utils = require("@flowgram.ai/utils");
+var NodeEngineContext = class {
+  constructor() {
+    this.onChangeEmitter = new import_utils.Emitter();
+    this.onChange = this.onChangeEmitter.event;
+    this._readonly = NodeEngineContext.DEFAULT_READONLY;
+    this._json = NodeEngineContext.DEFAULT_JSON;
+  }
+  get json() {
+    return this._json;
+  }
+  get readonly() {
+    return this._readonly;
+  }
+  set readonly(value) {
+    this._readonly = value;
+    this.fireChange();
+  }
+  fireChange() {
+    this.updateJSON();
+    this.onChangeEmitter.fire(this);
+  }
+  updateJSON() {
+    this._json = {
+      readonly: this._readonly
+    };
+  }
+};
+NodeEngineContext.DEFAULT_READONLY = false;
+NodeEngineContext.DEFAULT_JSON = { readonly: NodeEngineContext.DEFAULT_READONLY };
+NodeEngineContext = __decorateClass([
+  (0, import_inversify2.injectable)()
+], NodeEngineContext);
+
+// src/node/node-engine.ts
+var import_inversify3 = require("inversify");
+var NodeEngine = class {
+};
+__decorateClass([
+  (0, import_inversify3.inject)(NodeManager)
+], NodeEngine.prototype, "nodeManager", 2);
+__decorateClass([
+  (0, import_inversify3.inject)(NodeEngineContext)
+], NodeEngine.prototype, "context", 2);
+NodeEngine = __decorateClass([
+  (0, import_inversify3.injectable)()
+], NodeEngine);
+
+// src/node/node-container-module.ts
+var NodeContainerModule = new import_inversify4.ContainerModule((bind, unbind, isBound, rebind) => {
+  bind(NodeEngine).toSelf().inSingletonScope();
+  bind(NodeManager).toSelf().inSingletonScope();
+  bind(NodeEngineContext).toSelf().inSingletonScope();
+});
+
+// src/node/core-plugins.ts
+var PLUGIN_KEY = {
+  FORM: "Plugin_Form",
+  ERROR: "Plugin_Error"
+};
+
+// src/node/core-materials.ts
+var MATERIAL_KEY = {
+  NODE_ERROR_RENDER: "node_error_render",
+  NODE_PLACEHOLDER_RENDER: "node_placeholder_render"
+};
+
+// src/error/flow-node-error-data.ts
+var import_core = require("@flowgram.ai/core");
+var FlowNodeErrorData = class extends import_core.EntityData {
+  getDefaultData() {
+    return { error: null };
+  }
+  setError(e) {
+    this.update({ error: e });
+  }
+  getError() {
+    return this.data.error;
+  }
+};
+FlowNodeErrorData.type = "FlowNodeErrorData";
+
+// src/error/error-container-module.ts
+var import_inversify6 = require("inversify");
+var import_utils2 = require("@flowgram.ai/utils");
+
+// src/error/error-node-contribution.ts
+var import_inversify5 = require("inversify");
+
+// src/error/renders/error-render.tsx
+var import_react2 = __toESM(require("react"));
+var import_core2 = require("@flowgram.ai/core");
+
+// src/error/renders/default-error-render.tsx
+var import_react = __toESM(require("react"));
+var ERROR_STYLE = {
+  color: "#f54a45"
+};
+var defaultErrorRender = ({ error }) => /* @__PURE__ */ import_react.default.createElement("div", { style: ERROR_STYLE }, error.message);
+
+// src/error/renders/error-render.tsx
+var ErrorRender = ({ node, playgroundContext }) => {
+  const refresh = (0, import_core2.useRefresh)();
+  const nodeErrorData = node.getData(FlowNodeErrorData);
+  const nodeError = nodeErrorData.getError();
+  const nodeManager = (0, import_core2.useService)(NodeManager);
+  const nodeErrorRender = nodeManager.getMaterialRender(MATERIAL_KEY.NODE_ERROR_RENDER);
+  const renderError = (0, import_react2.useCallback)(() => {
+    if (!nodeErrorRender) {
+      return defaultErrorRender({
+        error: nodeError,
+        context: { node, playgroundContext }
+      });
+    }
+    return nodeErrorRender({
+      error: nodeError,
+      context: { node, playgroundContext }
+    });
+  }, [nodeError, node, playgroundContext]);
+  (0, import_react2.useEffect)(() => {
+    const disposable = nodeErrorData.onDataChange(() => {
+      refresh();
+    });
+    return () => {
+      disposable.dispose();
+    };
+  }, []);
+  return nodeError ? renderError() : null;
+};
+var errorPluginRender = (props) => /* @__PURE__ */ import_react2.default.createElement(ErrorRender, { ...props });
+
+// src/error/error-node-contribution.ts
+var ErrorNodeContribution = class {
+  onRegister(nodeManager) {
+    nodeManager.registerPluginRender(PLUGIN_KEY.ERROR, errorPluginRender);
+  }
+};
+ErrorNodeContribution = __decorateClass([
+  (0, import_inversify5.injectable)()
+], ErrorNodeContribution);
+
+// src/error/error-container-module.ts
+var ErrorContainerModule = new import_inversify6.ContainerModule((bind) => {
+  (0, import_utils2.bindContributions)(bind, ErrorNodeContribution, [NodeContribution]);
+});
+
+// src/error/client.ts
+function getNodeError(node) {
+  return node.getData(FlowNodeErrorData).getError();
+}
+
+// src/form/form-core-container-module.ts
+var import_inversify13 = require("inversify");
+var import_utils7 = require("@flowgram.ai/utils");
+
+// src/form/services/form-context-maker.ts
+var import_inversify7 = require("inversify");
+var import_core3 = require("@flowgram.ai/core");
+var FormContextMaker = class {
+  makeFormItemMaterialContext(formItem, options) {
+    return {
+      meta: formItem.meta,
+      path: formItem.path,
+      readonly: this.nodeEngineContext.readonly,
+      getFormItemValueByPath: formItem.formModel.getFormItemValueByPath.bind(formItem.formModel),
+      onFormValidate: formItem.formModel.onValidate.bind(formItem.formModel),
+      form: formItem.formModel,
+      node: formItem.formModel.flowNodeEntity,
+      playgroundContext: this.playgroundContext,
+      index: options?.getIndex()
+    };
+  }
+};
+__decorateClass([
+  (0, import_inversify7.inject)(NodeEngineContext)
+], FormContextMaker.prototype, "nodeEngineContext", 2);
+__decorateClass([
+  (0, import_core3.injectPlaygroundContext)()
+], FormContextMaker.prototype, "playgroundContext", 2);
+FormContextMaker = __decorateClass([
+  (0, import_inversify7.injectable)()
+], FormContextMaker);
+
+// src/form/services/form-path-service.ts
+var import_inversify8 = require("inversify");
+var FormPathService = class {
+  static normalize(path) {
+    if (path === FormPathService.ROOT) {
+      return path;
+    }
+    if (path.endsWith(FormPathService.DIVIDER)) {
+      path = path.slice(0, -1);
+    }
+    return path;
+  }
+  static join(paths) {
+    if (paths[1].startsWith(FormPathService.ROOT)) {
+      throw new Error(
+        `FormPathService Error: join failed, invalid paths[1], paths[1]= ${paths[1]}`
+      );
+    }
+    if (paths[0].endsWith(FormPathService.DIVIDER)) {
+      return `${paths[0]}${paths[1]}`;
+    }
+    return paths.join(FormPathService.DIVIDER);
+  }
+  static toArrayPath(path) {
+    return FormPathService.join([path, FormPathService.ARRAY]);
+  }
+  static parseArrayItemPath(path) {
+    const names = path.split("/");
+    let i = 0;
+    while (i < names.length) {
+      const itemIndex = parseInt(names[i]);
+      if (!isNaN(itemIndex)) {
+        const arrayPath = FormPathService.toArrayPath(
+          names.slice(0, i).join(FormPathService.DIVIDER)
+        );
+        const restPath = names.slice(i + 1).join(FormPathService.DIVIDER);
+        const itemMetaPath = FormPathService.join([arrayPath, restPath]);
+        return { itemIndex, arrayPath, itemMetaPath };
+      }
+      i = i + 1;
+    }
+    return null;
+  }
+  simplify(path) {
+    const segments = path.split(FormPathService.DIVIDER);
+    const resSegments = [];
+    for (let i = 0; i < segments.length; i++) {
+      if (!segments[i]) {
+        throw new Error("FormPathService: join failed");
+      }
+      if (segments[i] === FormPathService.RELATIVE_CURRENT) {
+        continue;
+      }
+      if (segments[i] === FormPathService.RELATIVE_PARENT) {
+        resSegments.pop();
+      }
+      resSegments.push(segments[i]);
+    }
+    return resSegments.join(FormPathService.DIVIDER);
+  }
+};
+FormPathService.ROOT = "/";
+FormPathService.DIVIDER = "/";
+FormPathService.RELATIVE_PARENT = "..";
+FormPathService.RELATIVE_CURRENT = ".";
+FormPathService.ARRAY = "[]";
+FormPathService = __decorateClass([
+  (0, import_inversify8.injectable)()
+], FormPathService);
+
+// src/form/services/form-manager.ts
+var import_lodash2 = require("lodash");
+var import_inversify11 = require("inversify");
+var import_core4 = require("@flowgram.ai/core");
+
+// src/form/models/form-model.ts
+var import_inversify9 = require("inversify");
+var import_utils3 = require("@flowgram.ai/utils");
+var FormModelFactory = Symbol("FormModelFactory");
+var FormModelEntity = Symbol("FormModelEntity");
+var FormModel = class {
+  constructor() {
+    this.toDispose = new import_utils3.DisposableCollection();
+  }
+};
+FormModel = __decorateClass([
+  (0, import_inversify9.injectable)()
+], FormModel);
+
+// src/form/models/form-item.ts
+var import_utils4 = require("@flowgram.ai/utils");
+var FormItem = class {
+  constructor(meta, path, formModel) {
+    this.onInitEventEmitter = new import_utils4.Emitter();
+    this.onInit = this.onInitEventEmitter.event;
+    this.toDispose = new import_utils4.DisposableCollection();
+    this.onDispose = this.toDispose.onDispose;
+    this.meta = meta;
+    this.path = path;
+    this.formModel = formModel;
+    this.toDispose.push(this.onInitEventEmitter);
+  }
+  set domRef(domRef) {
+    this._domRef = domRef;
+  }
+  get domRef() {
+    return this._domRef;
+  }
+  dispose() {
+    this.toDispose.dispose();
+  }
+};
+
+// src/form/models/form-meta.ts
+var FormMeta = class {
+  constructor(root, options) {
+    this._root = root;
+    this._options = options;
+  }
+  get root() {
+    return this._root;
+  }
+  get options() {
+    return this._options;
+  }
+  static traverse({ formItemMeta, parentPath = "", handle }) {
+    if (!formItemMeta) {
+      return;
+    }
+    const isRoot = !parentPath;
+    const path = isRoot ? FormPathService.ROOT : formItemMeta.name ? FormPathService.join([parentPath, formItemMeta.name]) : parentPath;
+    handle({ formItemMeta, path });
+    if (formItemMeta.items) {
+      this.traverse({
+        formItemMeta: formItemMeta.items,
+        handle,
+        parentPath: FormPathService.toArrayPath(path)
+      });
+    }
+    if (formItemMeta.children && formItemMeta.children.length) {
+      formItemMeta.children.forEach((child) => {
+        this.traverse({ formItemMeta: child, handle, parentPath: path });
+      });
+    }
+  }
+};
+
+// src/form/models/form-ability-extension-registry.ts
+var import_inversify10 = require("inversify");
+var FormAbilityExtensionRegistry = class {
+  constructor() {
+    this.registry = /* @__PURE__ */ new Map();
+  }
+  register(extension) {
+    this.registry.set(extension.key, extension);
+  }
+  get(key) {
+    return this.registry.get(key);
+  }
+  get objectMap() {
+    return Object.fromEntries(this.registry);
+  }
+  get collection() {
+    return Array.from(this.registry.values());
+  }
+};
+FormAbilityExtensionRegistry = __decorateClass([
+  (0, import_inversify10.injectable)()
+], FormAbilityExtensionRegistry);
+
+// src/form/form-contribution.ts
+var FormContribution = Symbol("FormContribution");
+
+// src/form/abilities/setter-ability/setter-ability.ts
+var _SetterAbility = class _SetterAbility {
+  get type() {
+    return _SetterAbility.type;
+  }
+};
+_SetterAbility.type = "setter";
+var SetterAbility = _SetterAbility;
+
+// src/form/abilities/decorator-ability/decorator-ability.ts
+var _DecoratorAbility = class _DecoratorAbility {
+  get type() {
+    return _DecoratorAbility.type;
+  }
+};
+_DecoratorAbility.type = "decorator";
+var DecoratorAbility = _DecoratorAbility;
+
+// src/form/abilities/visibility-ability/visibility-ability.ts
+var _VisibilityAbility = class _VisibilityAbility {
+  get type() {
+    return _VisibilityAbility.type;
+  }
+};
+_VisibilityAbility.type = "visibility";
+var VisibilityAbility = _VisibilityAbility;
+
+// src/form/abilities/effect-ability/effect-ability.ts
+var _EffectAbility = class _EffectAbility {
+  get type() {
+    return _EffectAbility.type;
+  }
+};
+_EffectAbility.type = "effect";
+var EffectAbility = _EffectAbility;
+
+// src/form/abilities/default-ability/default-ability.ts
+var _DefaultAbility = class _DefaultAbility {
+  get type() {
+    return _DefaultAbility.type;
+  }
+};
+_DefaultAbility.type = "default";
+var DefaultAbility = _DefaultAbility;
+
+// src/form/abilities/validation-ability/validation-ability.ts
+var _ValidationAbility = class _ValidationAbility {
+  get type() {
+    return _ValidationAbility.type;
+  }
+};
+_ValidationAbility.type = "validation";
+var ValidationAbility = _ValidationAbility;
+
+// src/form/services/form-manager.ts
+var FormManager = class {
+  constructor() {
+    this.abilityRegistry = /* @__PURE__ */ new Map();
+    this.setterHocs = [];
+    this.extensionRegistryMap = /* @__PURE__ */ new Map();
+    this.formContributions = [];
+  }
+  get components() {
+    return (0, import_lodash2.mapValues)(
+      this.extensionRegistryMap.get(SetterAbility.type)?.objectMap || {},
+      (setter) => setter.component
+    );
+  }
+  get decorators() {
+    return (0, import_lodash2.mapValues)(
+      this.extensionRegistryMap.get(DecoratorAbility.type)?.objectMap || {},
+      (decorator) => decorator.component
+    );
+  }
+  registerAbilityExtension(type, extension) {
+    if (!this.extensionRegistryMap.get(type)) {
+      this.extensionRegistryMap.set(type, new FormAbilityExtensionRegistry());
+    }
+    const registry = this.extensionRegistryMap.get(type);
+    if (!registry) {
+      return;
+    }
+    registry.register(extension);
+  }
+  getAbilityExtension(abilityType, extensionKey) {
+    return this.extensionRegistryMap.get(abilityType)?.get(extensionKey);
+  }
+  registerAbility(Ability) {
+    const ability = new Ability();
+    this.abilityRegistry.set(ability.type, ability);
+  }
+  registerAbilities(Abilities) {
+    Abilities.forEach(this.registerAbility.bind(this));
+  }
+  getAbility(type) {
+    return this.abilityRegistry.get(type);
+  }
+  /**
+   * @deprecated
+   * Setter Hoc and setter are no longer supported in NodeEngineV2
+   * @param hoc
+   */
+  registerSetterHoc(hoc) {
+    this.setterHocs.push(hoc);
+  }
+  init() {
+    this.formContributions.forEach((contrib) => contrib.onRegister?.(this));
+  }
+};
+__decorateClass([
+  (0, import_inversify11.inject)(FormPathService)
+], FormManager.prototype, "pathManager", 2);
+__decorateClass([
+  (0, import_inversify11.inject)(FormContextMaker)
+], FormManager.prototype, "formContextMaker", 2);
+__decorateClass([
+  (0, import_core4.injectPlaygroundContext)()
+], FormManager.prototype, "playgroundContext", 2);
+__decorateClass([
+  (0, import_inversify11.multiInject)(FormContribution),
+  (0, import_inversify11.optional)()
+], FormManager.prototype, "formContributions", 2);
+__decorateClass([
+  (0, import_inversify11.postConstruct)()
+], FormManager.prototype, "init", 1);
+FormManager = __decorateClass([
+  (0, import_inversify11.injectable)()
+], FormManager);
+
+// src/form/form-node-contribution.ts
+var import_inversify12 = require("inversify");
+
+// src/form/form-render.tsx
+var import_react3 = __toESM(require("react"));
+var import_utils6 = require("@flowgram.ai/utils");
+
+// src/form/flow-node-form-data.ts
+var import_utils5 = require("@flowgram.ai/utils");
+var import_core5 = require("@flowgram.ai/core");
+var FlowNodeFormData = class extends import_core5.EntityData {
+  constructor(entity, opts) {
+    super(entity);
+    /**
+     * @deprecated rehaje 版表单form Values change 事件
+     * @protected
+     */
+    this.onDetailChangeEmitter = new import_utils5.Emitter();
+    /**
+     * @deprecated 该方法为旧版引擎（rehaje）表单数据变更事件, 新版节点引擎请使用
+     * this.getFormModel<FormModelV2>().onFormValuesChange.
+     * @protected
+     */
+    this.onDetailChange = this.onDetailChangeEmitter.event;
+    this.flowNodeEntity = entity;
+    this.formModel = opts.formModelFactory(entity);
+    this.toDispose.push(this.onDetailChangeEmitter);
+    this.toDispose.push(
+      import_utils5.Disposable.create(() => {
+        this.formModel.dispose();
+      })
+    );
+  }
+  getFormModel() {
+    return this.formModel;
+  }
+  getDefaultData() {
+    return {};
+  }
+  createForm(formMetaOrFormMetaGenerator, initialValue) {
+    const errorData = this.flowNodeEntity.getData(FlowNodeErrorData);
+    errorData.setError(null);
+    try {
+      this.formModel.init(formMetaOrFormMetaGenerator, initialValue);
+    } catch (e) {
+      errorData.setError(e);
+    }
+  }
+  recreateForm(formMetaOrFormMetaGenerator, initialValue) {
+    this.createForm(formMetaOrFormMetaGenerator, initialValue);
+  }
+  toJSON() {
+    return this.formModel.toJSON();
+  }
+  dispose() {
+    super.dispose();
+  }
+  /**
+   * @deprecated rehaje 版表单form Values change 事件触发函数
+   * @protected
+   */
+  fireDetaiChange(detailChangeEvent) {
+    this.onDetailChangeEmitter.fire(detailChangeEvent);
+  }
+};
+FlowNodeFormData.type = "FlowNodeEntityFormData";
+
+// src/form/form-render.tsx
+function getFormModelFromNode(node) {
+  return node.getData(FlowNodeFormData)?.getFormModel();
+}
+function FormRender({ node }) {
+  const refresh = (0, import_utils6.useRefresh)();
+  const formModel = getFormModelFromNode(node);
+  (0, import_react3.useEffect)(() => {
+    const disposable = formModel?.onInitialized(() => {
+      refresh();
+    });
+    return () => {
+      disposable.dispose();
+    };
+  }, [formModel]);
+  return formModel?.initialized ? formModel.render() : null;
+}
+var formPluginRender = (props) => /* @__PURE__ */ import_react3.default.createElement(FormRender, { ...props });
+
+// src/form/form-node-contribution.ts
+var FormNodeContribution = class {
+  onRegister(nodeManager) {
+    nodeManager.registerPluginRender(PLUGIN_KEY.FORM, formPluginRender);
+  }
+};
+FormNodeContribution = __decorateClass([
+  (0, import_inversify12.injectable)()
+], FormNodeContribution);
+
+// src/form/form-core-container-module.ts
+var FormCoreContainerModule = new import_inversify13.ContainerModule((bind) => {
+  bind(FormManager).toSelf().inSingletonScope();
+  bind(FormPathService).toSelf().inSingletonScope();
+  bind(FormContextMaker).toSelf().inSingletonScope();
+  (0, import_utils7.bindContributions)(bind, FormNodeContribution, [NodeContribution]);
+});
+
+// src/form/types/form-model.types.ts
+var FormItemEventName = /* @__PURE__ */ ((FormItemEventName2) => {
+  FormItemEventName2["onFormValueChange"] = "onFormValueChange";
+  FormItemEventName2["onFormItemInit"] = "onFormItemInit";
+  return FormItemEventName2;
+})(FormItemEventName || {});
+
+// src/form/types/form-meta.types.ts
+var FORM_VOID = "form-void";
+
+// src/form/client/index.ts
+function isNodeFormReady(node) {
+  return node.getData(FlowNodeFormData).getFormModel().initialized;
+}
+function getFormModel(node) {
+  return node.getData(FlowNodeFormData).formModel;
+}
+
+// src/client/create-node-container-modules.ts
+function createNodeContainerModules() {
+  return [NodeContainerModule, FormCoreContainerModule, ErrorContainerModule];
+}
+
+// src/client/node-render.tsx
+var import_react7 = __toESM(require("react"));
+var import_core8 = require("@flowgram.ai/core");
+
+// src/node-react/context/node-engine-react-context.ts
+var import_react4 = __toESM(require("react"));
+var NodeEngineReactContext = import_react4.default.createContext(
+  NodeEngineContext.DEFAULT_JSON
+);
+
+// src/node-react/hooks/use-node-engine-context.ts
+var import_react5 = require("react");
+var import_core6 = require("@flowgram.ai/core");
+function useNodeEngineContext() {
+  const refresh = (0, import_core6.useRefresh)();
+  const nodeEngineContext = (0, import_core6.useService)(NodeEngineContext);
+  (0, import_react5.useEffect)(() => {
+    const disposable = nodeEngineContext.onChange(() => {
+      refresh();
+    });
+    return () => {
+      disposable.dispose();
+    };
+  }, []);
+  return nodeEngineContext;
+}
+
+// src/node-react/hooks/use-form-Item.ts
+var import_react6 = require("react");
+var import_core7 = require("@flowgram.ai/core");
+function useFormItem(path) {
+  const refresh = (0, import_core7.useRefresh)();
+  const node = (0, import_core7.useEntityFromContext)();
+  const formData = node.getData(FlowNodeFormData);
+  const formItem = formData.getFormModel().getFormItemByPath(path);
+  (0, import_react6.useEffect)(() => {
+    const disposable = formData.onDataChange(() => {
+      refresh();
+    });
+    return () => {
+      disposable.dispose();
+    };
+  }, []);
+  return formItem;
+}
+
+// src/client/node-render.tsx
+var PureNodeRender = ({ node }) => {
+  const refresh = (0, import_core8.useRefresh)();
+  const nodeErrorData = node.getData(FlowNodeErrorData);
+  const formModel = getFormModel(node);
+  const isNodeError = !!getNodeError(node);
+  const isFormReady = isNodeFormReady(node);
+  const playgroundContext = (0, import_core8.useService)(import_core8.PlaygroundContext);
+  const nodeManager = (0, import_core8.useService)(NodeManager);
+  const nodeFormRender = nodeManager.getPluginRender(PLUGIN_KEY.FORM);
+  const nodeErrorRender = nodeManager.getPluginRender(PLUGIN_KEY.ERROR);
+  const nodePlaceholderRender = nodeManager.getMaterialRender(MATERIAL_KEY.NODE_PLACEHOLDER_RENDER);
+  const nodeEngineContext = useNodeEngineContext();
+  (0, import_react7.useEffect)(() => {
+    const errorDisposable = nodeErrorData.onDataChange(() => {
+      refresh();
+    });
+    const formDisposable = formModel.onInitialized(() => {
+      refresh();
+    });
+    return () => {
+      errorDisposable.dispose();
+      formDisposable.dispose();
+    };
+  }, []);
+  const renderContent = (0, import_react7.useCallback)(() => {
+    if (!formModel.formMeta) {
+      return null;
+    }
+    if (isNodeError) {
+      return nodeErrorRender({ node, playgroundContext });
+    }
+    if (isFormReady) {
+      return nodeFormRender({ node, playgroundContext });
+    }
+    return nodePlaceholderRender?.({ node, playgroundContext }) || null;
+  }, [
+    isNodeError,
+    isFormReady,
+    nodeErrorRender,
+    nodeFormRender,
+    nodePlaceholderRender,
+    node,
+    playgroundContext
+  ]);
+  return /* @__PURE__ */ import_react7.default.createElement(NodeEngineReactContext.Provider, { value: nodeEngineContext.json }, nodeManager.nodeRenderHoc(renderContent)());
+};
+var NodeRender = (0, import_react7.memo)(PureNodeRender);
+
+// src/client/node-material-client.ts
+function registerNodeErrorRender(nodeManager, render) {
+  nodeManager.registerMaterialRender(MATERIAL_KEY.NODE_ERROR_RENDER, render);
+}
+function registerNodePlaceholderRender(nodeManager, render) {
+  nodeManager.registerMaterialRender(MATERIAL_KEY.NODE_PLACEHOLDER_RENDER, render);
+}
+
+// src/client/create-node-entity-datas.ts
+function createNodeEntityDatas() {
+  return [FlowNodeFormData, FlowNodeErrorData];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DecoratorAbility,
+  DefaultAbility,
+  EffectAbility,
+  ErrorContainerModule,
+  FORM_VOID,
+  FlowNodeErrorData,
+  FlowNodeFormData,
+  FormAbilityExtensionRegistry,
+  FormContextMaker,
+  FormContribution,
+  FormCoreContainerModule,
+  FormItem,
+  FormItemEventName,
+  FormManager,
+  FormMeta,
+  FormModel,
+  FormModelEntity,
+  FormModelFactory,
+  FormPathService,
+  MATERIAL_KEY,
+  MaterialRenderKey,
+  NodeContainerModule,
+  NodeContribution,
+  NodeEngine,
+  NodeEngineContext,
+  NodeEngineReactContext,
+  NodeManager,
+  NodeRender,
+  PLUGIN_KEY,
+  SetterAbility,
+  ValidationAbility,
+  VisibilityAbility,
+  createNodeContainerModules,
+  createNodeEntityDatas,
+  getFormModel,
+  getNodeError,
+  isNodeFormReady,
+  registerNodeErrorRender,
+  registerNodePlaceholderRender,
+  useFormItem,
+  useNodeEngineContext
+});
+//# sourceMappingURL=index.js.map