@vtaits/react-hook-form-schema/dist/chunk-33QDERGU.js

Integration of react-hook-form and @vtaits/form-schema

import {
  renderBySchema
} from "./chunk-VHBMH3GH.js";

// src/fields/dynamic/dynamic.tsx
import { dynamic as dynamicBase } from "@vtaits/form-schema/fields/dynamic";

// src/fields/dynamic/DynamicField.tsx
import { isEqual, isPromise } from "es-toolkit";
import { useEffect, useMemo, useRef, useState } from "react";
import { useAsync } from "react-async-hook";
import useLatest from "use-latest";
function DynamicField({
  renderParams: {
    name,
    fieldSchema,
    getFieldSchema,
    getFieldType,
    parents,
    payload,
    dependencies
  },
  formResult,
  formResult: { getValues }
}) {
  const formResultRef = useLatest(formResult);
  const { getSchema, onShow, onHide } = fieldSchema;
  const onShowRef = useLatest(onShow);
  const onHideRef = useLatest(onHide);
  const prevDependenciesRef = useRef(dependencies);
  const countSchema = () => getSchema({
    dependencies,
    values: formResult.getValues(),
    phase: "render",
    getFieldSchema,
    getFieldType,
    parents
  });
  const [schemaResult, setSchemaResult] = useState(() => countSchema());
  const isFirstRenderCheckDependenciesRef = useRef(true);
  useEffect(() => {
    if (isFirstRenderCheckDependenciesRef.current) {
      isFirstRenderCheckDependenciesRef.current = false;
      return;
    }
    if (!isEqual(prevDependenciesRef.current, dependencies)) {
      setSchemaResult(countSchema());
      prevDependenciesRef.current = dependencies;
    }
  }, [dependencies]);
  const { result: schemaResultAsync } = useAsync(async () => {
    const res = await schemaResult;
    return res;
  }, [schemaResult]);
  const schema = useMemo(() => {
    if (isPromise(schemaResult)) {
      return schemaResultAsync || null;
    }
    return schemaResult;
  }, [schemaResult, schemaResultAsync]);
  const schemaRef = useLatest(schema);
  const isFirstRenderRef = useRef(true);
  const hasSchema = Boolean(schema);
  useEffect(() => {
    if (isFirstRenderRef.current) {
      isFirstRenderRef.current = false;
      return;
    }
    if (hasSchema) {
      if (onShowRef.current) {
        const currentSchema = schemaRef.current;
        if (!currentSchema) {
          throw new Error("[react-hook-form-schema] schema is not defined");
        }
        onShowRef.current(
          formResultRef.current,
          name,
          currentSchema,
          getFieldSchema,
          getFieldType,
          parents
        );
      }
      return;
    }
    if (onHideRef.current) {
      onHideRef.current(
        formResultRef.current,
        name,
        getFieldSchema,
        getFieldType,
        parents
      );
      return;
    }
    isFirstRenderRef.current = true;
  }, [
    formResultRef,
    getFieldSchema,
    getFieldType,
    hasSchema,
    name,
    onHideRef,
    onShowRef,
    schemaRef
  ]);
  if (!schema) {
    return null;
  }
  return renderBySchema(
    formResult,
    getFieldSchema,
    getFieldType,
    getValues,
    name,
    payload,
    parents
  );
}

// src/fields/dynamic/dynamic.tsx
import { jsx } from "react/jsx-runtime";
var dynamic = {
  ...dynamicBase,
  render: (renderParams, formResult) => /* @__PURE__ */ jsx(DynamicField, { renderParams, formResult })
};

export {
  dynamic
};
//# sourceMappingURL=chunk-33QDERGU.js.map