@strapi/content-manager 0.0.0-experimental.e0df4d50334a17a1beb3d203bff414fbbff62f7b → 0.0.0-experimental.e100737b0ed96d0d80a5c6f4925c7374e63a342a

package/dist/admin/hooks/useContentTypeSchema.mjs

@@ -0,0 +1,93 @@
+import * as React from 'react';
+import { useNotification, useAPIErrorHandler } from '@strapi/admin/strapi-admin';
+import { useGetInitialDataQuery } from '../services/init.mjs';
+
+/**
+ * @internal
+ * @description Given a model UID, return the schema and the schemas
+ * of the associated components within said model's schema. A wrapper
+ * implementation around the `useGetInitialDataQuery` with a unique
+ * `selectFromResult` function to memoize the calculation.
+ *
+ * If no model is provided, the hook will return all the schemas.
+ */ const useContentTypeSchema = (model)=>{
+    const { toggleNotification } = useNotification();
+    const { _unstableFormatAPIError: formatAPIError } = useAPIErrorHandler();
+    const { data, error, isLoading, isFetching } = useGetInitialDataQuery(undefined);
+    const { components, contentType, contentTypes } = React.useMemo(()=>{
+        const contentType = data?.contentTypes.find((ct)=>ct.uid === model);
+        const componentsByKey = data?.components.reduce((acc, component)=>{
+            acc[component.uid] = component;
+            return acc;
+        }, {});
+        const components = extractContentTypeComponents(contentType?.attributes, componentsByKey);
+        return {
+            components: Object.keys(components).length === 0 ? undefined : components,
+            contentType,
+            contentTypes: data?.contentTypes ?? []
+        };
+    }, [
+        model,
+        data
+    ]);
+    React.useEffect(()=>{
+        if (error) {
+            toggleNotification({
+                type: 'danger',
+                message: formatAPIError(error)
+            });
+        }
+    }, [
+        toggleNotification,
+        error,
+        formatAPIError
+    ]);
+    return {
+        // This must be memoized to avoid inifiinite re-renders where the empty object is different everytime.
+        components: React.useMemo(()=>components ?? {}, [
+            components
+        ]),
+        schema: contentType,
+        schemas: contentTypes,
+        isLoading: isLoading || isFetching
+    };
+};
+/* -------------------------------------------------------------------------------------------------
+ * extractContentTypeComponents
+ * -----------------------------------------------------------------------------------------------*/ /**
+ * @internal
+ * @description Extracts the components used in a content type's attributes recursively.
+ */ const extractContentTypeComponents = (attributes = {}, allComponents = {})=>{
+    const getComponents = (attributes)=>{
+        return attributes.reduce((acc, attribute)=>{
+            /**
+       * If the attribute is a component or dynamiczone, we need to recursively
+       * extract the component UIDs from its attributes.
+       */ if (attribute.type === 'component') {
+                const componentAttributes = Object.values(allComponents[attribute.component]?.attributes ?? {});
+                acc.push(attribute.component, ...getComponents(componentAttributes));
+            } else if (attribute.type === 'dynamiczone') {
+                acc.push(...attribute.components, /**
+           * Dynamic zones have an array of components, so we flatMap over them
+           * performing the same search as above.
+           */ ...attribute.components.flatMap((componentUid)=>{
+                    const componentAttributes = Object.values(allComponents[componentUid]?.attributes ?? {});
+                    return getComponents(componentAttributes);
+                }));
+            }
+            return acc;
+        }, []);
+    };
+    const componentUids = getComponents(Object.values(attributes));
+    const uniqueComponentUids = [
+        ...new Set(componentUids)
+    ];
+    const componentsByKey = uniqueComponentUids.reduce((acc, uid)=>{
+        acc[uid] = allComponents[uid];
+        return acc;
+    }, {});
+    return componentsByKey;
+};
+
+export { extractContentTypeComponents, useContentTypeSchema };
+//# sourceMappingURL=useContentTypeSchema.mjs.map

package/dist/admin/hooks/useContentTypeSchema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useContentTypeSchema.mjs","sources":["../../../admin/src/hooks/useContentTypeSchema.ts"],"sourcesContent":["import * as React from 'react';\n\nimport { useNotification, useAPIErrorHandler } from '@strapi/admin/strapi-admin';\n\nimport { useGetInitialDataQuery } from '../services/init';\n\nimport type { Component } from '../../../shared/contracts/components';\nimport type { ContentType } from '../../../shared/contracts/content-types';\nimport type { Schema } from '@strapi/types';\n\n/* -------------------------------------------------------------------------------------------------\n * useContentTypeSchema\n * -----------------------------------------------------------------------------------------------*/\ntype ComponentsDictionary = Record<string, Component>;\n\n/**\n * @internal\n * @description Given a model UID, return the schema and the schemas\n * of the associated components within said model's schema. A wrapper\n * implementation around the `useGetInitialDataQuery` with a unique\n * `selectFromResult` function to memoize the calculation.\n *\n * If no model is provided, the hook will return all the schemas.\n */\nconst useContentTypeSchema = (model?: string) => {\n  const { toggleNotification } = useNotification();\n  const { _unstableFormatAPIError: formatAPIError } = useAPIErrorHandler();\n\n  const { data, error, isLoading, isFetching } = useGetInitialDataQuery(undefined);\n\n  const { components, contentType, contentTypes } = React.useMemo(() => {\n    const contentType = data?.contentTypes.find((ct) => ct.uid === model);\n\n    const componentsByKey = data?.components.reduce<ComponentsDictionary>((acc, component) => {\n      acc[component.uid] = component;\n\n      return acc;\n    }, {});\n\n    const components = extractContentTypeComponents(contentType?.attributes, componentsByKey);\n\n    return {\n      components: Object.keys(components).length === 0 ? undefined : components,\n      contentType,\n      contentTypes: data?.contentTypes ?? [],\n    };\n  }, [model, data]);\n\n  React.useEffect(() => {\n    if (error) {\n      toggleNotification({\n        type: 'danger',\n        message: formatAPIError(error),\n      });\n    }\n  }, [toggleNotification, error, formatAPIError]);\n\n  return {\n    // This must be memoized to avoid inifiinite re-renders where the empty object is different everytime.\n    components: React.useMemo(() => components ?? {}, [components]),\n    schema: contentType,\n    schemas: contentTypes,\n    isLoading: isLoading || isFetching,\n  };\n};\n\n/* -------------------------------------------------------------------------------------------------\n * extractContentTypeComponents\n * -----------------------------------------------------------------------------------------------*/\n/**\n * @internal\n * @description Extracts the components used in a content type's attributes recursively.\n */\nconst extractContentTypeComponents = (\n  attributes: ContentType['attributes'] = {},\n  allComponents: ComponentsDictionary = {}\n): ComponentsDictionary => {\n  const getComponents = (attributes: Schema.Attribute.AnyAttribute[]) => {\n    return attributes.reduce<string[]>((acc, attribute) => {\n      /**\n       * If the attribute is a component or dynamiczone, we need to recursively\n       * extract the component UIDs from its attributes.\n       */\n      if (attribute.type === 'component') {\n        const componentAttributes = Object.values(\n          allComponents[attribute.component]?.attributes ?? {}\n        );\n\n        acc.push(attribute.component, ...getComponents(componentAttributes));\n      } else if (attribute.type === 'dynamiczone') {\n        acc.push(\n          ...attribute.components,\n          /**\n           * Dynamic zones have an array of components, so we flatMap over them\n           * performing the same search as above.\n           */\n          ...attribute.components.flatMap((componentUid) => {\n            const componentAttributes = Object.values(\n              allComponents[componentUid]?.attributes ?? {}\n            );\n\n            return getComponents(componentAttributes);\n          })\n        );\n      }\n\n      return acc;\n    }, []);\n  };\n\n  const componentUids = getComponents(Object.values(attributes));\n\n  const uniqueComponentUids = [...new Set(componentUids)];\n\n  const componentsByKey = uniqueComponentUids.reduce<ComponentsDictionary>((acc, uid) => {\n    acc[uid] = allComponents[uid];\n\n    return acc;\n  }, {});\n\n  return componentsByKey;\n};\n\nexport { useContentTypeSchema, extractContentTypeComponents };\nexport type { ComponentsDictionary };\n"],"names":["useContentTypeSchema","model","toggleNotification","useNotification","_unstableFormatAPIError","formatAPIError","useAPIErrorHandler","data","error","isLoading","isFetching","useGetInitialDataQuery","undefined","components","contentType","contentTypes","React","useMemo","find","ct","uid","componentsByKey","reduce","acc","component","extractContentTypeComponents","attributes","Object","keys","length","useEffect","type","message","schema","schemas","allComponents","getComponents","attribute","componentAttributes","values","push","flatMap","componentUid","componentUids","uniqueComponentUids","Set"],"mappings":"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"}

package/dist/admin/hooks/useDebounce.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var React = require('react');
+
+function useDebounce(value, delay) {
+    const [debouncedValue, setDebouncedValue] = React.useState(value);
+    React.useEffect(()=>{
+        const handler = setTimeout(()=>{
+            setDebouncedValue(value);
+        }, delay);
+        return ()=>{
+            clearTimeout(handler);
+        };
+    }, [
+        value,
+        delay
+    ]);
+    return debouncedValue;
+}
+
+exports.useDebounce = useDebounce;
+//# sourceMappingURL=useDebounce.js.map

package/dist/admin/hooks/useDebounce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDebounce.js","sources":["../../../admin/src/hooks/useDebounce.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\n\nexport function useDebounce<TValue>(value: TValue, delay: number): TValue {\n  const [debouncedValue, setDebouncedValue] = useState(value);\n\n  useEffect(() => {\n    const handler = setTimeout(() => {\n      setDebouncedValue(value);\n    }, delay);\n\n    return () => {\n      clearTimeout(handler);\n    };\n  }, [value, delay]);\n\n  return debouncedValue;\n}\n"],"names":["useDebounce","value","delay","debouncedValue","setDebouncedValue","useState","useEffect","handler","setTimeout","clearTimeout"],"mappings":";;;;AAEO,SAASA,WAAAA,CAAoBC,KAAa,EAAEC,KAAa,EAAA;AAC9D,IAAA,MAAM,CAACC,cAAAA,EAAgBC,iBAAkB,CAAA,GAAGC,cAASJ,CAAAA,KAAAA,CAAAA;IAErDK,eAAU,CAAA,IAAA;AACR,QAAA,MAAMC,UAAUC,UAAW,CAAA,IAAA;YACzBJ,iBAAkBH,CAAAA,KAAAA,CAAAA;SACjBC,EAAAA,KAAAA,CAAAA;QAEH,OAAO,IAAA;YACLO,YAAaF,CAAAA,OAAAA,CAAAA;AACf,SAAA;KACC,EAAA;AAACN,QAAAA,KAAAA;AAAOC,QAAAA;AAAM,KAAA,CAAA;IAEjB,OAAOC,cAAAA;AACT;;;;"}

package/dist/admin/hooks/useDebounce.mjs

@@ -0,0 +1,20 @@
+import { useState, useEffect } from 'react';
+
+function useDebounce(value, delay) {
+    const [debouncedValue, setDebouncedValue] = useState(value);
+    useEffect(()=>{
+        const handler = setTimeout(()=>{
+            setDebouncedValue(value);
+        }, delay);
+        return ()=>{
+            clearTimeout(handler);
+        };
+    }, [
+        value,
+        delay
+    ]);
+    return debouncedValue;
+}
+
+export { useDebounce };
+//# sourceMappingURL=useDebounce.mjs.map

package/dist/admin/hooks/useDebounce.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDebounce.mjs","sources":["../../../admin/src/hooks/useDebounce.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\n\nexport function useDebounce<TValue>(value: TValue, delay: number): TValue {\n  const [debouncedValue, setDebouncedValue] = useState(value);\n\n  useEffect(() => {\n    const handler = setTimeout(() => {\n      setDebouncedValue(value);\n    }, delay);\n\n    return () => {\n      clearTimeout(handler);\n    };\n  }, [value, delay]);\n\n  return debouncedValue;\n}\n"],"names":["useDebounce","value","delay","debouncedValue","setDebouncedValue","useState","useEffect","handler","setTimeout","clearTimeout"],"mappings":";;AAEO,SAASA,WAAAA,CAAoBC,KAAa,EAAEC,KAAa,EAAA;AAC9D,IAAA,MAAM,CAACC,cAAAA,EAAgBC,iBAAkB,CAAA,GAAGC,QAASJ,CAAAA,KAAAA,CAAAA;IAErDK,SAAU,CAAA,IAAA;AACR,QAAA,MAAMC,UAAUC,UAAW,CAAA,IAAA;YACzBJ,iBAAkBH,CAAAA,KAAAA,CAAAA;SACjBC,EAAAA,KAAAA,CAAAA;QAEH,OAAO,IAAA;YACLO,YAAaF,CAAAA,OAAAA,CAAAA;AACf,SAAA;KACC,EAAA;AAACN,QAAAA,KAAAA;AAAOC,QAAAA;AAAM,KAAA,CAAA;IAEjB,OAAOC,cAAAA;AACT;;;;"}

package/dist/admin/hooks/useDocument.js

@@ -0,0 +1,244 @@
+'use strict';
+
+var React = require('react');
+var strapiAdmin = require('@strapi/admin/strapi-admin');
+var reactIntl = require('react-intl');
+var reactRouterDom = require('react-router-dom');
+var yup = require('yup');
+var collections = require('../constants/collections.js');
+var data = require('../pages/EditView/utils/data.js');
+var forms = require('../pages/EditView/utils/forms.js');
+var documents = require('../services/documents.js');
+var api = require('../utils/api.js');
+var validation = require('../utils/validation.js');
+var useContentTypeSchema = require('./useContentTypeSchema.js');
+var useDocumentLayout = require('./useDocumentLayout.js');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+/* -------------------------------------------------------------------------------------------------
+ * useDocument
+ * -----------------------------------------------------------------------------------------------*/ /**
+ * @alpha
+ * @public
+ * @description Returns a document based on the model, collection type & id passed as arguments.
+ * Also extracts its schema from the redux cache to be used for creating a validation schema.
+ * @example
+ * ```tsx
+ * const { id, model, collectionType } = useParams<{ id: string; model: string; collectionType: string }>();
+ *
+ * if(!model || !collectionType) return null;
+ *
+ * const { document, isLoading, validate } = useDocument({ documentId: id, model, collectionType, params: { locale: 'en-GB' } })
+ * const { update } = useDocumentActions()
+ *
+ * const onSubmit = async (document: Document) => {
+ *  const errors = validate(document);
+ *
+ *  if(errors) {
+ *      // handle errors
+ *  }
+ *
+ *  await update({ collectionType, model, id }, document)
+ * }
+ * ```
+ *
+ * @see {@link https://contributor.strapi.io/docs/core/content-manager/hooks/use-document} for more information
+ */ const useDocument = (args, opts)=>{
+    const { toggleNotification } = strapiAdmin.useNotification();
+    const { _unstableFormatAPIError: formatAPIError } = strapiAdmin.useAPIErrorHandler();
+    const { formatMessage } = reactIntl.useIntl();
+    const { currentData: data$1, isLoading: isLoadingDocument, isFetching: isFetchingDocument, error, refetch } = documents.useGetDocumentQuery(args, {
+        ...opts,
+        skip: !args.documentId && args.collectionType !== collections.SINGLE_TYPES || opts?.skip
+    });
+    const document = data$1?.data;
+    const meta = data$1?.meta;
+    const { components, schema, schemas, isLoading: isLoadingSchema } = useContentTypeSchema.useContentTypeSchema(args.model);
+    const isSingleType = schema?.kind === 'singleType';
+    const getTitle = (mainField)=>{
+        // Always use mainField if it's not an id
+        if (mainField !== 'id' && document?.[mainField]) {
+            return document[mainField];
+        }
+        // When it's a singleType without a mainField, use the contentType displayName
+        if (isSingleType && schema?.info.displayName) {
+            return schema.info.displayName;
+        }
+        // Otherwise, use a fallback
+        return formatMessage({
+            id: 'content-manager.containers.untitled',
+            defaultMessage: 'Untitled'
+        });
+    };
+    React__namespace.useEffect(()=>{
+        if (error) {
+            toggleNotification({
+                type: 'danger',
+                message: formatAPIError(error)
+            });
+        }
+    }, [
+        toggleNotification,
+        error,
+        formatAPIError,
+        args.collectionType
+    ]);
+    const validationSchema = React__namespace.useMemo(()=>{
+        if (!schema) {
+            return null;
+        }
+        return validation.createYupSchema(schema.attributes, components);
+    }, [
+        schema,
+        components
+    ]);
+    const validate = React__namespace.useCallback((document)=>{
+        if (!validationSchema) {
+            throw new Error('There is no validation schema generated, this is likely due to the schema not being loaded yet.');
+        }
+        try {
+            validationSchema.validateSync(document, {
+                abortEarly: false,
+                strict: true
+            });
+            return null;
+        } catch (error) {
+            if (error instanceof yup.ValidationError) {
+                return strapiAdmin.getYupValidationErrors(error);
+            }
+            throw error;
+        }
+    }, [
+        validationSchema
+    ]);
+    /**
+   * Here we prepare the form for editing, we need to:
+   * - remove prohibited fields from the document (passwords | ADD YOURS WHEN THERES A NEW ONE)
+   * - swap out count objects on relations for empty arrays
+   * - set __temp_key__ on array objects for drag & drop
+   *
+   * We also prepare the form for new documents, so we need to:
+   * - set default values on fields
+   */ const getInitialFormValues = React__namespace.useCallback((isCreatingDocument = false)=>{
+        if (!document && !isCreatingDocument && !isSingleType || !schema) {
+            return undefined;
+        }
+        /**
+       * Check that we have an ID so we know the
+       * document has been created in some way.
+       */ const form = document?.id ? document : forms.createDefaultForm(schema, components);
+        return data.transformDocument(schema, components)(form);
+    }, [
+        document,
+        isSingleType,
+        schema,
+        components
+    ]);
+    const isLoading = isLoadingDocument || isFetchingDocument || isLoadingSchema;
+    const hasError = !!error;
+    return {
+        components,
+        document,
+        meta,
+        isLoading,
+        hasError,
+        schema,
+        schemas,
+        validate,
+        getTitle,
+        getInitialFormValues,
+        refetch
+    };
+};
+/* -------------------------------------------------------------------------------------------------
+ * useDoc
+ * -----------------------------------------------------------------------------------------------*/ /**
+ * @internal this hook uses the router to extract the model, collection type & id from the url.
+ * therefore, it shouldn't be used outside of the content-manager because it won't work as intended.
+ */ const useDoc = ()=>{
+    const { id, slug, collectionType, origin } = reactRouterDom.useParams();
+    const [{ query }] = strapiAdmin.useQueryParams();
+    const params = React__namespace.useMemo(()=>api.buildValidParams(query), [
+        query
+    ]);
+    if (!collectionType) {
+        throw new Error('Could not find collectionType in url params');
+    }
+    if (!slug) {
+        throw new Error('Could not find model in url params');
+    }
+    const document = useDocument({
+        documentId: origin || id,
+        model: slug,
+        collectionType,
+        params
+    }, {
+        skip: id === 'create' || !origin && !id && collectionType !== collections.SINGLE_TYPES
+    });
+    const returnId = origin || id === 'create' ? undefined : id;
+    return {
+        collectionType,
+        model: slug,
+        id: returnId,
+        ...document
+    };
+};
+/**
+ * @public
+ * @experimental
+ * Content manager context hooks for plugin development.
+ * Make sure to use this hook inside the content manager.
+ */ const useContentManagerContext = ()=>{
+    const { collectionType, model, id, components, isLoading: isLoadingDoc, schema, schemas } = useDoc();
+    const layout = useDocumentLayout.useDocumentLayout(model);
+    const form = strapiAdmin.useForm('useContentManagerContext', (state)=>state);
+    const isSingleType = collectionType === collections.SINGLE_TYPES;
+    const slug = model;
+    const isCreatingEntry = id === 'create';
+    useContentTypeSchema.useContentTypeSchema();
+    const isLoading = isLoadingDoc || layout.isLoading;
+    const error = layout.error;
+    return {
+        error,
+        isLoading,
+        // Base metadata
+        model,
+        collectionType,
+        id,
+        slug,
+        isCreatingEntry,
+        isSingleType,
+        hasDraftAndPublish: schema?.options?.draftAndPublish ?? false,
+        // All schema infos
+        components,
+        contentType: schema,
+        contentTypes: schemas,
+        // Form state
+        form,
+        // layout infos
+        layout
+    };
+};
+
+exports.useContentManagerContext = useContentManagerContext;
+exports.useDoc = useDoc;
+exports.useDocument = useDocument;
+//# sourceMappingURL=useDocument.js.map

package/dist/admin/hooks/useDocument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDocument.js","sources":["../../../admin/src/hooks/useDocument.ts"],"sourcesContent":["/**\n * This hook doesn't use a context provider because we fetch directly from the server,\n * this sounds expensive but actually, it's really not. Because we have redux-toolkit-query\n * being a cache layer so if nothing invalidates the cache, we don't fetch again.\n */\n\nimport * as React from 'react';\n\nimport {\n  useNotification,\n  useAPIErrorHandler,\n  useQueryParams,\n  FormErrors,\n  getYupValidationErrors,\n  useForm,\n} from '@strapi/admin/strapi-admin';\nimport { useIntl } from 'react-intl';\nimport { useParams } from 'react-router-dom';\nimport { ValidationError } from 'yup';\n\nimport { SINGLE_TYPES } from '../constants/collections';\nimport { type AnyData, transformDocument } from '../pages/EditView/utils/data';\nimport { createDefaultForm } from '../pages/EditView/utils/forms';\nimport { useGetDocumentQuery } from '../services/documents';\nimport { buildValidParams } from '../utils/api';\nimport { createYupSchema } from '../utils/validation';\n\nimport { useContentTypeSchema, ComponentsDictionary } from './useContentTypeSchema';\nimport { useDocumentLayout } from './useDocumentLayout';\n\nimport type { FindOne } from '../../../shared/contracts/collection-types';\nimport type { ContentType } from '../../../shared/contracts/content-types';\nimport type { Modules } from '@strapi/types';\n\ninterface UseDocumentArgs {\n  collectionType: string;\n  model: string;\n  documentId?: string;\n  params?: object;\n}\n\ntype UseDocumentOpts = Parameters<typeof useGetDocumentQuery>[1];\n\ntype Document = FindOne.Response['data'];\n\ntype Schema = ContentType;\n\ntype UseDocument = (\n  args: UseDocumentArgs,\n  opts?: UseDocumentOpts\n) => {\n  /**\n   * These are the schemas of the components used in the content type, organised\n   * by their uid.\n   */\n  components: ComponentsDictionary;\n  document?: Document;\n  meta?: FindOne.Response['meta'];\n  isLoading: boolean;\n  /**\n   * This is the schema of the content type, it is not the same as the layout.\n   */\n  schema?: Schema;\n  schemas?: Schema[];\n  hasError?: boolean;\n  refetch: () => void;\n  validate: (document: Document) => null | FormErrors;\n  /**\n   * Get the document's title\n   */\n  getTitle: (mainField: string) => string;\n  /**\n   * Get the initial form values for the document\n   */\n  getInitialFormValues: (isCreatingDocument?: boolean) => AnyData | undefined;\n};\n\n/* -------------------------------------------------------------------------------------------------\n * useDocument\n * -----------------------------------------------------------------------------------------------*/\n\n/**\n * @alpha\n * @public\n * @description Returns a document based on the model, collection type & id passed as arguments.\n * Also extracts its schema from the redux cache to be used for creating a validation schema.\n * @example\n * ```tsx\n * const { id, model, collectionType } = useParams<{ id: string; model: string; collectionType: string }>();\n *\n * if(!model || !collectionType) return null;\n *\n * const { document, isLoading, validate } = useDocument({ documentId: id, model, collectionType, params: { locale: 'en-GB' } })\n * const { update } = useDocumentActions()\n *\n * const onSubmit = async (document: Document) => {\n *  const errors = validate(document);\n *\n *  if(errors) {\n *      // handle errors\n *  }\n *\n *  await update({ collectionType, model, id }, document)\n * }\n * ```\n *\n * @see {@link https://contributor.strapi.io/docs/core/content-manager/hooks/use-document} for more information\n */\nconst useDocument: UseDocument = (args, opts) => {\n  const { toggleNotification } = useNotification();\n  const { _unstableFormatAPIError: formatAPIError } = useAPIErrorHandler();\n  const { formatMessage } = useIntl();\n\n  const {\n    currentData: data,\n    isLoading: isLoadingDocument,\n    isFetching: isFetchingDocument,\n    error,\n    refetch,\n  } = useGetDocumentQuery(args, {\n    ...opts,\n    skip: (!args.documentId && args.collectionType !== SINGLE_TYPES) || opts?.skip,\n  });\n  const document = data?.data;\n  const meta = data?.meta;\n\n  const {\n    components,\n    schema,\n    schemas,\n    isLoading: isLoadingSchema,\n  } = useContentTypeSchema(args.model);\n  const isSingleType = schema?.kind === 'singleType';\n\n  const getTitle = (mainField: string) => {\n    // Always use mainField if it's not an id\n    if (mainField !== 'id' && document?.[mainField]) {\n      return document[mainField];\n    }\n\n    // When it's a singleType without a mainField, use the contentType displayName\n    if (isSingleType && schema?.info.displayName) {\n      return schema.info.displayName;\n    }\n\n    // Otherwise, use a fallback\n    return formatMessage({\n      id: 'content-manager.containers.untitled',\n      defaultMessage: 'Untitled',\n    });\n  };\n\n  React.useEffect(() => {\n    if (error) {\n      toggleNotification({\n        type: 'danger',\n        message: formatAPIError(error),\n      });\n    }\n  }, [toggleNotification, error, formatAPIError, args.collectionType]);\n\n  const validationSchema = React.useMemo(() => {\n    if (!schema) {\n      return null;\n    }\n\n    return createYupSchema(schema.attributes, components);\n  }, [schema, components]);\n\n  const validate = React.useCallback(\n    (document: Modules.Documents.AnyDocument): FormErrors | null => {\n      if (!validationSchema) {\n        throw new Error(\n          'There is no validation schema generated, this is likely due to the schema not being loaded yet.'\n        );\n      }\n\n      try {\n        validationSchema.validateSync(document, { abortEarly: false, strict: true });\n        return null;\n      } catch (error) {\n        if (error instanceof ValidationError) {\n          return getYupValidationErrors(error);\n        }\n\n        throw error;\n      }\n    },\n    [validationSchema]\n  );\n\n  /**\n   * Here we prepare the form for editing, we need to:\n   * - remove prohibited fields from the document (passwords | ADD YOURS WHEN THERES A NEW ONE)\n   * - swap out count objects on relations for empty arrays\n   * - set __temp_key__ on array objects for drag & drop\n   *\n   * We also prepare the form for new documents, so we need to:\n   * - set default values on fields\n   */\n  const getInitialFormValues = React.useCallback(\n    (isCreatingDocument: boolean = false) => {\n      if ((!document && !isCreatingDocument && !isSingleType) || !schema) {\n        return undefined;\n      }\n\n      /**\n       * Check that we have an ID so we know the\n       * document has been created in some way.\n       */\n      const form = document?.id ? document : createDefaultForm(schema, components);\n\n      return transformDocument(schema, components)(form);\n    },\n    [document, isSingleType, schema, components]\n  );\n\n  const isLoading = isLoadingDocument || isFetchingDocument || isLoadingSchema;\n  const hasError = !!error;\n\n  return {\n    components,\n    document,\n    meta,\n    isLoading,\n    hasError,\n    schema,\n    schemas,\n    validate,\n    getTitle,\n    getInitialFormValues,\n    refetch,\n  } satisfies ReturnType<UseDocument>;\n};\n\n/* -------------------------------------------------------------------------------------------------\n * useDoc\n * -----------------------------------------------------------------------------------------------*/\n\n/**\n * @internal this hook uses the router to extract the model, collection type & id from the url.\n * therefore, it shouldn't be used outside of the content-manager because it won't work as intended.\n */\nconst useDoc = () => {\n  const { id, slug, collectionType, origin } = useParams<{\n    id: string;\n    origin: string;\n    slug: string;\n    collectionType: string;\n  }>();\n  const [{ query }] = useQueryParams();\n  const params = React.useMemo(() => buildValidParams(query), [query]);\n\n  if (!collectionType) {\n    throw new Error('Could not find collectionType in url params');\n  }\n\n  if (!slug) {\n    throw new Error('Could not find model in url params');\n  }\n\n  const document = useDocument(\n    { documentId: origin || id, model: slug, collectionType, params },\n    {\n      skip: id === 'create' || (!origin && !id && collectionType !== SINGLE_TYPES),\n    }\n  );\n\n  const returnId = origin || id === 'create' ? undefined : id;\n\n  return {\n    collectionType,\n    model: slug,\n    id: returnId,\n    ...document,\n  };\n};\n\n/**\n * @public\n * @experimental\n * Content manager context hooks for plugin development.\n * Make sure to use this hook inside the content manager.\n */\nconst useContentManagerContext = () => {\n  const {\n    collectionType,\n    model,\n    id,\n    components,\n    isLoading: isLoadingDoc,\n    schema,\n    schemas,\n  } = useDoc();\n\n  const layout = useDocumentLayout(model);\n\n  const form = useForm<unknown>('useContentManagerContext', (state) => state);\n\n  const isSingleType = collectionType === SINGLE_TYPES;\n  const slug = model;\n  const isCreatingEntry = id === 'create';\n\n  const {} = useContentTypeSchema();\n\n  const isLoading = isLoadingDoc || layout.isLoading;\n  const error = layout.error;\n\n  return {\n    error,\n    isLoading,\n\n    // Base metadata\n    model,\n    collectionType,\n    id,\n    slug,\n    isCreatingEntry,\n    isSingleType,\n    hasDraftAndPublish: schema?.options?.draftAndPublish ?? false,\n\n    // All schema infos\n    components,\n    contentType: schema,\n    contentTypes: schemas,\n\n    // Form state\n    form,\n\n    // layout infos\n    layout,\n  };\n};\n\nexport { useDocument, useDoc, useContentManagerContext };\nexport type { UseDocument, UseDocumentArgs, Document, Schema, ComponentsDictionary };\n"],"names":["useDocument","args","opts","toggleNotification","useNotification","_unstableFormatAPIError","formatAPIError","useAPIErrorHandler","formatMessage","useIntl","currentData","data","isLoading","isLoadingDocument","isFetching","isFetchingDocument","error","refetch","useGetDocumentQuery","skip","documentId","collectionType","SINGLE_TYPES","document","meta","components","schema","schemas","isLoadingSchema","useContentTypeSchema","model","isSingleType","kind","getTitle","mainField","info","displayName","id","defaultMessage","React","useEffect","type","message","validationSchema","useMemo","createYupSchema","attributes","validate","useCallback","Error","validateSync","abortEarly","strict","ValidationError","getYupValidationErrors","getInitialFormValues","isCreatingDocument","undefined","form","createDefaultForm","transformDocument","hasError","useDoc","slug","origin","useParams","query","useQueryParams","params","buildValidParams","returnId","useContentManagerContext","isLoadingDoc","layout","useDocumentLayout","useForm","state","isCreatingEntry","hasDraftAndPublish","options","draftAndPublish","contentType","contentTypes"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+BA,MAAMA,WAA2B,GAAA,CAACC,IAAMC,EAAAA,IAAAA,GAAAA;IACtC,MAAM,EAAEC,kBAAkB,EAAE,GAAGC,2BAAAA,EAAAA;AAC/B,IAAA,MAAM,EAAEC,uBAAAA,EAAyBC,cAAc,EAAE,GAAGC,8BAAAA,EAAAA;IACpD,MAAM,EAAEC,aAAa,EAAE,GAAGC,iBAAAA,EAAAA;AAE1B,IAAA,MAAM,EACJC,WAAaC,EAAAA,MAAI,EACjBC,SAAAA,EAAWC,iBAAiB,EAC5BC,UAAAA,EAAYC,kBAAkB,EAC9BC,KAAK,EACLC,OAAO,EACR,GAAGC,8BAAoBjB,IAAM,EAAA;AAC5B,QAAA,GAAGC,IAAI;QACPiB,IAAM,EAAC,CAAClB,IAAKmB,CAAAA,UAAU,IAAInB,IAAKoB,CAAAA,cAAc,KAAKC,wBAAAA,IAAiBpB,IAAMiB,EAAAA;AAC5E,KAAA,CAAA;AACA,IAAA,MAAMI,WAAWZ,MAAMA,EAAAA,IAAAA;AACvB,IAAA,MAAMa,OAAOb,MAAMa,EAAAA,IAAAA;AAEnB,IAAA,MAAM,EACJC,UAAU,EACVC,MAAM,EACNC,OAAO,EACPf,SAAAA,EAAWgB,eAAe,EAC3B,GAAGC,yCAAAA,CAAqB5B,KAAK6B,KAAK,CAAA;IACnC,MAAMC,YAAAA,GAAeL,QAAQM,IAAS,KAAA,YAAA;AAEtC,IAAA,MAAMC,WAAW,CAACC,SAAAA,GAAAA;;AAEhB,QAAA,IAAIA,SAAc,KAAA,IAAA,IAAQX,QAAU,GAACW,UAAU,EAAE;YAC/C,OAAOX,QAAQ,CAACW,SAAU,CAAA;AAC5B;;QAGA,IAAIH,YAAAA,IAAgBL,MAAQS,EAAAA,IAAAA,CAAKC,WAAa,EAAA;YAC5C,OAAOV,MAAAA,CAAOS,IAAI,CAACC,WAAW;AAChC;;AAGA,QAAA,OAAO5B,aAAc,CAAA;YACnB6B,EAAI,EAAA,qCAAA;YACJC,cAAgB,EAAA;AAClB,SAAA,CAAA;AACF,KAAA;AAEAC,IAAAA,gBAAAA,CAAMC,SAAS,CAAC,IAAA;AACd,QAAA,IAAIxB,KAAO,EAAA;YACTb,kBAAmB,CAAA;gBACjBsC,IAAM,EAAA,QAAA;AACNC,gBAAAA,OAAAA,EAASpC,cAAeU,CAAAA,KAAAA;AAC1B,aAAA,CAAA;AACF;KACC,EAAA;AAACb,QAAAA,kBAAAA;AAAoBa,QAAAA,KAAAA;AAAOV,QAAAA,cAAAA;AAAgBL,QAAAA,IAAAA,CAAKoB;AAAe,KAAA,CAAA;IAEnE,MAAMsB,gBAAAA,GAAmBJ,gBAAMK,CAAAA,OAAO,CAAC,IAAA;AACrC,QAAA,IAAI,CAAClB,MAAQ,EAAA;YACX,OAAO,IAAA;AACT;QAEA,OAAOmB,0BAAAA,CAAgBnB,MAAOoB,CAAAA,UAAU,EAAErB,UAAAA,CAAAA;KACzC,EAAA;AAACC,QAAAA,MAAAA;AAAQD,QAAAA;AAAW,KAAA,CAAA;AAEvB,IAAA,MAAMsB,QAAWR,GAAAA,gBAAAA,CAAMS,WAAW,CAChC,CAACzB,QAAAA,GAAAA;AACC,QAAA,IAAI,CAACoB,gBAAkB,EAAA;AACrB,YAAA,MAAM,IAAIM,KACR,CAAA,iGAAA,CAAA;AAEJ;QAEA,IAAI;YACFN,gBAAiBO,CAAAA,YAAY,CAAC3B,QAAU,EAAA;gBAAE4B,UAAY,EAAA,KAAA;gBAAOC,MAAQ,EAAA;AAAK,aAAA,CAAA;YAC1E,OAAO,IAAA;AACT,SAAA,CAAE,OAAOpC,KAAO,EAAA;AACd,YAAA,IAAIA,iBAAiBqC,mBAAiB,EAAA;AACpC,gBAAA,OAAOC,kCAAuBtC,CAAAA,KAAAA,CAAAA;AAChC;YAEA,MAAMA,KAAAA;AACR;KAEF,EAAA;AAAC2B,QAAAA;AAAiB,KAAA,CAAA;AAGpB;;;;;;;;AAQC,MACD,MAAMY,oBAAuBhB,GAAAA,gBAAAA,CAAMS,WAAW,CAC5C,CAACQ,qBAA8B,KAAK,GAAA;QAClC,IAAK,CAACjC,QAAY,IAAA,CAACiC,sBAAsB,CAACzB,YAAAA,IAAiB,CAACL,MAAQ,EAAA;YAClE,OAAO+B,SAAAA;AACT;AAEA;;;AAGC,UACD,MAAMC,IAAOnC,GAAAA,QAAAA,EAAUc,EAAKd,GAAAA,QAAAA,GAAWoC,wBAAkBjC,MAAQD,EAAAA,UAAAA,CAAAA;QAEjE,OAAOmC,sBAAAA,CAAkBlC,QAAQD,UAAYiC,CAAAA,CAAAA,IAAAA,CAAAA;KAE/C,EAAA;AAACnC,QAAAA,QAAAA;AAAUQ,QAAAA,YAAAA;AAAcL,QAAAA,MAAAA;AAAQD,QAAAA;AAAW,KAAA,CAAA;IAG9C,MAAMb,SAAAA,GAAYC,qBAAqBE,kBAAsBa,IAAAA,eAAAA;IAC7D,MAAMiC,QAAAA,GAAW,CAAC,CAAC7C,KAAAA;IAEnB,OAAO;AACLS,QAAAA,UAAAA;AACAF,QAAAA,QAAAA;AACAC,QAAAA,IAAAA;AACAZ,QAAAA,SAAAA;AACAiD,QAAAA,QAAAA;AACAnC,QAAAA,MAAAA;AACAC,QAAAA,OAAAA;AACAoB,QAAAA,QAAAA;AACAd,QAAAA,QAAAA;AACAsB,QAAAA,oBAAAA;AACAtC,QAAAA;AACF,KAAA;AACF;AAEA;;;;;AAOC,UACK6C,MAAS,GAAA,IAAA;IACb,MAAM,EAAEzB,EAAE,EAAE0B,IAAI,EAAE1C,cAAc,EAAE2C,MAAM,EAAE,GAAGC,wBAAAA,EAAAA;AAM7C,IAAA,MAAM,CAAC,EAAEC,KAAK,EAAE,CAAC,GAAGC,0BAAAA,EAAAA;AACpB,IAAA,MAAMC,SAAS7B,gBAAMK,CAAAA,OAAO,CAAC,IAAMyB,qBAAiBH,KAAQ,CAAA,EAAA;AAACA,QAAAA;AAAM,KAAA,CAAA;AAEnE,IAAA,IAAI,CAAC7C,cAAgB,EAAA;AACnB,QAAA,MAAM,IAAI4B,KAAM,CAAA,6CAAA,CAAA;AAClB;AAEA,IAAA,IAAI,CAACc,IAAM,EAAA;AACT,QAAA,MAAM,IAAId,KAAM,CAAA,oCAAA,CAAA;AAClB;AAEA,IAAA,MAAM1B,WAAWvB,WACf,CAAA;AAAEoB,QAAAA,UAAAA,EAAY4C,MAAU3B,IAAAA,EAAAA;QAAIP,KAAOiC,EAAAA,IAAAA;AAAM1C,QAAAA,cAAAA;AAAgB+C,QAAAA;KACzD,EAAA;AACEjD,QAAAA,IAAAA,EAAMkB,OAAO,QAAa,IAAA,CAAC2B,MAAU,IAAA,CAAC3B,MAAMhB,cAAmBC,KAAAA;AACjE,KAAA,CAAA;AAGF,IAAA,MAAMgD,QAAWN,GAAAA,MAAAA,IAAU3B,EAAO,KAAA,QAAA,GAAWoB,SAAYpB,GAAAA,EAAAA;IAEzD,OAAO;AACLhB,QAAAA,cAAAA;QACAS,KAAOiC,EAAAA,IAAAA;QACP1B,EAAIiC,EAAAA,QAAAA;AACJ,QAAA,GAAG/C;AACL,KAAA;AACF;AAEA;;;;;AAKC,UACKgD,wBAA2B,GAAA,IAAA;AAC/B,IAAA,MAAM,EACJlD,cAAc,EACdS,KAAK,EACLO,EAAE,EACFZ,UAAU,EACVb,SAAAA,EAAW4D,YAAY,EACvB9C,MAAM,EACNC,OAAO,EACR,GAAGmC,MAAAA,EAAAA;AAEJ,IAAA,MAAMW,SAASC,mCAAkB5C,CAAAA,KAAAA,CAAAA;AAEjC,IAAA,MAAM4B,IAAOiB,GAAAA,mBAAAA,CAAiB,0BAA4B,EAAA,CAACC,KAAUA,GAAAA,KAAAA,CAAAA;AAErE,IAAA,MAAM7C,eAAeV,cAAmBC,KAAAA,wBAAAA;AACxC,IAAA,MAAMyC,IAAOjC,GAAAA,KAAAA;AACb,IAAA,MAAM+C,kBAAkBxC,EAAO,KAAA,QAAA;AAE/B,IAAWR,yCAAAA;IAEX,MAAMjB,SAAAA,GAAY4D,YAAgBC,IAAAA,MAAAA,CAAO7D,SAAS;IAClD,MAAMI,KAAAA,GAAQyD,OAAOzD,KAAK;IAE1B,OAAO;AACLA,QAAAA,KAAAA;AACAJ,QAAAA,SAAAA;;AAGAkB,QAAAA,KAAAA;AACAT,QAAAA,cAAAA;AACAgB,QAAAA,EAAAA;AACA0B,QAAAA,IAAAA;AACAc,QAAAA,eAAAA;AACA9C,QAAAA,YAAAA;QACA+C,kBAAoBpD,EAAAA,MAAAA,EAAQqD,SAASC,eAAmB,IAAA,KAAA;;AAGxDvD,QAAAA,UAAAA;QACAwD,WAAavD,EAAAA,MAAAA;QACbwD,YAAcvD,EAAAA,OAAAA;;AAGd+B,QAAAA,IAAAA;;AAGAe,QAAAA;AACF,KAAA;AACF;;;;;;"}

package/dist/admin/hooks/useDocument.mjs

@@ -0,0 +1,221 @@
+import * as React from 'react';
+import { useNotification, useAPIErrorHandler, getYupValidationErrors, useForm, useQueryParams } from '@strapi/admin/strapi-admin';
+import { useIntl } from 'react-intl';
+import { useParams } from 'react-router-dom';
+import { ValidationError } from 'yup';
+import { SINGLE_TYPES } from '../constants/collections.mjs';
+import { transformDocument } from '../pages/EditView/utils/data.mjs';
+import { createDefaultForm } from '../pages/EditView/utils/forms.mjs';
+import { useGetDocumentQuery } from '../services/documents.mjs';
+import { buildValidParams } from '../utils/api.mjs';
+import { createYupSchema } from '../utils/validation.mjs';
+import { useContentTypeSchema } from './useContentTypeSchema.mjs';
+import { useDocumentLayout } from './useDocumentLayout.mjs';
+
+/* -------------------------------------------------------------------------------------------------
+ * useDocument
+ * -----------------------------------------------------------------------------------------------*/ /**
+ * @alpha
+ * @public
+ * @description Returns a document based on the model, collection type & id passed as arguments.
+ * Also extracts its schema from the redux cache to be used for creating a validation schema.
+ * @example
+ * ```tsx
+ * const { id, model, collectionType } = useParams<{ id: string; model: string; collectionType: string }>();
+ *
+ * if(!model || !collectionType) return null;
+ *
+ * const { document, isLoading, validate } = useDocument({ documentId: id, model, collectionType, params: { locale: 'en-GB' } })
+ * const { update } = useDocumentActions()
+ *
+ * const onSubmit = async (document: Document) => {
+ *  const errors = validate(document);
+ *
+ *  if(errors) {
+ *      // handle errors
+ *  }
+ *
+ *  await update({ collectionType, model, id }, document)
+ * }
+ * ```
+ *
+ * @see {@link https://contributor.strapi.io/docs/core/content-manager/hooks/use-document} for more information
+ */ const useDocument = (args, opts)=>{
+    const { toggleNotification } = useNotification();
+    const { _unstableFormatAPIError: formatAPIError } = useAPIErrorHandler();
+    const { formatMessage } = useIntl();
+    const { currentData: data, isLoading: isLoadingDocument, isFetching: isFetchingDocument, error, refetch } = useGetDocumentQuery(args, {
+        ...opts,
+        skip: !args.documentId && args.collectionType !== SINGLE_TYPES || opts?.skip
+    });
+    const document = data?.data;
+    const meta = data?.meta;
+    const { components, schema, schemas, isLoading: isLoadingSchema } = useContentTypeSchema(args.model);
+    const isSingleType = schema?.kind === 'singleType';
+    const getTitle = (mainField)=>{
+        // Always use mainField if it's not an id
+        if (mainField !== 'id' && document?.[mainField]) {
+            return document[mainField];
+        }
+        // When it's a singleType without a mainField, use the contentType displayName
+        if (isSingleType && schema?.info.displayName) {
+            return schema.info.displayName;
+        }
+        // Otherwise, use a fallback
+        return formatMessage({
+            id: 'content-manager.containers.untitled',
+            defaultMessage: 'Untitled'
+        });
+    };
+    React.useEffect(()=>{
+        if (error) {
+            toggleNotification({
+                type: 'danger',
+                message: formatAPIError(error)
+            });
+        }
+    }, [
+        toggleNotification,
+        error,
+        formatAPIError,
+        args.collectionType
+    ]);
+    const validationSchema = React.useMemo(()=>{
+        if (!schema) {
+            return null;
+        }
+        return createYupSchema(schema.attributes, components);
+    }, [
+        schema,
+        components
+    ]);
+    const validate = React.useCallback((document)=>{
+        if (!validationSchema) {
+            throw new Error('There is no validation schema generated, this is likely due to the schema not being loaded yet.');
+        }
+        try {
+            validationSchema.validateSync(document, {
+                abortEarly: false,
+                strict: true
+            });
+            return null;
+        } catch (error) {
+            if (error instanceof ValidationError) {
+                return getYupValidationErrors(error);
+            }
+            throw error;
+        }
+    }, [
+        validationSchema
+    ]);
+    /**
+   * Here we prepare the form for editing, we need to:
+   * - remove prohibited fields from the document (passwords | ADD YOURS WHEN THERES A NEW ONE)
+   * - swap out count objects on relations for empty arrays
+   * - set __temp_key__ on array objects for drag & drop
+   *
+   * We also prepare the form for new documents, so we need to:
+   * - set default values on fields
+   */ const getInitialFormValues = React.useCallback((isCreatingDocument = false)=>{
+        if (!document && !isCreatingDocument && !isSingleType || !schema) {
+            return undefined;
+        }
+        /**
+       * Check that we have an ID so we know the
+       * document has been created in some way.
+       */ const form = document?.id ? document : createDefaultForm(schema, components);
+        return transformDocument(schema, components)(form);
+    }, [
+        document,
+        isSingleType,
+        schema,
+        components
+    ]);
+    const isLoading = isLoadingDocument || isFetchingDocument || isLoadingSchema;
+    const hasError = !!error;
+    return {
+        components,
+        document,
+        meta,
+        isLoading,
+        hasError,
+        schema,
+        schemas,
+        validate,
+        getTitle,
+        getInitialFormValues,
+        refetch
+    };
+};
+/* -------------------------------------------------------------------------------------------------
+ * useDoc
+ * -----------------------------------------------------------------------------------------------*/ /**
+ * @internal this hook uses the router to extract the model, collection type & id from the url.
+ * therefore, it shouldn't be used outside of the content-manager because it won't work as intended.
+ */ const useDoc = ()=>{
+    const { id, slug, collectionType, origin } = useParams();
+    const [{ query }] = useQueryParams();
+    const params = React.useMemo(()=>buildValidParams(query), [
+        query
+    ]);
+    if (!collectionType) {
+        throw new Error('Could not find collectionType in url params');
+    }
+    if (!slug) {
+        throw new Error('Could not find model in url params');
+    }
+    const document = useDocument({
+        documentId: origin || id,
+        model: slug,
+        collectionType,
+        params
+    }, {
+        skip: id === 'create' || !origin && !id && collectionType !== SINGLE_TYPES
+    });
+    const returnId = origin || id === 'create' ? undefined : id;
+    return {
+        collectionType,
+        model: slug,
+        id: returnId,
+        ...document
+    };
+};
+/**
+ * @public
+ * @experimental
+ * Content manager context hooks for plugin development.
+ * Make sure to use this hook inside the content manager.
+ */ const useContentManagerContext = ()=>{
+    const { collectionType, model, id, components, isLoading: isLoadingDoc, schema, schemas } = useDoc();
+    const layout = useDocumentLayout(model);
+    const form = useForm('useContentManagerContext', (state)=>state);
+    const isSingleType = collectionType === SINGLE_TYPES;
+    const slug = model;
+    const isCreatingEntry = id === 'create';
+    useContentTypeSchema();
+    const isLoading = isLoadingDoc || layout.isLoading;
+    const error = layout.error;
+    return {
+        error,
+        isLoading,
+        // Base metadata
+        model,
+        collectionType,
+        id,
+        slug,
+        isCreatingEntry,
+        isSingleType,
+        hasDraftAndPublish: schema?.options?.draftAndPublish ?? false,
+        // All schema infos
+        components,
+        contentType: schema,
+        contentTypes: schemas,
+        // Form state
+        form,
+        // layout infos
+        layout
+    };
+};
+
+export { useContentManagerContext, useDoc, useDocument };
+//# sourceMappingURL=useDocument.mjs.map