1364 lines
44 KiB
JavaScript
1364 lines
44 KiB
JavaScript
import {
|
||
useTypedSelector
|
||
} from "./chunk-VE2D6HMA.js";
|
||
import {
|
||
DocumentRBAC,
|
||
DynamicZone,
|
||
MemoizedBlocksInput,
|
||
MemoizedComponentInput,
|
||
MemoizedUIDInput,
|
||
MemoizedWysiwyg,
|
||
NotAllowedInput,
|
||
PERMISSIONS,
|
||
getDisplayName,
|
||
getRelationLabel,
|
||
useDocumentRBAC,
|
||
useDynamicZone,
|
||
useFieldHint,
|
||
useLazyComponents
|
||
} from "./chunk-GXKJFURG.js";
|
||
import {
|
||
DocumentStatus,
|
||
RelativeTime
|
||
} from "./chunk-7FUKGPNR.js";
|
||
import "./chunk-NAZM6EA4.js";
|
||
import {
|
||
COLLECTION_TYPES,
|
||
buildValidParams,
|
||
prepareTempKeys,
|
||
removeFieldsThatDontExistOnSchema,
|
||
useDoc,
|
||
useDocLayout,
|
||
useDocument,
|
||
useDocumentLayout,
|
||
useGetContentTypeConfigurationQuery
|
||
} from "./chunk-UATNJIHQ.js";
|
||
import {
|
||
contentManagerApi
|
||
} from "./chunk-P4VL3IHZ.js";
|
||
import "./chunk-HIZVCZYI.js";
|
||
import "./chunk-6LY4MOO2.js";
|
||
import "./chunk-QF6GPHA4.js";
|
||
import "./chunk-SYWYLB7I.js";
|
||
import "./chunk-S3HPKOXW.js";
|
||
import "./chunk-JRLAXHTE.js";
|
||
import "./chunk-E4IFZ6ZT.js";
|
||
import "./chunk-QLEKUQKW.js";
|
||
import "./chunk-4J3VOWQV.js";
|
||
import "./chunk-PFI4R5WA.js";
|
||
import "./chunk-B3BGMYGX.js";
|
||
import "./chunk-W6ICJ5TB.js";
|
||
import "./chunk-IHYIPMY2.js";
|
||
import "./chunk-UWHSN2C7.js";
|
||
import "./chunk-ERK7O2GM.js";
|
||
import "./chunk-FCIM6RNO.js";
|
||
import "./chunk-J33IXKN4.js";
|
||
import {
|
||
ConfirmDialog
|
||
} from "./chunk-NP53ZCXD.js";
|
||
import "./chunk-KFLQQE5L.js";
|
||
import "./chunk-ED4XR3VQ.js";
|
||
import "./chunk-MBK4V2X7.js";
|
||
import "./chunk-5ESYXDTN.js";
|
||
import "./chunk-K65KIEAL.js";
|
||
import "./chunk-B7ZLODDO.js";
|
||
import "./chunk-PW7XKCYO.js";
|
||
import "./chunk-RMBEU7DO.js";
|
||
import "./chunk-RI2W2UZ6.js";
|
||
import "./chunk-IY256CNP.js";
|
||
import "./chunk-IFOFBKTA.js";
|
||
import "./chunk-XLSIZGJF.js";
|
||
import "./chunk-EGNP2T5O.js";
|
||
import {
|
||
useTracking
|
||
} from "./chunk-GSN7U3BK.js";
|
||
import "./chunk-T3B5F2LV.js";
|
||
import "./chunk-YXDCVYVT.js";
|
||
import "./chunk-QIJGNK42.js";
|
||
import "./chunk-7PUJSL55.js";
|
||
import "./chunk-C2ZJTFO7.js";
|
||
import "./chunk-C75BZXCZ.js";
|
||
import "./chunk-APGTER6B.js";
|
||
import "./chunk-ZM6TT53G.js";
|
||
import {
|
||
MemoizedInputRenderer
|
||
} from "./chunk-6AXVGFVQ.js";
|
||
import {
|
||
Form,
|
||
useField,
|
||
useForm
|
||
} from "./chunk-BFLP6DBI.js";
|
||
import {
|
||
useRBAC
|
||
} from "./chunk-CMLQV3Z2.js";
|
||
import "./chunk-D4WYVNVM.js";
|
||
import "./chunk-MMOBCIZG.js";
|
||
import "./chunk-IGCTEXRF.js";
|
||
import {
|
||
Layouts
|
||
} from "./chunk-TIVRAWTC.js";
|
||
import "./chunk-PQINNV4N.js";
|
||
import "./chunk-VYSYYPOB.js";
|
||
import {
|
||
Page
|
||
} from "./chunk-5CAWUBTQ.js";
|
||
import {
|
||
useQueryParams,
|
||
useStrapiApp
|
||
} from "./chunk-W2TBR6J3.js";
|
||
import "./chunk-QEGMJR7H.js";
|
||
import {
|
||
require_lib,
|
||
require_pipe
|
||
} from "./chunk-LCL5TIBZ.js";
|
||
import "./chunk-WOQNBAGN.js";
|
||
import "./chunk-BHLYCXQ7.js";
|
||
import {
|
||
createContext
|
||
} from "./chunk-76QM3EFM.js";
|
||
import "./chunk-CE4VABH2.js";
|
||
import "./chunk-5VODLFKF.js";
|
||
import {
|
||
useNotification
|
||
} from "./chunk-N55RVBRV.js";
|
||
import {
|
||
Alert,
|
||
Box,
|
||
Button,
|
||
Dialog,
|
||
Divider,
|
||
Field,
|
||
Flex,
|
||
FocusTrap,
|
||
Grid,
|
||
Link as Link2,
|
||
Main,
|
||
Portal$1,
|
||
TooltipImpl,
|
||
Typography,
|
||
useIntl
|
||
} from "./chunk-7XB6XSWQ.js";
|
||
import "./chunk-5ZC4PE57.js";
|
||
import {
|
||
Link,
|
||
NavLink,
|
||
Navigate,
|
||
useNavigate,
|
||
useParams
|
||
} from "./chunk-TUXTO2Z5.js";
|
||
import "./chunk-FOD4ENRR.js";
|
||
import {
|
||
ForwardRef$3,
|
||
ForwardRef$5j
|
||
} from "./chunk-WRD5KPDH.js";
|
||
import {
|
||
require_jsx_runtime
|
||
} from "./chunk-NIAJZ5MX.js";
|
||
import {
|
||
dt
|
||
} from "./chunk-ACIMPXWY.js";
|
||
import {
|
||
require_react
|
||
} from "./chunk-MADUDGYZ.js";
|
||
import {
|
||
__toESM
|
||
} from "./chunk-PLDDJCW6.js";
|
||
|
||
// node_modules/@strapi/content-manager/dist/admin/history/pages/History.mjs
|
||
var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
|
||
var React4 = __toESM(require_react(), 1);
|
||
var import_qs3 = __toESM(require_lib(), 1);
|
||
|
||
// node_modules/@strapi/content-manager/dist/admin/history/components/VersionContent.mjs
|
||
var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
|
||
var React2 = __toESM(require_react(), 1);
|
||
var import_pipe = __toESM(require_pipe(), 1);
|
||
|
||
// node_modules/@strapi/content-manager/dist/admin/history/components/VersionInputRenderer.mjs
|
||
var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
|
||
var React = __toESM(require_react(), 1);
|
||
var StyledAlert = dt(Alert).attrs({
|
||
closeLabel: "Close",
|
||
onClose: () => {
|
||
},
|
||
shadow: "none"
|
||
})`
|
||
button {
|
||
display: none;
|
||
}
|
||
`;
|
||
var LinkEllipsis = dt(Link2)`
|
||
display: block;
|
||
|
||
& > span {
|
||
white-space: nowrap;
|
||
overflow: hidden;
|
||
text-overflow: ellipsis;
|
||
display: block;
|
||
}
|
||
`;
|
||
var CustomRelationInput = (props) => {
|
||
const { formatMessage } = useIntl();
|
||
const field = useField(props.name);
|
||
let formattedFieldValue;
|
||
if (field) {
|
||
formattedFieldValue = Array.isArray(field.value) ? {
|
||
results: field.value,
|
||
meta: {
|
||
missingCount: 0
|
||
}
|
||
} : field.value;
|
||
}
|
||
if (!formattedFieldValue || formattedFieldValue.results.length === 0 && formattedFieldValue.meta.missingCount === 0) {
|
||
return (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, {
|
||
children: [
|
||
(0, import_jsx_runtime.jsx)(Field.Label, {
|
||
action: props.labelAction,
|
||
children: props.label
|
||
}),
|
||
(0, import_jsx_runtime.jsx)(Box, {
|
||
marginTop: 1,
|
||
children: (0, import_jsx_runtime.jsx)(StyledAlert, {
|
||
variant: "default",
|
||
children: formatMessage({
|
||
id: "content-manager.history.content.no-relations",
|
||
defaultMessage: "No relations."
|
||
})
|
||
})
|
||
})
|
||
]
|
||
});
|
||
}
|
||
const { results, meta } = formattedFieldValue;
|
||
return (0, import_jsx_runtime.jsxs)(Box, {
|
||
children: [
|
||
(0, import_jsx_runtime.jsx)(Field.Label, {
|
||
children: props.label
|
||
}),
|
||
results.length > 0 && (0, import_jsx_runtime.jsx)(Flex, {
|
||
direction: "column",
|
||
gap: 2,
|
||
marginTop: 1,
|
||
alignItems: "stretch",
|
||
children: results.map((relationData) => {
|
||
const { targetModel } = props.attribute;
|
||
const href = `../${COLLECTION_TYPES}/${targetModel}/${relationData.documentId}`;
|
||
const label = getRelationLabel(relationData, props.mainField);
|
||
const isAdminUserRelation = targetModel === "admin::user";
|
||
return (0, import_jsx_runtime.jsxs)(Flex, {
|
||
paddingTop: 2,
|
||
paddingBottom: 2,
|
||
paddingLeft: 4,
|
||
paddingRight: 4,
|
||
hasRadius: true,
|
||
borderColor: "neutral200",
|
||
background: "neutral150",
|
||
justifyContent: "space-between",
|
||
children: [
|
||
(0, import_jsx_runtime.jsx)(Box, {
|
||
minWidth: 0,
|
||
paddingTop: 1,
|
||
paddingBottom: 1,
|
||
paddingRight: 4,
|
||
children: (0, import_jsx_runtime.jsx)(TooltipImpl, {
|
||
label,
|
||
children: isAdminUserRelation ? (0, import_jsx_runtime.jsx)(Typography, {
|
||
children: label
|
||
}) : (0, import_jsx_runtime.jsx)(LinkEllipsis, {
|
||
tag: NavLink,
|
||
to: href,
|
||
children: label
|
||
})
|
||
})
|
||
}),
|
||
(0, import_jsx_runtime.jsx)(DocumentStatus, {
|
||
status: relationData.status
|
||
})
|
||
]
|
||
}, relationData.documentId ?? relationData.id);
|
||
})
|
||
}),
|
||
meta.missingCount > 0 && /* @ts-expect-error – we dont need closeLabel */
|
||
(0, import_jsx_runtime.jsx)(StyledAlert, {
|
||
marginTop: 1,
|
||
variant: "warning",
|
||
title: formatMessage({
|
||
id: "content-manager.history.content.missing-relations.title",
|
||
defaultMessage: "{number, plural, =1 {Missing relation} other {{number} missing relations}}"
|
||
}, {
|
||
number: meta.missingCount
|
||
}),
|
||
children: formatMessage({
|
||
id: "content-manager.history.content.missing-relations.message",
|
||
defaultMessage: "{number, plural, =1 {It has} other {They have}} been deleted and can't be restored."
|
||
}, {
|
||
number: meta.missingCount
|
||
})
|
||
})
|
||
]
|
||
});
|
||
};
|
||
var createInitialValuesForPath = (keyPath, value) => {
|
||
const keys = keyPath.split(".");
|
||
const root = {};
|
||
let node = root;
|
||
keys.forEach((key, index) => {
|
||
if (key === "__proto__" || key === "constructor") return;
|
||
if (index === keys.length - 1) {
|
||
node[key] = value;
|
||
} else {
|
||
node[key] = node[key] || {};
|
||
}
|
||
node = node[key];
|
||
});
|
||
return root;
|
||
};
|
||
var CustomMediaInput = (props) => {
|
||
const { value } = useField(props.name);
|
||
const results = (value == null ? void 0 : value.results) ?? [];
|
||
const meta = (value == null ? void 0 : value.meta) ?? {
|
||
missingCount: 0
|
||
};
|
||
const { formatMessage } = useIntl();
|
||
const fields = useStrapiApp("CustomMediaInput", (state) => state.fields);
|
||
const MediaLibrary = fields.media;
|
||
return (0, import_jsx_runtime.jsxs)(Flex, {
|
||
direction: "column",
|
||
gap: 2,
|
||
alignItems: "stretch",
|
||
children: [
|
||
(0, import_jsx_runtime.jsx)(Form, {
|
||
method: "PUT",
|
||
disabled: true,
|
||
initialValues: createInitialValuesForPath(props.name, results),
|
||
children: (0, import_jsx_runtime.jsx)(MediaLibrary, {
|
||
...props,
|
||
disabled: true,
|
||
multiple: results.length > 1
|
||
})
|
||
}),
|
||
meta.missingCount > 0 && (0, import_jsx_runtime.jsx)(StyledAlert, {
|
||
variant: "warning",
|
||
closeLabel: "Close",
|
||
onClose: () => {
|
||
},
|
||
title: formatMessage({
|
||
id: "content-manager.history.content.missing-assets.title",
|
||
defaultMessage: "{number, plural, =1 {Missing asset} other {{number} missing assets}}"
|
||
}, {
|
||
number: meta.missingCount
|
||
}),
|
||
children: formatMessage({
|
||
id: "content-manager.history.content.missing-assets.message",
|
||
defaultMessage: "{number, plural, =1 {It has} other {They have}} been deleted in the Media Library and can't be restored."
|
||
}, {
|
||
number: meta.missingCount
|
||
})
|
||
})
|
||
]
|
||
});
|
||
};
|
||
var getLabelAction = (labelAction) => {
|
||
if (!React.isValidElement(labelAction)) {
|
||
return labelAction;
|
||
}
|
||
const labelActionTitleId = labelAction.props.title.id;
|
||
if (labelActionTitleId === "i18n.Field.localized") {
|
||
return React.cloneElement(labelAction, {
|
||
...labelAction.props,
|
||
title: {
|
||
id: "history.content.localized",
|
||
defaultMessage: "This value is specific to this locale. If you restore this version, the content will not be replaced for other locales."
|
||
}
|
||
});
|
||
}
|
||
if (labelActionTitleId === "i18n.Field.not-localized") {
|
||
return React.cloneElement(labelAction, {
|
||
...labelAction.props,
|
||
title: {
|
||
id: "history.content.not-localized",
|
||
defaultMessage: "This value is common to all locales. If you restore this version and save the changes, the content will be replaced for all locales."
|
||
}
|
||
});
|
||
}
|
||
return labelAction;
|
||
};
|
||
var VersionInputRenderer = ({ visible, hint: providedHint, shouldIgnoreRBAC = false, labelAction, ...props }) => {
|
||
const customLabelAction = getLabelAction(labelAction);
|
||
const { formatMessage } = useIntl();
|
||
const version = useHistoryContext("VersionContent", (state) => state.selectedVersion);
|
||
const configuration = useHistoryContext("VersionContent", (state) => state.configuration);
|
||
const fieldSizes = useTypedSelector((state) => state["content-manager"].app.fieldSizes);
|
||
const { id, components } = useDoc();
|
||
const isFormDisabled = useForm("InputRenderer", (state) => state.disabled);
|
||
const isInDynamicZone = useDynamicZone("isInDynamicZone", (state) => state.isInDynamicZone);
|
||
const canCreateFields = useDocumentRBAC("InputRenderer", (rbac) => rbac.canCreateFields);
|
||
const canReadFields = useDocumentRBAC("InputRenderer", (rbac) => rbac.canReadFields);
|
||
const canUpdateFields = useDocumentRBAC("InputRenderer", (rbac) => rbac.canUpdateFields);
|
||
const canUserAction = useDocumentRBAC("InputRenderer", (rbac) => rbac.canUserAction);
|
||
const editableFields = id ? canUpdateFields : canCreateFields;
|
||
const readableFields = id ? canReadFields : canCreateFields;
|
||
const canUserReadField = canUserAction(props.name, readableFields, props.type);
|
||
const canUserEditField = canUserAction(props.name, editableFields, props.type);
|
||
const fields = useStrapiApp("InputRenderer", (app) => app.fields);
|
||
const { lazyComponentStore } = useLazyComponents(attributeHasCustomFieldProperty(props.attribute) ? [
|
||
props.attribute.customField
|
||
] : void 0);
|
||
const hint = useFieldHint(providedHint, props.attribute);
|
||
const { edit: { components: componentsLayout } } = useDocLayout();
|
||
if (!visible) {
|
||
return null;
|
||
}
|
||
if (!shouldIgnoreRBAC && !canUserReadField && !isInDynamicZone) {
|
||
return (0, import_jsx_runtime.jsx)(NotAllowedInput, {
|
||
hint,
|
||
...props
|
||
});
|
||
}
|
||
const fieldIsDisabled = !canUserEditField && !isInDynamicZone || props.disabled || isFormDisabled;
|
||
const addedAttributes = version.meta.unknownAttributes.added;
|
||
if (Object.keys(addedAttributes).includes(props.name)) {
|
||
return (0, import_jsx_runtime.jsxs)(Flex, {
|
||
direction: "column",
|
||
alignItems: "flex-start",
|
||
gap: 1,
|
||
children: [
|
||
(0, import_jsx_runtime.jsx)(Field.Label, {
|
||
children: props.label
|
||
}),
|
||
(0, import_jsx_runtime.jsx)(StyledAlert, {
|
||
width: "100%",
|
||
closeLabel: "Close",
|
||
onClose: () => {
|
||
},
|
||
variant: "warning",
|
||
title: formatMessage({
|
||
id: "content-manager.history.content.new-field.title",
|
||
defaultMessage: "New field"
|
||
}),
|
||
children: formatMessage({
|
||
id: "content-manager.history.content.new-field.message",
|
||
defaultMessage: "This field didn't exist when this version was saved. If you restore this version, it will be empty."
|
||
})
|
||
})
|
||
]
|
||
});
|
||
}
|
||
if (attributeHasCustomFieldProperty(props.attribute)) {
|
||
const CustomInput = lazyComponentStore[props.attribute.customField];
|
||
if (CustomInput) {
|
||
return (0, import_jsx_runtime.jsx)(CustomInput, {
|
||
...props,
|
||
// @ts-expect-error – TODO: fix this type error in the useLazyComponents hook.
|
||
hint,
|
||
labelAction: customLabelAction,
|
||
disabled: fieldIsDisabled
|
||
});
|
||
}
|
||
return (0, import_jsx_runtime.jsx)(MemoizedInputRenderer, {
|
||
...props,
|
||
hint,
|
||
labelAction: customLabelAction,
|
||
// @ts-expect-error – this workaround lets us display that the custom field is missing.
|
||
type: props.attribute.customField,
|
||
disabled: fieldIsDisabled
|
||
});
|
||
}
|
||
if (props.type === "media") {
|
||
return (0, import_jsx_runtime.jsx)(CustomMediaInput, {
|
||
...props,
|
||
labelAction: customLabelAction,
|
||
disabled: fieldIsDisabled
|
||
});
|
||
}
|
||
const addedInputTypes = Object.keys(fields);
|
||
if (!attributeHasCustomFieldProperty(props.attribute) && addedInputTypes.includes(props.type)) {
|
||
const CustomInput = fields[props.type];
|
||
return (0, import_jsx_runtime.jsx)(CustomInput, {
|
||
...props,
|
||
// @ts-expect-error – TODO: fix this type error in the useLibrary hook.
|
||
hint,
|
||
labelAction: customLabelAction,
|
||
disabled: fieldIsDisabled
|
||
});
|
||
}
|
||
switch (props.type) {
|
||
case "blocks":
|
||
return (0, import_jsx_runtime.jsx)(MemoizedBlocksInput, {
|
||
...props,
|
||
hint,
|
||
type: props.type,
|
||
disabled: fieldIsDisabled
|
||
});
|
||
case "component":
|
||
const { layout } = componentsLayout[props.attribute.component];
|
||
const [remainingFieldsLayout] = getRemaingFieldsLayout({
|
||
layout: [
|
||
layout
|
||
],
|
||
metadatas: configuration.components[props.attribute.component].metadatas,
|
||
fieldSizes,
|
||
schemaAttributes: components[props.attribute.component].attributes
|
||
});
|
||
return (0, import_jsx_runtime.jsx)(MemoizedComponentInput, {
|
||
...props,
|
||
layout: [
|
||
...layout,
|
||
...remainingFieldsLayout || []
|
||
],
|
||
hint,
|
||
labelAction: customLabelAction,
|
||
disabled: fieldIsDisabled,
|
||
children: (inputProps) => (0, import_jsx_runtime.jsx)(VersionInputRenderer, {
|
||
...inputProps,
|
||
shouldIgnoreRBAC: true
|
||
})
|
||
});
|
||
case "dynamiczone":
|
||
return (0, import_jsx_runtime.jsx)(DynamicZone, {
|
||
...props,
|
||
hint,
|
||
labelAction: customLabelAction,
|
||
disabled: fieldIsDisabled,
|
||
children: (inputProps) => (0, import_jsx_runtime.jsx)(VersionInputRenderer, {
|
||
...inputProps,
|
||
shouldIgnoreRBAC: true
|
||
})
|
||
});
|
||
case "relation":
|
||
return (0, import_jsx_runtime.jsx)(CustomRelationInput, {
|
||
...props,
|
||
hint,
|
||
labelAction: customLabelAction,
|
||
disabled: fieldIsDisabled
|
||
});
|
||
case "richtext":
|
||
return (0, import_jsx_runtime.jsx)(MemoizedWysiwyg, {
|
||
...props,
|
||
hint,
|
||
type: props.type,
|
||
labelAction: customLabelAction,
|
||
disabled: fieldIsDisabled
|
||
});
|
||
case "uid":
|
||
return (0, import_jsx_runtime.jsx)(MemoizedUIDInput, {
|
||
...props,
|
||
hint,
|
||
type: props.type,
|
||
labelAction: customLabelAction,
|
||
disabled: fieldIsDisabled
|
||
});
|
||
case "enumeration":
|
||
return (0, import_jsx_runtime.jsx)(MemoizedInputRenderer, {
|
||
...props,
|
||
hint,
|
||
labelAction: customLabelAction,
|
||
options: props.attribute.enum.map((value) => ({
|
||
value
|
||
})),
|
||
// @ts-expect-error – Temp workaround so we don't forget custom-fields don't work!
|
||
type: props.customField ? "custom-field" : props.type,
|
||
disabled: fieldIsDisabled
|
||
});
|
||
default:
|
||
const { unique: _unique, mainField: _mainField, ...restProps } = props;
|
||
return (0, import_jsx_runtime.jsx)(MemoizedInputRenderer, {
|
||
...restProps,
|
||
hint,
|
||
labelAction: customLabelAction,
|
||
// @ts-expect-error – Temp workaround so we don't forget custom-fields don't work!
|
||
type: props.customField ? "custom-field" : props.type,
|
||
disabled: fieldIsDisabled
|
||
});
|
||
}
|
||
};
|
||
var attributeHasCustomFieldProperty = (attribute) => "customField" in attribute && typeof attribute.customField === "string";
|
||
|
||
// node_modules/@strapi/content-manager/dist/admin/history/components/VersionContent.mjs
|
||
var createLayoutFromFields = (fields) => {
|
||
return fields.reduce((rows, field) => {
|
||
if (field.type === "dynamiczone") {
|
||
rows.push([
|
||
field
|
||
]);
|
||
return rows;
|
||
}
|
||
if (!rows[rows.length - 1]) {
|
||
rows.push([]);
|
||
}
|
||
rows[rows.length - 1].push(field);
|
||
return rows;
|
||
}, []).map((row) => [
|
||
row
|
||
]);
|
||
};
|
||
function getRemaingFieldsLayout({ layout, metadatas, schemaAttributes, fieldSizes }) {
|
||
const fieldsInLayout = layout.flatMap((panel) => panel.flatMap((row) => row.flatMap((field) => field.name)));
|
||
const remainingFields = Object.entries(metadatas).reduce((currentRemainingFields, [name, field]) => {
|
||
if (!fieldsInLayout.includes(name) && field.edit.visible === true) {
|
||
const attribute = schemaAttributes[name];
|
||
currentRemainingFields.push({
|
||
attribute,
|
||
type: attribute.type,
|
||
visible: true,
|
||
disabled: true,
|
||
label: field.edit.label || name,
|
||
name,
|
||
size: fieldSizes[attribute.type].default ?? 12
|
||
});
|
||
}
|
||
return currentRemainingFields;
|
||
}, []);
|
||
return createLayoutFromFields(remainingFields);
|
||
}
|
||
var FormPanel = ({ panel }) => {
|
||
if (panel.some((row) => row.some((field) => field.type === "dynamiczone"))) {
|
||
const [row] = panel;
|
||
const [field] = row;
|
||
return (0, import_jsx_runtime2.jsx)(Grid.Root, {
|
||
gap: 4,
|
||
children: (0, import_jsx_runtime2.jsx)(Grid.Item, {
|
||
col: 12,
|
||
s: 12,
|
||
xs: 12,
|
||
direction: "column",
|
||
alignItems: "stretch",
|
||
children: (0, import_jsx_runtime2.jsx)(VersionInputRenderer, {
|
||
...field
|
||
})
|
||
})
|
||
}, field.name);
|
||
}
|
||
return (0, import_jsx_runtime2.jsx)(Box, {
|
||
hasRadius: true,
|
||
background: "neutral0",
|
||
shadow: "tableShadow",
|
||
paddingLeft: 6,
|
||
paddingRight: 6,
|
||
paddingTop: 6,
|
||
paddingBottom: 6,
|
||
borderColor: "neutral150",
|
||
children: (0, import_jsx_runtime2.jsx)(Flex, {
|
||
direction: "column",
|
||
alignItems: "stretch",
|
||
gap: 6,
|
||
children: panel.map((row, gridRowIndex) => (0, import_jsx_runtime2.jsx)(Grid.Root, {
|
||
gap: 4,
|
||
children: row.map(({ size, ...field }) => {
|
||
return (0, import_jsx_runtime2.jsx)(Grid.Item, {
|
||
col: size,
|
||
s: 12,
|
||
xs: 12,
|
||
direction: "column",
|
||
alignItems: "stretch",
|
||
children: (0, import_jsx_runtime2.jsx)(VersionInputRenderer, {
|
||
...field
|
||
})
|
||
}, field.name);
|
||
})
|
||
}, gridRowIndex))
|
||
})
|
||
});
|
||
};
|
||
var VersionContent = () => {
|
||
const { formatMessage } = useIntl();
|
||
const { fieldSizes } = useTypedSelector((state) => state["content-manager"].app);
|
||
const version = useHistoryContext("VersionContent", (state) => state.selectedVersion);
|
||
const layout = useHistoryContext("VersionContent", (state) => state.layout);
|
||
const configuration = useHistoryContext("VersionContent", (state) => state.configuration);
|
||
const schema = useHistoryContext("VersionContent", (state) => state.schema);
|
||
const removedAttributes = version.meta.unknownAttributes.removed;
|
||
const removedAttributesAsFields = Object.entries(removedAttributes).map(([attributeName, attribute]) => {
|
||
const field = {
|
||
attribute,
|
||
shouldIgnoreRBAC: true,
|
||
type: attribute.type,
|
||
visible: true,
|
||
disabled: true,
|
||
label: attributeName,
|
||
name: attributeName,
|
||
size: fieldSizes[attribute.type].default ?? 12
|
||
};
|
||
return field;
|
||
});
|
||
const unknownFieldsLayout = createLayoutFromFields(removedAttributesAsFields);
|
||
const remainingFieldsLayout = getRemaingFieldsLayout({
|
||
metadatas: configuration.contentType.metadatas,
|
||
layout,
|
||
schemaAttributes: schema.attributes,
|
||
fieldSizes
|
||
});
|
||
const { components } = useDoc();
|
||
const transformedData = React2.useMemo(() => {
|
||
const transform = (schemaAttributes, components2 = {}) => (document) => {
|
||
const schema2 = {
|
||
attributes: schemaAttributes
|
||
};
|
||
const transformations = (0, import_pipe.default)(removeFieldsThatDontExistOnSchema(schema2), prepareTempKeys(schema2, components2));
|
||
return transformations(document);
|
||
};
|
||
return transform(version.schema, components)(version.data);
|
||
}, [
|
||
components,
|
||
version.data,
|
||
version.schema
|
||
]);
|
||
return (0, import_jsx_runtime2.jsxs)(Layouts.Content, {
|
||
children: [
|
||
(0, import_jsx_runtime2.jsx)(Box, {
|
||
paddingBottom: 8,
|
||
children: (0, import_jsx_runtime2.jsx)(Form, {
|
||
disabled: true,
|
||
method: "PUT",
|
||
initialValues: transformedData,
|
||
children: (0, import_jsx_runtime2.jsx)(Flex, {
|
||
direction: "column",
|
||
alignItems: "stretch",
|
||
gap: 6,
|
||
position: "relative",
|
||
children: [
|
||
...layout,
|
||
...remainingFieldsLayout
|
||
].map((panel, index) => {
|
||
return (0, import_jsx_runtime2.jsx)(FormPanel, {
|
||
panel
|
||
}, index);
|
||
})
|
||
})
|
||
})
|
||
}),
|
||
removedAttributesAsFields.length > 0 && (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, {
|
||
children: [
|
||
(0, import_jsx_runtime2.jsx)(Divider, {}),
|
||
(0, import_jsx_runtime2.jsxs)(Box, {
|
||
paddingTop: 8,
|
||
children: [
|
||
(0, import_jsx_runtime2.jsxs)(Flex, {
|
||
direction: "column",
|
||
alignItems: "flex-start",
|
||
paddingBottom: 6,
|
||
gap: 1,
|
||
children: [
|
||
(0, import_jsx_runtime2.jsx)(Typography, {
|
||
variant: "delta",
|
||
children: formatMessage({
|
||
id: "content-manager.history.content.unknown-fields.title",
|
||
defaultMessage: "Unknown fields"
|
||
})
|
||
}),
|
||
(0, import_jsx_runtime2.jsx)(Typography, {
|
||
variant: "pi",
|
||
children: formatMessage({
|
||
id: "content-manager.history.content.unknown-fields.message",
|
||
defaultMessage: "These fields have been deleted or renamed in the Content-Type Builder. <b>These fields will not be restored.</b>"
|
||
}, {
|
||
b: (chunks) => (0, import_jsx_runtime2.jsx)(Typography, {
|
||
variant: "pi",
|
||
fontWeight: "bold",
|
||
children: chunks
|
||
})
|
||
})
|
||
})
|
||
]
|
||
}),
|
||
(0, import_jsx_runtime2.jsx)(Form, {
|
||
disabled: true,
|
||
method: "PUT",
|
||
initialValues: version.data,
|
||
children: (0, import_jsx_runtime2.jsx)(Flex, {
|
||
direction: "column",
|
||
alignItems: "stretch",
|
||
gap: 6,
|
||
position: "relative",
|
||
children: unknownFieldsLayout.map((panel, index) => {
|
||
return (0, import_jsx_runtime2.jsx)(FormPanel, {
|
||
panel
|
||
}, index);
|
||
})
|
||
})
|
||
})
|
||
]
|
||
})
|
||
]
|
||
})
|
||
]
|
||
});
|
||
};
|
||
|
||
// node_modules/@strapi/content-manager/dist/admin/history/components/VersionHeader.mjs
|
||
var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
|
||
var React3 = __toESM(require_react(), 1);
|
||
var import_qs = __toESM(require_lib(), 1);
|
||
|
||
// node_modules/@strapi/content-manager/dist/admin/history/services/historyVersion.mjs
|
||
var historyVersionsApi = contentManagerApi.injectEndpoints({
|
||
endpoints: (builder) => ({
|
||
getHistoryVersions: builder.query({
|
||
query(params) {
|
||
return {
|
||
url: `/content-manager/history-versions`,
|
||
method: "GET",
|
||
config: {
|
||
params
|
||
}
|
||
};
|
||
},
|
||
providesTags: [
|
||
"HistoryVersion"
|
||
]
|
||
}),
|
||
restoreVersion: builder.mutation({
|
||
query({ params, body }) {
|
||
return {
|
||
url: `/content-manager/history-versions/${params.versionId}/restore`,
|
||
method: "PUT",
|
||
data: body
|
||
};
|
||
},
|
||
invalidatesTags: (_res, _error, { documentId, collectionType, params }) => {
|
||
return [
|
||
"HistoryVersion",
|
||
{
|
||
type: "Document",
|
||
id: collectionType === COLLECTION_TYPES ? `${params.contentType}_${documentId}` : params.contentType
|
||
}
|
||
];
|
||
}
|
||
})
|
||
})
|
||
});
|
||
var { useGetHistoryVersionsQuery, useRestoreVersionMutation } = historyVersionsApi;
|
||
|
||
// node_modules/@strapi/content-manager/dist/admin/history/components/VersionHeader.mjs
|
||
var VersionHeader = ({ headerId }) => {
|
||
var _a;
|
||
const [isConfirmDialogOpen, setIsConfirmDialogOpen] = React3.useState(false);
|
||
const navigate = useNavigate();
|
||
const { formatMessage, formatDate } = useIntl();
|
||
const { trackUsage } = useTracking();
|
||
const { toggleNotification } = useNotification();
|
||
const [{ query }] = useQueryParams();
|
||
const { collectionType, slug } = useParams();
|
||
const [restoreVersion, { isLoading }] = useRestoreVersionMutation();
|
||
const { allowedActions } = useRBAC(PERMISSIONS.map((action) => ({
|
||
action,
|
||
subject: slug
|
||
})));
|
||
const version = useHistoryContext("VersionHeader", (state) => state.selectedVersion);
|
||
const mainField = useHistoryContext("VersionHeader", (state) => state.mainField);
|
||
const schema = useHistoryContext("VersionHeader", (state) => state.schema);
|
||
const isCurrentVersion = useHistoryContext("VersionHeader", (state) => state.page === 1 && state.versions.data[0].id === state.selectedVersion.id);
|
||
const mainFieldValue = version.data[mainField];
|
||
const getNextNavigation = () => {
|
||
const pluginsQueryParams = (0, import_qs.stringify)({
|
||
plugins: query.plugins
|
||
}, {
|
||
encode: false
|
||
});
|
||
return {
|
||
pathname: "..",
|
||
search: pluginsQueryParams
|
||
};
|
||
};
|
||
const handleRestore = async () => {
|
||
try {
|
||
const response = await restoreVersion({
|
||
documentId: version.relatedDocumentId,
|
||
collectionType,
|
||
params: {
|
||
versionId: version.id,
|
||
contentType: version.contentType
|
||
},
|
||
body: {
|
||
contentType: version.contentType
|
||
}
|
||
});
|
||
if ("data" in response) {
|
||
navigate(getNextNavigation(), {
|
||
relative: "path"
|
||
});
|
||
toggleNotification({
|
||
type: "success",
|
||
title: formatMessage({
|
||
id: "content-manager.restore.success.title",
|
||
defaultMessage: "Version restored."
|
||
}),
|
||
message: formatMessage({
|
||
id: "content-manager.restore.success.message",
|
||
defaultMessage: "A past version of the content was restored."
|
||
})
|
||
});
|
||
trackUsage("didRestoreHistoryVersion");
|
||
}
|
||
if ("error" in response) {
|
||
toggleNotification({
|
||
type: "danger",
|
||
message: formatMessage({
|
||
id: "content-manager.history.restore.error.message",
|
||
defaultMessage: "Could not restore version."
|
||
})
|
||
});
|
||
}
|
||
} catch (error) {
|
||
toggleNotification({
|
||
type: "danger",
|
||
message: formatMessage({
|
||
id: "notification.error",
|
||
defaultMessage: "An error occurred"
|
||
})
|
||
});
|
||
}
|
||
};
|
||
return (0, import_jsx_runtime3.jsxs)(Dialog.Root, {
|
||
open: isConfirmDialogOpen,
|
||
onOpenChange: setIsConfirmDialogOpen,
|
||
children: [
|
||
(0, import_jsx_runtime3.jsx)(Layouts.BaseHeader, {
|
||
id: headerId,
|
||
title: formatDate(new Date(version.createdAt), {
|
||
year: "numeric",
|
||
month: "numeric",
|
||
day: "numeric",
|
||
hour: "numeric",
|
||
minute: "numeric"
|
||
}),
|
||
subtitle: (0, import_jsx_runtime3.jsx)(Typography, {
|
||
variant: "epsilon",
|
||
textColor: "neutral600",
|
||
children: formatMessage({
|
||
id: "content-manager.history.version.subtitle",
|
||
defaultMessage: "{hasLocale, select, true {{subtitle}, in {locale}} other {{subtitle}}}"
|
||
}, {
|
||
hasLocale: Boolean(version.locale),
|
||
subtitle: `${mainFieldValue || ""} (${schema.info.singularName})`.trim(),
|
||
locale: (_a = version.locale) == null ? void 0 : _a.name
|
||
})
|
||
}),
|
||
navigationAction: (0, import_jsx_runtime3.jsx)(Link2, {
|
||
startIcon: (0, import_jsx_runtime3.jsx)(ForwardRef$5j, {}),
|
||
tag: NavLink,
|
||
to: getNextNavigation(),
|
||
relative: "path",
|
||
isExternal: false,
|
||
children: formatMessage({
|
||
id: "global.back",
|
||
defaultMessage: "Back"
|
||
})
|
||
}),
|
||
sticky: false,
|
||
primaryAction: (0, import_jsx_runtime3.jsx)(Dialog.Trigger, {
|
||
children: (0, import_jsx_runtime3.jsx)(Button, {
|
||
disabled: !allowedActions.canUpdate || isCurrentVersion,
|
||
onClick: () => {
|
||
setIsConfirmDialogOpen(true);
|
||
},
|
||
children: formatMessage({
|
||
id: "content-manager.history.restore.confirm.button",
|
||
defaultMessage: "Restore"
|
||
})
|
||
})
|
||
})
|
||
}),
|
||
(0, import_jsx_runtime3.jsx)(ConfirmDialog, {
|
||
onConfirm: handleRestore,
|
||
endAction: (0, import_jsx_runtime3.jsx)(Button, {
|
||
variant: "secondary",
|
||
onClick: handleRestore,
|
||
loading: isLoading,
|
||
children: formatMessage({
|
||
id: "content-manager.history.restore.confirm.button",
|
||
defaultMessage: "Restore"
|
||
})
|
||
}),
|
||
children: (0, import_jsx_runtime3.jsxs)(Flex, {
|
||
direction: "column",
|
||
alignItems: "center",
|
||
justifyContent: "center",
|
||
gap: 2,
|
||
textAlign: "center",
|
||
children: [
|
||
(0, import_jsx_runtime3.jsx)(Flex, {
|
||
justifyContent: "center",
|
||
children: (0, import_jsx_runtime3.jsx)(ForwardRef$3, {
|
||
width: "24px",
|
||
height: "24px",
|
||
fill: "danger600"
|
||
})
|
||
}),
|
||
(0, import_jsx_runtime3.jsx)(Typography, {
|
||
children: formatMessage({
|
||
id: "content-manager.history.restore.confirm.title",
|
||
defaultMessage: "Are you sure you want to restore this version?"
|
||
})
|
||
}),
|
||
(0, import_jsx_runtime3.jsx)(Typography, {
|
||
children: formatMessage({
|
||
id: "content-manager.history.restore.confirm.message",
|
||
defaultMessage: "{isDraft, select, true {The restored content will override your draft.} other {The restored content won't be published, it will override the draft and be saved as pending changes. You'll be able to publish the changes at anytime.}}"
|
||
}, {
|
||
isDraft: version.status === "draft"
|
||
})
|
||
})
|
||
]
|
||
})
|
||
})
|
||
]
|
||
});
|
||
};
|
||
|
||
// node_modules/@strapi/content-manager/dist/admin/history/components/VersionsList.mjs
|
||
var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
|
||
var import_react = __toESM(require_react(), 1);
|
||
var import_qs2 = __toESM(require_lib(), 1);
|
||
var BlueText = (children) => (0, import_jsx_runtime4.jsx)(Typography, {
|
||
textColor: "primary600",
|
||
variant: "pi",
|
||
children
|
||
});
|
||
var VersionCard = ({ version, isCurrent }) => {
|
||
const { formatDate, formatMessage } = useIntl();
|
||
const [{ query }] = useQueryParams();
|
||
const isActive = query.id === version.id.toString();
|
||
const author = version.createdBy && getDisplayName(version.createdBy);
|
||
return (0, import_jsx_runtime4.jsxs)(Flex, {
|
||
direction: "column",
|
||
alignItems: "flex-start",
|
||
gap: 3,
|
||
hasRadius: true,
|
||
borderWidth: "1px",
|
||
borderStyle: "solid",
|
||
borderColor: isActive ? "primary600" : "neutral200",
|
||
color: "neutral800",
|
||
padding: 5,
|
||
tag: Link,
|
||
to: `?${(0, import_qs2.stringify)({
|
||
...query,
|
||
id: version.id
|
||
})}`,
|
||
style: {
|
||
textDecoration: "none"
|
||
},
|
||
children: [
|
||
(0, import_jsx_runtime4.jsxs)(Flex, {
|
||
direction: "column",
|
||
gap: 1,
|
||
alignItems: "flex-start",
|
||
children: [
|
||
(0, import_jsx_runtime4.jsx)(Typography, {
|
||
tag: "h3",
|
||
fontWeight: "semiBold",
|
||
children: formatDate(version.createdAt, {
|
||
day: "numeric",
|
||
month: "numeric",
|
||
year: "numeric",
|
||
hour: "2-digit",
|
||
minute: "2-digit"
|
||
})
|
||
}),
|
||
(0, import_jsx_runtime4.jsx)(Typography, {
|
||
tag: "p",
|
||
variant: "pi",
|
||
textColor: "neutral600",
|
||
children: formatMessage({
|
||
id: "content-manager.history.sidebar.versionDescription",
|
||
defaultMessage: "{distanceToNow}{isAnonymous, select, true {} other { by {author}}}{isCurrent, select, true { <b>(current)</b>} other {}}"
|
||
}, {
|
||
distanceToNow: (0, import_jsx_runtime4.jsx)(RelativeTime, {
|
||
timestamp: new Date(version.createdAt)
|
||
}),
|
||
author,
|
||
isAnonymous: !Boolean(version.createdBy),
|
||
isCurrent,
|
||
b: BlueText
|
||
})
|
||
})
|
||
]
|
||
}),
|
||
version.status && (0, import_jsx_runtime4.jsx)(DocumentStatus, {
|
||
status: version.status,
|
||
size: "XS"
|
||
})
|
||
]
|
||
});
|
||
};
|
||
var PaginationButton = ({ page, children }) => {
|
||
const [{ query }] = useQueryParams();
|
||
const { id: _id, ...queryRest } = query;
|
||
return (0, import_jsx_runtime4.jsx)(Link, {
|
||
to: {
|
||
search: (0, import_qs2.stringify)({
|
||
...queryRest,
|
||
page
|
||
})
|
||
},
|
||
style: {
|
||
textDecoration: "none"
|
||
},
|
||
children: (0, import_jsx_runtime4.jsx)(Typography, {
|
||
variant: "omega",
|
||
textColor: "primary600",
|
||
children
|
||
})
|
||
});
|
||
};
|
||
var VersionsList = () => {
|
||
const { formatMessage } = useIntl();
|
||
const { versions, page } = useHistoryContext("VersionsList", (state) => ({
|
||
versions: state.versions,
|
||
page: state.page
|
||
}));
|
||
return (0, import_jsx_runtime4.jsxs)(Flex, {
|
||
shrink: 0,
|
||
direction: "column",
|
||
alignItems: "stretch",
|
||
width: "320px",
|
||
height: "100vh",
|
||
background: "neutral0",
|
||
borderColor: "neutral200",
|
||
borderWidth: "0 0 0 1px",
|
||
borderStyle: "solid",
|
||
tag: "aside",
|
||
children: [
|
||
(0, import_jsx_runtime4.jsxs)(Flex, {
|
||
direction: "row",
|
||
justifyContent: "space-between",
|
||
padding: 4,
|
||
borderColor: "neutral200",
|
||
borderWidth: "0 0 1px",
|
||
borderStyle: "solid",
|
||
tag: "header",
|
||
children: [
|
||
(0, import_jsx_runtime4.jsx)(Typography, {
|
||
tag: "h2",
|
||
variant: "omega",
|
||
fontWeight: "semiBold",
|
||
children: formatMessage({
|
||
id: "content-manager.history.sidebar.title",
|
||
defaultMessage: "Versions"
|
||
})
|
||
}),
|
||
(0, import_jsx_runtime4.jsx)(Box, {
|
||
background: "neutral150",
|
||
hasRadius: true,
|
||
padding: 1,
|
||
children: (0, import_jsx_runtime4.jsx)(Typography, {
|
||
variant: "sigma",
|
||
textColor: "neutral600",
|
||
children: versions.meta.pagination.total
|
||
})
|
||
})
|
||
]
|
||
}),
|
||
(0, import_jsx_runtime4.jsxs)(Box, {
|
||
flex: 1,
|
||
overflow: "auto",
|
||
children: [
|
||
versions.meta.pagination.page > 1 && (0, import_jsx_runtime4.jsx)(Box, {
|
||
paddingTop: 4,
|
||
textAlign: "center",
|
||
children: (0, import_jsx_runtime4.jsx)(PaginationButton, {
|
||
page: page - 1,
|
||
children: formatMessage({
|
||
id: "content-manager.history.sidebar.show-newer",
|
||
defaultMessage: "Show newer versions"
|
||
})
|
||
})
|
||
}),
|
||
(0, import_jsx_runtime4.jsx)(Flex, {
|
||
direction: "column",
|
||
gap: 3,
|
||
padding: 4,
|
||
tag: "ul",
|
||
alignItems: "stretch",
|
||
children: versions.data.map((version, index) => (0, import_jsx_runtime4.jsx)("li", {
|
||
"aria-label": formatMessage({
|
||
id: "content-manager.history.sidebar.title.version-card.aria-label",
|
||
defaultMessage: "Version card"
|
||
}),
|
||
children: (0, import_jsx_runtime4.jsx)(VersionCard, {
|
||
version,
|
||
isCurrent: page === 1 && index === 0
|
||
})
|
||
}, version.id))
|
||
}),
|
||
versions.meta.pagination.page < versions.meta.pagination.pageCount && (0, import_jsx_runtime4.jsx)(Box, {
|
||
paddingBottom: 4,
|
||
textAlign: "center",
|
||
children: (0, import_jsx_runtime4.jsx)(PaginationButton, {
|
||
page: page + 1,
|
||
children: formatMessage({
|
||
id: "content-manager.history.sidebar.show-older",
|
||
defaultMessage: "Show older versions"
|
||
})
|
||
})
|
||
})
|
||
]
|
||
})
|
||
]
|
||
});
|
||
};
|
||
|
||
// node_modules/@strapi/content-manager/dist/admin/history/pages/History.mjs
|
||
var [HistoryProvider, useHistoryContext] = createContext("HistoryPage");
|
||
var HistoryPage = () => {
|
||
var _a, _b, _c, _d, _e, _f;
|
||
const headerId = React4.useId();
|
||
const { formatMessage } = useIntl();
|
||
const { slug, id: documentId, collectionType } = useParams();
|
||
const { isLoading: isLoadingDocument, schema } = useDocument({
|
||
collectionType,
|
||
model: slug
|
||
});
|
||
const { isLoading: isLoadingLayout, edit: { layout, settings: { displayName, mainField } } } = useDocumentLayout(slug);
|
||
const { data: configuration, isLoading: isLoadingConfiguration } = useGetContentTypeConfigurationQuery(slug);
|
||
const [{ query }] = useQueryParams();
|
||
const { id: selectedVersionId, ...queryWithoutId } = query;
|
||
const validQueryParamsWithoutId = buildValidParams(queryWithoutId);
|
||
const page = validQueryParamsWithoutId.page ? Number(validQueryParamsWithoutId.page) : 1;
|
||
const versionsResponse = useGetHistoryVersionsQuery({
|
||
contentType: slug,
|
||
...documentId ? {
|
||
documentId
|
||
} : {},
|
||
// Omit id since it's not needed by the endpoint and caused extra refetches
|
||
...validQueryParamsWithoutId
|
||
}, {
|
||
refetchOnMountOrArgChange: true
|
||
});
|
||
const initialRequestId = React4.useRef(versionsResponse.requestId);
|
||
const isStaleRequest = versionsResponse.requestId === initialRequestId.current;
|
||
if (!slug || collectionType === COLLECTION_TYPES && !documentId) {
|
||
return (0, import_jsx_runtime5.jsx)(Navigate, {
|
||
to: "/content-manager"
|
||
});
|
||
}
|
||
if (isLoadingDocument || isLoadingLayout || versionsResponse.isFetching || isStaleRequest || isLoadingConfiguration) {
|
||
return (0, import_jsx_runtime5.jsx)(Page.Loading, {});
|
||
}
|
||
if (!versionsResponse.isError && !((_b = (_a = versionsResponse.data) == null ? void 0 : _a.data) == null ? void 0 : _b.length)) {
|
||
return (0, import_jsx_runtime5.jsx)(import_jsx_runtime5.Fragment, {
|
||
children: (0, import_jsx_runtime5.jsx)(Page.NoData, {
|
||
action: (0, import_jsx_runtime5.jsx)(Link2, {
|
||
tag: NavLink,
|
||
to: `/content-manager/${collectionType}/${slug}${documentId ? `/${documentId}` : ""}`,
|
||
children: formatMessage({
|
||
id: "global.back",
|
||
defaultMessage: "Back"
|
||
})
|
||
})
|
||
})
|
||
});
|
||
}
|
||
if (((_d = (_c = versionsResponse.data) == null ? void 0 : _c.data) == null ? void 0 : _d.length) && !selectedVersionId) {
|
||
return (0, import_jsx_runtime5.jsx)(Navigate, {
|
||
to: {
|
||
search: (0, import_qs3.stringify)({
|
||
...query,
|
||
id: versionsResponse.data.data[0].id
|
||
})
|
||
},
|
||
replace: true
|
||
});
|
||
}
|
||
const selectedVersion = (_f = (_e = versionsResponse.data) == null ? void 0 : _e.data) == null ? void 0 : _f.find((version) => version.id.toString() === selectedVersionId);
|
||
if (versionsResponse.isError || !layout || !schema || !selectedVersion || !configuration || // This should not happen as it's covered by versionsResponse.isError, but we need it for TS
|
||
versionsResponse.data.error) {
|
||
return (0, import_jsx_runtime5.jsx)(Page.Error, {});
|
||
}
|
||
return (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, {
|
||
children: [
|
||
(0, import_jsx_runtime5.jsx)(Page.Title, {
|
||
children: formatMessage({
|
||
id: "content-manager.history.page-title",
|
||
defaultMessage: "{contentType} history"
|
||
}, {
|
||
contentType: displayName
|
||
})
|
||
}),
|
||
(0, import_jsx_runtime5.jsx)(HistoryProvider, {
|
||
contentType: slug,
|
||
id: documentId,
|
||
schema,
|
||
layout,
|
||
configuration,
|
||
selectedVersion,
|
||
versions: versionsResponse.data,
|
||
page,
|
||
mainField,
|
||
children: (0, import_jsx_runtime5.jsxs)(Flex, {
|
||
direction: "row",
|
||
alignItems: "flex-start",
|
||
children: [
|
||
(0, import_jsx_runtime5.jsxs)(Main, {
|
||
grow: 1,
|
||
height: "100vh",
|
||
background: "neutral100",
|
||
paddingBottom: 6,
|
||
overflow: "auto",
|
||
labelledBy: headerId,
|
||
children: [
|
||
(0, import_jsx_runtime5.jsx)(VersionHeader, {
|
||
headerId
|
||
}),
|
||
(0, import_jsx_runtime5.jsx)(VersionContent, {})
|
||
]
|
||
}),
|
||
(0, import_jsx_runtime5.jsx)(VersionsList, {})
|
||
]
|
||
})
|
||
})
|
||
]
|
||
});
|
||
};
|
||
var ProtectedHistoryPageImpl = () => {
|
||
const { slug } = useParams();
|
||
const { permissions = [], isLoading, error } = useRBAC(PERMISSIONS.map((action) => ({
|
||
action,
|
||
subject: slug
|
||
})));
|
||
if (isLoading) {
|
||
return (0, import_jsx_runtime5.jsx)(Page.Loading, {});
|
||
}
|
||
if (error || !slug) {
|
||
return (0, import_jsx_runtime5.jsx)(Box, {
|
||
height: "100vh",
|
||
width: "100vw",
|
||
position: "fixed",
|
||
top: 0,
|
||
left: 0,
|
||
zIndex: 2,
|
||
background: "neutral0",
|
||
children: (0, import_jsx_runtime5.jsx)(Page.Error, {})
|
||
});
|
||
}
|
||
return (0, import_jsx_runtime5.jsx)(Box, {
|
||
height: "100vh",
|
||
width: "100vw",
|
||
position: "fixed",
|
||
top: 0,
|
||
left: 0,
|
||
zIndex: 2,
|
||
background: "neutral0",
|
||
children: (0, import_jsx_runtime5.jsx)(Page.Protect, {
|
||
permissions,
|
||
children: ({ permissions: permissions2 }) => (0, import_jsx_runtime5.jsx)(DocumentRBAC, {
|
||
permissions: permissions2,
|
||
children: (0, import_jsx_runtime5.jsx)(HistoryPage, {})
|
||
})
|
||
})
|
||
});
|
||
};
|
||
var ProtectedHistoryPage = () => {
|
||
return (0, import_jsx_runtime5.jsx)(Portal$1, {
|
||
children: (0, import_jsx_runtime5.jsx)(FocusTrap, {
|
||
children: (0, import_jsx_runtime5.jsx)(ProtectedHistoryPageImpl, {})
|
||
})
|
||
});
|
||
};
|
||
export {
|
||
HistoryProvider,
|
||
ProtectedHistoryPage,
|
||
useHistoryContext
|
||
};
|
||
//# sourceMappingURL=History-UKPXPR4M.js.map
|