738 lines
20 KiB
JavaScript
738 lines
20 KiB
JavaScript
import {
|
|
require_isEqual
|
|
} from "./chunk-VYSYYPOB.js";
|
|
import {
|
|
getIn,
|
|
setIn
|
|
} from "./chunk-BHLYCXQ7.js";
|
|
import {
|
|
createContext
|
|
} from "./chunk-76QM3EFM.js";
|
|
import {
|
|
fn
|
|
} from "./chunk-5VODLFKF.js";
|
|
import {
|
|
Box,
|
|
Button,
|
|
Dialog,
|
|
useCallbackRef,
|
|
useComposedRefs,
|
|
useIntl
|
|
} from "./chunk-7XB6XSWQ.js";
|
|
import {
|
|
useBlocker
|
|
} from "./chunk-TUXTO2Z5.js";
|
|
import {
|
|
ForwardRef$3
|
|
} from "./chunk-WRD5KPDH.js";
|
|
import {
|
|
require_jsx_runtime
|
|
} from "./chunk-NIAJZ5MX.js";
|
|
import {
|
|
require_react
|
|
} from "./chunk-MADUDGYZ.js";
|
|
import {
|
|
__toESM
|
|
} from "./chunk-PLDDJCW6.js";
|
|
|
|
// node_modules/fractional-indexing/src/index.js
|
|
var BASE_62_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
|
|
function midpoint(a, b, digits) {
|
|
const zero = digits[0];
|
|
if (b != null && a >= b) {
|
|
throw new Error(a + " >= " + b);
|
|
}
|
|
if (a.slice(-1) === zero || b && b.slice(-1) === zero) {
|
|
throw new Error("trailing zero");
|
|
}
|
|
if (b) {
|
|
let n = 0;
|
|
while ((a[n] || zero) === b[n]) {
|
|
n++;
|
|
}
|
|
if (n > 0) {
|
|
return b.slice(0, n) + midpoint(a.slice(n), b.slice(n), digits);
|
|
}
|
|
}
|
|
const digitA = a ? digits.indexOf(a[0]) : 0;
|
|
const digitB = b != null ? digits.indexOf(b[0]) : digits.length;
|
|
if (digitB - digitA > 1) {
|
|
const midDigit = Math.round(0.5 * (digitA + digitB));
|
|
return digits[midDigit];
|
|
} else {
|
|
if (b && b.length > 1) {
|
|
return b.slice(0, 1);
|
|
} else {
|
|
return digits[digitA] + midpoint(a.slice(1), null, digits);
|
|
}
|
|
}
|
|
}
|
|
function validateInteger(int) {
|
|
if (int.length !== getIntegerLength(int[0])) {
|
|
throw new Error("invalid integer part of order key: " + int);
|
|
}
|
|
}
|
|
function getIntegerLength(head) {
|
|
if (head >= "a" && head <= "z") {
|
|
return head.charCodeAt(0) - "a".charCodeAt(0) + 2;
|
|
} else if (head >= "A" && head <= "Z") {
|
|
return "Z".charCodeAt(0) - head.charCodeAt(0) + 2;
|
|
} else {
|
|
throw new Error("invalid order key head: " + head);
|
|
}
|
|
}
|
|
function getIntegerPart(key) {
|
|
const integerPartLength = getIntegerLength(key[0]);
|
|
if (integerPartLength > key.length) {
|
|
throw new Error("invalid order key: " + key);
|
|
}
|
|
return key.slice(0, integerPartLength);
|
|
}
|
|
function validateOrderKey(key, digits) {
|
|
if (key === "A" + digits[0].repeat(26)) {
|
|
throw new Error("invalid order key: " + key);
|
|
}
|
|
const i = getIntegerPart(key);
|
|
const f = key.slice(i.length);
|
|
if (f.slice(-1) === digits[0]) {
|
|
throw new Error("invalid order key: " + key);
|
|
}
|
|
}
|
|
function incrementInteger(x, digits) {
|
|
validateInteger(x);
|
|
const [head, ...digs] = x.split("");
|
|
let carry = true;
|
|
for (let i = digs.length - 1; carry && i >= 0; i--) {
|
|
const d = digits.indexOf(digs[i]) + 1;
|
|
if (d === digits.length) {
|
|
digs[i] = digits[0];
|
|
} else {
|
|
digs[i] = digits[d];
|
|
carry = false;
|
|
}
|
|
}
|
|
if (carry) {
|
|
if (head === "Z") {
|
|
return "a" + digits[0];
|
|
}
|
|
if (head === "z") {
|
|
return null;
|
|
}
|
|
const h = String.fromCharCode(head.charCodeAt(0) + 1);
|
|
if (h > "a") {
|
|
digs.push(digits[0]);
|
|
} else {
|
|
digs.pop();
|
|
}
|
|
return h + digs.join("");
|
|
} else {
|
|
return head + digs.join("");
|
|
}
|
|
}
|
|
function decrementInteger(x, digits) {
|
|
validateInteger(x);
|
|
const [head, ...digs] = x.split("");
|
|
let borrow = true;
|
|
for (let i = digs.length - 1; borrow && i >= 0; i--) {
|
|
const d = digits.indexOf(digs[i]) - 1;
|
|
if (d === -1) {
|
|
digs[i] = digits.slice(-1);
|
|
} else {
|
|
digs[i] = digits[d];
|
|
borrow = false;
|
|
}
|
|
}
|
|
if (borrow) {
|
|
if (head === "a") {
|
|
return "Z" + digits.slice(-1);
|
|
}
|
|
if (head === "A") {
|
|
return null;
|
|
}
|
|
const h = String.fromCharCode(head.charCodeAt(0) - 1);
|
|
if (h < "Z") {
|
|
digs.push(digits.slice(-1));
|
|
} else {
|
|
digs.pop();
|
|
}
|
|
return h + digs.join("");
|
|
} else {
|
|
return head + digs.join("");
|
|
}
|
|
}
|
|
function generateKeyBetween(a, b, digits = BASE_62_DIGITS) {
|
|
if (a != null) {
|
|
validateOrderKey(a, digits);
|
|
}
|
|
if (b != null) {
|
|
validateOrderKey(b, digits);
|
|
}
|
|
if (a != null && b != null && a >= b) {
|
|
throw new Error(a + " >= " + b);
|
|
}
|
|
if (a == null) {
|
|
if (b == null) {
|
|
return "a" + digits[0];
|
|
}
|
|
const ib2 = getIntegerPart(b);
|
|
const fb2 = b.slice(ib2.length);
|
|
if (ib2 === "A" + digits[0].repeat(26)) {
|
|
return ib2 + midpoint("", fb2, digits);
|
|
}
|
|
if (ib2 < b) {
|
|
return ib2;
|
|
}
|
|
const res = decrementInteger(ib2, digits);
|
|
if (res == null) {
|
|
throw new Error("cannot decrement any more");
|
|
}
|
|
return res;
|
|
}
|
|
if (b == null) {
|
|
const ia2 = getIntegerPart(a);
|
|
const fa2 = a.slice(ia2.length);
|
|
const i2 = incrementInteger(ia2, digits);
|
|
return i2 == null ? ia2 + midpoint(fa2, null, digits) : i2;
|
|
}
|
|
const ia = getIntegerPart(a);
|
|
const fa = a.slice(ia.length);
|
|
const ib = getIntegerPart(b);
|
|
const fb = b.slice(ib.length);
|
|
if (ia === ib) {
|
|
return ia + midpoint(fa, fb, digits);
|
|
}
|
|
const i = incrementInteger(ia, digits);
|
|
if (i == null) {
|
|
throw new Error("cannot increment any more");
|
|
}
|
|
if (i < b) {
|
|
return i;
|
|
}
|
|
return ia + midpoint(fa, null, digits);
|
|
}
|
|
function generateNKeysBetween(a, b, n, digits = BASE_62_DIGITS) {
|
|
if (n === 0) {
|
|
return [];
|
|
}
|
|
if (n === 1) {
|
|
return [generateKeyBetween(a, b, digits)];
|
|
}
|
|
if (b == null) {
|
|
let c2 = generateKeyBetween(a, b, digits);
|
|
const result = [c2];
|
|
for (let i = 0; i < n - 1; i++) {
|
|
c2 = generateKeyBetween(c2, b, digits);
|
|
result.push(c2);
|
|
}
|
|
return result;
|
|
}
|
|
if (a == null) {
|
|
let c2 = generateKeyBetween(a, b, digits);
|
|
const result = [c2];
|
|
for (let i = 0; i < n - 1; i++) {
|
|
c2 = generateKeyBetween(a, c2, digits);
|
|
result.push(c2);
|
|
}
|
|
result.reverse();
|
|
return result;
|
|
}
|
|
const mid = Math.floor(n / 2);
|
|
const c = generateKeyBetween(a, b, digits);
|
|
return [
|
|
...generateNKeysBetween(a, c, mid, digits),
|
|
c,
|
|
...generateNKeysBetween(c, b, n - mid - 1, digits)
|
|
];
|
|
}
|
|
|
|
// node_modules/@strapi/admin/dist/admin/admin/src/components/Form.mjs
|
|
var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
|
|
var React = __toESM(require_react(), 1);
|
|
var import_isEqual = __toESM(require_isEqual(), 1);
|
|
var ERR_MSG = "The Form Component has not been initialised, ensure you are using this hook within a Form component";
|
|
var [FormProvider, useForm] = createContext("Form", {
|
|
disabled: false,
|
|
errors: {},
|
|
initialValues: {},
|
|
isSubmitting: false,
|
|
modified: false,
|
|
addFieldRow: () => {
|
|
throw new Error(ERR_MSG);
|
|
},
|
|
moveFieldRow: () => {
|
|
throw new Error(ERR_MSG);
|
|
},
|
|
onChange: () => {
|
|
throw new Error(ERR_MSG);
|
|
},
|
|
removeFieldRow: () => {
|
|
throw new Error(ERR_MSG);
|
|
},
|
|
resetForm: () => {
|
|
throw new Error(ERR_MSG);
|
|
},
|
|
setErrors: () => {
|
|
throw new Error(ERR_MSG);
|
|
},
|
|
setValues: () => {
|
|
throw new Error(ERR_MSG);
|
|
},
|
|
setSubmitting: () => {
|
|
throw new Error(ERR_MSG);
|
|
},
|
|
validate: async () => {
|
|
throw new Error(ERR_MSG);
|
|
},
|
|
values: {}
|
|
});
|
|
var Form = React.forwardRef(({ disabled = false, method, onSubmit, initialErrors, ...props }, ref) => {
|
|
const formRef = React.useRef(null);
|
|
const initialValues = React.useRef(props.initialValues ?? {});
|
|
const [state, dispatch] = React.useReducer(reducer, {
|
|
errors: initialErrors ?? {},
|
|
isSubmitting: false,
|
|
values: props.initialValues ?? {}
|
|
});
|
|
React.useEffect(() => {
|
|
if (!(0, import_isEqual.default)(initialValues.current, props.initialValues)) {
|
|
initialValues.current = props.initialValues ?? {};
|
|
dispatch({
|
|
type: "SET_INITIAL_VALUES",
|
|
payload: props.initialValues ?? {}
|
|
});
|
|
}
|
|
}, [
|
|
props.initialValues
|
|
]);
|
|
const setErrors = React.useCallback((errors) => {
|
|
dispatch({
|
|
type: "SET_ERRORS",
|
|
payload: errors
|
|
});
|
|
}, []);
|
|
const setValues = React.useCallback((values) => {
|
|
dispatch({
|
|
type: "SET_VALUES",
|
|
payload: values
|
|
});
|
|
}, []);
|
|
React.useEffect(() => {
|
|
if (Object.keys(state.errors).length === 0) return;
|
|
const ref2 = setTimeout(() => {
|
|
const [firstError] = formRef.current.querySelectorAll("[data-strapi-field-error]");
|
|
if (firstError) {
|
|
const errorId = firstError.getAttribute("id");
|
|
const formElementInError = formRef.current.querySelector(`[aria-describedby="${errorId}"]`);
|
|
if (formElementInError && formElementInError instanceof HTMLElement) {
|
|
formElementInError.focus();
|
|
}
|
|
}
|
|
});
|
|
return () => clearTimeout(ref2);
|
|
}, [
|
|
state.errors
|
|
]);
|
|
const validate = React.useCallback(async (shouldSetErrors = true, options = {}) => {
|
|
setErrors({});
|
|
if (!props.validationSchema && !props.validate) {
|
|
return {
|
|
data: state.values
|
|
};
|
|
}
|
|
try {
|
|
let data;
|
|
if (props.validationSchema) {
|
|
data = await props.validationSchema.validate(state.values, {
|
|
abortEarly: false
|
|
});
|
|
} else if (props.validate) {
|
|
data = await props.validate(state.values, options);
|
|
} else {
|
|
throw new Error("No validation schema or validate function provided");
|
|
}
|
|
return {
|
|
data
|
|
};
|
|
} catch (err) {
|
|
if (isErrorYupValidationError(err)) {
|
|
const errors = getYupValidationErrors(err);
|
|
if (shouldSetErrors) {
|
|
setErrors(errors);
|
|
}
|
|
return {
|
|
errors
|
|
};
|
|
} else {
|
|
if (true) {
|
|
console.warn(`Warning: An unhandled error was caught during validation in <Form validationSchema />`, err);
|
|
}
|
|
throw err;
|
|
}
|
|
}
|
|
}, [
|
|
props,
|
|
setErrors,
|
|
state.values
|
|
]);
|
|
const handleSubmit = async (e) => {
|
|
e.stopPropagation();
|
|
e.preventDefault();
|
|
if (!onSubmit) {
|
|
return;
|
|
}
|
|
dispatch({
|
|
type: "SUBMIT_ATTEMPT"
|
|
});
|
|
try {
|
|
const { data, errors } = await validate();
|
|
if (errors) {
|
|
setErrors(errors);
|
|
throw new Error("Submission failed");
|
|
}
|
|
await onSubmit(data, {
|
|
setErrors,
|
|
setValues,
|
|
resetForm
|
|
});
|
|
dispatch({
|
|
type: "SUBMIT_SUCCESS"
|
|
});
|
|
} catch (err) {
|
|
dispatch({
|
|
type: "SUBMIT_FAILURE"
|
|
});
|
|
if (err instanceof Error && err.message === "Submission failed") {
|
|
return;
|
|
}
|
|
}
|
|
};
|
|
const modified = React.useMemo(() => !(0, import_isEqual.default)(initialValues.current, state.values), [
|
|
state.values
|
|
]);
|
|
const handleChange = useCallbackRef((eventOrPath, v) => {
|
|
if (typeof eventOrPath === "string") {
|
|
dispatch({
|
|
type: "SET_FIELD_VALUE",
|
|
payload: {
|
|
field: eventOrPath,
|
|
value: v
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
const target = eventOrPath.target || eventOrPath.currentTarget;
|
|
const { type, name, id, value, options, multiple } = target;
|
|
const field = name || id;
|
|
if (!field && true) {
|
|
console.warn(`\`onChange\` was called with an event, but you forgot to pass a \`name\` or \`id'\` attribute to your input. The field to update cannot be determined`);
|
|
}
|
|
let val;
|
|
if (/number|range/.test(type)) {
|
|
const parsed = parseFloat(value);
|
|
val = isNaN(parsed) ? "" : parsed;
|
|
} else if (/checkbox/.test(type)) {
|
|
val = !getIn(state.values, field);
|
|
} else if (options && multiple) {
|
|
val = Array.from(options).filter((el) => el.selected).map((el) => el.value);
|
|
} else {
|
|
if (value === "") {
|
|
val = null;
|
|
} else {
|
|
val = value;
|
|
}
|
|
}
|
|
if (field) {
|
|
dispatch({
|
|
type: "SET_FIELD_VALUE",
|
|
payload: {
|
|
field,
|
|
value: val
|
|
}
|
|
});
|
|
}
|
|
});
|
|
const addFieldRow = React.useCallback((field, value, addAtIndex) => {
|
|
dispatch({
|
|
type: "ADD_FIELD_ROW",
|
|
payload: {
|
|
field,
|
|
value,
|
|
addAtIndex
|
|
}
|
|
});
|
|
}, []);
|
|
const removeFieldRow = React.useCallback((field, removeAtIndex) => {
|
|
dispatch({
|
|
type: "REMOVE_FIELD_ROW",
|
|
payload: {
|
|
field,
|
|
removeAtIndex
|
|
}
|
|
});
|
|
}, []);
|
|
const moveFieldRow = React.useCallback((field, fromIndex, toIndex) => {
|
|
dispatch({
|
|
type: "MOVE_FIELD_ROW",
|
|
payload: {
|
|
field,
|
|
fromIndex,
|
|
toIndex
|
|
}
|
|
});
|
|
}, []);
|
|
const resetForm = React.useCallback(() => {
|
|
dispatch({
|
|
type: "RESET_FORM",
|
|
payload: {
|
|
errors: {},
|
|
isSubmitting: false,
|
|
values: initialValues.current
|
|
}
|
|
});
|
|
}, []);
|
|
const setSubmitting = React.useCallback((isSubmitting) => {
|
|
dispatch({
|
|
type: "SET_ISSUBMITTING",
|
|
payload: isSubmitting
|
|
});
|
|
}, []);
|
|
const composedRefs = useComposedRefs(formRef, ref);
|
|
return (0, import_jsx_runtime.jsx)(Box, {
|
|
tag: "form",
|
|
ref: composedRefs,
|
|
method,
|
|
noValidate: true,
|
|
onSubmit: handleSubmit,
|
|
width: props.width,
|
|
height: props.height,
|
|
children: (0, import_jsx_runtime.jsx)(FormProvider, {
|
|
disabled,
|
|
onChange: handleChange,
|
|
initialValues: initialValues.current,
|
|
modified,
|
|
addFieldRow,
|
|
moveFieldRow,
|
|
removeFieldRow,
|
|
resetForm,
|
|
setErrors,
|
|
setValues,
|
|
setSubmitting,
|
|
validate,
|
|
...state,
|
|
children: typeof props.children === "function" ? props.children({
|
|
modified,
|
|
disabled,
|
|
onChange: handleChange,
|
|
...state,
|
|
setErrors,
|
|
resetForm
|
|
}) : props.children
|
|
})
|
|
});
|
|
});
|
|
var isErrorYupValidationError = (err) => typeof err === "object" && err !== null && "name" in err && typeof err.name === "string" && err.name === "ValidationError";
|
|
var getYupValidationErrors = (err) => {
|
|
let errors = {};
|
|
if (err.inner) {
|
|
if (err.inner.length === 0) {
|
|
return setIn(errors, err.path, err.message);
|
|
}
|
|
for (const error of err.inner) {
|
|
if (!getIn(errors, error.path)) {
|
|
errors = setIn(errors, error.path, error.message);
|
|
}
|
|
}
|
|
}
|
|
return errors;
|
|
};
|
|
var reducer = (state, action) => fn(state, (draft) => {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
switch (action.type) {
|
|
case "SET_INITIAL_VALUES":
|
|
draft.values = action.payload;
|
|
break;
|
|
case "SET_VALUES":
|
|
draft.values = action.payload;
|
|
break;
|
|
case "SUBMIT_ATTEMPT":
|
|
draft.isSubmitting = true;
|
|
break;
|
|
case "SUBMIT_FAILURE":
|
|
draft.isSubmitting = false;
|
|
break;
|
|
case "SUBMIT_SUCCESS":
|
|
draft.isSubmitting = false;
|
|
break;
|
|
case "SET_FIELD_VALUE":
|
|
draft.values = setIn(state.values, action.payload.field, action.payload.value);
|
|
break;
|
|
case "ADD_FIELD_ROW": {
|
|
const currentField = getIn(state.values, action.payload.field, []);
|
|
let position = action.payload.addAtIndex;
|
|
if (position === void 0) {
|
|
position = currentField.length;
|
|
} else if (position < 0) {
|
|
position = 0;
|
|
}
|
|
const [key] = generateNKeysBetween(position > 0 ? (_a = currentField.at(position - 1)) == null ? void 0 : _a.__temp_key__ : null, (_b = currentField.at(position)) == null ? void 0 : _b.__temp_key__, 1);
|
|
draft.values = setIn(state.values, action.payload.field, currentField.toSpliced(position, 0, {
|
|
...action.payload.value,
|
|
__temp_key__: key
|
|
}));
|
|
break;
|
|
}
|
|
case "MOVE_FIELD_ROW": {
|
|
const { field, fromIndex, toIndex } = action.payload;
|
|
const currentField = [
|
|
...getIn(state.values, field, [])
|
|
];
|
|
const currentRow = currentField[fromIndex];
|
|
const startKey = fromIndex > toIndex ? (_c = currentField[toIndex - 1]) == null ? void 0 : _c.__temp_key__ : (_d = currentField[toIndex]) == null ? void 0 : _d.__temp_key__;
|
|
const endKey = fromIndex > toIndex ? (_e = currentField[toIndex]) == null ? void 0 : _e.__temp_key__ : (_f = currentField[toIndex + 1]) == null ? void 0 : _f.__temp_key__;
|
|
const [newKey] = generateNKeysBetween(startKey, endKey, 1);
|
|
currentField.splice(fromIndex, 1);
|
|
currentField.splice(toIndex, 0, {
|
|
...currentRow,
|
|
__temp_key__: newKey
|
|
});
|
|
draft.values = setIn(state.values, field, currentField);
|
|
break;
|
|
}
|
|
case "REMOVE_FIELD_ROW": {
|
|
const currentField = getIn(state.values, action.payload.field, []);
|
|
let position = action.payload.removeAtIndex;
|
|
if (position === void 0) {
|
|
position = currentField.length - 1;
|
|
} else if (position < 0) {
|
|
position = 0;
|
|
}
|
|
const newValue = setIn(currentField, position.toString(), void 0).filter((val) => val);
|
|
draft.values = setIn(state.values, action.payload.field, newValue.length > 0 ? newValue : []);
|
|
break;
|
|
}
|
|
case "SET_ERRORS":
|
|
if (!(0, import_isEqual.default)(state.errors, action.payload)) {
|
|
draft.errors = action.payload;
|
|
}
|
|
break;
|
|
case "SET_ISSUBMITTING":
|
|
draft.isSubmitting = action.payload;
|
|
break;
|
|
case "RESET_FORM":
|
|
draft.values = action.payload.values;
|
|
draft.errors = action.payload.errors;
|
|
draft.isSubmitting = action.payload.isSubmitting;
|
|
break;
|
|
}
|
|
});
|
|
function useField(path) {
|
|
const { formatMessage } = useIntl();
|
|
const initialValue = useForm("useField", (state) => getIn(state.initialValues, path));
|
|
const value = useForm("useField", (state) => getIn(state.values, path));
|
|
const handleChange = useForm("useField", (state) => state.onChange);
|
|
const rawError = useForm("useField", (state) => getIn(state.errors, path));
|
|
const error = useForm("useField", (state) => {
|
|
const error2 = getIn(state.errors, path);
|
|
if (isErrorMessageDescriptor(error2)) {
|
|
const { values, ...message } = error2;
|
|
return formatMessage(message, values);
|
|
}
|
|
return error2;
|
|
});
|
|
return {
|
|
initialValue,
|
|
/**
|
|
* Errors can be a string, or a MessageDescriptor, so we need to handle both cases.
|
|
* If it's anything else, we don't return it.
|
|
*/
|
|
rawError,
|
|
error: isErrorMessageDescriptor(error) ? formatMessage({
|
|
id: error.id,
|
|
defaultMessage: error.defaultMessage
|
|
}, error.values) : typeof error === "string" ? error : void 0,
|
|
onChange: handleChange,
|
|
value
|
|
};
|
|
}
|
|
var isErrorMessageDescriptor = (object) => {
|
|
return typeof object === "object" && object !== null && !Array.isArray(object) && "id" in object && "defaultMessage" in object;
|
|
};
|
|
var Blocker = ({ onProceed = () => {
|
|
}, onCancel = () => {
|
|
} }) => {
|
|
const { formatMessage } = useIntl();
|
|
const modified = useForm("Blocker", (state) => state.modified);
|
|
const isSubmitting = useForm("Blocker", (state) => state.isSubmitting);
|
|
const blocker = useBlocker(({ currentLocation, nextLocation }) => {
|
|
return !isSubmitting && modified && (currentLocation.pathname !== nextLocation.pathname || currentLocation.search !== nextLocation.search);
|
|
});
|
|
if (blocker.state === "blocked") {
|
|
const handleCancel = (isOpen) => {
|
|
if (!isOpen) {
|
|
onCancel();
|
|
blocker.reset();
|
|
}
|
|
};
|
|
return (0, import_jsx_runtime.jsx)(Dialog.Root, {
|
|
open: true,
|
|
onOpenChange: handleCancel,
|
|
children: (0, import_jsx_runtime.jsxs)(Dialog.Content, {
|
|
children: [
|
|
(0, import_jsx_runtime.jsx)(Dialog.Header, {
|
|
children: formatMessage({
|
|
id: "app.components.ConfirmDialog.title",
|
|
defaultMessage: "Confirmation"
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime.jsx)(Dialog.Body, {
|
|
icon: (0, import_jsx_runtime.jsx)(ForwardRef$3, {
|
|
width: "24px",
|
|
height: "24px",
|
|
fill: "danger600"
|
|
}),
|
|
children: formatMessage({
|
|
id: "global.prompt.unsaved",
|
|
defaultMessage: "You have unsaved changes, are you sure you want to leave?"
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime.jsxs)(Dialog.Footer, {
|
|
children: [
|
|
(0, import_jsx_runtime.jsx)(Dialog.Cancel, {
|
|
children: (0, import_jsx_runtime.jsx)(Button, {
|
|
variant: "tertiary",
|
|
children: formatMessage({
|
|
id: "app.components.Button.cancel",
|
|
defaultMessage: "Cancel"
|
|
})
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime.jsx)(Button, {
|
|
onClick: () => {
|
|
onProceed();
|
|
blocker.proceed();
|
|
},
|
|
variant: "danger",
|
|
children: formatMessage({
|
|
id: "app.components.Button.confirm",
|
|
defaultMessage: "Confirm"
|
|
})
|
|
})
|
|
]
|
|
})
|
|
]
|
|
})
|
|
});
|
|
}
|
|
return null;
|
|
};
|
|
|
|
export {
|
|
generateNKeysBetween,
|
|
useForm,
|
|
Form,
|
|
getYupValidationErrors,
|
|
useField,
|
|
Blocker
|
|
};
|
|
//# sourceMappingURL=chunk-BFLP6DBI.js.map
|