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

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

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

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

// src/fields/set/SetField.tsx
import { useUI } from "@vtaits/react-form-schema-base-ui";
import { useMemo } from "react";
import {
  Controller
} from "react-hook-form";

// src/fields/set/defaultRender.tsx
import { Fragment } from "react";
import { Fragment as Fragment2, jsx } from "react/jsx-runtime";
function defaultRender(renderField, names, excludePaths) {
  const excludePathGroups = excludePaths ? Object.groupBy(excludePaths, (path) => path[0]) : void 0;
  const namesForRender = excludePathGroups ? names.filter((name) => {
    const excludePathsForField = excludePathGroups[name];
    if (!excludePathsForField) {
      return true;
    }
    return excludePathsForField.every((path) => path.length > 1);
  }) : names;
  return /* @__PURE__ */ jsx(Fragment2, { children: namesForRender.map((name) => {
    const excludePathsForField = excludePathGroups ? excludePathGroups[name] : void 0;
    const content = excludePathsForField ? renderField(name, {
      excludePaths: excludePathsForField.map(([_, ...rest]) => rest)
    }) : renderField(name);
    return /* @__PURE__ */ jsx(Fragment, { children: content }, name);
  }) });
}

// src/fields/set/SetField.tsx
import { jsx as jsx2 } from "react/jsx-runtime";
function getRenderPath(payload) {
  if (!payload) {
    return null;
  }
  const renderPath = payload.renderPath;
  if (!Array.isArray(renderPath)) {
    return null;
  }
  if (typeof renderPath[0] !== "string") {
    throw new Error(
      `[set] \`renderPath\` should be an array of strings, received: \`${renderPath[0]}\``
    );
  }
  return renderPath;
}
function SetField({
  renderParams: {
    fieldPath,
    fieldSchema,
    getFieldSchema,
    getFieldType,
    name: nameParam,
    payload,
    parents
  },
  formResult
}) {
  const {
    label,
    isWrapped,
    rootProps,
    nested,
    schemas,
    renderSet = defaultRender
  } = fieldSchema;
  const names = useMemo(() => Object.keys(schemas), [schemas]);
  const { control, getValues } = formResult;
  const { renderSet: uiRenderSet, renderWrapper } = useUI();
  return /* @__PURE__ */ jsx2(
    Controller,
    {
      name: fieldPath,
      control,
      render: ({ field }) => {
        const providedParents = nested ? [
          ...parents,
          {
            name: nameParam,
            values: field.value
          }
        ] : parents;
        const renderField = (childName, payload2) => renderBySchema(
          formResult,
          getFieldSchema,
          getFieldType,
          getValues,
          childName,
          payload2,
          providedParents
        );
        const renderPath = getRenderPath(payload);
        if (renderPath) {
          const [fieldName, ...restPath] = renderPath;
          return renderField(fieldName, {
            ...payload,
            renderPath: restPath
          });
        }
        const content = renderSet(
          renderField,
          names,
          payload?.excludePaths
        );
        if (!isWrapped) {
          return content;
        }
        return renderWrapper({
          children: uiRenderSet({
            children: content,
            label,
            rootProps
          })
        });
      }
    }
  );
}

// src/fields/set/set.tsx
import { jsx as jsx3 } from "react/jsx-runtime";
var set = {
  ...setBase,
  render: (renderParams, formResult) => /* @__PURE__ */ jsx3(SetField, { renderParams, formResult })
};

export {
  set
};
//# sourceMappingURL=chunk-MXCLMEFM.js.map