payload 1.15.7 → 1.15.9

package/packages/payload/dist/admin/components/views/Versions/Default.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DefaultVersionsView", {
+    enumerable: true,
+    get: function() {
+        return DefaultVersionsView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _reacti18next = require("react-i18next");
+const _Gutter = require("../../elements/Gutter");
+const _Loading = require("../../elements/Loading");
+const _Paginator = /*#__PURE__*/ _interop_require_default(require("../../elements/Paginator"));
+const _PerPage = /*#__PURE__*/ _interop_require_default(require("../../elements/PerPage"));
+const _Table = require("../../elements/Table");
+const _Meta = /*#__PURE__*/ _interop_require_default(require("../../utilities/Meta"));
+const _SearchParams = require("../../utilities/SearchParams");
+const _SetStepNav = require("../collections/Edit/SetStepNav");
+const _columns = require("./columns");
+require("./index.scss");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const baseClass = 'versions';
+const DefaultVersionsView = (props)=>{
+    const { id, collection, data, entityLabel, global, isLoadingVersions, latestDraftVersion, latestPublishedVersion, versionsData } = props;
+    const { t } = (0, _reacti18next.useTranslation)('version');
+    const { limit } = (0, _SearchParams.useSearchParams)();
+    const useAsTitle = collection?.admin?.useAsTitle || 'id';
+    let metaDesc;
+    let metaTitle;
+    if (collection) {
+        metaTitle = `${t('versions')} - ${data[useAsTitle]} - ${entityLabel}`;
+        metaDesc = t('viewingVersions', {
+            documentTitle: data[useAsTitle],
+            entityLabel
+        });
+    }
+    if (global) {
+        metaTitle = `${t('versions')} - ${entityLabel}`;
+        metaDesc = t('viewingVersionsGlobal', {
+            entityLabel
+        });
+    }
+    const versionCount = versionsData?.totalDocs || 0;
+    return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/ _react.default.createElement(_SetStepNav.SetStepNav, {
+        collection: collection,
+        global: global,
+        id: id,
+        isEditing: true,
+        view: t('versions')
+    }), /*#__PURE__*/ _react.default.createElement(_Loading.LoadingOverlayToggle, {
+        name: "versions",
+        show: isLoadingVersions
+    }), /*#__PURE__*/ _react.default.createElement("main", {
+        className: baseClass
+    }, /*#__PURE__*/ _react.default.createElement(_Meta.default, {
+        description: metaDesc,
+        title: metaTitle
+    }), /*#__PURE__*/ _react.default.createElement(_Gutter.Gutter, {
+        className: `${baseClass}__wrap`
+    }, versionCount === 0 && /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__no-versions`
+    }, t('noFurtherVersionsFound')), versionCount > 0 && /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/ _react.default.createElement(_Table.Table, {
+        columns: (0, _columns.buildVersionColumns)(collection, global, t, latestDraftVersion, latestPublishedVersion),
+        data: versionsData?.docs
+    }), /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__page-controls`
+    }, /*#__PURE__*/ _react.default.createElement(_Paginator.default, {
+        hasNextPage: versionsData.hasNextPage,
+        hasPrevPage: versionsData.hasPrevPage,
+        limit: versionsData.limit,
+        nextPage: versionsData.nextPage,
+        numberOfNeighbors: 1,
+        page: versionsData.page,
+        prevPage: versionsData.prevPage,
+        totalPages: versionsData.totalPages
+    }), versionsData?.totalDocs > 0 && /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__page-info`
+    }, versionsData.page * versionsData.limit - (versionsData.limit - 1), "-", versionsData.totalPages > 1 && versionsData.totalPages !== versionsData.page ? versionsData.limit * versionsData.page : versionsData.totalDocs, ' ', t('of'), " ", versionsData.totalDocs), /*#__PURE__*/ _react.default.createElement(_PerPage.default, {
+        limit: limit ? Number(limit) : 10,
+        limits: collection?.admin?.pagination?.limits
+    })))))));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/admin/components/views/Versions/Default.tsx"],"sourcesContent":["import React from 'react'\nimport { useTranslation } from 'react-i18next'\n\nimport type { Props } from './types'\n\nimport { Gutter } from '../../elements/Gutter'\nimport { LoadingOverlayToggle } from '../../elements/Loading'\nimport Paginator from '../../elements/Paginator'\nimport PerPage from '../../elements/PerPage'\nimport { Table } from '../../elements/Table'\nimport Meta from '../../utilities/Meta'\nimport { useSearchParams } from '../../utilities/SearchParams'\nimport { SetStepNav } from '../collections/Edit/SetStepNav'\nimport { buildVersionColumns } from './columns'\nimport './index.scss'\n\nconst baseClass = 'versions'\n\nexport const DefaultVersionsView: React.FC<Props> = (props) => {\n  const {\n    id,\n    collection,\n    data,\n    entityLabel,\n    global,\n    isLoadingVersions,\n    latestDraftVersion,\n    latestPublishedVersion,\n    versionsData,\n  } = props\n\n  const { t } = useTranslation('version')\n\n  const { limit } = useSearchParams()\n\n  const useAsTitle = collection?.admin?.useAsTitle || 'id'\n\n  let metaDesc: string\n  let metaTitle: string\n\n  if (collection) {\n    metaTitle = `${t('versions')} - ${data[useAsTitle]} - ${entityLabel}`\n    metaDesc = t('viewingVersions', { documentTitle: data[useAsTitle], entityLabel })\n  }\n\n  if (global) {\n    metaTitle = `${t('versions')} - ${entityLabel}`\n    metaDesc = t('viewingVersionsGlobal', { entityLabel })\n  }\n\n  const versionCount = versionsData?.totalDocs || 0\n\n  return (\n    <React.Fragment>\n      <SetStepNav collection={collection} global={global} id={id} isEditing view={t('versions')} />\n      <LoadingOverlayToggle name=\"versions\" show={isLoadingVersions} />\n      <main className={baseClass}>\n        <Meta description={metaDesc} title={metaTitle} />\n        <Gutter className={`${baseClass}__wrap`}>\n          {versionCount === 0 && (\n            <div className={`${baseClass}__no-versions`}>{t('noFurtherVersionsFound')}</div>\n          )}\n          {versionCount > 0 && (\n            <React.Fragment>\n              {/* <div className={`${baseClass}__version-count`}>\n                {t(versionCount === 1 ? 'versionCount_one' : 'versionCount_many', {\n                  count: versionCount,\n                })}\n              </div> */}\n              <Table\n                columns={buildVersionColumns(\n                  collection,\n                  global,\n                  t,\n                  latestDraftVersion,\n                  latestPublishedVersion,\n                )}\n                data={versionsData?.docs}\n              />\n              <div className={`${baseClass}__page-controls`}>\n                <Paginator\n                  hasNextPage={versionsData.hasNextPage}\n                  hasPrevPage={versionsData.hasPrevPage}\n                  limit={versionsData.limit}\n                  nextPage={versionsData.nextPage}\n                  numberOfNeighbors={1}\n                  page={versionsData.page}\n                  prevPage={versionsData.prevPage}\n                  totalPages={versionsData.totalPages}\n                />\n                {versionsData?.totalDocs > 0 && (\n                  <React.Fragment>\n                    <div className={`${baseClass}__page-info`}>\n                      {versionsData.page * versionsData.limit - (versionsData.limit - 1)}-\n                      {versionsData.totalPages > 1 && versionsData.totalPages !== versionsData.page\n                        ? versionsData.limit * versionsData.page\n                        : versionsData.totalDocs}{' '}\n                      {t('of')} {versionsData.totalDocs}\n                    </div>\n                    <PerPage\n                      limit={limit ? Number(limit) : 10}\n                      limits={collection?.admin?.pagination?.limits}\n                    />\n                  </React.Fragment>\n                )}\n              </div>\n            </React.Fragment>\n          )}\n        </Gutter>\n      </main>\n    </React.Fragment>\n  )\n}\n"],"names":["DefaultVersionsView","baseClass","props","id","collection","data","entityLabel","global","isLoadingVersions","latestDraftVersion","latestPublishedVersion","versionsData","t","useTranslation","limit","useSearchParams","useAsTitle","admin","metaDesc","metaTitle","documentTitle","versionCount","totalDocs","React","Fragment","SetStepNav","isEditing","view","LoadingOverlayToggle","name","show","main","className","Meta","description","title","Gutter","div","Table","columns","buildVersionColumns","docs","Paginator","hasNextPage","hasPrevPage","nextPage","numberOfNeighbors","page","prevPage","totalPages","PerPage","Number","limits","pagination"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAkBaA;;;eAAAA;;;8DAlBK;8BACa;wBAIR;yBACc;kEACf;gEACF;uBACE;6DACL;8BACe;4BACL;yBACS;QAC7B;;;;;;AAEP,MAAMC,YAAY;AAEX,MAAMD,sBAAuC,CAACE;IACnD,MAAM,EACJC,EAAE,EACFC,UAAU,EACVC,IAAI,EACJC,WAAW,EACXC,MAAM,EACNC,iBAAiB,EACjBC,kBAAkB,EAClBC,sBAAsB,EACtBC,YAAY,EACb,GAAGT;IAEJ,MAAM,EAAEU,CAAC,EAAE,GAAGC,IAAAA,4BAAc,EAAC;IAE7B,MAAM,EAAEC,KAAK,EAAE,GAAGC,IAAAA,6BAAe;IAEjC,MAAMC,aAAaZ,YAAYa,OAAOD,cAAc;IAEpD,IAAIE;IACJ,IAAIC;IAEJ,IAAIf,YAAY;QACde,YAAY,CAAC,EAAEP,EAAE,YAAY,GAAG,EAAEP,IAAI,CAACW,WAAW,CAAC,GAAG,EAAEV,YAAY,CAAC;QACrEY,WAAWN,EAAE,mBAAmB;YAAEQ,eAAef,IAAI,CAACW,WAAW;YAAEV;QAAY;IACjF;IAEA,IAAIC,QAAQ;QACVY,YAAY,CAAC,EAAEP,EAAE,YAAY,GAAG,EAAEN,YAAY,CAAC;QAC/CY,WAAWN,EAAE,yBAAyB;YAAEN;QAAY;IACtD;IAEA,MAAMe,eAAeV,cAAcW,aAAa;IAEhD,qBACE,6BAACC,cAAK,CAACC,QAAQ,sBACb,6BAACC,sBAAU;QAACrB,YAAYA;QAAYG,QAAQA;QAAQJ,IAAIA;QAAIuB,WAAAA;QAAUC,MAAMf,EAAE;sBAC9E,6BAACgB,6BAAoB;QAACC,MAAK;QAAWC,MAAMtB;sBAC5C,6BAACuB;QAAKC,WAAW/B;qBACf,6BAACgC,aAAI;QAACC,aAAahB;QAAUiB,OAAOhB;sBACpC,6BAACiB,cAAM;QAACJ,WAAW,CAAC,EAAE/B,UAAU,MAAM,CAAC;OACpCoB,iBAAiB,mBAChB,6BAACgB;QAAIL,WAAW,CAAC,EAAE/B,UAAU,aAAa,CAAC;OAAGW,EAAE,4BAEjDS,eAAe,mBACd,6BAACE,cAAK,CAACC,QAAQ,sBAMb,6BAACc,YAAK;QACJC,SAASC,IAAAA,4BAAmB,EAC1BpC,YACAG,QACAK,GACAH,oBACAC;QAEFL,MAAMM,cAAc8B;sBAEtB,6BAACJ;QAAIL,WAAW,CAAC,EAAE/B,UAAU,eAAe,CAAC;qBAC3C,6BAACyC,kBAAS;QACRC,aAAahC,aAAagC,WAAW;QACrCC,aAAajC,aAAaiC,WAAW;QACrC9B,OAAOH,aAAaG,KAAK;QACzB+B,UAAUlC,aAAakC,QAAQ;QAC/BC,mBAAmB;QACnBC,MAAMpC,aAAaoC,IAAI;QACvBC,UAAUrC,aAAaqC,QAAQ;QAC/BC,YAAYtC,aAAasC,UAAU;QAEpCtC,cAAcW,YAAY,mBACzB,6BAACC,cAAK,CAACC,QAAQ,sBACb,6BAACa;QAAIL,WAAW,CAAC,EAAE/B,UAAU,WAAW,CAAC;OACtCU,aAAaoC,IAAI,GAAGpC,aAAaG,KAAK,GAAIH,CAAAA,aAAaG,KAAK,GAAG,CAAA,GAAG,KAClEH,aAAasC,UAAU,GAAG,KAAKtC,aAAasC,UAAU,KAAKtC,aAAaoC,IAAI,GACzEpC,aAAaG,KAAK,GAAGH,aAAaoC,IAAI,GACtCpC,aAAaW,SAAS,EAAE,KAC3BV,EAAE,OAAM,KAAED,aAAaW,SAAS,iBAEnC,6BAAC4B,gBAAO;QACNpC,OAAOA,QAAQqC,OAAOrC,SAAS;QAC/BsC,QAAQhD,YAAYa,OAAOoC,YAAYD;;AAW7D"}

package/packages/payload/dist/admin/components/views/Versions/cells/AutosaveCell.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+type AutosaveCellProps = {
+    latestDraftVersion?: string;
+    latestPublishedVersion?: string;
+    rowData: any;
+};
+export declare const renderPill: (data: any, latestVersion: any, currentLabel: any, previousLabel: any, pillStyle: any) => React.JSX.Element;
+export declare const AutosaveCell: React.FC<AutosaveCellProps>;
+export {};
+//# sourceMappingURL=AutosaveCell.d.ts.map

package/packages/payload/dist/admin/components/views/Versions/cells/AutosaveCell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutosaveCell.d.ts","sourceRoot":"","sources":["../../../../../../src/admin/components/views/Versions/cells/AutosaveCell.tsx"],"names":[],"mappings":"AACA,OAAO,KAAmB,MAAM,OAAO,CAAA;AAKvC,KAAK,iBAAiB,GAAG;IACvB,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B,OAAO,EAAE,GAAG,CAAA;CACb,CAAA;AAED,eAAO,MAAM,UAAU,6GAWtB,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAoCpD,CAAA"}

package/packages/payload/dist/admin/components/views/Versions/cells/AutosaveCell.js

@@ -0,0 +1,90 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AutosaveCell: function() {
+        return AutosaveCell;
+    },
+    renderPill: function() {
+        return renderPill;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacti18next = require("react-i18next");
+const _ = require("../../../");
+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 renderPill = (data, latestVersion, currentLabel, previousLabel, pillStyle)=>{
+    return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, data?.id === latestVersion ? /*#__PURE__*/ _react.default.createElement(_.Pill, {
+        pillStyle: pillStyle
+    }, currentLabel) : /*#__PURE__*/ _react.default.createElement(_.Pill, null, previousLabel), "  ");
+};
+const AutosaveCell = ({ latestDraftVersion, latestPublishedVersion, rowData })=>{
+    const { t } = (0, _reacti18next.useTranslation)();
+    const status = rowData?.version._status;
+    const versionInfo = {
+        draft: {
+            currentLabel: t('version:currentDraft'),
+            latestVersion: latestDraftVersion,
+            pillStyle: undefined,
+            previousLabel: t('version:draft')
+        },
+        published: {
+            currentLabel: t('version:currentPublishedVersion'),
+            latestVersion: latestPublishedVersion,
+            pillStyle: 'success',
+            previousLabel: t('version:previouslyPublished')
+        }
+    };
+    const { currentLabel, latestVersion, pillStyle, previousLabel } = versionInfo[status] || {};
+    return /*#__PURE__*/ _react.default.createElement(_react.Fragment, null, rowData?.autosave && /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/ _react.default.createElement(_.Pill, null, t('version:autosave')), "  "), status && renderPill(rowData, latestVersion, currentLabel, previousLabel, pillStyle));
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/packages/payload/dist/admin/components/views/Versions/columns.d.ts

@@ -0,0 +1,6 @@
+import type { TFunction } from 'react-i18next';
+import type { SanitizedCollectionConfig } from '../../../../collections/config/types';
+import type { SanitizedGlobalConfig } from '../../../../globals/config/types';
+import type { Column } from '../../elements/Table/types';
+export declare const buildVersionColumns: (collection: SanitizedCollectionConfig, global: SanitizedGlobalConfig, t: TFunction, latestDraftVersion?: string, latestPublishedVersion?: string) => Column[];
+//# sourceMappingURL=columns.d.ts.map

package/packages/payload/dist/admin/components/views/Versions/columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columns.d.ts","sourceRoot":"","sources":["../../../../../src/admin/components/views/Versions/columns.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAM9C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAA;AACrF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAA;AAC7E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAA;AAmCxD,eAAO,MAAM,mBAAmB,eAClB,yBAAyB,UAC7B,qBAAqB,KAC1B,SAAS,uBACS,MAAM,2BACF,MAAM,KAC9B,MAAM,EAqDR,CAAA"}

package/packages/payload/dist/admin/components/views/Versions/columns.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "buildVersionColumns", {
+    enumerable: true,
+    get: function() {
+        return buildVersionColumns;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _reacti18next = require("react-i18next");
+const _reactrouterdom = require("react-router-dom");
+const _formatDate = require("../../../utilities/formatDate");
+const _SortColumn = /*#__PURE__*/ _interop_require_default(require("../../elements/SortColumn"));
+const _Config = require("../../utilities/Config");
+const _AutosaveCell = require("./cells/AutosaveCell");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const CreatedAtCell = ({ id, collection, date, global })=>{
+    const { admin: { dateFormat }, routes: { admin } } = (0, _Config.useConfig)();
+    const { params: { id: docID } } = (0, _reactrouterdom.useRouteMatch)();
+    const { i18n } = (0, _reacti18next.useTranslation)();
+    let to;
+    if (collection) to = `${admin}/collections/${collection.slug}/${docID}/versions/${id}`;
+    if (global) to = `${admin}/globals/${global.slug}/versions/${id}`;
+    return /*#__PURE__*/ _react.default.createElement(_reactrouterdom.Link, {
+        to: to
+    }, date && (0, _formatDate.formatDate)(date, dateFormat, i18n?.language));
+};
+const TextCell = ({ children })=>/*#__PURE__*/ _react.default.createElement("span", null, children);
+const buildVersionColumns = (collection, global, t, latestDraftVersion, latestPublishedVersion)=>{
+    const entityConfig = collection || global;
+    const columns = [
+        {
+            name: '',
+            accessor: 'updatedAt',
+            active: true,
+            components: {
+                Heading: /*#__PURE__*/ _react.default.createElement(_SortColumn.default, {
+                    label: t('general:updatedAt'),
+                    name: "updatedAt"
+                }),
+                renderCell: (row, data)=>/*#__PURE__*/ _react.default.createElement(CreatedAtCell, {
+                        collection: collection,
+                        date: data,
+                        global: global,
+                        id: row?.id
+                    })
+            },
+            label: ''
+        },
+        {
+            name: '',
+            accessor: 'id',
+            active: true,
+            components: {
+                Heading: /*#__PURE__*/ _react.default.createElement(_SortColumn.default, {
+                    disable: true,
+                    label: t('versionID'),
+                    name: "id"
+                }),
+                renderCell: (row, data)=>/*#__PURE__*/ _react.default.createElement(TextCell, null, data)
+            },
+            label: ''
+        }
+    ];
+    if (entityConfig?.versions?.drafts || entityConfig?.versions?.drafts && entityConfig.versions.drafts?.autosave) {
+        columns.push({
+            name: '',
+            accessor: 'autosave',
+            active: true,
+            components: {
+                Heading: /*#__PURE__*/ _react.default.createElement(_SortColumn.default, {
+                    disable: true,
+                    label: t('status'),
+                    name: "autosave"
+                }),
+                renderCell: (row)=>{
+                    return /*#__PURE__*/ _react.default.createElement(_AutosaveCell.AutosaveCell, {
+                        latestDraftVersion: latestDraftVersion,
+                        latestPublishedVersion: latestPublishedVersion,
+                        rowData: row
+                    });
+                }
+            },
+            label: ''
+        });
+    }
+    return columns;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/packages/payload/dist/admin/components/views/Versions/index.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { IndexProps } from './types';
+declare const VersionsView: React.FC<IndexProps>;
+export default VersionsView;
+//# sourceMappingURL=index.d.ts.map

package/packages/payload/dist/admin/components/views/Versions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/admin/components/views/Versions/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA8B,MAAM,OAAO,CAAA;AAGlD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAYzC,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,UAAU,CA+LtC,CAAA;AACD,eAAe,YAAY,CAAA"}

package/packages/payload/dist/admin/components/views/Versions/index.js

@@ -0,0 +1,235 @@
+"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 _reacti18next = require("react-i18next");
+const _getTranslation = require("../../../../utilities/getTranslation");
+const _usePayloadAPI = /*#__PURE__*/ _interop_require_default(require("../../../hooks/usePayloadAPI"));
+const _ActionsProvider = require("../../utilities/ActionsProvider");
+const _Auth = require("../../utilities/Auth");
+const _Config = require("../../utilities/Config");
+const _EditDepth = require("../../utilities/EditDepth");
+const _RenderCustomComponent = /*#__PURE__*/ _interop_require_default(require("../../utilities/RenderCustomComponent"));
+const _SearchParams = require("../../utilities/SearchParams");
+const _Default = require("./Default");
+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 VersionsView = (props)=>{
+    const { id, collection, global } = props;
+    const { permissions, user } = (0, _Auth.useAuth)();
+    const [fetchURL, setFetchURL] = (0, _react.useState)('');
+    const { setViewActions } = (0, _ActionsProvider.useActions)();
+    const { routes: { admin, api }, serverURL } = (0, _Config.useConfig)();
+    const { i18n } = (0, _reacti18next.useTranslation)('version');
+    const { limit, page, sort } = (0, _SearchParams.useSearchParams)();
+    let CustomVersionsView = null;
+    let docURL;
+    let entityLabel;
+    let slug;
+    let editURL;
+    const [latestDraftVersion, setLatestDraftVersion] = (0, _react.useState)(undefined);
+    const [latestPublishedVersion, setLatestPublishedVersion] = (0, _react.useState)(undefined);
+    if (collection) {
+        ({ slug } = collection);
+        docURL = `${serverURL}${api}/${slug}/${id}`;
+        entityLabel = (0, _getTranslation.getTranslation)(collection.labels.singular, i18n);
+        editURL = `${admin}/collections/${collection.slug}/${id}`;
+        // The component definition could come from multiple places in the config
+        // we need to cascade into the proper component from the top-down
+        // 1. "components.Edit"
+        // 2. "components.Edit.Versions"
+        // 3. "components.Edit.Versions.Component"
+        const EditCollection = collection?.admin?.components?.views?.Edit;
+        if (typeof EditCollection === 'function') {
+            CustomVersionsView = EditCollection;
+        } else if (typeof EditCollection === 'object' && typeof EditCollection.Versions === 'function') {
+            CustomVersionsView = EditCollection.Versions;
+        } else if (typeof EditCollection?.Versions === 'object' && 'Component' in EditCollection.Versions && typeof EditCollection.Versions.Component === 'function') {
+            CustomVersionsView = EditCollection.Versions.Component;
+        }
+    }
+    if (global) {
+        ({ slug } = global);
+        docURL = `${serverURL}${api}/globals/${slug}`;
+        entityLabel = (0, _getTranslation.getTranslation)(global.label, i18n);
+        editURL = `${admin}/globals/${global.slug}`;
+        // See note above about cascading component definitions
+        const EditGlobal = global?.admin?.components?.views?.Edit;
+        if (typeof EditGlobal === 'function') {
+            CustomVersionsView = EditGlobal;
+        } else if (typeof EditGlobal === 'object' && typeof EditGlobal.Versions === 'function') {
+            CustomVersionsView = EditGlobal.Versions;
+        } else if (typeof EditGlobal?.Versions === 'object' && 'Component' in EditGlobal.Versions && typeof EditGlobal.Versions.Component === 'function') {
+            CustomVersionsView = EditGlobal.Versions.Component;
+        }
+    }
+    const [{ data, isLoading }] = (0, _usePayloadAPI.default)(docURL, {
+        initialParams: {
+            draft: 'true'
+        }
+    });
+    const [{ data: versionsData, isLoading: isLoadingVersions }, { setParams }] = (0, _usePayloadAPI.default)(fetchURL);
+    const hasDraftsEnabled = collection?.versions?.drafts || global?.versions?.drafts;
+    const sharedParams = (status)=>{
+        return {
+            depth: 0,
+            limit: 1,
+            sort: '-updatedAt',
+            where: {
+                'version._status': {
+                    equals: status
+                }
+            }
+        };
+    };
+    const [{ data: draft }] = (0, _usePayloadAPI.default)(fetchURL, {
+        initialParams: hasDraftsEnabled ? {
+            ...sharedParams('draft')
+        } : {}
+    });
+    const [{ data: published }] = (0, _usePayloadAPI.default)(fetchURL, {
+        initialParams: hasDraftsEnabled ? {
+            ...sharedParams('published')
+        } : {}
+    });
+    (0, _react.useEffect)(()=>{
+        if (hasDraftsEnabled) {
+            const formattedPublished = published?.docs?.length > 0 && published?.docs[0];
+            const formattedDraft = draft?.docs?.length > 0 && draft?.docs[0];
+            if (!formattedPublished || !formattedDraft) return;
+            const publishedNewerThanDraft = formattedPublished?.updatedAt > formattedDraft?.updatedAt;
+            setLatestDraftVersion(publishedNewerThanDraft ? undefined : formattedDraft?.id);
+            setLatestPublishedVersion(formattedPublished.latest ? formattedPublished?.id : undefined);
+        }
+    }, [
+        hasDraftsEnabled,
+        draft,
+        published
+    ]);
+    (0, _react.useEffect)(()=>{
+        const params = {
+            depth: 1,
+            limit,
+            page: undefined,
+            sort: undefined,
+            where: {}
+        };
+        if (page) params.page = page;
+        if (sort) params.sort = sort;
+        let fetchURLToSet;
+        if (collection) {
+            fetchURLToSet = `${serverURL}${api}/${collection.slug}/versions`;
+            params.where = {
+                parent: {
+                    equals: id
+                }
+            };
+        }
+        if (global) {
+            fetchURLToSet = `${serverURL}${api}/globals/${global.slug}/versions`;
+        }
+        // Performance enhancement
+        // Setting the Fetch URL this way
+        // prevents a double-fetch
+        setFetchURL(fetchURLToSet);
+        setParams(params);
+    }, [
+        setParams,
+        page,
+        sort,
+        limit,
+        serverURL,
+        api,
+        id,
+        global,
+        collection
+    ]);
+    (0, _react.useEffect)(()=>{
+        const editConfig = (collection || global)?.admin?.components?.views?.Edit;
+        const versionsActions = editConfig && 'Versions' in editConfig && 'actions' in editConfig.Versions ? editConfig.Versions.actions : [];
+        setViewActions(versionsActions);
+        return ()=>{
+            setViewActions([]);
+        };
+    }, [
+        collection,
+        global,
+        setViewActions
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_EditDepth.EditDepthContext.Provider, {
+        value: 1
+    }, /*#__PURE__*/ _react.default.createElement(_RenderCustomComponent.default, {
+        CustomComponent: CustomVersionsView,
+        DefaultComponent: _Default.DefaultVersionsView,
+        componentProps: {
+            id,
+            canAccessAdmin: permissions?.canAccessAdmin,
+            collection,
+            data,
+            editURL,
+            entityLabel,
+            fetchURL,
+            global,
+            isLoading,
+            isLoadingVersions,
+            latestDraftVersion,
+            latestPublishedVersion,
+            user,
+            versionsData
+        }
+    }));
+};
+const _default = VersionsView;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/admin/components/views/Versions/index.tsx"],"sourcesContent":["import React, { useEffect, useState } from 'react'\nimport { useTranslation } from 'react-i18next'\n\nimport type { IndexProps } from './types'\n\nimport { getTranslation } from '../../../../utilities/getTranslation'\nimport usePayloadAPI from '../../../hooks/usePayloadAPI'\nimport { useActions } from '../../utilities/ActionsProvider'\nimport { useAuth } from '../../utilities/Auth'\nimport { useConfig } from '../../utilities/Config'\nimport { EditDepthContext } from '../../utilities/EditDepth'\nimport RenderCustomComponent from '../../utilities/RenderCustomComponent'\nimport { useSearchParams } from '../../utilities/SearchParams'\nimport { DefaultVersionsView } from './Default'\n\nconst VersionsView: React.FC<IndexProps> = (props) => {\n  const { id, collection, global } = props\n\n  const { permissions, user } = useAuth()\n\n  const [fetchURL, setFetchURL] = useState('')\n\n  const { setViewActions } = useActions()\n\n  const {\n    routes: { admin, api },\n    serverURL,\n  } = useConfig()\n\n  const { i18n } = useTranslation('version')\n\n  const { limit, page, sort } = useSearchParams()\n\n  let CustomVersionsView: React.ComponentType | null = null\n  let docURL: string\n  let entityLabel: string\n  let slug: string\n  let editURL: string\n  const [latestDraftVersion, setLatestDraftVersion] = useState(undefined)\n  const [latestPublishedVersion, setLatestPublishedVersion] = useState(undefined)\n\n  if (collection) {\n    ;({ slug } = collection)\n    docURL = `${serverURL}${api}/${slug}/${id}`\n    entityLabel = getTranslation(collection.labels.singular, i18n)\n    editURL = `${admin}/collections/${collection.slug}/${id}`\n\n    // The component definition could come from multiple places in the config\n    // we need to cascade into the proper component from the top-down\n    // 1. \"components.Edit\"\n    // 2. \"components.Edit.Versions\"\n    // 3. \"components.Edit.Versions.Component\"\n    const EditCollection = collection?.admin?.components?.views?.Edit\n\n    if (typeof EditCollection === 'function') {\n      CustomVersionsView = EditCollection\n    } else if (\n      typeof EditCollection === 'object' &&\n      typeof EditCollection.Versions === 'function'\n    ) {\n      CustomVersionsView = EditCollection.Versions\n    } else if (\n      typeof EditCollection?.Versions === 'object' &&\n      'Component' in EditCollection.Versions &&\n      typeof EditCollection.Versions.Component === 'function'\n    ) {\n      CustomVersionsView = EditCollection.Versions.Component\n    }\n  }\n\n  if (global) {\n    ;({ slug } = global)\n    docURL = `${serverURL}${api}/globals/${slug}`\n    entityLabel = getTranslation(global.label, i18n)\n    editURL = `${admin}/globals/${global.slug}`\n\n    // See note above about cascading component definitions\n    const EditGlobal = global?.admin?.components?.views?.Edit\n\n    if (typeof EditGlobal === 'function') {\n      CustomVersionsView = EditGlobal\n    } else if (typeof EditGlobal === 'object' && typeof EditGlobal.Versions === 'function') {\n      CustomVersionsView = EditGlobal.Versions\n    } else if (\n      typeof EditGlobal?.Versions === 'object' &&\n      'Component' in EditGlobal.Versions &&\n      typeof EditGlobal.Versions.Component === 'function'\n    ) {\n      CustomVersionsView = EditGlobal.Versions.Component\n    }\n  }\n\n  const [{ data, isLoading }] = usePayloadAPI(docURL, { initialParams: { draft: 'true' } })\n  const [{ data: versionsData, isLoading: isLoadingVersions }, { setParams }] =\n    usePayloadAPI(fetchURL)\n\n  const hasDraftsEnabled = collection?.versions?.drafts || global?.versions?.drafts\n\n  const sharedParams = (status) => {\n    return {\n      depth: 0,\n      limit: 1,\n      sort: '-updatedAt',\n      where: {\n        'version._status': {\n          equals: status,\n        },\n      },\n    }\n  }\n\n  const [{ data: draft }] = usePayloadAPI(fetchURL, {\n    initialParams: hasDraftsEnabled ? { ...sharedParams('draft') } : {},\n  })\n\n  const [{ data: published }] = usePayloadAPI(fetchURL, {\n    initialParams: hasDraftsEnabled ? { ...sharedParams('published') } : {},\n  })\n\n  useEffect(() => {\n    if (hasDraftsEnabled) {\n      const formattedPublished = published?.docs?.length > 0 && published?.docs[0]\n      const formattedDraft = draft?.docs?.length > 0 && draft?.docs[0]\n\n      if (!formattedPublished || !formattedDraft) return\n\n      const publishedNewerThanDraft = formattedPublished?.updatedAt > formattedDraft?.updatedAt\n      setLatestDraftVersion(publishedNewerThanDraft ? undefined : formattedDraft?.id)\n      setLatestPublishedVersion(formattedPublished.latest ? formattedPublished?.id : undefined)\n    }\n  }, [hasDraftsEnabled, draft, published])\n\n  useEffect(() => {\n    const params = {\n      depth: 1,\n      limit,\n      page: undefined,\n      sort: undefined,\n      where: {},\n    }\n\n    if (page) params.page = page\n    if (sort) params.sort = sort\n\n    let fetchURLToSet: string\n\n    if (collection) {\n      fetchURLToSet = `${serverURL}${api}/${collection.slug}/versions`\n      params.where = {\n        parent: {\n          equals: id,\n        },\n      }\n    }\n\n    if (global) {\n      fetchURLToSet = `${serverURL}${api}/globals/${global.slug}/versions`\n    }\n\n    // Performance enhancement\n    // Setting the Fetch URL this way\n    // prevents a double-fetch\n\n    setFetchURL(fetchURLToSet)\n\n    setParams(params)\n  }, [setParams, page, sort, limit, serverURL, api, id, global, collection])\n\n  useEffect(() => {\n    const editConfig = (collection || global)?.admin?.components?.views?.Edit\n    const versionsActions =\n      editConfig && 'Versions' in editConfig && 'actions' in editConfig.Versions\n        ? editConfig.Versions.actions\n        : []\n\n    setViewActions(versionsActions)\n\n    return () => {\n      setViewActions([])\n    }\n  }, [collection, global, setViewActions])\n\n  return (\n    <EditDepthContext.Provider value={1}>\n      <RenderCustomComponent\n        CustomComponent={CustomVersionsView}\n        DefaultComponent={DefaultVersionsView}\n        componentProps={{\n          id,\n          canAccessAdmin: permissions?.canAccessAdmin,\n          collection,\n          data,\n          editURL,\n          entityLabel,\n          fetchURL,\n          global,\n          isLoading,\n          isLoadingVersions,\n          latestDraftVersion,\n          latestPublishedVersion,\n          user,\n          versionsData,\n        }}\n      />\n    </EditDepthContext.Provider>\n  )\n}\nexport default VersionsView\n"],"names":["VersionsView","props","id","collection","global","permissions","user","useAuth","fetchURL","setFetchURL","useState","setViewActions","useActions","routes","admin","api","serverURL","useConfig","i18n","useTranslation","limit","page","sort","useSearchParams","CustomVersionsView","docURL","entityLabel","slug","editURL","latestDraftVersion","setLatestDraftVersion","undefined","latestPublishedVersion","setLatestPublishedVersion","getTranslation","labels","singular","EditCollection","components","views","Edit","Versions","Component","label","EditGlobal","data","isLoading","usePayloadAPI","initialParams","draft","versionsData","isLoadingVersions","setParams","hasDraftsEnabled","versions","drafts","sharedParams","status","depth","where","equals","published","useEffect","formattedPublished","docs","length","formattedDraft","publishedNewerThanDraft","updatedAt","latest","params","fetchURLToSet","parent","editConfig","versionsActions","actions","EditDepthContext","Provider","value","RenderCustomComponent","CustomComponent","DefaultComponent","DefaultVersionsView","componentProps","canAccessAdmin"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}