@strapi/content-manager 5.48.0 → 5.48.1

package/dist/admin/services/contentTypes.mjs

@@ -1,3 +1,4 @@
+import { normalizeContentTypeConfigurationUpdateResponse, normalizeContentTypeSettingsResponse, normalizeContentTypeConfigurationResponse } from '../utils/layouts/normalizeContentManagerLayout.mjs';
 import { contentManagerApi } from './api.mjs';
 
 const contentTypesApi = contentManagerApi.injectEndpoints({
@@ -7,7 +8,7 @@ const contentTypesApi = contentManagerApi.injectEndpoints({
                         url: `/content-manager/content-types/${uid}/configuration`,
                         method: 'GET'
                     }),
-                transformResponse: (response)=>response.data,
+                transformResponse: (response, _meta, uid)=>normalizeContentTypeConfigurationResponse(response.data, uid),
                 providesTags: (_result, _error, uid)=>[
                         {
                             type: 'ContentTypesConfiguration',
@@ -21,7 +22,7 @@ const contentTypesApi = contentManagerApi.injectEndpoints({
             }),
             getAllContentTypeSettings: builder.query({
                 query: ()=>'/content-manager/content-types-settings',
-                transformResponse: (response)=>response.data,
+                transformResponse: (response)=>normalizeContentTypeSettingsResponse(response.data),
                 providesTags: [
                     {
                         type: 'ContentTypeSettings',
@@ -35,7 +36,7 @@ const contentTypesApi = contentManagerApi.injectEndpoints({
                         method: 'PUT',
                         data: body
                     }),
-                transformResponse: (response)=>response.data,
+                transformResponse: (response)=>normalizeContentTypeConfigurationUpdateResponse(response.data),
                 invalidatesTags: (_result, _error, { uid })=>[
                         {
                             type: 'ContentTypesConfiguration',

package/dist/admin/services/contentTypes.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"contentTypes.mjs","sources":["../../../admin/src/services/contentTypes.ts"],"sourcesContent":["import {\n  FindContentTypeConfiguration,\n  UpdateContentTypeConfiguration,\n  FindContentTypesSettings,\n} from '../../../shared/contracts/content-types';\n\nimport { contentManagerApi } from './api';\n\nconst contentTypesApi = contentManagerApi.injectEndpoints({\n  endpoints: (builder) => ({\n    getContentTypeConfiguration: builder.query<\n      FindContentTypeConfiguration.Response['data'],\n      string\n    >({\n      query: (uid) => ({\n        url: `/content-manager/content-types/${uid}/configuration`,\n        method: 'GET',\n      }),\n      transformResponse: (response: FindContentTypeConfiguration.Response) => response.data,\n      providesTags: (_result, _error, uid) => [\n        { type: 'ContentTypesConfiguration', id: uid },\n        { type: 'ContentTypeSettings', id: 'LIST' },\n      ],\n    }),\n    getAllContentTypeSettings: builder.query<FindContentTypesSettings.Response['data'], void>({\n      query: () => '/content-manager/content-types-settings',\n      transformResponse: (response: FindContentTypesSettings.Response) => response.data,\n      providesTags: [{ type: 'ContentTypeSettings', id: 'LIST' }],\n    }),\n    updateContentTypeConfiguration: builder.mutation<\n      UpdateContentTypeConfiguration.Response['data'],\n      UpdateContentTypeConfiguration.Request['body'] & {\n        uid: string;\n      }\n    >({\n      query: ({ uid, ...body }) => ({\n        url: `/content-manager/content-types/${uid}/configuration`,\n        method: 'PUT',\n        data: body,\n      }),\n      transformResponse: (response: UpdateContentTypeConfiguration.Response) => response.data,\n      invalidatesTags: (_result, _error, { uid }) => [\n        { type: 'ContentTypesConfiguration', id: uid },\n        { type: 'ContentTypeSettings', id: 'LIST' },\n        // Is this necessary?\n        { type: 'InitialData' },\n      ],\n    }),\n  }),\n});\n\nconst {\n  useGetContentTypeConfigurationQuery,\n  useGetAllContentTypeSettingsQuery,\n  useUpdateContentTypeConfigurationMutation,\n} = contentTypesApi;\n\nexport {\n  useGetContentTypeConfigurationQuery,\n  useGetAllContentTypeSettingsQuery,\n  useUpdateContentTypeConfigurationMutation,\n};\n"],"names":["contentTypesApi","contentManagerApi","injectEndpoints","endpoints","builder","getContentTypeConfiguration","query","uid","url","method","transformResponse","response","data","providesTags","_result","_error","type","id","getAllContentTypeSettings","updateContentTypeConfiguration","mutation","body","invalidatesTags","useGetContentTypeConfigurationQuery","useGetAllContentTypeSettingsQuery","useUpdateContentTypeConfigurationMutation"],"mappings":";;AAQA,MAAMA,eAAAA,GAAkBC,iBAAAA,CAAkBC,eAAe,CAAC;IACxDC,SAAAA,EAAW,CAACC,WAAa;YACvBC,2BAAAA,EAA6BD,OAAAA,CAAQE,KAAK,CAGxC;gBACAA,KAAAA,EAAO,CAACC,OAAS;AACfC,wBAAAA,GAAAA,EAAK,CAAC,+BAA+B,EAAED,GAAAA,CAAI,cAAc,CAAC;wBAC1DE,MAAAA,EAAQ;qBACV,CAAA;gBACAC,iBAAAA,EAAmB,CAACC,QAAAA,GAAoDA,QAAAA,CAASC,IAAI;gBACrFC,YAAAA,EAAc,CAACC,OAAAA,EAASC,MAAAA,EAAQR,GAAAA,GAAQ;AACtC,wBAAA;4BAAES,IAAAA,EAAM,2BAAA;4BAA6BC,EAAAA,EAAIV;AAAI,yBAAA;AAC7C,wBAAA;4BAAES,IAAAA,EAAM,qBAAA;4BAAuBC,EAAAA,EAAI;AAAO;AAC3C;AACH,aAAA,CAAA;YACAC,yBAAAA,EAA2Bd,OAAAA,CAAQE,KAAK,CAAkD;AACxFA,gBAAAA,KAAAA,EAAO,IAAM,yCAAA;gBACbI,iBAAAA,EAAmB,CAACC,QAAAA,GAAgDA,QAAAA,CAASC,IAAI;gBACjFC,YAAAA,EAAc;AAAC,oBAAA;wBAAEG,IAAAA,EAAM,qBAAA;wBAAuBC,EAAAA,EAAI;AAAO;AAAE;AAC7D,aAAA,CAAA;YACAE,8BAAAA,EAAgCf,OAAAA,CAAQgB,QAAQ,CAK9C;AACAd,gBAAAA,KAAAA,EAAO,CAAC,EAAEC,GAAG,EAAE,GAAGc,IAAAA,EAAM,IAAM;AAC5Bb,wBAAAA,GAAAA,EAAK,CAAC,+BAA+B,EAAED,GAAAA,CAAI,cAAc,CAAC;wBAC1DE,MAAAA,EAAQ,KAAA;wBACRG,IAAAA,EAAMS;qBACR,CAAA;gBACAX,iBAAAA,EAAmB,CAACC,QAAAA,GAAsDA,QAAAA,CAASC,IAAI;AACvFU,gBAAAA,eAAAA,EAAiB,CAACR,OAAAA,EAASC,MAAAA,EAAQ,EAAER,GAAG,EAAE,GAAK;AAC7C,wBAAA;4BAAES,IAAAA,EAAM,2BAAA;4BAA6BC,EAAAA,EAAIV;AAAI,yBAAA;AAC7C,wBAAA;4BAAES,IAAAA,EAAM,qBAAA;4BAAuBC,EAAAA,EAAI;AAAO,yBAAA;;AAE1C,wBAAA;4BAAED,IAAAA,EAAM;AAAc;AACvB;AACH,aAAA;SACF;AACF,CAAA,CAAA;AAEA,MAAM,EACJO,mCAAmC,EACnCC,iCAAiC,EACjCC,yCAAyC,EAC1C,GAAGzB;;;;"}
+{"version":3,"file":"contentTypes.mjs","sources":["../../../admin/src/services/contentTypes.ts"],"sourcesContent":["import {\n  FindContentTypeConfiguration,\n  UpdateContentTypeConfiguration,\n  FindContentTypesSettings,\n} from '../../../shared/contracts/content-types';\nimport {\n  normalizeContentTypeConfigurationResponse,\n  normalizeContentTypeConfigurationUpdateResponse,\n  normalizeContentTypeSettingsResponse,\n} from '../utils/layouts/normalizeContentManagerLayout';\n\nimport { contentManagerApi } from './api';\n\nconst contentTypesApi = contentManagerApi.injectEndpoints({\n  endpoints: (builder) => ({\n    getContentTypeConfiguration: builder.query<\n      FindContentTypeConfiguration.Response['data'],\n      string\n    >({\n      query: (uid) => ({\n        url: `/content-manager/content-types/${uid}/configuration`,\n        method: 'GET',\n      }),\n      transformResponse: (response: FindContentTypeConfiguration.Response, _meta, uid) =>\n        normalizeContentTypeConfigurationResponse(response.data, uid),\n      providesTags: (_result, _error, uid) => [\n        { type: 'ContentTypesConfiguration', id: uid },\n        { type: 'ContentTypeSettings', id: 'LIST' },\n      ],\n    }),\n    getAllContentTypeSettings: builder.query<FindContentTypesSettings.Response['data'], void>({\n      query: () => '/content-manager/content-types-settings',\n      transformResponse: (response: FindContentTypesSettings.Response) =>\n        normalizeContentTypeSettingsResponse(response.data),\n      providesTags: [{ type: 'ContentTypeSettings', id: 'LIST' }],\n    }),\n    updateContentTypeConfiguration: builder.mutation<\n      UpdateContentTypeConfiguration.Response['data'],\n      UpdateContentTypeConfiguration.Request['body'] & {\n        uid: string;\n      }\n    >({\n      query: ({ uid, ...body }) => ({\n        url: `/content-manager/content-types/${uid}/configuration`,\n        method: 'PUT',\n        data: body,\n      }),\n      transformResponse: (response: UpdateContentTypeConfiguration.Response) =>\n        normalizeContentTypeConfigurationUpdateResponse(response.data),\n      invalidatesTags: (_result, _error, { uid }) => [\n        { type: 'ContentTypesConfiguration', id: uid },\n        { type: 'ContentTypeSettings', id: 'LIST' },\n        // Is this necessary?\n        { type: 'InitialData' },\n      ],\n    }),\n  }),\n});\n\nconst {\n  useGetContentTypeConfigurationQuery,\n  useGetAllContentTypeSettingsQuery,\n  useUpdateContentTypeConfigurationMutation,\n} = contentTypesApi;\n\nexport {\n  useGetContentTypeConfigurationQuery,\n  useGetAllContentTypeSettingsQuery,\n  useUpdateContentTypeConfigurationMutation,\n};\n"],"names":["contentTypesApi","contentManagerApi","injectEndpoints","endpoints","builder","getContentTypeConfiguration","query","uid","url","method","transformResponse","response","_meta","normalizeContentTypeConfigurationResponse","data","providesTags","_result","_error","type","id","getAllContentTypeSettings","normalizeContentTypeSettingsResponse","updateContentTypeConfiguration","mutation","body","normalizeContentTypeConfigurationUpdateResponse","invalidatesTags","useGetContentTypeConfigurationQuery","useGetAllContentTypeSettingsQuery","useUpdateContentTypeConfigurationMutation"],"mappings":";;;AAaA,MAAMA,eAAAA,GAAkBC,iBAAAA,CAAkBC,eAAe,CAAC;IACxDC,SAAAA,EAAW,CAACC,WAAa;YACvBC,2BAAAA,EAA6BD,OAAAA,CAAQE,KAAK,CAGxC;gBACAA,KAAAA,EAAO,CAACC,OAAS;AACfC,wBAAAA,GAAAA,EAAK,CAAC,+BAA+B,EAAED,GAAAA,CAAI,cAAc,CAAC;wBAC1DE,MAAAA,EAAQ;qBACV,CAAA;AACAC,gBAAAA,iBAAAA,EAAmB,CAACC,QAAAA,EAAiDC,KAAAA,EAAOL,MAC1EM,yCAAAA,CAA0CF,QAAAA,CAASG,IAAI,EAAEP,GAAAA,CAAAA;gBAC3DQ,YAAAA,EAAc,CAACC,OAAAA,EAASC,MAAAA,EAAQV,GAAAA,GAAQ;AACtC,wBAAA;4BAAEW,IAAAA,EAAM,2BAAA;4BAA6BC,EAAAA,EAAIZ;AAAI,yBAAA;AAC7C,wBAAA;4BAAEW,IAAAA,EAAM,qBAAA;4BAAuBC,EAAAA,EAAI;AAAO;AAC3C;AACH,aAAA,CAAA;YACAC,yBAAAA,EAA2BhB,OAAAA,CAAQE,KAAK,CAAkD;AACxFA,gBAAAA,KAAAA,EAAO,IAAM,yCAAA;AACbI,gBAAAA,iBAAAA,EAAmB,CAACC,QAAAA,GAClBU,oCAAAA,CAAqCV,QAAAA,CAASG,IAAI,CAAA;gBACpDC,YAAAA,EAAc;AAAC,oBAAA;wBAAEG,IAAAA,EAAM,qBAAA;wBAAuBC,EAAAA,EAAI;AAAO;AAAE;AAC7D,aAAA,CAAA;YACAG,8BAAAA,EAAgClB,OAAAA,CAAQmB,QAAQ,CAK9C;AACAjB,gBAAAA,KAAAA,EAAO,CAAC,EAAEC,GAAG,EAAE,GAAGiB,IAAAA,EAAM,IAAM;AAC5BhB,wBAAAA,GAAAA,EAAK,CAAC,+BAA+B,EAAED,GAAAA,CAAI,cAAc,CAAC;wBAC1DE,MAAAA,EAAQ,KAAA;wBACRK,IAAAA,EAAMU;qBACR,CAAA;AACAd,gBAAAA,iBAAAA,EAAmB,CAACC,QAAAA,GAClBc,+CAAAA,CAAgDd,QAAAA,CAASG,IAAI,CAAA;AAC/DY,gBAAAA,eAAAA,EAAiB,CAACV,OAAAA,EAASC,MAAAA,EAAQ,EAAEV,GAAG,EAAE,GAAK;AAC7C,wBAAA;4BAAEW,IAAAA,EAAM,2BAAA;4BAA6BC,EAAAA,EAAIZ;AAAI,yBAAA;AAC7C,wBAAA;4BAAEW,IAAAA,EAAM,qBAAA;4BAAuBC,EAAAA,EAAI;AAAO,yBAAA;;AAE1C,wBAAA;4BAAED,IAAAA,EAAM;AAAc;AACvB;AACH,aAAA;SACF;AACF,CAAA,CAAA;AAEA,MAAM,EACJS,mCAAmC,EACnCC,iCAAiC,EACjCC,yCAAyC,EAC1C,GAAG7B;;;;"}

package/dist/admin/src/pages/EditView/components/FormInputs/DynamicZone/DynamicComponent.d.ts

@@ -3,7 +3,7 @@ import { type UseDragAndDropOptions } from '../../../../../hooks/useDragAndDrop'
 import { type InputRendererProps } from '../../InputRenderer';
 import type { ComponentPickerProps } from './ComponentPicker';
 interface DynamicComponentProps extends Pick<UseDragAndDropOptions, 'onGrabItem' | 'onDropItem' | 'onCancel'>, Pick<ComponentPickerProps, 'dynamicComponentsByCategory'> {
-    componentUid: string;
+    componentUid?: string;
     disabled?: boolean;
     index: number;
     name: string;

package/dist/admin/src/pages/EditView/components/FormInputs/Wysiwyg/utils/sanitizer.d.ts

@@ -0,0 +1,2 @@
+declare const sanitize: (html: string) => string;
+export { sanitize };

package/dist/admin/src/pages/ListConfiguration/components/SortDisplayedFields.d.ts

@@ -1,6 +1,6 @@
 import type { ListLayout } from '../../../hooks/useDocumentLayout';
-interface SortDisplayedFieldsProps extends Pick<ListLayout, 'layout'> {
+interface SortDisplayedFieldsProps extends Pick<ListLayout, 'metadatas'> {
 }
-declare const SortDisplayedFields: () => import("react/jsx-runtime").JSX.Element;
+declare const SortDisplayedFields: ({ metadatas }: SortDisplayedFieldsProps) => import("react/jsx-runtime").JSX.Element;
 export { SortDisplayedFields };
 export type { SortDisplayedFieldsProps };

package/dist/admin/src/pages/ListView/components/TableCells/Media.d.ts

@@ -8,8 +8,8 @@ interface MediaFile {
             url?: string;
         };
     };
-    mime: string;
-    name: string;
+    mime?: string | null;
+    name?: string | null;
     url: string;
 }
 interface MediaSingleProps extends MediaFile {

package/dist/admin/src/pages/formatComponentConfigurationEditLayout.d.ts

@@ -1,6 +1,7 @@
 import { ComponentsDictionary } from '../hooks/useContentTypeSchema';
 import { EditLayout } from '../hooks/useDocumentLayout';
 import type { Component, FindComponentConfiguration } from '../../../shared/contracts/components';
+import type { Schema } from '../hooks/useDocument';
 /**
  * Formats API configuration + schemas into the shape expected by the component
  * "Configure the view" form. Matches the ListView / content-type path: nested
@@ -8,8 +9,9 @@ import type { Component, FindComponentConfiguration } from '../../../shared/cont
  * and full component schemas so `getMainField` can resolve fields inside nested
  * component attributes (see #25509).
  */
-declare const formatComponentConfigurationEditLayout: (data: FindComponentConfiguration.Response['data'], { schema, components }: {
+declare const formatComponentConfigurationEditLayout: (data: FindComponentConfiguration.Response['data'], { schema, components, schemas, }: {
     schema?: Component;
     components: ComponentsDictionary;
+    schemas?: Schema[];
 }) => EditLayout;
 export { formatComponentConfigurationEditLayout };

package/dist/admin/src/utils/layouts/normalizeContentManagerLayout.d.ts

@@ -0,0 +1,24 @@
+import type { Component, FindComponentConfiguration } from '../../../../shared/contracts/components';
+import type { FindContentTypeConfiguration, FindContentTypesSettings, UpdateContentTypeConfiguration } from '../../../../shared/contracts/content-types';
+import type { ComponentsDictionary, Schema } from '../../hooks/useDocument';
+type ContentTypeConfigurationData = FindContentTypeConfiguration.Response['data'];
+type ComponentConfigurationData = FindComponentConfiguration.Response['data'];
+type ComponentConfigurationResponseData = ComponentConfigurationData['component'];
+type NormalizationContext = {
+    components: ComponentsDictionary;
+    schema?: Schema | Component;
+    schemas: Schema[];
+};
+type ComponentNormalizationContext = {
+    components: ComponentsDictionary;
+    schema?: Component;
+    schemas: Schema[];
+};
+declare const normalizeContentTypeConfigurationResponse: (data: unknown, uid?: string) => FindContentTypeConfiguration.Response['data'];
+declare const normalizeContentTypeConfigurationUpdateResponse: (data: unknown) => UpdateContentTypeConfiguration.Response['data'];
+declare const normalizeComponentConfigurationResponse: (data: unknown, uid?: string) => FindComponentConfiguration.Response['data'];
+declare const normalizeComponentConfigurationUpdateResponse: (data: unknown) => ComponentConfigurationResponseData;
+declare const normalizeContentTypeSettingsResponse: (data: unknown) => FindContentTypesSettings.Response['data'];
+declare const normalizeContentManagerLayout: (data: ContentTypeConfigurationData, context: NormalizationContext) => ContentTypeConfigurationData;
+declare const normalizeComponentConfigurationLayout: (data: ComponentConfigurationData, context: ComponentNormalizationContext) => ComponentConfigurationData;
+export { normalizeContentManagerLayout, normalizeComponentConfigurationLayout, normalizeContentTypeConfigurationResponse, normalizeContentTypeConfigurationUpdateResponse, normalizeComponentConfigurationResponse, normalizeComponentConfigurationUpdateResponse, normalizeContentTypeSettingsResponse, };

package/dist/admin/translations/en.json.js

@@ -47,6 +47,7 @@ var en = {
     "components.DynamicZone.move-up-label": "Move component up",
     "components.DynamicZone.pick-compo": "Pick one component",
     "components.DynamicZone.required": "Component is required",
+    "components.DynamicZone.unknown-component": "Unknown component",
     "components.DynamicZone.move-up": "Move up",
     "components.DynamicZone.move-down": "Move down",
     "components.EmptyAttributesBlock.button": "Go to settings page",

package/dist/admin/translations/en.json.js.map

@@ -1 +1 @@
-{"version":3,"file":"en.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"en.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/admin/translations/en.json.mjs

@@ -43,6 +43,7 @@ var en = {
     "components.DynamicZone.move-up-label": "Move component up",
     "components.DynamicZone.pick-compo": "Pick one component",
     "components.DynamicZone.required": "Component is required",
+    "components.DynamicZone.unknown-component": "Unknown component",
     "components.DynamicZone.move-up": "Move up",
     "components.DynamicZone.move-down": "Move down",
     "components.EmptyAttributesBlock.button": "Go to settings page",

package/dist/admin/translations/en.json.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"en.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"en.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/admin/utils/attributes.js

@@ -22,10 +22,25 @@ const checkIfAttributeIsDisplayable = (attribute)=>{
     if (!mainFieldName) {
         return undefined;
     }
-    const mainFieldType = attribute.type === 'component' ? components[attribute.component].attributes[mainFieldName].type : schemas.find((schema)=>schema.uid === attribute.targetModel)?.attributes[mainFieldName].type;
+    if (attribute.type === 'component') {
+        const mainFieldType = components[attribute.component]?.attributes?.[mainFieldName]?.type;
+        return {
+            name: mainFieldType ? mainFieldName : 'id',
+            type: mainFieldType ?? 'custom'
+        };
+    }
+    if (attribute.type === 'relation') {
+        const target = 'targetModel' in attribute ? attribute.targetModel : 'target' in attribute ? attribute.target : undefined;
+        const targetSchema = schemas.find((schema)=>schema.uid === target);
+        const mainFieldType = targetSchema?.attributes?.[mainFieldName]?.type;
+        return {
+            name: !targetSchema || mainFieldType ? mainFieldName : 'id',
+            type: mainFieldType ?? 'custom'
+        };
+    }
     return {
         name: mainFieldName,
-        type: mainFieldType ?? 'string'
+        type: 'string'
     };
 };
 

package/dist/admin/utils/attributes.js.map

@@ -1 +1 @@
-{"version":3,"file":"attributes.js","sources":["../../../admin/src/utils/attributes.ts"],"sourcesContent":["import type { ComponentsDictionary, Schema } from '../hooks/useDocument';\nimport type { Schema as SchemaUtils } from '@strapi/types';\n\nconst checkIfAttributeIsDisplayable = (attribute: SchemaUtils.Attribute.AnyAttribute) => {\n  const { type } = attribute;\n\n  if (type === 'relation') {\n    return !attribute.relation.toLowerCase().includes('morph');\n  }\n\n  return !['json', 'dynamiczone', 'richtext', 'password', 'blocks'].includes(type) && !!type;\n};\n\ninterface MainField {\n  name: string;\n  type: SchemaUtils.Attribute.Kind | 'custom';\n}\n\n/**\n * @internal\n * @description given an attribute, content-type schemas & component schemas, find the mainField name & type.\n * If the attribute does not need a `mainField` then we return undefined. If we do not find the type\n * of the field, we assume it's a string #sensible-defaults\n */\nconst getMainField = (\n  attribute: SchemaUtils.Attribute.AnyAttribute,\n  mainFieldName: string | undefined,\n  { schemas, components }: { schemas: Schema[]; components: ComponentsDictionary }\n): MainField | undefined => {\n  if (!mainFieldName) {\n    return undefined;\n  }\n\n  const mainFieldType =\n    attribute.type === 'component'\n      ? components[attribute.component].attributes[mainFieldName].type\n      : // @ts-expect-error – `targetModel` does exist on the attribute for a relation.\n        schemas.find((schema) => schema.uid === attribute.targetModel)?.attributes[mainFieldName]\n          .type;\n\n  return {\n    name: mainFieldName,\n    type: mainFieldType ?? 'string',\n  };\n};\n\nexport { checkIfAttributeIsDisplayable, getMainField };\nexport type { MainField };\n"],"names":["checkIfAttributeIsDisplayable","attribute","type","relation","toLowerCase","includes","getMainField","mainFieldName","schemas","components","undefined","mainFieldType","component","attributes","find","schema","uid","targetModel","name"],"mappings":";;AAGA,MAAMA,gCAAgC,CAACC,SAAAA,GAAAA;IACrC,MAAM,EAAEC,IAAI,EAAE,GAAGD,SAAAA;AAEjB,IAAA,IAAIC,SAAS,UAAA,EAAY;AACvB,QAAA,OAAO,CAACD,SAAAA,CAAUE,QAAQ,CAACC,WAAW,EAAA,CAAGC,QAAQ,CAAC,OAAA,CAAA;AACpD,IAAA;AAEA,IAAA,OAAO,CAAC;AAAC,QAAA,MAAA;AAAQ,QAAA,aAAA;AAAe,QAAA,UAAA;AAAY,QAAA,UAAA;AAAY,QAAA;AAAS,KAAA,CAACA,QAAQ,CAACH,IAAAA,CAAAA,IAAS,CAAC,CAACA,IAAAA;AACxF;AAOA;;;;;IAMA,MAAMI,eAAe,CACnBL,SAAAA,EACAM,eACA,EAAEC,OAAO,EAAEC,UAAU,EAA2D,GAAA;AAEhF,IAAA,IAAI,CAACF,aAAAA,EAAe;QAClB,OAAOG,SAAAA;AACT,IAAA;AAEA,IAAA,MAAMC,aAAAA,GACJV,SAAAA,CAAUC,IAAI,KAAK,WAAA,GACfO,UAAU,CAACR,SAAAA,CAAUW,SAAS,CAAC,CAACC,UAAU,CAACN,aAAAA,CAAc,CAACL,IAAI,GAE9DM,OAAAA,CAAQM,IAAI,CAAC,CAACC,SAAWA,MAAAA,CAAOC,GAAG,KAAKf,SAAAA,CAAUgB,WAAW,CAAA,EAAGJ,UAAU,CAACN,cAAc,CACtFL,IAAAA;IAET,OAAO;QACLgB,IAAAA,EAAMX,aAAAA;AACNL,QAAAA,IAAAA,EAAMS,aAAAA,IAAiB;AACzB,KAAA;AACF;;;;;"}
+{"version":3,"file":"attributes.js","sources":["../../../admin/src/utils/attributes.ts"],"sourcesContent":["import type { ComponentsDictionary, Schema } from '../hooks/useDocument';\nimport type { Schema as SchemaUtils } from '@strapi/types';\n\nconst checkIfAttributeIsDisplayable = (attribute: SchemaUtils.Attribute.AnyAttribute) => {\n  const { type } = attribute;\n\n  if (type === 'relation') {\n    return !attribute.relation.toLowerCase().includes('morph');\n  }\n\n  return !['json', 'dynamiczone', 'richtext', 'password', 'blocks'].includes(type) && !!type;\n};\n\ninterface MainField {\n  name: string;\n  type: SchemaUtils.Attribute.Kind | 'custom';\n}\n\n/**\n * @internal\n * @description given an attribute, content-type schemas & component schemas, find the mainField name & type.\n * If the attribute does not need a `mainField` then we return undefined. If we do not find the type\n * of the field, we assume it's a string #sensible-defaults\n */\nconst getMainField = (\n  attribute: SchemaUtils.Attribute.AnyAttribute,\n  mainFieldName: string | undefined,\n  { schemas, components }: { schemas: Schema[]; components: ComponentsDictionary }\n): MainField | undefined => {\n  if (!mainFieldName) {\n    return undefined;\n  }\n\n  if (attribute.type === 'component') {\n    const mainFieldType = components[attribute.component]?.attributes?.[mainFieldName]?.type;\n\n    return {\n      name: mainFieldType ? mainFieldName : 'id',\n      type: mainFieldType ?? 'custom',\n    };\n  }\n\n  if (attribute.type === 'relation') {\n    const target =\n      'targetModel' in attribute\n        ? attribute.targetModel\n        : 'target' in attribute\n          ? attribute.target\n          : undefined;\n    const targetSchema = schemas.find((schema) => schema.uid === target);\n    const mainFieldType = targetSchema?.attributes?.[mainFieldName]?.type;\n\n    return {\n      name: !targetSchema || mainFieldType ? mainFieldName : 'id',\n      type: mainFieldType ?? 'custom',\n    };\n  }\n\n  return {\n    name: mainFieldName,\n    type: 'string',\n  };\n};\n\nexport { checkIfAttributeIsDisplayable, getMainField };\nexport type { MainField };\n"],"names":["checkIfAttributeIsDisplayable","attribute","type","relation","toLowerCase","includes","getMainField","mainFieldName","schemas","components","undefined","mainFieldType","component","attributes","name","target","targetModel","targetSchema","find","schema","uid"],"mappings":";;AAGA,MAAMA,gCAAgC,CAACC,SAAAA,GAAAA;IACrC,MAAM,EAAEC,IAAI,EAAE,GAAGD,SAAAA;AAEjB,IAAA,IAAIC,SAAS,UAAA,EAAY;AACvB,QAAA,OAAO,CAACD,SAAAA,CAAUE,QAAQ,CAACC,WAAW,EAAA,CAAGC,QAAQ,CAAC,OAAA,CAAA;AACpD,IAAA;AAEA,IAAA,OAAO,CAAC;AAAC,QAAA,MAAA;AAAQ,QAAA,aAAA;AAAe,QAAA,UAAA;AAAY,QAAA,UAAA;AAAY,QAAA;AAAS,KAAA,CAACA,QAAQ,CAACH,IAAAA,CAAAA,IAAS,CAAC,CAACA,IAAAA;AACxF;AAOA;;;;;IAMA,MAAMI,eAAe,CACnBL,SAAAA,EACAM,eACA,EAAEC,OAAO,EAAEC,UAAU,EAA2D,GAAA;AAEhF,IAAA,IAAI,CAACF,aAAAA,EAAe;QAClB,OAAOG,SAAAA;AACT,IAAA;IAEA,IAAIT,SAAAA,CAAUC,IAAI,KAAK,WAAA,EAAa;QAClC,MAAMS,aAAAA,GAAgBF,UAAU,CAACR,SAAAA,CAAUW,SAAS,CAAC,EAAEC,UAAAA,GAAaN,aAAAA,CAAc,EAAEL,IAAAA;QAEpF,OAAO;AACLY,YAAAA,IAAAA,EAAMH,gBAAgBJ,aAAAA,GAAgB,IAAA;AACtCL,YAAAA,IAAAA,EAAMS,aAAAA,IAAiB;AACzB,SAAA;AACF,IAAA;IAEA,IAAIV,SAAAA,CAAUC,IAAI,KAAK,UAAA,EAAY;QACjC,MAAMa,MAAAA,GACJ,aAAA,IAAiBd,SAAAA,GACbA,SAAAA,CAAUe,WAAW,GACrB,QAAA,IAAYf,SAAAA,GACVA,SAAAA,CAAUc,MAAM,GAChBL,SAAAA;QACR,MAAMO,YAAAA,GAAeT,QAAQU,IAAI,CAAC,CAACC,MAAAA,GAAWA,MAAAA,CAAOC,GAAG,KAAKL,MAAAA,CAAAA;AAC7D,QAAA,MAAMJ,aAAAA,GAAgBM,YAAAA,EAAcJ,UAAAA,GAAaN,cAAc,EAAEL,IAAAA;QAEjE,OAAO;YACLY,IAAAA,EAAM,CAACG,YAAAA,IAAgBN,aAAAA,GAAgBJ,aAAAA,GAAgB,IAAA;AACvDL,YAAAA,IAAAA,EAAMS,aAAAA,IAAiB;AACzB,SAAA;AACF,IAAA;IAEA,OAAO;QACLG,IAAAA,EAAMP,aAAAA;QACNL,IAAAA,EAAM;AACR,KAAA;AACF;;;;;"}

package/dist/admin/utils/attributes.mjs

@@ -20,10 +20,25 @@ const checkIfAttributeIsDisplayable = (attribute)=>{
     if (!mainFieldName) {
         return undefined;
     }
-    const mainFieldType = attribute.type === 'component' ? components[attribute.component].attributes[mainFieldName].type : schemas.find((schema)=>schema.uid === attribute.targetModel)?.attributes[mainFieldName].type;
+    if (attribute.type === 'component') {
+        const mainFieldType = components[attribute.component]?.attributes?.[mainFieldName]?.type;
+        return {
+            name: mainFieldType ? mainFieldName : 'id',
+            type: mainFieldType ?? 'custom'
+        };
+    }
+    if (attribute.type === 'relation') {
+        const target = 'targetModel' in attribute ? attribute.targetModel : 'target' in attribute ? attribute.target : undefined;
+        const targetSchema = schemas.find((schema)=>schema.uid === target);
+        const mainFieldType = targetSchema?.attributes?.[mainFieldName]?.type;
+        return {
+            name: !targetSchema || mainFieldType ? mainFieldName : 'id',
+            type: mainFieldType ?? 'custom'
+        };
+    }
     return {
         name: mainFieldName,
-        type: mainFieldType ?? 'string'
+        type: 'string'
     };
 };
 

package/dist/admin/utils/attributes.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"attributes.mjs","sources":["../../../admin/src/utils/attributes.ts"],"sourcesContent":["import type { ComponentsDictionary, Schema } from '../hooks/useDocument';\nimport type { Schema as SchemaUtils } from '@strapi/types';\n\nconst checkIfAttributeIsDisplayable = (attribute: SchemaUtils.Attribute.AnyAttribute) => {\n  const { type } = attribute;\n\n  if (type === 'relation') {\n    return !attribute.relation.toLowerCase().includes('morph');\n  }\n\n  return !['json', 'dynamiczone', 'richtext', 'password', 'blocks'].includes(type) && !!type;\n};\n\ninterface MainField {\n  name: string;\n  type: SchemaUtils.Attribute.Kind | 'custom';\n}\n\n/**\n * @internal\n * @description given an attribute, content-type schemas & component schemas, find the mainField name & type.\n * If the attribute does not need a `mainField` then we return undefined. If we do not find the type\n * of the field, we assume it's a string #sensible-defaults\n */\nconst getMainField = (\n  attribute: SchemaUtils.Attribute.AnyAttribute,\n  mainFieldName: string | undefined,\n  { schemas, components }: { schemas: Schema[]; components: ComponentsDictionary }\n): MainField | undefined => {\n  if (!mainFieldName) {\n    return undefined;\n  }\n\n  const mainFieldType =\n    attribute.type === 'component'\n      ? components[attribute.component].attributes[mainFieldName].type\n      : // @ts-expect-error – `targetModel` does exist on the attribute for a relation.\n        schemas.find((schema) => schema.uid === attribute.targetModel)?.attributes[mainFieldName]\n          .type;\n\n  return {\n    name: mainFieldName,\n    type: mainFieldType ?? 'string',\n  };\n};\n\nexport { checkIfAttributeIsDisplayable, getMainField };\nexport type { MainField };\n"],"names":["checkIfAttributeIsDisplayable","attribute","type","relation","toLowerCase","includes","getMainField","mainFieldName","schemas","components","undefined","mainFieldType","component","attributes","find","schema","uid","targetModel","name"],"mappings":"AAGA,MAAMA,gCAAgC,CAACC,SAAAA,GAAAA;IACrC,MAAM,EAAEC,IAAI,EAAE,GAAGD,SAAAA;AAEjB,IAAA,IAAIC,SAAS,UAAA,EAAY;AACvB,QAAA,OAAO,CAACD,SAAAA,CAAUE,QAAQ,CAACC,WAAW,EAAA,CAAGC,QAAQ,CAAC,OAAA,CAAA;AACpD,IAAA;AAEA,IAAA,OAAO,CAAC;AAAC,QAAA,MAAA;AAAQ,QAAA,aAAA;AAAe,QAAA,UAAA;AAAY,QAAA,UAAA;AAAY,QAAA;AAAS,KAAA,CAACA,QAAQ,CAACH,IAAAA,CAAAA,IAAS,CAAC,CAACA,IAAAA;AACxF;AAOA;;;;;IAMA,MAAMI,eAAe,CACnBL,SAAAA,EACAM,eACA,EAAEC,OAAO,EAAEC,UAAU,EAA2D,GAAA;AAEhF,IAAA,IAAI,CAACF,aAAAA,EAAe;QAClB,OAAOG,SAAAA;AACT,IAAA;AAEA,IAAA,MAAMC,aAAAA,GACJV,SAAAA,CAAUC,IAAI,KAAK,WAAA,GACfO,UAAU,CAACR,SAAAA,CAAUW,SAAS,CAAC,CAACC,UAAU,CAACN,aAAAA,CAAc,CAACL,IAAI,GAE9DM,OAAAA,CAAQM,IAAI,CAAC,CAACC,SAAWA,MAAAA,CAAOC,GAAG,KAAKf,SAAAA,CAAUgB,WAAW,CAAA,EAAGJ,UAAU,CAACN,cAAc,CACtFL,IAAAA;IAET,OAAO;QACLgB,IAAAA,EAAMX,aAAAA;AACNL,QAAAA,IAAAA,EAAMS,aAAAA,IAAiB;AACzB,KAAA;AACF;;;;"}
+{"version":3,"file":"attributes.mjs","sources":["../../../admin/src/utils/attributes.ts"],"sourcesContent":["import type { ComponentsDictionary, Schema } from '../hooks/useDocument';\nimport type { Schema as SchemaUtils } from '@strapi/types';\n\nconst checkIfAttributeIsDisplayable = (attribute: SchemaUtils.Attribute.AnyAttribute) => {\n  const { type } = attribute;\n\n  if (type === 'relation') {\n    return !attribute.relation.toLowerCase().includes('morph');\n  }\n\n  return !['json', 'dynamiczone', 'richtext', 'password', 'blocks'].includes(type) && !!type;\n};\n\ninterface MainField {\n  name: string;\n  type: SchemaUtils.Attribute.Kind | 'custom';\n}\n\n/**\n * @internal\n * @description given an attribute, content-type schemas & component schemas, find the mainField name & type.\n * If the attribute does not need a `mainField` then we return undefined. If we do not find the type\n * of the field, we assume it's a string #sensible-defaults\n */\nconst getMainField = (\n  attribute: SchemaUtils.Attribute.AnyAttribute,\n  mainFieldName: string | undefined,\n  { schemas, components }: { schemas: Schema[]; components: ComponentsDictionary }\n): MainField | undefined => {\n  if (!mainFieldName) {\n    return undefined;\n  }\n\n  if (attribute.type === 'component') {\n    const mainFieldType = components[attribute.component]?.attributes?.[mainFieldName]?.type;\n\n    return {\n      name: mainFieldType ? mainFieldName : 'id',\n      type: mainFieldType ?? 'custom',\n    };\n  }\n\n  if (attribute.type === 'relation') {\n    const target =\n      'targetModel' in attribute\n        ? attribute.targetModel\n        : 'target' in attribute\n          ? attribute.target\n          : undefined;\n    const targetSchema = schemas.find((schema) => schema.uid === target);\n    const mainFieldType = targetSchema?.attributes?.[mainFieldName]?.type;\n\n    return {\n      name: !targetSchema || mainFieldType ? mainFieldName : 'id',\n      type: mainFieldType ?? 'custom',\n    };\n  }\n\n  return {\n    name: mainFieldName,\n    type: 'string',\n  };\n};\n\nexport { checkIfAttributeIsDisplayable, getMainField };\nexport type { MainField };\n"],"names":["checkIfAttributeIsDisplayable","attribute","type","relation","toLowerCase","includes","getMainField","mainFieldName","schemas","components","undefined","mainFieldType","component","attributes","name","target","targetModel","targetSchema","find","schema","uid"],"mappings":"AAGA,MAAMA,gCAAgC,CAACC,SAAAA,GAAAA;IACrC,MAAM,EAAEC,IAAI,EAAE,GAAGD,SAAAA;AAEjB,IAAA,IAAIC,SAAS,UAAA,EAAY;AACvB,QAAA,OAAO,CAACD,SAAAA,CAAUE,QAAQ,CAACC,WAAW,EAAA,CAAGC,QAAQ,CAAC,OAAA,CAAA;AACpD,IAAA;AAEA,IAAA,OAAO,CAAC;AAAC,QAAA,MAAA;AAAQ,QAAA,aAAA;AAAe,QAAA,UAAA;AAAY,QAAA,UAAA;AAAY,QAAA;AAAS,KAAA,CAACA,QAAQ,CAACH,IAAAA,CAAAA,IAAS,CAAC,CAACA,IAAAA;AACxF;AAOA;;;;;IAMA,MAAMI,eAAe,CACnBL,SAAAA,EACAM,eACA,EAAEC,OAAO,EAAEC,UAAU,EAA2D,GAAA;AAEhF,IAAA,IAAI,CAACF,aAAAA,EAAe;QAClB,OAAOG,SAAAA;AACT,IAAA;IAEA,IAAIT,SAAAA,CAAUC,IAAI,KAAK,WAAA,EAAa;QAClC,MAAMS,aAAAA,GAAgBF,UAAU,CAACR,SAAAA,CAAUW,SAAS,CAAC,EAAEC,UAAAA,GAAaN,aAAAA,CAAc,EAAEL,IAAAA;QAEpF,OAAO;AACLY,YAAAA,IAAAA,EAAMH,gBAAgBJ,aAAAA,GAAgB,IAAA;AACtCL,YAAAA,IAAAA,EAAMS,aAAAA,IAAiB;AACzB,SAAA;AACF,IAAA;IAEA,IAAIV,SAAAA,CAAUC,IAAI,KAAK,UAAA,EAAY;QACjC,MAAMa,MAAAA,GACJ,aAAA,IAAiBd,SAAAA,GACbA,SAAAA,CAAUe,WAAW,GACrB,QAAA,IAAYf,SAAAA,GACVA,SAAAA,CAAUc,MAAM,GAChBL,SAAAA;QACR,MAAMO,YAAAA,GAAeT,QAAQU,IAAI,CAAC,CAACC,MAAAA,GAAWA,MAAAA,CAAOC,GAAG,KAAKL,MAAAA,CAAAA;AAC7D,QAAA,MAAMJ,aAAAA,GAAgBM,YAAAA,EAAcJ,UAAAA,GAAaN,cAAc,EAAEL,IAAAA;QAEjE,OAAO;YACLY,IAAAA,EAAM,CAACG,YAAAA,IAAgBN,aAAAA,GAAgBJ,aAAAA,GAAgB,IAAA;AACvDL,YAAAA,IAAAA,EAAMS,aAAAA,IAAiB;AACzB,SAAA;AACF,IAAA;IAEA,OAAO;QACLG,IAAAA,EAAMP,aAAAA;QACNL,IAAAA,EAAM;AACR,KAAA;AACF;;;;"}

package/dist/admin/utils/layouts/normalizeContentManagerLayout.js

@@ -0,0 +1,329 @@
+'use strict';
+
+const DEFAULT_RESPONSE_SETTINGS = {
+    bulkable: true,
+    filterable: true,
+    searchable: true,
+    pageSize: 10,
+    mainField: 'id',
+    defaultSortBy: '',
+    defaultSortOrder: 'ASC'
+};
+const isRecord = (value)=>{
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+};
+const warnOnceInDevelopment = (()=>{
+    const warnings = new Set();
+    return (message)=>{
+        if (process.env.NODE_ENV !== 'development' || warnings.has(message)) {
+            return;
+        }
+        warnings.add(message);
+        console.warn(`[Content Manager] ${message}`);
+    };
+})();
+const normalizeResponseSettings = (settings, path)=>{
+    if (!isRecord(settings)) {
+        warnOnceInDevelopment(`Received malformed settings at "${path}". Falling back to defaults.`);
+    }
+    return {
+        ...DEFAULT_RESPONSE_SETTINGS,
+        ...isRecord(settings) ? settings : {}
+    };
+};
+const normalizeResponseMetadatas = (metadatas, path)=>{
+    if (!isRecord(metadatas)) {
+        warnOnceInDevelopment(`Received malformed metadatas at "${path}". Falling back to empty.`);
+        return {};
+    }
+    return Object.entries(metadatas).reduce((acc, [name, metadata])=>{
+        const metadataRecord = isRecord(metadata) ? metadata : {};
+        if (!isRecord(metadata)) {
+            warnOnceInDevelopment(`Received malformed metadata for "${path}.${name}". Repairing entry.`);
+        }
+        if (!isRecord(metadataRecord.edit)) {
+            warnOnceInDevelopment(`Received malformed edit metadata for "${path}.${name}". Falling back to empty.`);
+        }
+        if (!isRecord(metadataRecord.list)) {
+            warnOnceInDevelopment(`Received malformed list metadata for "${path}.${name}". Falling back to empty.`);
+        }
+        acc[name] = {
+            edit: isRecord(metadataRecord.edit) ? metadataRecord.edit : {},
+            list: isRecord(metadataRecord.list) ? metadataRecord.list : {}
+        };
+        return acc;
+    }, {});
+};
+const normalizeResponseLayouts = (layouts, path)=>{
+    if (!isRecord(layouts)) {
+        warnOnceInDevelopment(`Received malformed layouts at "${path}". Falling back to empty.`);
+        return {
+            edit: [],
+            list: []
+        };
+    }
+    if (!Array.isArray(layouts.edit)) {
+        warnOnceInDevelopment(`Received malformed edit layout at "${path}". Falling back to empty.`);
+    }
+    if (!Array.isArray(layouts.list)) {
+        warnOnceInDevelopment(`Received malformed list layout at "${path}". Falling back to empty.`);
+    }
+    return {
+        edit: Array.isArray(layouts.edit) ? layouts.edit.map((row, rowIndex)=>{
+            if (!Array.isArray(row)) {
+                warnOnceInDevelopment(`Dropped malformed edit layout row "${path}.edit.${rowIndex}".`);
+                return [];
+            }
+            return row.filter((field, fieldIndex)=>{
+                const isValidField = isRecord(field) && typeof field.name === 'string' && typeof field.size === 'number';
+                if (!isValidField) {
+                    warnOnceInDevelopment(`Dropped malformed edit layout field "${path}.edit.${rowIndex}.${fieldIndex}".`);
+                }
+                return isValidField;
+            });
+        }) : [],
+        list: Array.isArray(layouts.list) ? layouts.list.filter((field, index)=>{
+            const isValidField = typeof field === 'string';
+            if (!isValidField) {
+                warnOnceInDevelopment(`Dropped malformed list layout field "${path}.list.${index}".`);
+            }
+            return isValidField;
+        }) : []
+    };
+};
+const normalizeConfigurationResponse = (configuration, uid, path = uid ?? 'configuration')=>{
+    if (!isRecord(configuration)) {
+        warnOnceInDevelopment(`Received malformed configuration at "${path}". Repairing entry.`);
+    }
+    const configurationRecord = isRecord(configuration) ? configuration : {};
+    return {
+        ...configurationRecord,
+        ...uid ? {
+            uid
+        } : {},
+        settings: normalizeResponseSettings(configurationRecord.settings, `${path}.settings`),
+        metadatas: normalizeResponseMetadatas(configurationRecord.metadatas, `${path}.metadatas`),
+        layouts: normalizeResponseLayouts(configurationRecord.layouts, `${path}.layouts`)
+    };
+};
+const normalizeComponentsRecord = (components)=>{
+    if (!isRecord(components)) {
+        warnOnceInDevelopment('Received malformed component configuration record. Falling back to empty.');
+        return {};
+    }
+    return Object.entries(components).reduce((acc, [uid, configuration])=>{
+        acc[uid] = normalizeConfigurationResponse(configuration, uid, `components.${uid}`);
+        return acc;
+    }, {});
+};
+const normalizeContentTypeConfigurationResponse = (data, uid)=>{
+    if (!isRecord(data)) {
+        warnOnceInDevelopment('Received malformed content-type configuration response. Repairing data.');
+    }
+    const dataRecord = isRecord(data) ? data : {};
+    return {
+        contentType: normalizeConfigurationResponse(dataRecord.contentType, uid, 'contentType'),
+        components: normalizeComponentsRecord(dataRecord.components)
+    };
+};
+const normalizeContentTypeConfigurationUpdateResponse = (data)=>{
+    if (!isRecord(data)) {
+        warnOnceInDevelopment('Received malformed content-type configuration update response. Repairing data.');
+    }
+    const dataRecord = isRecord(data) ? data : {};
+    return {
+        contentType: normalizeConfigurationResponse(dataRecord.contentType, undefined, 'contentType'),
+        components: normalizeComponentsRecord(dataRecord.components)
+    };
+};
+const normalizeComponentConfigurationResponse = (data, uid)=>{
+    if (!isRecord(data)) {
+        warnOnceInDevelopment('Received malformed component configuration response. Repairing data.');
+    }
+    const dataRecord = isRecord(data) ? data : {};
+    return {
+        component: normalizeConfigurationResponse(dataRecord.component, uid, 'component'),
+        components: normalizeComponentsRecord(dataRecord.components)
+    };
+};
+const normalizeComponentConfigurationUpdateResponse = (data)=>{
+    return normalizeConfigurationResponse(data, undefined, 'component');
+};
+const normalizeContentTypeSettingsResponse = (data)=>{
+    if (!Array.isArray(data)) {
+        warnOnceInDevelopment('Received malformed content-type settings response. Falling back to empty.');
+        return [];
+    }
+    return data.filter((entry, index)=>{
+        const isValidEntry = isRecord(entry);
+        if (!isValidEntry) {
+            warnOnceInDevelopment(`Dropped malformed content-type settings entry "${index}".`);
+        }
+        return isValidEntry;
+    }).filter((entry)=>{
+        const hasUid = typeof entry.uid === 'string';
+        if (!hasUid) {
+            warnOnceInDevelopment('Dropped content-type settings entry without a uid.');
+        }
+        return hasUid;
+    }).map((entry)=>({
+            uid: entry.uid,
+            settings: normalizeResponseSettings(entry.settings, `contentTypeSettings.${entry.uid}`)
+        }));
+};
+const hasAttribute = (attributes, name)=>{
+    return Boolean(name && attributes?.[name]);
+};
+const getTargetAttributes = (attribute, { components, schemas })=>{
+    if (attribute.type === 'component') {
+        return components[attribute.component]?.attributes;
+    }
+    if (attribute.type === 'relation') {
+        const target = 'targetModel' in attribute ? attribute.targetModel : 'target' in attribute ? attribute.target : undefined;
+        return schemas.find((schema)=>schema.uid === target)?.attributes;
+    }
+    return undefined;
+};
+const hasTargetSchema = (attribute, { schemas })=>{
+    if (attribute.type !== 'relation') {
+        return true;
+    }
+    const target = 'targetModel' in attribute ? attribute.targetModel : 'target' in attribute ? attribute.target : undefined;
+    return schemas.some((schema)=>schema.uid === target);
+};
+const normalizeMainField = (attribute, mainField, context, path)=>{
+    if (!mainField) {
+        return mainField;
+    }
+    const targetAttributes = getTargetAttributes(attribute, context);
+    if (!targetAttributes) {
+        if (attribute.type === 'relation' && !hasTargetSchema(attribute, context)) {
+            return mainField;
+        }
+        if (attribute.type !== 'component' && attribute.type !== 'relation') {
+            return mainField;
+        }
+        warnOnceInDevelopment(`Reset invalid mainField "${mainField}" at "${path}" to "id".`);
+        return 'id';
+    }
+    if (hasAttribute(targetAttributes, mainField)) {
+        return mainField;
+    }
+    warnOnceInDevelopment(`Reset invalid mainField "${mainField}" at "${path}" to "id".`);
+    return 'id';
+};
+const normalizeSettings = (settings, attributes, path)=>{
+    if (!settings.mainField || hasAttribute(attributes, settings.mainField) || settings.mainField === 'id') {
+        return settings;
+    }
+    warnOnceInDevelopment(`Reset invalid mainField "${settings.mainField}" at "${path}" to "id".`);
+    return {
+        ...settings,
+        mainField: 'id'
+    };
+};
+const hasResolvableComponent = (attribute, context)=>{
+    if (!attribute || !('component' in attribute) || typeof attribute.component !== 'string') {
+        return true;
+    }
+    return Boolean(context.components[attribute.component]);
+};
+const normalizeMetadatas = (metadatas, attributes, context, path)=>{
+    return Object.entries(metadatas).reduce((acc, [name, metadata])=>{
+        const attribute = attributes?.[name];
+        if (!attribute) {
+            warnOnceInDevelopment(`Dropped metadata for unknown field "${path}.metadatas.${name}".`);
+            return acc;
+        }
+        if (!hasResolvableComponent(attribute, context)) {
+            warnOnceInDevelopment(`Dropped metadata for field "${path}.metadatas.${name}" because its component schema is unavailable.`);
+            return acc;
+        }
+        acc[name] = {
+            edit: {
+                ...metadata.edit,
+                // `mainField` is present at runtime for component/relation edit metadata.
+                ...'mainField' in metadata.edit ? {
+                    mainField: normalizeMainField(attribute, metadata.edit.mainField, context, `${path}.metadatas.${name}.edit.mainField`)
+                } : {}
+            },
+            list: {
+                ...metadata.list,
+                mainField: normalizeMainField(attribute, metadata.list.mainField, context, `${path}.metadatas.${name}.list.mainField`)
+            }
+        };
+        return acc;
+    }, {});
+};
+const normalizeLayouts = (layouts, attributes, metadatas, context, path)=>{
+    const hasRenderableField = (name)=>{
+        const attribute = attributes?.[name];
+        return Boolean(attribute && metadatas[name] && hasResolvableComponent(attribute, context));
+    };
+    return {
+        edit: (layouts.edit ?? []).map((row, rowIndex)=>row.filter((field)=>{
+                const isRenderable = hasRenderableField(field.name);
+                if (!isRenderable) {
+                    warnOnceInDevelopment(`Dropped non-renderable edit layout field "${path}.layouts.edit.${rowIndex}.${field.name}".`);
+                }
+                return isRenderable;
+            })).filter((row)=>row.length > 0),
+        list: (layouts.list ?? []).filter((name, index)=>{
+            const isRenderable = hasRenderableField(name);
+            if (!isRenderable) {
+                warnOnceInDevelopment(`Dropped non-renderable list layout field "${path}.layouts.list.${index}.${name}".`);
+            }
+            return isRenderable;
+        })
+    };
+};
+const normalizeConfiguration = (configuration, attributes, context)=>{
+    const path = configuration.uid ?? 'configuration';
+    const metadatas = normalizeMetadatas(configuration.metadatas, attributes, context, path);
+    const layouts = normalizeLayouts(configuration.layouts, attributes, metadatas, context, path);
+    return {
+        ...configuration,
+        settings: normalizeSettings(configuration.settings, attributes, `${path}.settings.mainField`),
+        metadatas,
+        layouts
+    };
+};
+const normalizeComponents = (componentConfigurations, context)=>{
+    return Object.entries(componentConfigurations).reduce((acc, [uid, configuration])=>{
+        const componentSchema = context.components[uid];
+        if (!componentSchema) {
+            return acc;
+        }
+        acc[uid] = normalizeConfiguration(configuration, componentSchema.attributes, context);
+        return acc;
+    }, {});
+};
+const normalizeContentManagerLayout = (data, context)=>{
+    const normalizedComponents = normalizeComponents(data.components, context);
+    return {
+        contentType: normalizeConfiguration(data.contentType, context.schema?.attributes, context),
+        components: normalizedComponents
+    };
+};
+const normalizeComponentConfigurationLayout = (data, context)=>{
+    const normalizedComponents = normalizeComponents(data.components, {
+        components: context.components,
+        schemas: context.schemas
+    });
+    return {
+        component: normalizeConfiguration(data.component, context.schema?.attributes, {
+            components: context.components,
+            schemas: context.schemas
+        }),
+        components: normalizedComponents
+    };
+};
+
+exports.normalizeComponentConfigurationLayout = normalizeComponentConfigurationLayout;
+exports.normalizeComponentConfigurationResponse = normalizeComponentConfigurationResponse;
+exports.normalizeComponentConfigurationUpdateResponse = normalizeComponentConfigurationUpdateResponse;
+exports.normalizeContentManagerLayout = normalizeContentManagerLayout;
+exports.normalizeContentTypeConfigurationResponse = normalizeContentTypeConfigurationResponse;
+exports.normalizeContentTypeConfigurationUpdateResponse = normalizeContentTypeConfigurationUpdateResponse;
+exports.normalizeContentTypeSettingsResponse = normalizeContentTypeSettingsResponse;
+//# sourceMappingURL=normalizeContentManagerLayout.js.map