@sanity/form-builder/lib/inputs/ObjectInput/ObjectInputField.js

Sanity form builder

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ObjectInputField = void 0;
var _react = _interopRequireWildcard(require("react"));
var _components = require("@sanity/base/components");
var _content = require("@sanity/util/content");
var _internal = require("@sanity/base/_internal");
var _FormBuilderInput = require("../../FormBuilderInput");
var _InvalidValueInput = require("../InvalidValueInput");
var _ConditionalHiddenField = require("../common/ConditionalHiddenField");
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
// This component renders a single type in an object type. It emits onChange events telling the owner about the name of the type
// that changed. This gives the owner an opportunity to use the same event handler function for all of its fields
var ObjectInputField = /*#__PURE__*/(0, _react.forwardRef)(function ObjectInputField(props, forwardedRef) {
  var _useConditionalReadOn;
  var value = props.value,
    field = props.field,
    level = props.level,
    onChange = props.onChange,
    onFocus = props.onFocus,
    onBlur = props.onBlur,
    markers = props.markers,
    focusPath = props.focusPath,
    filterField = props.filterField,
    compareValue = props.compareValue,
    presence = props.presence,
    parent = props.parent,
    readOnly = props.readOnly;
  var conditionalReadOnly = (_useConditionalReadOn = (0, _internal.useConditionalReadOnly)()) !== null && _useConditionalReadOn !== void 0 ? _useConditionalReadOn : readOnly;
  var handleChange = (0, _react.useCallback)(event => {
    var isReadOnly = conditionalReadOnly !== null && conditionalReadOnly !== void 0 ? conditionalReadOnly : field.type.readOnly;
    if (typeof isReadOnly === 'boolean' && isReadOnly) {
      return;
    }
    onChange(event, field);
  }, [conditionalReadOnly, field, onChange]);
  var fieldPath = (0, _react.useMemo)(() => [field.name], [field.name]);
  var valueTypeName = (0, _content.resolveTypeName)(value);
  var isValueCompatible =
  // undefined is always valid
  value === undefined || isAssignable(valueTypeName, field.type);
  var children = (0, _react.useMemo)(() => {
    if (!isValueCompatible) {
      return null;
    }
    return /*#__PURE__*/_react.default.createElement(_FormBuilderInput.FormBuilderInput, {
      value: value,
      type: field.type,
      onChange: handleChange,
      path: fieldPath,
      onFocus: onFocus,
      onBlur: onBlur,
      focusPath: focusPath,
      filterField: filterField,
      markers: markers,
      compareValue: compareValue,
      level: level,
      presence: presence,
      _internal_parent: parent,
      ref: forwardedRef,
      readOnly: conditionalReadOnly || field.type.readOnly
    });
  }, [isValueCompatible, value, field.type, handleChange, fieldPath, onFocus, onBlur, focusPath, filterField, markers, compareValue, level, presence, parent, forwardedRef, conditionalReadOnly]);
  if (!isValueCompatible) {
    return /*#__PURE__*/_react.default.createElement(_components.FormFieldSet, {
      title: field.type.title,
      level: level,
      __unstable_presence: presence
    }, /*#__PURE__*/_react.default.createElement(_InvalidValueInput.InvalidValueInput, {
      value: value,
      onChange: handleChange,
      validTypes: [field.type.name],
      actualType: valueTypeName,
      ref: forwardedRef
    }));
  }
  return /*#__PURE__*/_react.default.createElement(_ConditionalHiddenField.ConditionalHiddenField, {
    parent: props.parent,
    value: value,
    hidden: field.type.hidden
  }, children);
});

/**
 * Check whether the given value type is assignable to the given schema type
 * @param valueTypeName The resolved value type name
 * @param schemaType The schema type
 */
exports.ObjectInputField = ObjectInputField;
function isAssignable(valueTypeName, schemaType) {
  return valueTypeName === schemaType.name ||
  // todo: we should consider removing this check, and not allow aliasing native type and
  //  ensure custom object types always gets annotated with _type
  valueTypeName === schemaType.jsonType;
}