@payloadcms/ui 3.0.0-alpha.0 → 3.0.0-alpha.1

package/dist/elements/PreviewButton/index.js

@@ -0,0 +1,129 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacttoastify = require("react-toastify");
+const _RenderCustomComponent = require("../../elements/RenderCustomComponent");
+const _Auth = require("../../providers/Auth");
+const _Config = require("../../providers/Config");
+const _DocumentInfo = require("../../providers/DocumentInfo");
+const _Locale = require("../../providers/Locale");
+const _Translation = require("../../providers/Translation");
+const _Button = require("../Button");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const baseClass = 'preview-btn';
+const DefaultPreviewButton = ({ disabled, label, preview })=>{
+    return /*#__PURE__*/ _react.default.createElement(_Button.Button, {
+        buttonStyle: "secondary",
+        className: baseClass,
+        disabled: disabled,
+        onClick: preview,
+        size: "small"
+    }, label);
+};
+const PreviewButton = ({ CustomComponent, generatePreviewURL })=>{
+    const { id, collectionSlug, globalSlug } = (0, _DocumentInfo.useDocumentInfo)();
+    const [isLoading, setIsLoading] = (0, _react.useState)(false);
+    const { code: locale } = (0, _Locale.useLocale)();
+    const { token } = (0, _Auth.useAuth)();
+    const { routes: { api }, serverURL } = (0, _Config.useConfig)();
+    const { t } = (0, _Translation.useTranslation)();
+    const isGeneratingPreviewURL = (0, _react.useRef)(false);
+    // we need to regenerate the preview URL every time the button is clicked
+    // to do this we need to fetch the document data fresh from the API
+    // this will ensure the latest data is used when generating the preview URL
+    const preview = (0, _react.useCallback)(async ()=>{
+        if (!generatePreviewURL || isGeneratingPreviewURL.current) return;
+        isGeneratingPreviewURL.current = true;
+        try {
+            setIsLoading(true);
+            let url = `${serverURL}${api}`;
+            if (collectionSlug) url = `${url}/${collectionSlug}/${id}`;
+            if (globalSlug) url = `${url}/globals/${globalSlug}`;
+            const data = await fetch(`${url}?draft=true&locale=${locale}&fallback-locale=null`).then((res)=>res.json());
+            const previewURL = await generatePreviewURL(data, {
+                locale,
+                token
+            });
+            if (!previewURL) throw new Error();
+            setIsLoading(false);
+            isGeneratingPreviewURL.current = false;
+            window.open(previewURL, '_blank');
+        } catch (err) {
+            setIsLoading(false);
+            isGeneratingPreviewURL.current = false;
+            _reacttoastify.toast.error(t('error:previewing'));
+        }
+    }, [
+        serverURL,
+        api,
+        collectionSlug,
+        globalSlug,
+        id,
+        generatePreviewURL,
+        locale,
+        token,
+        t
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_RenderCustomComponent.RenderCustomComponent, {
+        CustomComponent: CustomComponent,
+        DefaultComponent: DefaultPreviewButton,
+        componentProps: {
+            DefaultButton: DefaultPreviewButton,
+            disabled: isLoading || !generatePreviewURL,
+            label: isLoading ? t('general:loading') : t('version:preview'),
+            preview
+        }
+    });
+};
+const _default = PreviewButton;
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/elements/PreviewSizes/index.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _FileMeta = /*#__PURE__*/ _interop_require_default(require("../FileDetails/FileMeta"));
+require("./index.scss");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const baseClass = 'preview-sizes';
+const sortSizes = (sizes, imageSizes)=>{
+    if (!imageSizes || imageSizes.length === 0) return sizes;
+    const orderedSizes = {};
+    imageSizes.forEach(({ name })=>{
+        if (sizes[name]) {
+            orderedSizes[name] = sizes[name];
+        }
+    });
+    return orderedSizes;
+};
+const PreviewSizeCard = ({ name, active, meta, onClick, previewSrc })=>{
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: [
+            `${baseClass}__sizeOption`,
+            active && `${baseClass}--selected`
+        ].filter(Boolean).join(' '),
+        onClick: typeof onClick === 'function' ? onClick : undefined,
+        onKeyDown: (e)=>{
+            if (typeof onClick !== 'function') return;
+            if (e.key === 'Enter') onClick();
+        },
+        role: "button",
+        tabIndex: 0
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__image`
+    }, /*#__PURE__*/ _react.default.createElement("img", {
+        alt: meta.filename,
+        src: previewSrc
+    })), /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__sizeMeta`
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__sizeName`
+    }, name), /*#__PURE__*/ _react.default.createElement(_FileMeta.default, meta)));
+};
+const PreviewSizes = ({ doc, imageCacheTag, uploadConfig })=>{
+    const { imageSizes } = uploadConfig;
+    const { sizes } = doc;
+    const [orderedSizes, setOrderedSizes] = (0, _react.useState)(()=>sortSizes(sizes, imageSizes));
+    const [selectedSize, setSelectedSize] = (0, _react.useState)(null);
+    const generateImageUrl = (doc)=>{
+        if (!doc.filename) return null;
+        if (doc.url) return `${doc.url}${imageCacheTag ? `?${imageCacheTag}` : ''}`;
+    };
+    (0, _react.useEffect)(()=>{
+        setOrderedSizes(sortSizes(sizes, imageSizes));
+    }, [
+        sizes,
+        imageSizes,
+        imageCacheTag
+    ]);
+    const mainPreviewSrc = selectedSize ? generateImageUrl(doc.sizes[selectedSize]) : generateImageUrl(doc);
+    const originalImage = (0, _react.useMemo)(()=>({
+            filename: doc.filename,
+            filesize: doc.filesize,
+            height: doc.height,
+            mimeType: doc.mimeType,
+            url: doc.url,
+            width: doc.width
+        }), [
+        doc
+    ]);
+    const originalFilename = 'Original';
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: baseClass
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__imageWrap`
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__meta`
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__sizeName`
+    }, selectedSize || originalFilename), /*#__PURE__*/ _react.default.createElement(_FileMeta.default, selectedSize ? orderedSizes[selectedSize] : originalImage)), /*#__PURE__*/ _react.default.createElement("img", {
+        alt: doc.filename,
+        className: `${baseClass}__preview`,
+        src: mainPreviewSrc
+    })), /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__listWrap`
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__list`
+    }, /*#__PURE__*/ _react.default.createElement(PreviewSizeCard, {
+        active: !selectedSize,
+        meta: originalImage,
+        name: originalFilename,
+        onClick: ()=>setSelectedSize(null),
+        previewSrc: generateImageUrl(doc)
+    }), Object.entries(orderedSizes).map(([key, val])=>{
+        const selected = selectedSize === key;
+        const previewSrc = generateImageUrl(val);
+        if (previewSrc) {
+            return /*#__PURE__*/ _react.default.createElement(PreviewSizeCard, {
+                active: selected,
+                key: key,
+                meta: val,
+                name: key,
+                onClick: ()=>setSelectedSize(key),
+                previewSrc: previewSrc
+            });
+        }
+        return null;
+    }))));
+};
+const _default = PreviewSizes;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/elements/PreviewSizes/index.tsx"],"sourcesContent":["import type {\n  Data,\n  FileSize,\n  SanitizedCollectionConfig,\n  SanitizedUploadConfig,\n} from 'payload/types'\n\nimport React, { useEffect, useMemo, useState } from 'react'\n\nimport FileMeta from '../FileDetails/FileMeta'\nimport './index.scss'\n\nconst baseClass = 'preview-sizes'\n\ntype FileInfo = FileSize & {\n  url: string\n}\ntype FilesSizesWithUrl = {\n  [key: string]: FileInfo\n}\n\nconst sortSizes = (sizes: FilesSizesWithUrl, imageSizes: SanitizedUploadConfig['imageSizes']) => {\n  if (!imageSizes || imageSizes.length === 0) return sizes\n\n  const orderedSizes: FilesSizesWithUrl = {}\n\n  imageSizes.forEach(({ name }) => {\n    if (sizes[name]) {\n      orderedSizes[name] = sizes[name]\n    }\n  })\n\n  return orderedSizes\n}\n\ntype PreviewSizeCardProps = {\n  active: boolean\n  meta: FileInfo\n  name: string\n  onClick?: () => void\n  previewSrc: string\n}\nconst PreviewSizeCard: React.FC<PreviewSizeCardProps> = ({\n  name,\n  active,\n  meta,\n  onClick,\n  previewSrc,\n}) => {\n  return (\n    <div\n      className={[`${baseClass}__sizeOption`, active && `${baseClass}--selected`]\n        .filter(Boolean)\n        .join(' ')}\n      onClick={typeof onClick === 'function' ? onClick : undefined}\n      onKeyDown={(e) => {\n        if (typeof onClick !== 'function') return\n        if (e.key === 'Enter') onClick()\n      }}\n      role=\"button\"\n      tabIndex={0}\n    >\n      <div className={`${baseClass}__image`}>\n        <img alt={meta.filename} src={previewSrc} />\n      </div>\n      <div className={`${baseClass}__sizeMeta`}>\n        <div className={`${baseClass}__sizeName`}>{name}</div>\n        <FileMeta {...meta} />\n      </div>\n    </div>\n  )\n}\n\nconst PreviewSizes: React.FC<{\n  doc: Data & {\n    sizes?: FilesSizesWithUrl\n  }\n  imageCacheTag?: string\n  uploadConfig: SanitizedCollectionConfig['upload']\n}> = ({ doc, imageCacheTag, uploadConfig }) => {\n  const { imageSizes } = uploadConfig\n  const { sizes } = doc\n\n  const [orderedSizes, setOrderedSizes] = useState<FilesSizesWithUrl>(() =>\n    sortSizes(sizes, imageSizes),\n  )\n  const [selectedSize, setSelectedSize] = useState<null | string>(null)\n\n  const generateImageUrl = (doc) => {\n    if (!doc.filename) return null\n    if (doc.url) return `${doc.url}${imageCacheTag ? `?${imageCacheTag}` : ''}`\n  }\n  useEffect(() => {\n    setOrderedSizes(sortSizes(sizes, imageSizes))\n  }, [sizes, imageSizes, imageCacheTag])\n\n  const mainPreviewSrc = selectedSize\n    ? generateImageUrl(doc.sizes[selectedSize])\n    : generateImageUrl(doc)\n\n  const originalImage = useMemo(\n    (): FileInfo => ({\n      filename: doc.filename,\n      filesize: doc.filesize,\n      height: doc.height,\n      mimeType: doc.mimeType,\n      url: doc.url,\n      width: doc.width,\n    }),\n    [doc],\n  )\n  const originalFilename = 'Original'\n\n  return (\n    <div className={baseClass}>\n      <div className={`${baseClass}__imageWrap`}>\n        <div className={`${baseClass}__meta`}>\n          <div className={`${baseClass}__sizeName`}>{selectedSize || originalFilename}</div>\n          <FileMeta {...(selectedSize ? orderedSizes[selectedSize] : originalImage)} />\n        </div>\n        <img alt={doc.filename} className={`${baseClass}__preview`} src={mainPreviewSrc} />\n      </div>\n      <div className={`${baseClass}__listWrap`}>\n        <div className={`${baseClass}__list`}>\n          <PreviewSizeCard\n            active={!selectedSize}\n            meta={originalImage}\n            name={originalFilename}\n            onClick={() => setSelectedSize(null)}\n            previewSrc={generateImageUrl(doc)}\n          />\n\n          {Object.entries(orderedSizes).map(([key, val]) => {\n            const selected = selectedSize === key\n            const previewSrc = generateImageUrl(val)\n\n            if (previewSrc) {\n              return (\n                <PreviewSizeCard\n                  active={selected}\n                  key={key}\n                  meta={val}\n                  name={key}\n                  onClick={() => setSelectedSize(key)}\n                  previewSrc={previewSrc}\n                />\n              )\n            }\n\n            return null\n          })}\n        </div>\n      </div>\n    </div>\n  )\n}\nexport default PreviewSizes\n"],"names":["baseClass","sortSizes","sizes","imageSizes","length","orderedSizes","forEach","name","PreviewSizeCard","active","meta","onClick","previewSrc","div","className","filter","Boolean","join","undefined","onKeyDown","e","key","role","tabIndex","img","alt","filename","src","FileMeta","PreviewSizes","doc","imageCacheTag","uploadConfig","setOrderedSizes","useState","selectedSize","setSelectedSize","generateImageUrl","url","useEffect","mainPreviewSrc","originalImage","useMemo","filesize","height","mimeType","width","originalFilename","Object","entries","map","val","selected"],"mappings":"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"}

package/dist/elements/Publish/index.js

@@ -0,0 +1,153 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Publish", {
+    enumerable: true,
+    get: function() {
+        return Publish;
+    }
+});
+const _qs = /*#__PURE__*/ _interop_require_default(require("qs"));
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _RenderCustomComponent = require("../../elements/RenderCustomComponent");
+const _context = require("../../forms/Form/context");
+const _Submit = /*#__PURE__*/ _interop_require_default(require("../../forms/Submit"));
+const _Config = require("../../providers/Config");
+const _DocumentInfo = require("../../providers/DocumentInfo");
+const _Locale = require("../../providers/Locale");
+const _Translation = require("../../providers/Translation");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const DefaultPublishButton = ({ id, canPublish, disabled, label, publish })=>{
+    if (!canPublish) return null;
+    return /*#__PURE__*/ _react.default.createElement(_Submit.default, {
+        buttonId: id,
+        disabled: disabled,
+        onClick: publish,
+        size: "small",
+        type: "button"
+    }, label);
+};
+const Publish = ({ CustomComponent })=>{
+    const { code } = (0, _Locale.useLocale)();
+    const { id, collectionSlug, globalSlug, publishedDoc, unpublishedVersions } = (0, _DocumentInfo.useDocumentInfo)();
+    const [hasPublishPermission, setHasPublishPermission] = _react.default.useState(false);
+    const { getData, submit } = (0, _context.useForm)();
+    const modified = (0, _context.useFormModified)();
+    const { routes: { api }, serverURL } = (0, _Config.useConfig)();
+    const { t } = (0, _Translation.useTranslation)();
+    const hasNewerVersions = unpublishedVersions?.totalDocs > 0;
+    const canPublish = modified || hasNewerVersions || !publishedDoc;
+    const publish = (0, _react.useCallback)(()=>{
+        void submit({
+            overrides: {
+                _status: 'published'
+            }
+        });
+    }, [
+        submit
+    ]);
+    _react.default.useEffect(()=>{
+        const fetchPublishAccess = async ()=>{
+            let docAccessURL;
+            let operation = 'update';
+            const params = {
+                locale: code || undefined
+            };
+            if (globalSlug) {
+                docAccessURL = `/globals/${globalSlug}/access`;
+            } else if (collectionSlug) {
+                if (!id) operation = 'create';
+                docAccessURL = `/${collectionSlug}/access${id ? `/${id}` : ''}`;
+            }
+            if (docAccessURL) {
+                const data = getData();
+                const res = await fetch(`${serverURL}${api}${docAccessURL}?${_qs.default.stringify(params)}`, {
+                    body: JSON.stringify({
+                        ...data,
+                        _status: 'published'
+                    }),
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    method: 'post'
+                });
+                const json = await res.json();
+                const result = Boolean(json?.[operation]?.permission);
+                setHasPublishPermission(result);
+            } else {
+                setHasPublishPermission(true);
+            }
+        };
+        void fetchPublishAccess();
+    }, [
+        api,
+        code,
+        collectionSlug,
+        getData,
+        globalSlug,
+        id,
+        serverURL
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_RenderCustomComponent.RenderCustomComponent, {
+        CustomComponent: CustomComponent,
+        DefaultComponent: DefaultPublishButton,
+        componentProps: {
+            id: 'action-save',
+            DefaultButton: DefaultPublishButton,
+            canPublish: hasPublishPermission,
+            disabled: !canPublish,
+            label: t('version:publishChanges'),
+            publish
+        }
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/elements/Publish/index.tsx"],"sourcesContent":["'use client'\nimport type { CustomPublishButtonProps, DefaultPublishButtonProps } from 'payload/types'\n\nimport qs from 'qs'\nimport React, { useCallback } from 'react'\n\nimport { RenderCustomComponent } from '../../elements/RenderCustomComponent'\nimport { useForm, useFormModified } from '../../forms/Form/context'\nimport FormSubmit from '../../forms/Submit'\nimport { useConfig } from '../../providers/Config'\nimport { useDocumentInfo } from '../../providers/DocumentInfo'\nimport { useLocale } from '../../providers/Locale'\nimport { useTranslation } from '../../providers/Translation'\n\nconst DefaultPublishButton: React.FC<DefaultPublishButtonProps> = ({\n  id,\n  canPublish,\n  disabled,\n  label,\n  publish,\n}) => {\n  if (!canPublish) return null\n\n  return (\n    <FormSubmit buttonId={id} disabled={disabled} onClick={publish} size=\"small\" type=\"button\">\n      {label}\n    </FormSubmit>\n  )\n}\n\ntype Props = {\n  CustomComponent?: CustomPublishButtonProps\n}\n\nexport const Publish: React.FC<Props> = ({ CustomComponent }) => {\n  const { code } = useLocale()\n  const { id, collectionSlug, globalSlug, publishedDoc, unpublishedVersions } = useDocumentInfo()\n  const [hasPublishPermission, setHasPublishPermission] = React.useState(false)\n  const { getData, submit } = useForm()\n  const modified = useFormModified()\n  const {\n    routes: { api },\n    serverURL,\n  } = useConfig()\n  const { t } = useTranslation()\n\n  const hasNewerVersions = unpublishedVersions?.totalDocs > 0\n  const canPublish = modified || hasNewerVersions || !publishedDoc\n\n  const publish = useCallback(() => {\n    void submit({\n      overrides: {\n        _status: 'published',\n      },\n    })\n  }, [submit])\n\n  React.useEffect(() => {\n    const fetchPublishAccess = async () => {\n      let docAccessURL: string\n      let operation = 'update'\n\n      const params = {\n        locale: code || undefined,\n      }\n      if (globalSlug) {\n        docAccessURL = `/globals/${globalSlug}/access`\n      } else if (collectionSlug) {\n        if (!id) operation = 'create'\n        docAccessURL = `/${collectionSlug}/access${id ? `/${id}` : ''}`\n      }\n\n      if (docAccessURL) {\n        const data = getData()\n\n        const res = await fetch(`${serverURL}${api}${docAccessURL}?${qs.stringify(params)}`, {\n          body: JSON.stringify({\n            ...data,\n            _status: 'published',\n          }),\n          credentials: 'include',\n          headers: {\n            'Content-Type': 'application/json',\n          },\n          method: 'post',\n        })\n        const json = await res.json()\n        const result = Boolean(json?.[operation]?.permission)\n        setHasPublishPermission(result)\n      } else {\n        setHasPublishPermission(true)\n      }\n    }\n\n    void fetchPublishAccess()\n  }, [api, code, collectionSlug, getData, globalSlug, id, serverURL])\n\n  return (\n    <RenderCustomComponent\n      CustomComponent={CustomComponent}\n      DefaultComponent={DefaultPublishButton}\n      componentProps={{\n        id: 'action-save',\n        DefaultButton: DefaultPublishButton,\n        canPublish: hasPublishPermission,\n        disabled: !canPublish,\n        label: t('version:publishChanges'),\n        publish,\n      }}\n    />\n  )\n}\n"],"names":["Publish","DefaultPublishButton","id","canPublish","disabled","label","publish","FormSubmit","buttonId","onClick","size","type","CustomComponent","code","useLocale","collectionSlug","globalSlug","publishedDoc","unpublishedVersions","useDocumentInfo","hasPublishPermission","setHasPublishPermission","React","useState","getData","submit","useForm","modified","useFormModified","routes","api","serverURL","useConfig","t","useTranslation","hasNewerVersions","totalDocs","useCallback","overrides","_status","useEffect","fetchPublishAccess","docAccessURL","operation","params","locale","undefined","data","res","fetch","qs","stringify","body","JSON","credentials","headers","method","json","result","Boolean","permission","RenderCustomComponent","DefaultComponent","componentProps","DefaultButton"],"mappings":"AAAA;;;;;+BAkCaA;;;eAAAA;;;2DA/BE;+DACoB;uCAEG;yBACG;+DAClB;wBACG;8BACM;wBACN;6BACK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE/B,MAAMC,uBAA4D,CAAC,EACjEC,EAAE,EACFC,UAAU,EACVC,QAAQ,EACRC,KAAK,EACLC,OAAO,EACR;IACC,IAAI,CAACH,YAAY,OAAO;IAExB,qBACE,6BAACI,eAAU;QAACC,UAAUN;QAAIE,UAAUA;QAAUK,SAASH;QAASI,MAAK;QAAQC,MAAK;OAC/EN;AAGP;AAMO,MAAML,UAA2B,CAAC,EAAEY,eAAe,EAAE;IAC1D,MAAM,EAAEC,IAAI,EAAE,GAAGC,IAAAA,iBAAS;IAC1B,MAAM,EAAEZ,EAAE,EAAEa,cAAc,EAAEC,UAAU,EAAEC,YAAY,EAAEC,mBAAmB,EAAE,GAAGC,IAAAA,6BAAe;IAC7F,MAAM,CAACC,sBAAsBC,wBAAwB,GAAGC,cAAK,CAACC,QAAQ,CAAC;IACvE,MAAM,EAAEC,OAAO,EAAEC,MAAM,EAAE,GAAGC,IAAAA,gBAAO;IACnC,MAAMC,WAAWC,IAAAA,wBAAe;IAChC,MAAM,EACJC,QAAQ,EAAEC,GAAG,EAAE,EACfC,SAAS,EACV,GAAGC,IAAAA,iBAAS;IACb,MAAM,EAAEC,CAAC,EAAE,GAAGC,IAAAA,2BAAc;IAE5B,MAAMC,mBAAmBjB,qBAAqBkB,YAAY;IAC1D,MAAMjC,aAAawB,YAAYQ,oBAAoB,CAAClB;IAEpD,MAAMX,UAAU+B,IAAAA,kBAAW,EAAC;QAC1B,KAAKZ,OAAO;YACVa,WAAW;gBACTC,SAAS;YACX;QACF;IACF,GAAG;QAACd;KAAO;IAEXH,cAAK,CAACkB,SAAS,CAAC;QACd,MAAMC,qBAAqB;YACzB,IAAIC;YACJ,IAAIC,YAAY;YAEhB,MAAMC,SAAS;gBACbC,QAAQhC,QAAQiC;YAClB;YACA,IAAI9B,YAAY;gBACd0B,eAAe,CAAC,SAAS,EAAE1B,WAAW,OAAO,CAAC;YAChD,OAAO,IAAID,gBAAgB;gBACzB,IAAI,CAACb,IAAIyC,YAAY;gBACrBD,eAAe,CAAC,CAAC,EAAE3B,eAAe,OAAO,EAAEb,KAAK,CAAC,CAAC,EAAEA,GAAG,CAAC,GAAG,GAAG,CAAC;YACjE;YAEA,IAAIwC,cAAc;gBAChB,MAAMK,OAAOvB;gBAEb,MAAMwB,MAAM,MAAMC,MAAM,CAAC,EAAElB,UAAU,EAAED,IAAI,EAAEY,aAAa,CAAC,EAAEQ,WAAE,CAACC,SAAS,CAACP,QAAQ,CAAC,EAAE;oBACnFQ,MAAMC,KAAKF,SAAS,CAAC;wBACnB,GAAGJ,IAAI;wBACPR,SAAS;oBACX;oBACAe,aAAa;oBACbC,SAAS;wBACP,gBAAgB;oBAClB;oBACAC,QAAQ;gBACV;gBACA,MAAMC,OAAO,MAAMT,IAAIS,IAAI;gBAC3B,MAAMC,SAASC,QAAQF,MAAM,CAACd,UAAU,EAAEiB;gBAC1CvC,wBAAwBqC;YAC1B,OAAO;gBACLrC,wBAAwB;YAC1B;QACF;QAEA,KAAKoB;IACP,GAAG;QAACX;QAAKjB;QAAME;QAAgBS;QAASR;QAAYd;QAAI6B;KAAU;IAElE,qBACE,6BAAC8B,4CAAqB;QACpBjD,iBAAiBA;QACjBkD,kBAAkB7D;QAClB8D,gBAAgB;YACd7D,IAAI;YACJ8D,eAAe/D;YACfE,YAAYiB;YACZhB,UAAU,CAACD;YACXE,OAAO4B,EAAE;YACT3B;QACF;;AAGN"}