@strapi/admin 5.0.0-alpha.1 → 5.0.0-alpha.3

package/dist/admin/useDocumentLayout-wBQQmFJL.js

@@ -0,0 +1,764 @@
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const React = require('react');
+const reactRouterDom = require('react-router-dom');
+const layout = require('./reducers-uDxSALD_.js');
+const dateFns = require('date-fns');
+const reactIntl = require('react-intl');
+const designSystem = require('@strapi/design-system');
+const Icons = require('@strapi/icons');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
+  if (e) {
+    for (const k in e) {
+      if (k !== 'default') {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+const React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+const getDisplayName = ({
+  firstname,
+  lastname,
+  username,
+  email
+} = {}, formatMessage) => {
+  if (username) {
+    return username;
+  }
+  if (firstname) {
+    return formatMessage(
+      {
+        id: "global.fullname",
+        defaultMessage: "{firstname} {lastname}"
+      },
+      {
+        firstname,
+        lastname
+      }
+    ).trim();
+  }
+  return email ?? "";
+};
+
+const [DocumentRBACProvider, useDocumentRBAC] = layout.createContext(
+  "DocumentRBAC",
+  {
+    canCreate: false,
+    canCreateFields: [],
+    canDelete: false,
+    canPublish: false,
+    canRead: false,
+    canReadFields: [],
+    canUpdate: false,
+    canUpdateFields: [],
+    canUserAction: () => false,
+    isLoading: false
+  }
+);
+const DocumentRBAC = ({ children, permissions }) => {
+  const { slug } = reactRouterDom.useParams();
+  if (!slug) {
+    throw new Error("Cannot find the slug param in the URL");
+  }
+  const userPermissions = layout.useAuth("DocumentRBAC", (state) => state.permissions);
+  const contentTypePermissions = React__namespace.useMemo(() => {
+    const contentTypePermissions2 = userPermissions.filter(
+      (permission) => permission.subject === slug
+    );
+    return contentTypePermissions2.reduce((acc, permission) => {
+      const [action] = permission.action.split(".").slice(-1);
+      return { ...acc, [action]: [permission] };
+    }, {});
+  }, [slug, userPermissions]);
+  const { isLoading, allowedActions } = layout.useRBAC(contentTypePermissions, permissions ?? void 0);
+  const canCreateFields = !isLoading && allowedActions.canCreate ? extractAndDedupeFields(contentTypePermissions.create) : [];
+  const canReadFields = !isLoading && allowedActions.canRead ? extractAndDedupeFields(contentTypePermissions.read) : [];
+  const canUpdateFields = !isLoading && allowedActions.canUpdate ? extractAndDedupeFields(contentTypePermissions.update) : [];
+  const canUserAction = React__namespace.useCallback(
+    (fieldName, fieldsUserCanAction, fieldType) => {
+      const name = removeNumericalStrings(fieldName.split("."));
+      const componentFieldNames = fieldsUserCanAction.filter((field) => field.split(".").length > 1);
+      if (fieldType === "component") {
+        const componentOrDynamicZoneFields = componentFieldNames.map((field) => field.split("."));
+        return componentOrDynamicZoneFields.some((field) => {
+          return field.includes(fieldName);
+        });
+      }
+      if (name.length > 1) {
+        return componentFieldNames.includes(name.join("."));
+      }
+      return fieldsUserCanAction.includes(fieldName);
+    },
+    []
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    DocumentRBACProvider,
+    {
+      isLoading,
+      canCreateFields,
+      canReadFields,
+      canUpdateFields,
+      canUserAction,
+      ...allowedActions,
+      children
+    }
+  );
+};
+const extractAndDedupeFields = (permissions = []) => permissions.flatMap((permission) => permission.properties?.fields).filter(
+  (field, index, arr) => arr.indexOf(field) === index && typeof field === "string"
+);
+const removeNumericalStrings = (arr) => arr.filter((item) => isNaN(Number(item)));
+
+const intervals = ["years", "months", "days", "hours", "minutes", "seconds"];
+const RelativeTime = React__namespace.forwardRef(
+  ({ timestamp, customIntervals = [], ...restProps }, forwardedRef) => {
+    const { formatRelativeTime, formatDate, formatTime } = reactIntl.useIntl();
+    const interval = dateFns.intervalToDuration({
+      start: timestamp,
+      end: Date.now()
+      // see https://github.com/date-fns/date-fns/issues/2891 – No idea why it's all partial it returns it every time.
+    });
+    const unit = intervals.find((intervalUnit) => {
+      return interval[intervalUnit] > 0 && Object.keys(interval).includes(intervalUnit);
+    });
+    const relativeTime = dateFns.isPast(timestamp) ? -interval[unit] : interval[unit];
+    const customInterval = customIntervals.find(
+      (custom) => interval[custom.unit] < custom.threshold
+    );
+    const displayText = customInterval ? customInterval.text : formatRelativeTime(relativeTime, unit, { numeric: "auto" });
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "time",
+      {
+        ref: forwardedRef,
+        dateTime: timestamp.toISOString(),
+        role: "time",
+        title: `${formatDate(timestamp)} ${formatTime(timestamp)}`,
+        ...restProps,
+        children: displayText
+      }
+    );
+  }
+);
+
+const BooleanInput = React.forwardRef((props, ref) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const field = layout.useField(props.name);
+  const fieldRef = layout.useFocusInputField(props.name);
+  const composedRefs = designSystem.useComposedRefs(ref, fieldRef);
+  return (
+    // @ts-expect-error – label _could_ be a ReactNode since it's a child, this should be fixed in the DS.
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.ToggleInput,
+      {
+        ref: composedRefs,
+        checked: field.value === null ? null : field.value || false,
+        error: field.error,
+        offLabel: formatMessage({
+          id: "app.components.ToggleCheckbox.off-label",
+          defaultMessage: "False"
+        }),
+        onLabel: formatMessage({
+          id: "app.components.ToggleCheckbox.on-label",
+          defaultMessage: "True"
+        }),
+        onChange: field.onChange,
+        onClear: () => {
+          field.onChange(props.name, null);
+        },
+        ...props
+      }
+    )
+  );
+});
+
+const CheckboxInput = React.forwardRef((props, ref) => {
+  const field = layout.useField(props.name);
+  const fieldRef = layout.useFocusInputField(props.name);
+  const composedRefs = designSystem.useComposedRefs(ref, fieldRef);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    designSystem.Checkbox,
+    {
+      onValueChange: (checked) => field.onChange(props.name, checked),
+      ref: composedRefs,
+      value: field.value,
+      ...props,
+      children: props.label || props["aria-label"]
+    }
+  );
+});
+
+const DateInput = React.forwardRef(({ type: _type, ...props }, ref) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const field = layout.useField(props.name);
+  const fieldRef = layout.useFocusInputField(props.name);
+  const composedRefs = designSystem.useComposedRefs(ref, fieldRef);
+  const value = typeof field.value === "string" ? new Date(field.value) : field.value;
+  return (
+    // @ts-expect-error – label _could_ be a ReactNode since it's a child, this should be fixed in the DS.
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.DatePicker,
+      {
+        ref: composedRefs,
+        clearLabel: formatMessage({ id: "clearLabel", defaultMessage: "Clear" }),
+        error: field.error,
+        id: props.name,
+        onChange: (date) => {
+          field.onChange(props.name, date);
+        },
+        onClear: () => field.onChange(props.name, void 0),
+        selectedDate: value,
+        ...props
+      }
+    )
+  );
+});
+
+const DateTimeInput = React.forwardRef((props, ref) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const field = layout.useField(props.name);
+  const fieldRef = layout.useFocusInputField(props.name);
+  const composedRefs = designSystem.useComposedRefs(ref, fieldRef);
+  const value = typeof field.value === "string" ? new Date(field.value) : field.value;
+  return (
+    // @ts-expect-error – label _could_ be a ReactNode since it's a child, this should be fixed in the DS.
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.DateTimePicker,
+      {
+        ref: composedRefs,
+        clearLabel: formatMessage({ id: "clearLabel", defaultMessage: "Clear" }),
+        error: field.error,
+        id: props.name,
+        onChange: (date) => {
+          field.onChange(props.name, date);
+        },
+        onClear: () => field.onChange(props.name, void 0),
+        value,
+        ...props
+      }
+    )
+  );
+});
+
+const EmailInput = React.forwardRef((props, ref) => {
+  const field = layout.useField(props.name);
+  const fieldRef = layout.useFocusInputField(props.name);
+  const composedRefs = designSystem.useComposedRefs(ref, fieldRef);
+  return (
+    // @ts-expect-error – label _could_ be a ReactNode since it's a child, this should be fixed in the DS.
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.TextInput,
+      {
+        ref: composedRefs,
+        autoComplete: "email",
+        error: field.error,
+        id: props.name,
+        onChange: field.onChange,
+        defaultValue: field.initialValue,
+        value: field.value,
+        ...props,
+        type: "email"
+      }
+    )
+  );
+});
+
+const EnumerationInput = React.forwardRef(
+  ({ options = [], ...props }, ref) => {
+    const field = layout.useField(props.name);
+    const fieldRef = layout.useFocusInputField(props.name);
+    const composedRefs = designSystem.useComposedRefs(ref, fieldRef);
+    return (
+      // @ts-expect-error – label _could_ be a ReactNode since it's a child, this should be fixed in the DS.
+      /* @__PURE__ */ jsxRuntime.jsx(
+        designSystem.SingleSelect,
+        {
+          ref: composedRefs,
+          error: field.error,
+          onChange: (value) => {
+            field.onChange(props.name, value);
+          },
+          value: field.value,
+          ...props,
+          children: options.map(({ value, label, disabled, hidden }) => {
+            return /* @__PURE__ */ jsxRuntime.jsx(designSystem.SingleSelectOption, { value, disabled, hidden, children: label ?? value }, value);
+          })
+        }
+      )
+    );
+  }
+);
+
+const JsonInput = React.forwardRef((props, ref) => {
+  const field = layout.useField(props.name);
+  const fieldRef = layout.useFocusInputField(props.name);
+  const composedRefs = designSystem.useComposedRefs(ref, fieldRef);
+  return (
+    // @ts-expect-error – label _could_ be a ReactNode since it's a child, this should be fixed in the DS.
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.JSONInput,
+      {
+        ref: composedRefs,
+        value: field.value,
+        error: field.error,
+        onChange: (json) => {
+          const value = props.required && !json.length ? null : json;
+          field.onChange(props.name, value);
+        },
+        minHeight: `${252 / 16}rem`,
+        maxHeight: `${504 / 16}rem`,
+        ...props
+      }
+    )
+  );
+});
+
+const NumberInputImpl = React.forwardRef(({ type, ...props }, ref) => {
+  const field = layout.useField(props.name);
+  const fieldRef = layout.useFocusInputField(props.name);
+  const composedRefs = designSystem.useComposedRefs(ref, fieldRef);
+  return (
+    // @ts-expect-error – label _could_ be a ReactNode since it's a child, this should be fixed in the DS.
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.NumberInput,
+      {
+        ref: composedRefs,
+        defaultValue: field.initialValue,
+        error: field.error,
+        id: props.name,
+        onValueChange: (value) => {
+          field.onChange(props.name, value);
+        },
+        step: type === "float" || type == "decimal" ? 0.01 : 1,
+        value: field.value,
+        ...props
+      }
+    )
+  );
+});
+
+const PasswordInput = React.forwardRef((props, ref) => {
+  const [showPassword, setShowPassword] = React.useState(false);
+  const { formatMessage } = reactIntl.useIntl();
+  const field = layout.useField(props.name);
+  const fieldRef = layout.useFocusInputField(props.name);
+  const composedRefs = designSystem.useComposedRefs(ref, fieldRef);
+  return (
+    // @ts-expect-error – label _could_ be a ReactNode since it's a child, this should be fixed in the DS.
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.TextInput,
+      {
+        ref: composedRefs,
+        autoComplete: "password",
+        error: field.error,
+        endAction: /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            "aria-label": formatMessage({
+              id: "Auth.form.password.show-password",
+              defaultMessage: "Show password"
+            }),
+            onClick: () => {
+              setShowPassword((prev) => !prev);
+            },
+            style: {
+              border: "none",
+              padding: 0,
+              background: "transparent"
+            },
+            type: "button",
+            children: showPassword ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Icon, { as: Icons.Eye, color: "neutral500" }) : /* @__PURE__ */ jsxRuntime.jsx(designSystem.Icon, { as: Icons.EyeStriked, color: "neutral500" })
+          }
+        ),
+        id: props.name,
+        onChange: field.onChange,
+        defaultValue: field.initialValue,
+        value: field.value,
+        ...props,
+        type: showPassword ? "text" : "password"
+      }
+    )
+  );
+});
+
+const StringInput = React.forwardRef(({ ...props }, ref) => {
+  const field = layout.useField(props.name);
+  const fieldRef = layout.useFocusInputField(props.name);
+  const composedRefs = designSystem.useComposedRefs(ref, fieldRef);
+  return (
+    // @ts-expect-error – label _could_ be a ReactNode since it's a child, this should be fixed in the DS.
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.TextInput,
+      {
+        ref: composedRefs,
+        error: field.error,
+        defaultValue: field.initialValue,
+        onChange: field.onChange,
+        value: field.value ?? "",
+        ...props
+      }
+    )
+  );
+});
+
+const TextareaInput = React.forwardRef((props, ref) => {
+  const field = layout.useField(props.name);
+  const fieldRef = layout.useFocusInputField(props.name);
+  const composedRefs = designSystem.useComposedRefs(ref, fieldRef);
+  return (
+    // @ts-expect-error – label _could_ be a ReactNode since it's a child, this should be fixed in the DS.
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Textarea,
+      {
+        ref: composedRefs,
+        defaultValue: field.initialValue,
+        error: field.error,
+        id: props.name,
+        onChange: field.onChange,
+        value: field.value ?? "",
+        ...props
+      }
+    )
+  );
+});
+
+const TimeInput = React.forwardRef((props, ref) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const field = layout.useField(props.name);
+  const fieldRef = layout.useFocusInputField(props.name);
+  const composedRefs = designSystem.useComposedRefs(ref, fieldRef);
+  return (
+    // @ts-expect-error – label _could_ be a ReactNode since it's a child, this should be fixed in the DS.
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.TimePicker,
+      {
+        ref: composedRefs,
+        clearLabel: formatMessage({ id: "clearLabel", defaultMessage: "Clear" }),
+        error: field.error,
+        id: props.name,
+        onChange: (time) => {
+          field.onChange(props.name, time);
+        },
+        onClear: () => field.onChange(props.name, void 0),
+        value: field.value ?? "",
+        ...props
+      }
+    )
+  );
+});
+
+const InputRenderer = React.memo(
+  React.forwardRef((props, forwardRef2) => {
+    switch (props.type) {
+      case "biginteger":
+      case "timestamp":
+      case "string":
+        return /* @__PURE__ */ jsxRuntime.jsx(StringInput, { ref: forwardRef2, ...props });
+      case "boolean":
+        return /* @__PURE__ */ jsxRuntime.jsx(BooleanInput, { ref: forwardRef2, ...props });
+      case "checkbox":
+        return /* @__PURE__ */ jsxRuntime.jsx(CheckboxInput, { ref: forwardRef2, ...props });
+      case "datetime":
+        return /* @__PURE__ */ jsxRuntime.jsx(DateTimeInput, { ref: forwardRef2, ...props });
+      case "date":
+        return /* @__PURE__ */ jsxRuntime.jsx(DateInput, { ref: forwardRef2, ...props });
+      case "decimal":
+      case "float":
+      case "integer":
+        return /* @__PURE__ */ jsxRuntime.jsx(NumberInputImpl, { ref: forwardRef2, ...props });
+      case "json":
+        return /* @__PURE__ */ jsxRuntime.jsx(JsonInput, { ref: forwardRef2, ...props });
+      case "email":
+        return /* @__PURE__ */ jsxRuntime.jsx(EmailInput, { ref: forwardRef2, ...props });
+      case "enumeration":
+        return /* @__PURE__ */ jsxRuntime.jsx(EnumerationInput, { ref: forwardRef2, ...props });
+      case "password":
+        return /* @__PURE__ */ jsxRuntime.jsx(PasswordInput, { ref: forwardRef2, ...props });
+      case "text":
+        return /* @__PURE__ */ jsxRuntime.jsx(TextareaInput, { ref: forwardRef2, ...props });
+      case "time":
+        return /* @__PURE__ */ jsxRuntime.jsx(TimeInput, { ref: forwardRef2, ...props });
+      default:
+        return /* @__PURE__ */ jsxRuntime.jsx(NotSupportedField, { ref: forwardRef2, ...props });
+    }
+  })
+);
+const NotSupportedField = React.forwardRef((props, ref) => {
+  const { error } = layout.useField(props.name);
+  const fieldRef = layout.useFocusInputField(props.name);
+  const composedRefs = designSystem.useComposedRefs(ref, fieldRef);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    designSystem.TextInput,
+    {
+      ref: composedRefs,
+      disabled: true,
+      error,
+      label: props.label,
+      id: props.name,
+      hint: props.hint,
+      name: props.name,
+      placeholder: `Unsupported field type: ${props.type}`,
+      required: props.required,
+      type: "text",
+      value: ""
+    }
+  );
+});
+
+const checkIfAttributeIsDisplayable = (attribute) => {
+  const { type } = attribute;
+  if (type === "relation") {
+    return !attribute.relation.toLowerCase().includes("morph");
+  }
+  return !["json", "dynamiczone", "richtext", "password", "blocks"].includes(type) && !!type;
+};
+const getMainField = (attribute, mainFieldName, { schemas, components }) => {
+  if (!mainFieldName) {
+    return void 0;
+  }
+  const mainFieldType = attribute.type === "component" ? components[attribute.component].attributes[mainFieldName].type : (
+    // @ts-expect-error – `targetModel` does exist on the attribute for a relation.
+    schemas.find((schema) => schema.uid === attribute.targetModel)?.attributes[mainFieldName].type
+  );
+  return {
+    name: mainFieldName,
+    type: mainFieldType ?? "string"
+  };
+};
+
+const DEFAULT_SETTINGS = {
+  bulkable: false,
+  filterable: false,
+  searchable: false,
+  pagination: false,
+  defaultSortBy: "",
+  defaultSortOrder: "asc",
+  mainField: "id",
+  pageSize: 10
+};
+const useDocumentLayout = (model) => {
+  const { schema, components } = layout.useDocument({ model, collectionType: "" }, { skip: true });
+  const [{ query }] = layout.useQueryParams();
+  const runHookWaterfall = layout.useStrapiApp("useDocumentLayout", (state) => state.runHookWaterfall);
+  const { toggleNotification } = layout.useNotification();
+  const { _unstableFormatAPIError: formatAPIError } = layout.useAPIErrorHandler();
+  const { isLoading: isLoadingSchemas, schemas } = layout.useContentTypeSchema();
+  const { data, isLoading: isLoadingConfigs, error } = layout.useGetContentTypeConfigurationQuery(model);
+  const isLoading = isLoadingSchemas || isLoadingConfigs;
+  React__namespace.useEffect(() => {
+    if (error) {
+      toggleNotification({
+        type: "danger",
+        message: formatAPIError(error)
+      });
+    }
+  }, [error, formatAPIError, toggleNotification]);
+  const editLayout = React__namespace.useMemo(
+    () => data ? formatEditLayout(data, { schemas, schema, components }) : {
+      layout: [],
+      components: {},
+      metadatas: {},
+      options: {},
+      settings: DEFAULT_SETTINGS
+    },
+    [data, schema, components, schemas]
+  );
+  const listLayout = React__namespace.useMemo(() => {
+    return data ? formatListLayout(data, { schemas, schema, components }) : {
+      layout: [],
+      metadatas: {},
+      options: {},
+      settings: DEFAULT_SETTINGS
+    };
+  }, [data, schema, schemas, components]);
+  const { layout: edit } = React__namespace.useMemo(
+    () => runHookWaterfall(layout.HOOKS.MUTATE_EDIT_VIEW_LAYOUT, {
+      layout: editLayout,
+      query
+    }),
+    [editLayout, query, runHookWaterfall]
+  );
+  return {
+    error,
+    isLoading,
+    edit,
+    list: listLayout
+  };
+};
+const useDocLayout = () => {
+  const { model } = layout.useDoc();
+  return useDocumentLayout(model);
+};
+const formatEditLayout = (data, {
+  schemas,
+  schema,
+  components
+}) => {
+  let currentPanelIndex = 0;
+  const panelledEditAttributes = convertEditLayoutToFieldLayouts(
+    data.contentType.layouts.edit,
+    schema?.attributes,
+    data.contentType.metadatas,
+    { configurations: data.components, schemas: components },
+    schemas
+  ).reduce((panels, row) => {
+    if (row.some((field) => field.type === "dynamiczone")) {
+      panels.push([row]);
+      currentPanelIndex += 2;
+    } else {
+      if (!panels[currentPanelIndex]) {
+        panels.push([]);
+      }
+      panels[currentPanelIndex].push(row);
+    }
+    return panels;
+  }, []);
+  const componentEditAttributes = Object.entries(data.components).reduce(
+    (acc, [uid, configuration]) => {
+      acc[uid] = {
+        layout: convertEditLayoutToFieldLayouts(
+          configuration.layouts.edit,
+          components[uid].attributes,
+          configuration.metadatas
+        ),
+        settings: {
+          ...configuration.settings,
+          icon: components[uid].info.icon,
+          displayName: components[uid].info.displayName
+        }
+      };
+      return acc;
+    },
+    {}
+  );
+  const editMetadatas = Object.entries(data.contentType.metadatas).reduce(
+    (acc, [attribute, metadata]) => {
+      return {
+        ...acc,
+        [attribute]: metadata.edit
+      };
+    },
+    {}
+  );
+  return {
+    layout: panelledEditAttributes,
+    components: componentEditAttributes,
+    metadatas: editMetadatas,
+    settings: {
+      ...data.contentType.settings,
+      displayName: schema?.info.displayName
+    },
+    options: {
+      ...schema?.options,
+      ...schema?.pluginOptions
+    }
+  };
+};
+const convertEditLayoutToFieldLayouts = (rows, attributes = {}, metadatas, components, schemas = []) => {
+  return rows.map(
+    (row) => row.map((field) => {
+      const attribute = attributes[field.name];
+      if (!attribute) {
+        return null;
+      }
+      const { edit: metadata } = metadatas[field.name];
+      const settings = attribute.type === "component" && components ? components.configurations[attribute.component].settings : {};
+      return {
+        attribute,
+        disabled: !metadata.editable,
+        hint: metadata.description,
+        label: metadata.label ?? "",
+        name: field.name,
+        // @ts-expect-error – mainField does exist on the metadata for a relation.
+        mainField: getMainField(attribute, metadata.mainField || settings.mainField, {
+          schemas,
+          components: components?.schemas ?? {}
+        }),
+        placeholder: metadata.placeholder ?? "",
+        required: attribute.required ?? false,
+        size: field.size,
+        unique: "unique" in attribute ? attribute.unique : false,
+        visible: metadata.visible ?? true,
+        type: attribute.type
+      };
+    }).filter((field) => field !== null)
+  );
+};
+const formatListLayout = (data, {
+  schemas,
+  schema,
+  components
+}) => {
+  const listMetadatas = Object.entries(data.contentType.metadatas).reduce(
+    (acc, [attribute, metadata]) => {
+      return {
+        ...acc,
+        [attribute]: metadata.list
+      };
+    },
+    {}
+  );
+  const listAttributes = convertListLayoutToFieldLayouts(
+    data.contentType.layouts.list,
+    schema?.attributes,
+    listMetadatas,
+    { configurations: data.components, schemas: components },
+    schemas
+  );
+  return {
+    layout: listAttributes,
+    settings: { ...data.contentType.settings, displayName: schema?.info.displayName },
+    metadatas: listMetadatas,
+    options: {
+      ...schema?.options,
+      ...schema?.pluginOptions
+    }
+  };
+};
+const convertListLayoutToFieldLayouts = (columns, attributes = {}, metadatas, components, schemas = []) => {
+  return columns.map((name) => {
+    const attribute = attributes[name];
+    if (!attribute) {
+      return null;
+    }
+    const metadata = metadatas[name];
+    const settings = attribute.type === "component" && components ? components.configurations[attribute.component].settings : {};
+    return {
+      attribute,
+      label: metadata.label ?? "",
+      mainField: getMainField(attribute, metadata.mainField || settings.mainField, {
+        schemas,
+        components: components?.schemas ?? {}
+      }),
+      name,
+      searchable: metadata.searchable ?? true,
+      sortable: metadata.sortable ?? true
+    };
+  }).filter((field) => field !== null);
+};
+
+exports.DEFAULT_SETTINGS = DEFAULT_SETTINGS;
+exports.DocumentRBAC = DocumentRBAC;
+exports.InputRenderer = InputRenderer;
+exports.RelativeTime = RelativeTime;
+exports.checkIfAttributeIsDisplayable = checkIfAttributeIsDisplayable;
+exports.convertEditLayoutToFieldLayouts = convertEditLayoutToFieldLayouts;
+exports.convertListLayoutToFieldLayouts = convertListLayoutToFieldLayouts;
+exports.getDisplayName = getDisplayName;
+exports.getMainField = getMainField;
+exports.useDocLayout = useDocLayout;
+exports.useDocumentLayout = useDocumentLayout;
+exports.useDocumentRBAC = useDocumentRBAC;
+//# sourceMappingURL=useDocumentLayout-wBQQmFJL.js.map