@strapi/i18n 0.0.0 → 5.0.0-beta.7

package/dist/_chunks/index-aiqKWFfV.mjs

@@ -0,0 +1,1061 @@
+import get from "lodash/get";
+import * as yup from "yup";
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { Typography, Field, Checkbox, Dialog, DialogBody, Flex, DialogFooter, Button as Button$1, Status, SingleSelect, SingleSelectOption, VisuallyHidden, useCollator, Popover, Box } from "@strapi/design-system";
+import { WarningCircle, Trash, Earth, EarthStriked, CaretDown } from "@strapi/icons";
+import { useIntl } from "react-intl";
+import { styled } from "styled-components";
+import { useAuth, getFetchClient, isFetchError, useQueryParams, useNotification } from "@strapi/admin/strapi-admin";
+import { unstable_useDocument, unstable_useDocumentActions } from "@strapi/content-manager/strapi-admin";
+import { useParams, useNavigate, matchPath } from "react-router-dom";
+import { createApi } from "@reduxjs/toolkit/query/react";
+import * as qs from "qs";
+import omit from "lodash/omit";
+const __variableDynamicImportRuntimeHelper = (glob, path) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(reject.bind(null, new Error("Unknown variable dynamic import: " + path)));
+  });
+};
+const pluginId = "i18n";
+const getTranslation = (id) => `${pluginId}.${id}`;
+const TextAlignTypography = styled(Typography)`
+  text-align: center;
+`;
+const CheckboxConfirmation = ({
+  description,
+  isCreating = false,
+  intlLabel,
+  name,
+  onChange,
+  value
+}) => {
+  const { formatMessage } = useIntl();
+  const [isOpen, setIsOpen] = React.useState(false);
+  const handleChange = (value2) => {
+    if (isCreating || value2) {
+      return onChange({ target: { name, value: value2, type: "checkbox" } });
+    }
+    if (!value2) {
+      return setIsOpen(true);
+    }
+    return null;
+  };
+  const handleConfirm = () => {
+    onChange({ target: { name, value: false, type: "checkbox" } });
+    setIsOpen(false);
+  };
+  const handleToggle = () => setIsOpen((prev) => !prev);
+  const label = intlLabel.id ? formatMessage(
+    { id: intlLabel.id, defaultMessage: intlLabel.defaultMessage },
+    { ...intlLabel.values }
+  ) : name;
+  const hint = description ? formatMessage(
+    { id: description.id, defaultMessage: description.defaultMessage },
+    { ...description.values }
+  ) : "";
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs(Field.Root, { hint, name, children: [
+      /* @__PURE__ */ jsx(Checkbox, { onValueChange: handleChange, value, type: "checkbox", children: label }),
+      /* @__PURE__ */ jsx(Field.Hint, {})
+    ] }),
+    isOpen && /* @__PURE__ */ jsxs(Dialog, { onClose: handleToggle, title: "Confirmation", isOpen, children: [
+      /* @__PURE__ */ jsx(DialogBody, { icon: /* @__PURE__ */ jsx(WarningCircle, {}), children: /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "stretch", gap: 2, children: [
+        /* @__PURE__ */ jsx(Flex, { justifyContent: "center", children: /* @__PURE__ */ jsx(TextAlignTypography, { id: "confirm-description", children: formatMessage({
+          id: getTranslation("CheckboxConfirmation.Modal.content"),
+          defaultMessage: "Disabling localization will engender the deletion of all your content but the one associated to your default locale (if existing)."
+        }) }) }),
+        /* @__PURE__ */ jsx(Flex, { justifyContent: "center", children: /* @__PURE__ */ jsx(Typography, { fontWeight: "semiBold", id: "confirm-description", children: formatMessage({
+          id: getTranslation("CheckboxConfirmation.Modal.body"),
+          defaultMessage: "Do you want to disable it?"
+        }) }) })
+      ] }) }),
+      /* @__PURE__ */ jsx(
+        DialogFooter,
+        {
+          startAction: /* @__PURE__ */ jsx(Button$1, { onClick: handleToggle, variant: "tertiary", children: formatMessage({
+            id: "components.popUpWarning.button.cancel",
+            defaultMessage: "No, cancel"
+          }) }),
+          endAction: /* @__PURE__ */ jsx(Button$1, { variant: "danger-light", onClick: handleConfirm, children: formatMessage({
+            id: getTranslation("CheckboxConfirmation.Modal.button-confirm"),
+            defaultMessage: "Yes, disable"
+          }) })
+        }
+      )
+    ] })
+  ] });
+};
+const LOCALIZED_FIELDS = [
+  "biginteger",
+  "boolean",
+  "component",
+  "date",
+  "datetime",
+  "decimal",
+  "dynamiczone",
+  "email",
+  "enumeration",
+  "float",
+  "integer",
+  "json",
+  "media",
+  "number",
+  "password",
+  "richtext",
+  "blocks",
+  "string",
+  "text",
+  "time"
+];
+const doesPluginOptionsHaveI18nLocalized = (opts) => typeof opts === "object" && opts !== null && "i18n" in opts && typeof opts.i18n === "object" && opts.i18n !== null && "localized" in opts.i18n && typeof opts.i18n.localized === "boolean";
+const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+const useI18n = () => {
+  const params = useParams();
+  const userPermissions = useAuth("useI18n", (state) => state.permissions);
+  const actions = React.useMemo(() => {
+    const permissions = userPermissions.filter((permission) => permission.subject === params.slug);
+    return permissions.reduce(
+      (acc, permission) => {
+        const [actionShorthand] = permission.action.split(".").slice(-1);
+        return {
+          ...acc,
+          [`can${capitalize(actionShorthand)}`]: permission.properties?.locales ?? []
+        };
+      },
+      { canCreate: [], canRead: [], canUpdate: [], canDelete: [], canPublish: [] }
+    );
+  }, [params.slug, userPermissions]);
+  const { schema } = unstable_useDocument(
+    {
+      // We can non-null assert these because below we skip the query if they are not present
+      collectionType: params.collectionType,
+      model: params.slug
+    },
+    {
+      skip: !params.slug || !params.collectionType
+    }
+  );
+  if (doesPluginOptionsHaveI18nLocalized(schema?.pluginOptions)) {
+    return {
+      hasI18n: schema.pluginOptions.i18n.localized,
+      ...actions
+    };
+  }
+  return {
+    hasI18n: false,
+    ...actions
+  };
+};
+const fetchBaseQuery = () => async (query, { signal }) => {
+  try {
+    const { get: get2, post, del, put } = getFetchClient();
+    if (typeof query === "string") {
+      const result = await get2(query, { signal });
+      return { data: result.data };
+    } else {
+      const { url, method = "GET", data, config } = query;
+      if (method === "POST") {
+        const result2 = await post(url, data, {
+          ...config,
+          signal
+        });
+        return { data: result2.data };
+      }
+      if (method === "DELETE") {
+        const result2 = await del(url, {
+          ...config,
+          signal
+        });
+        return { data: result2.data };
+      }
+      if (method === "PUT") {
+        const result2 = await put(url, data, {
+          ...config,
+          signal
+        });
+        return { data: result2.data };
+      }
+      const result = await get2(url, {
+        ...config,
+        signal
+      });
+      return { data: result.data };
+    }
+  } catch (err) {
+    if (isFetchError(err)) {
+      if (typeof err.response?.data === "object" && err.response?.data !== null && "error" in err.response?.data) {
+        return { data: void 0, error: err.response?.data.error };
+      } else {
+        return {
+          data: void 0,
+          error: {
+            name: "UnknownError",
+            message: "There was an unknown error response from the API",
+            details: err.response,
+            status: err.status
+          }
+        };
+      }
+    }
+    const error = err;
+    return {
+      data: void 0,
+      error: {
+        name: error.name,
+        message: error.message,
+        stack: error.stack
+      }
+    };
+  }
+};
+const isBaseQueryError = (error) => {
+  return error.name !== void 0;
+};
+const i18nApi = createApi({
+  reducerPath: "i18nApi",
+  baseQuery: fetchBaseQuery(),
+  tagTypes: ["Locale"],
+  endpoints: () => ({})
+});
+const localesApi = i18nApi.injectEndpoints({
+  endpoints: (builder) => ({
+    createLocale: builder.mutation({
+      query: (data) => ({
+        url: "/i18n/locales",
+        method: "POST",
+        data
+      }),
+      invalidatesTags: [{ type: "Locale", id: "LIST" }]
+    }),
+    deleteLocale: builder.mutation({
+      query: (id) => ({
+        url: `/i18n/locales/${id}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: (result, error, id) => [{ type: "Locale", id }]
+    }),
+    getLocales: builder.query({
+      query: () => "/i18n/locales",
+      providesTags: (res) => [
+        { type: "Locale", id: "LIST" },
+        ...Array.isArray(res) ? res.map((locale) => ({
+          type: "Locale",
+          id: locale.id
+        })) : []
+      ]
+    }),
+    getDefaultLocales: builder.query({
+      query: () => "/i18n/iso-locales"
+    }),
+    updateLocale: builder.mutation({
+      query: ({ id, ...data }) => ({
+        url: `/i18n/locales/${id}`,
+        method: "PUT",
+        data
+      }),
+      invalidatesTags: (result, error, { id }) => [{ type: "Locale", id }]
+    })
+  })
+});
+const {
+  useCreateLocaleMutation,
+  useDeleteLocaleMutation,
+  useGetLocalesQuery,
+  useGetDefaultLocalesQuery,
+  useUpdateLocaleMutation
+} = localesApi;
+const LocalePickerAction = ({
+  document,
+  meta,
+  model,
+  collectionType,
+  documentId
+}) => {
+  const { formatMessage } = useIntl();
+  const [{ query }, setQuery] = useQueryParams();
+  const { hasI18n, canCreate, canRead } = useI18n();
+  const { data: locales = [] } = useGetLocalesQuery();
+  const { schema } = unstable_useDocument({ model, collectionType, documentId });
+  const handleSelect = React.useCallback(
+    (value) => {
+      setQuery({
+        plugins: {
+          ...query.plugins,
+          i18n: {
+            locale: value
+          }
+        }
+      });
+    },
+    [query.plugins, setQuery]
+  );
+  React.useEffect(() => {
+    if (!Array.isArray(locales) || !hasI18n) {
+      return;
+    }
+    const currentDesiredLocale = query.plugins?.i18n?.locale;
+    const doesLocaleExist = locales.find((loc) => loc.code === currentDesiredLocale);
+    const defaultLocale = locales.find((locale) => locale.isDefault);
+    if (!doesLocaleExist && defaultLocale?.code) {
+      handleSelect(defaultLocale.code);
+    }
+  }, [handleSelect, hasI18n, locales, query.plugins?.i18n?.locale]);
+  if (!hasI18n || !Array.isArray(locales) || locales.length === 0) {
+    return null;
+  }
+  const currentLocale = query.plugins?.i18n?.locale || locales.find((loc) => loc.isDefault)?.code;
+  const allCurrentLocales = [
+    { status: getDocumentStatus(document, meta), locale: currentLocale },
+    ...meta?.availableLocales ?? []
+  ];
+  return {
+    label: formatMessage({
+      id: getTranslation("Settings.locales.modal.locales.label"),
+      defaultMessage: "Locales"
+    }),
+    options: locales.map((locale) => {
+      const currentLocaleDoc = allCurrentLocales.find(
+        (doc) => "locale" in doc ? doc.locale === locale.code : false
+      );
+      const status = currentLocaleDoc?.status ?? "draft";
+      const permissionsToCheck = currentLocaleDoc ? canCreate : canRead;
+      const statusVariant = status === "draft" ? "primary" : status === "published" ? "success" : "alternative";
+      return {
+        disabled: !permissionsToCheck.includes(locale.code),
+        value: locale.code,
+        label: locale.name,
+        startIcon: schema?.options?.draftAndPublish ? /* @__PURE__ */ jsx(
+          Status,
+          {
+            display: "flex",
+            paddingLeft: "6px",
+            paddingRight: "6px",
+            paddingTop: "2px",
+            paddingBottom: "2px",
+            showBullet: false,
+            size: "S",
+            variant: statusVariant,
+            children: /* @__PURE__ */ jsx(Typography, { tag: "span", variant: "pi", fontWeight: "bold", children: capitalize(status) })
+          }
+        ) : null
+      };
+    }),
+    onSelect: handleSelect,
+    value: currentLocale
+  };
+};
+const getDocumentStatus = (document, meta) => {
+  const docStatus = document?.status;
+  const statuses = meta?.availableStatus ?? [];
+  if (!docStatus) {
+    return "draft";
+  }
+  if (docStatus === "draft" && statuses.find((doc) => doc.publishedAt !== null)) {
+    return "published";
+  }
+  return docStatus;
+};
+const DeleteLocaleAction = ({
+  document,
+  documentId,
+  model,
+  collectionType
+}) => {
+  const { formatMessage } = useIntl();
+  const navigate = useNavigate();
+  const { toggleNotification } = useNotification();
+  const { delete: deleteAction } = unstable_useDocumentActions();
+  const { hasI18n, canDelete } = useI18n();
+  if (!hasI18n) {
+    return null;
+  }
+  return {
+    disabled: document?.locale && !canDelete.includes(document.locale) || !document || !document.id,
+    position: ["header", "table-row"],
+    label: formatMessage({
+      id: getTranslation("actions.delete.label"),
+      defaultMessage: "Delete locale"
+    }),
+    icon: /* @__PURE__ */ jsx(StyledTrash, {}),
+    variant: "danger",
+    dialog: {
+      type: "dialog",
+      title: formatMessage({
+        id: getTranslation("actions.delete.dialog.title"),
+        defaultMessage: "Confirmation"
+      }),
+      content: /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 2, children: [
+        /* @__PURE__ */ jsx(WarningCircle, { width: "24px", height: "24px", fill: "danger600" }),
+        /* @__PURE__ */ jsx(Typography, { tag: "p", variant: "omega", textAlign: "center", children: formatMessage({
+          id: getTranslation("actions.delete.dialog.body"),
+          defaultMessage: "Are you sure?"
+        }) })
+      ] }),
+      onConfirm: async () => {
+        if (!documentId || !document?.locale) {
+          console.error(
+            "You're trying to delete a document without an id or locale, this is likely a bug with Strapi. Please open an issue."
+          );
+          toggleNotification({
+            message: formatMessage({
+              id: getTranslation("actions.delete.error"),
+              defaultMessage: "An error occurred while trying to delete the document locale."
+            }),
+            type: "danger"
+          });
+          return;
+        }
+        const res = await deleteAction({
+          documentId,
+          model,
+          collectionType,
+          params: { locale: document.locale }
+        });
+        if (!("error" in res)) {
+          navigate({ pathname: `../${collectionType}/${model}` }, { replace: true });
+        }
+      }
+    }
+  };
+};
+const StyledTrash = styled(Trash)`
+  path {
+    fill: currentColor;
+  }
+`;
+const Emphasis = (chunks) => {
+  return /* @__PURE__ */ jsx(Typography, { fontWeight: "semiBold", textColor: "danger500", children: chunks });
+};
+const DeleteModalAdditionalInfo = () => {
+  const { hasI18n } = useI18n();
+  const { formatMessage } = useIntl();
+  if (!hasI18n) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(Typography, { textColor: "danger500", children: formatMessage(
+    {
+      id: getTranslation("Settings.list.actions.deleteAdditionalInfos"),
+      defaultMessage: "This will delete the active locale versions <em>(from Internationalization)</em>"
+    },
+    {
+      em: Emphasis
+    }
+  ) });
+};
+const PublishModalAdditionalInfo = () => {
+  const { hasI18n } = useI18n();
+  const { formatMessage } = useIntl();
+  if (!hasI18n) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(Typography, { textColor: "danger500", children: formatMessage(
+    {
+      id: getTranslation("Settings.list.actions.publishAdditionalInfos"),
+      defaultMessage: "This will publish the active locale versions <em>(from Internationalization)</em>"
+    },
+    {
+      em: Emphasis
+    }
+  ) });
+};
+const UnpublishModalAdditionalInfo = () => {
+  const { hasI18n } = useI18n();
+  const { formatMessage } = useIntl();
+  if (!hasI18n) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(Typography, { textColor: "danger500", children: formatMessage(
+    {
+      id: getTranslation("Settings.list.actions.unpublishAdditionalInfos"),
+      defaultMessage: "This will unpublish the active locale versions <em>(from Internationalization)</em>"
+    },
+    {
+      em: Emphasis
+    }
+  ) });
+};
+const Initializer = ({ setPlugin }) => {
+  const setPluginRef = React.useRef(setPlugin);
+  React.useEffect(() => {
+    setPluginRef.current(pluginId);
+  }, []);
+  return null;
+};
+const LocalePicker = () => {
+  const { formatMessage } = useIntl();
+  const [{ query }, setQuery] = useQueryParams();
+  const { hasI18n, canRead, canCreate } = useI18n();
+  const { data: locales = [] } = useGetLocalesQuery(void 0, {
+    skip: !hasI18n
+  });
+  const handleChange = React.useCallback(
+    (code, replace = false) => {
+      setQuery(
+        {
+          page: 1,
+          plugins: { ...query.plugins, i18n: { locale: code } }
+        },
+        "push",
+        replace
+      );
+    },
+    [query.plugins, setQuery]
+  );
+  React.useEffect(() => {
+    if (!Array.isArray(locales) || !hasI18n) {
+      return;
+    }
+    const currentDesiredLocale = query.plugins?.i18n?.locale;
+    const doesLocaleExist = locales.find((loc) => loc.code === currentDesiredLocale);
+    const defaultLocale = locales.find((locale) => locale.isDefault);
+    if (!doesLocaleExist && defaultLocale?.code) {
+      handleChange(defaultLocale.code, true);
+    }
+  }, [hasI18n, handleChange, locales, query.plugins?.i18n?.locale]);
+  if (!hasI18n || !Array.isArray(locales) || locales.length === 0) {
+    return null;
+  }
+  const displayedLocales = locales.filter((locale) => {
+    return canCreate.includes(locale.code) || canRead.includes(locale.code);
+  });
+  return /* @__PURE__ */ jsx(
+    SingleSelect,
+    {
+      size: "S",
+      "aria-label": formatMessage({
+        id: getTranslation("actions.select-locale"),
+        defaultMessage: "Select locale"
+      }),
+      value: query.plugins?.i18n?.locale || locales.find((locale) => locale.isDefault)?.code,
+      onChange: handleChange,
+      children: displayedLocales.map((locale) => /* @__PURE__ */ jsx(SingleSelectOption, { value: locale.code, children: locale.name }, locale.id))
+    }
+  );
+};
+const PERMISSIONS = {
+  accessMain: [{ action: "plugin::i18n.locale.read", subject: null }],
+  create: [{ action: "plugin::i18n.locale.create", subject: null }],
+  delete: [{ action: "plugin::i18n.locale.delete", subject: null }],
+  update: [{ action: "plugin::i18n.locale.update", subject: null }],
+  read: [{ action: "plugin::i18n.locale.read", subject: null }]
+};
+const mutateEditViewHook = ({ layout }) => {
+  if ("i18n" in layout.options && typeof layout.options.i18n === "object" && layout.options.i18n !== null && "localized" in layout.options.i18n && !layout.options.i18n.localized) {
+    return { layout };
+  }
+  const components = Object.entries(layout.components).reduce(
+    (acc, [key, componentLayout]) => {
+      return {
+        ...acc,
+        [key]: {
+          ...componentLayout,
+          layout: componentLayout.layout.map((row) => row.map(addLabelActionToField))
+        }
+      };
+    },
+    {}
+  );
+  return {
+    layout: {
+      ...layout,
+      components,
+      layout: layout.layout.map((panel) => panel.map((row) => row.map(addLabelActionToField)))
+    }
+  };
+};
+const addLabelActionToField = (field) => {
+  const isFieldLocalized = doesFieldHaveI18nPluginOpt(field.attribute.pluginOptions) ? field.attribute.pluginOptions.i18n.localized : true;
+  const labelActionProps = {
+    title: {
+      id: isFieldLocalized ? getTranslation("Field.localized") : getTranslation("Field.not-localized"),
+      defaultMessage: isFieldLocalized ? "This value is unique for the selected locale" : "This value is the same across all locales"
+    },
+    icon: isFieldLocalized ? /* @__PURE__ */ jsx(Earth, {}) : /* @__PURE__ */ jsx(EarthStriked, {})
+  };
+  return {
+    ...field,
+    labelAction: /* @__PURE__ */ jsx(LabelAction, { ...labelActionProps })
+  };
+};
+const doesFieldHaveI18nPluginOpt = (pluginOpts) => {
+  if (!pluginOpts) {
+    return false;
+  }
+  return "i18n" in pluginOpts && typeof pluginOpts.i18n === "object" && pluginOpts.i18n !== null && "localized" in pluginOpts.i18n;
+};
+const LabelAction = ({ title, icon }) => {
+  const { formatMessage } = useIntl();
+  return /* @__PURE__ */ jsxs(Span, { tag: "span", children: [
+    /* @__PURE__ */ jsx(VisuallyHidden, { tag: "span", children: `(${formatMessage(title)})` }),
+    React.cloneElement(icon, {
+      "aria-hidden": true,
+      focusable: false
+      // See: https://allyjs.io/tutorials/focusing-in-svg.html#making-svg-elements-focusable
+    })
+  ] });
+};
+const Span = styled(Flex)`
+  svg {
+    width: 12px;
+    height: 12px;
+
+    fill: ${({ theme }) => theme.colors.neutral500};
+
+    path {
+      fill: ${({ theme }) => theme.colors.neutral500};
+    }
+  }
+`;
+const LocaleListCell = ({
+  documentId,
+  locale: currentLocale,
+  collectionType,
+  model
+}) => {
+  const { meta, isLoading } = unstable_useDocument({
+    documentId,
+    collectionType,
+    model,
+    params: {
+      locale: currentLocale
+    }
+  });
+  const { locale: language } = useIntl();
+  const [visible, setVisible] = React.useState(false);
+  const buttonRef = React.useRef(null);
+  const { data: locales = [] } = useGetLocalesQuery();
+  const handleTogglePopover = (e) => {
+    e.stopPropagation();
+    setVisible((prev) => !prev);
+  };
+  const formatter = useCollator(language, {
+    sensitivity: "base"
+  });
+  if (!Array.isArray(locales) || isLoading) {
+    return null;
+  }
+  const availableLocales = meta?.availableLocales.map((doc) => doc.locale) ?? [];
+  const localesForDocument = locales.reduce((acc, locale) => {
+    const createdLocale = [currentLocale, ...availableLocales].find((loc) => {
+      return loc === locale.code;
+    });
+    if (createdLocale) {
+      acc.push(locale);
+    }
+    return acc;
+  }, []).map((locale) => {
+    if (locale.isDefault) {
+      return `${locale.name} (default)`;
+    }
+    return locale.name;
+  }).toSorted((a, b) => formatter.compare(a, b));
+  return /* @__PURE__ */ jsxs(Button, { type: "button", onClick: handleTogglePopover, ref: buttonRef, children: [
+    /* @__PURE__ */ jsxs(
+      ActionWrapper,
+      {
+        minWidth: "100%",
+        alignItems: "center",
+        justifyContent: "center",
+        height: "3.2rem",
+        width: "3.2rem",
+        children: [
+          /* @__PURE__ */ jsx(Typography, { textColor: "neutral800", ellipsis: true, children: localesForDocument.join(", ") }),
+          /* @__PURE__ */ jsx(Flex, { children: /* @__PURE__ */ jsx(CaretDown, {}) })
+        ]
+      }
+    ),
+    visible && /* @__PURE__ */ jsx(
+      Popover,
+      {
+        onDismiss: () => setVisible(false),
+        source: buttonRef,
+        spacing: 16,
+        centered: true,
+        children: /* @__PURE__ */ jsx("ul", { children: localesForDocument.map((name) => /* @__PURE__ */ jsx(Box, { padding: 3, tag: "li", children: /* @__PURE__ */ jsx(Typography, { children: name }) }, name)) })
+      }
+    )
+  ] });
+};
+const Button = styled.button`
+  width: 100%;
+
+  svg {
+    > g,
+    path {
+      fill: ${({ theme }) => theme.colors.neutral500};
+    }
+  }
+  &:hover {
+    svg {
+      > g,
+      path {
+        fill: ${({ theme }) => theme.colors.neutral600};
+      }
+    }
+  }
+  &:active {
+    svg {
+      > g,
+      path {
+        fill: ${({ theme }) => theme.colors.neutral400};
+      }
+    }
+  }
+`;
+const ActionWrapper = styled(Flex)`
+  svg {
+    height: 0.4rem;
+  }
+`;
+const addColumnToTableHook = ({ displayedHeaders, layout }) => {
+  const { options } = layout;
+  const isFieldLocalized = doesPluginOptionsHaveI18nLocalized(options) ? options.i18n.localized : false;
+  if (!isFieldLocalized) {
+    return { displayedHeaders, layout };
+  }
+  return {
+    displayedHeaders: [
+      ...displayedHeaders,
+      {
+        attribute: { type: "string" },
+        label: {
+          id: getTranslation("list-view.table.header.label"),
+          defaultMessage: "Available in"
+        },
+        searchable: false,
+        sortable: false,
+        name: "locales",
+        // @ts-expect-error – ID is seen as number | string; this will change when we move the type over.
+        cellFormatter: (props, _header, meta) => /* @__PURE__ */ jsx(LocaleListCell, { ...props, ...meta })
+      }
+    ],
+    layout
+  };
+};
+const addLocaleToReleasesHook = ({ displayedHeaders = [] }) => {
+  return {
+    displayedHeaders: [
+      // TODO: Fix when migrating to v5
+      // ...displayedHeaders,
+      {
+        key: "__locale__",
+        fieldSchema: { type: "string" },
+        metadatas: {
+          label: {
+            id: "content-releases.page.ReleaseDetails.table.header.label.locale",
+            defaultMessage: "locale"
+          },
+          searchable: false,
+          sortable: false
+        },
+        name: "locale"
+      }
+    ],
+    hasI18nEnabled: true
+  };
+};
+const extendCTBAttributeInitialDataMiddleware = () => {
+  return ({ getState }) => (next) => (action) => {
+    const enhanceAction = () => {
+      try {
+        const store = getState();
+        const hasi18nEnabled = get(
+          store,
+          [
+            "content-type-builder_dataManagerProvider",
+            "modifiedData",
+            "contentType",
+            "schema",
+            "pluginOptions",
+            "i18n",
+            "localized"
+          ],
+          false
+        );
+        if (hasi18nEnabled) {
+          const pluginOptions = action.options ? { ...action.options.pluginOptions, i18n: { localized: true } } : { i18n: { localized: true } };
+          return next({
+            ...action,
+            options: {
+              pluginOptions
+            }
+          });
+        }
+        return next(action);
+      } catch (err) {
+        return next(action);
+      }
+    };
+    if (action.type === "ContentTypeBuilder/FormModal/SET_ATTRIBUTE_DATA_SCHEMA" && action.forTarget === "contentType" && !["relation", "component"].includes(action.attributeType) && !action.isEditing) {
+      return enhanceAction();
+    }
+    if (action.type === "ContentTypeBuilder/FormModal/SET_CUSTOM_FIELD_DATA_SCHEMA" && action.forTarget === "contentType" && !action.isEditing) {
+      return enhanceAction();
+    }
+    if ((action.type === "ContentTypeBuilder/FormModal/RESET_PROPS_AND_SET_FORM_FOR_ADDING_AN_EXISTING_COMPO" || action.type === "ContentTypeBuilder/FormModal/RESET_PROPS_AND_SAVE_CURRENT_DATA") && action.forTarget === "contentType") {
+      return enhanceAction();
+    }
+    return next(action);
+  };
+};
+const extendCTBInitialDataMiddleware = () => {
+  return () => (next) => (action) => {
+    if (action.type === "ContentTypeBuilder/FormModal/SET_DATA_TO_EDIT" && action.modalType === "contentType") {
+      const i18n = { localized: false };
+      const pluginOptions = action.data.pluginOptions ? { ...action.data.pluginOptions, i18n } : { i18n };
+      const data = { ...action.data, pluginOptions };
+      if (action.actionType === "create") {
+        return next({ ...action, data });
+      }
+      if (!action.data.pluginOptions?.i18n?.localized) {
+        return next({ ...action, data });
+      }
+    }
+    return next(action);
+  };
+};
+const localeMiddleware = (ctx) => (next) => (permissions) => {
+  const match = matchPath("/content-manager/:collectionType/:model?/:id", ctx.pathname);
+  if (!match) {
+    return next(permissions);
+  }
+  const search = qs.parse(ctx.search);
+  if (typeof search !== "object") {
+    return next(permissions);
+  }
+  if (!("plugins" in search && typeof search.plugins === "object")) {
+    return next(permissions);
+  }
+  if (!("i18n" in search.plugins && typeof search.plugins.i18n === "object" && !Array.isArray(search.plugins.i18n))) {
+    return next(permissions);
+  }
+  const { locale } = search.plugins.i18n;
+  if (typeof locale !== "string") {
+    return next(permissions);
+  }
+  const revisedPermissions = permissions.filter(
+    (permission) => !permission.properties?.locales || permission.properties.locales.includes(locale)
+  );
+  return next(revisedPermissions);
+};
+const prefixPluginTranslations = (trad, pluginId2) => {
+  if (!pluginId2) {
+    throw new TypeError("pluginId can't be empty");
+  }
+  return Object.keys(trad).reduce((acc, current) => {
+    acc[`${pluginId2}.${current}`] = trad[current];
+    return acc;
+  }, {});
+};
+const mutateCTBContentTypeSchema = (nextSchema, prevSchema) => {
+  if (!doesPluginOptionsHaveI18nLocalized(nextSchema.pluginOptions)) {
+    return nextSchema;
+  }
+  const isNextSchemaLocalized = nextSchema.pluginOptions.i18n.localized;
+  const isPrevSchemaLocalized = doesPluginOptionsHaveI18nLocalized(
+    prevSchema?.schema?.pluginOptions
+  ) ? prevSchema?.schema?.pluginOptions.i18n.localized : false;
+  if (isNextSchemaLocalized && isPrevSchemaLocalized) {
+    return nextSchema;
+  }
+  if (isNextSchemaLocalized) {
+    const attributes = addLocalisationToFields(nextSchema.attributes);
+    return { ...nextSchema, attributes };
+  }
+  if (!isNextSchemaLocalized) {
+    const pluginOptions = omit(nextSchema.pluginOptions, "i18n");
+    const attributes = disableAttributesLocalisation(nextSchema.attributes);
+    return { ...nextSchema, pluginOptions, attributes };
+  }
+  return nextSchema;
+};
+const addLocalisationToFields = (attributes) => Object.keys(attributes).reduce((acc, current) => {
+  const currentAttribute = attributes[current];
+  if (LOCALIZED_FIELDS.includes(currentAttribute.type)) {
+    const i18n = { localized: true };
+    const pluginOptions = currentAttribute.pluginOptions ? { ...currentAttribute.pluginOptions, i18n } : { i18n };
+    acc[current] = { ...currentAttribute, pluginOptions };
+    return acc;
+  }
+  acc[current] = currentAttribute;
+  return acc;
+}, {});
+const disableAttributesLocalisation = (attributes) => Object.keys(attributes).reduce((acc, current) => {
+  acc[current] = omit(attributes[current], "pluginOptions.i18n");
+  return acc;
+}, {});
+const index = {
+  register(app) {
+    app.addMiddlewares([extendCTBAttributeInitialDataMiddleware, extendCTBInitialDataMiddleware]);
+    app.addMiddlewares([() => i18nApi.middleware]);
+    app.addReducers({
+      [i18nApi.reducerPath]: i18nApi.reducer
+    });
+    app.addRBACMiddleware([localeMiddleware]);
+    app.registerPlugin({
+      id: pluginId,
+      initializer: Initializer,
+      isReady: false,
+      name: pluginId
+    });
+  },
+  bootstrap(app) {
+    app.registerHook("Admin/CM/pages/ListView/inject-column-in-table", addColumnToTableHook);
+    app.registerHook("Admin/CM/pages/EditView/mutate-edit-view-layout", mutateEditViewHook);
+    app.registerHook(
+      "ContentReleases/pages/ReleaseDetails/add-locale-in-releases",
+      addLocaleToReleasesHook
+    );
+    app.addSettingsLink("global", {
+      intlLabel: {
+        id: getTranslation("plugin.name"),
+        defaultMessage: "Internationalization"
+      },
+      id: "internationalization",
+      to: "internationalization",
+      Component: () => import("./SettingsPage-CB5yd4O3.mjs").then((mod) => ({ default: mod.ProtectedSettingsPage })),
+      permissions: PERMISSIONS.accessMain
+    });
+    const contentManager = app.getPlugin("content-manager");
+    contentManager.apis.addDocumentHeaderAction([LocalePickerAction]);
+    contentManager.apis.addDocumentAction((actions) => {
+      const indexOfDeleteAction = actions.findIndex((action) => action.type === "delete");
+      actions.splice(indexOfDeleteAction, 0, DeleteLocaleAction);
+      return actions;
+    });
+    contentManager.injectComponent("listView", "actions", {
+      name: "i18n-locale-filter",
+      Component: LocalePicker
+    });
+    contentManager.injectComponent("listView", "publishModalAdditionalInfos", {
+      name: "i18n-publish-bullets-in-modal",
+      Component: PublishModalAdditionalInfo
+    });
+    contentManager.injectComponent("listView", "unpublishModalAdditionalInfos", {
+      name: "i18n-unpublish-bullets-in-modal",
+      Component: UnpublishModalAdditionalInfo
+    });
+    contentManager.injectComponent("listView", "deleteModalAdditionalInfos", {
+      name: "i18n-delete-bullets-in-modal",
+      Component: DeleteModalAdditionalInfo
+    });
+    const ctbPlugin = app.getPlugin("content-type-builder");
+    if (ctbPlugin) {
+      const ctbFormsAPI = ctbPlugin.apis.forms;
+      ctbFormsAPI.addContentTypeSchemaMutation(mutateCTBContentTypeSchema);
+      ctbFormsAPI.components.add({ id: "checkboxConfirmation", component: CheckboxConfirmation });
+      ctbFormsAPI.extendContentType({
+        validator: () => ({
+          i18n: yup.object().shape({
+            localized: yup.bool()
+          })
+        }),
+        form: {
+          advanced() {
+            return [
+              {
+                name: "pluginOptions.i18n.localized",
+                description: {
+                  id: getTranslation("plugin.schema.i18n.localized.description-content-type"),
+                  defaultMessage: "Allows translating an entry into different languages"
+                },
+                type: "checkboxConfirmation",
+                intlLabel: {
+                  id: getTranslation("plugin.schema.i18n.localized.label-content-type"),
+                  defaultMessage: "Localization"
+                }
+              }
+            ];
+          }
+        }
+      });
+      ctbFormsAPI.extendFields(LOCALIZED_FIELDS, {
+        validator: (args) => ({
+          i18n: yup.object().shape({
+            localized: yup.bool().test({
+              name: "ensure-unique-localization",
+              message: getTranslation("plugin.schema.i18n.ensure-unique-localization"),
+              test(value) {
+                if (value === void 0 || value) {
+                  return true;
+                }
+                const unique = get(args, ["3", "modifiedData", "unique"], null);
+                if (unique && !value) {
+                  return false;
+                }
+                return true;
+              }
+            })
+          })
+        }),
+        form: {
+          advanced({ contentTypeSchema, forTarget, type, step }) {
+            if (forTarget !== "contentType") {
+              return [];
+            }
+            const hasI18nEnabled = get(
+              contentTypeSchema,
+              ["schema", "pluginOptions", "i18n", "localized"],
+              false
+            );
+            if (!hasI18nEnabled) {
+              return [];
+            }
+            if (type === "component" && step === "1") {
+              return [];
+            }
+            return [
+              {
+                name: "pluginOptions.i18n.localized",
+                description: {
+                  id: getTranslation("plugin.schema.i18n.localized.description-field"),
+                  defaultMessage: "The field can have different values in each locale"
+                },
+                type: "checkbox",
+                intlLabel: {
+                  id: getTranslation("plugin.schema.i18n.localized.label-field"),
+                  defaultMessage: "Enable localization for this field"
+                }
+              }
+            ];
+          }
+        }
+      });
+    }
+  },
+  async registerTrads({ locales }) {
+    const importedTrads = await Promise.all(
+      locales.map((locale) => {
+        return __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/de.json": () => import("./de-9eCAqqrB.mjs"), "./translations/dk.json": () => import("./dk-2qBjxt-P.mjs"), "./translations/en.json": () => import("./en-CnrTsjWS.mjs"), "./translations/es.json": () => import("./es-DlmMVaBG.mjs"), "./translations/fr.json": () => import("./fr-3S6ke71d.mjs"), "./translations/ko.json": () => import("./ko-qTjQ8IMw.mjs"), "./translations/pl.json": () => import("./pl-B67TSHqT.mjs"), "./translations/ru.json": () => import("./ru-hagMa57T.mjs"), "./translations/tr.json": () => import("./tr-Dw_jmkG-.mjs"), "./translations/zh-Hans.json": () => import("./zh-Hans-Dyc-aR-h.mjs"), "./translations/zh.json": () => import("./zh-57YM4amO.mjs") }), `./translations/${locale}.json`).then(({ default: data }) => {
+          return {
+            data: prefixPluginTranslations(data, pluginId),
+            locale
+          };
+        }).catch(() => {
+          return {
+            data: {},
+            locale
+          };
+        });
+      })
+    );
+    return Promise.resolve(importedTrads);
+  }
+};
+export {
+  PERMISSIONS as P,
+  useGetDefaultLocalesQuery as a,
+  useDeleteLocaleMutation as b,
+  useUpdateLocaleMutation as c,
+  useGetLocalesQuery as d,
+  index as e,
+  getTranslation as g,
+  isBaseQueryError as i,
+  useCreateLocaleMutation as u
+};
+//# sourceMappingURL=index-aiqKWFfV.mjs.map