@strapi/admin 0.0.0-experimental.62ebf57bb35846666febb5ee2078fe02fe990f57 → 0.0.0-experimental.6340da17068c3bed7fb006e7bcc554c71129e282

package/dist/_internal/index.d.ts

@@ -0,0 +1 @@
+export { DefaultDocument } from '../admin/src/components/DefaultDocument';

package/dist/_internal.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var DefaultDocument = require('./admin/src/components/DefaultDocument.js');
+
+
+
+exports.DefaultDocument = DefaultDocument.DefaultDocument;
+//# sourceMappingURL=_internal.js.map

package/dist/_internal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_internal.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

package/dist/_internal.mjs

@@ -0,0 +1,2 @@
+export { DefaultDocument } from './admin/src/components/DefaultDocument.mjs';
+//# sourceMappingURL=_internal.mjs.map

package/dist/_internal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"_internal.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/admin/admin/src/App.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var reactRouterDom = require('react-router-dom');
+var GlobalNotifications = require('../../ee/admin/src/components/GlobalNotifications.js');
+var PageHelpers = require('./components/PageHelpers.js');
+var Providers = require('./components/Providers.js');
+var reducer = require('./reducer.js');
+
+const App = ({ strapi, store })=>{
+    React.useEffect(()=>{
+        const language = localStorage.getItem(reducer.LANGUAGE_LOCAL_STORAGE_KEY) || 'en';
+        {
+            document.documentElement.lang = language;
+        }
+    }, []);
+    /**
+   * @internal
+   * @experimental
+   *
+   * The `future-global::` namespace is intended for internal use.
+   * It is experimental and could change or be removed in the future.
+   */ const globalComponents = Object.entries(strapi.library.components).filter(([name])=>name.startsWith('future-global::')).map(([name, Component])=>({
+            name,
+            Component
+        }));
+    return /*#__PURE__*/ jsxRuntime.jsx(Providers.Providers, {
+        strapi: strapi,
+        store: store,
+        children: /*#__PURE__*/ jsxRuntime.jsxs(React.Suspense, {
+            fallback: /*#__PURE__*/ jsxRuntime.jsx(PageHelpers.Page.Loading, {}),
+            children: [
+                /*#__PURE__*/ jsxRuntime.jsx(GlobalNotifications.GlobalNotifications, {}),
+                window.strapi.future.isEnabled('unstableMediaLibrary') && globalComponents.map(({ name, Component })=>/*#__PURE__*/ jsxRuntime.jsx(Component, {}, name)),
+                /*#__PURE__*/ jsxRuntime.jsx(reactRouterDom.Outlet, {})
+            ]
+        })
+    });
+};
+
+exports.App = App;
+//# sourceMappingURL=App.js.map

package/dist/admin/admin/src/App.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"App.js","sources":["../../../../admin/src/App.tsx"],"sourcesContent":["/**\n *\n * App.js\n *\n */\nimport { Suspense, useEffect } from 'react';\n\nimport { Outlet } from 'react-router-dom';\n\nimport { GlobalNotifications } from '../../ee/admin/src/components/GlobalNotifications';\n\nimport { Page } from './components/PageHelpers';\nimport { Providers } from './components/Providers';\nimport { LANGUAGE_LOCAL_STORAGE_KEY } from './reducer';\n\nimport type { Store } from './core/store/configure';\nimport type { StrapiApp } from './StrapiApp';\n\ninterface AppProps {\n  strapi: StrapiApp;\n  store: Store;\n}\n\nconst App = ({ strapi, store }: AppProps) => {\n  useEffect(() => {\n    const language = localStorage.getItem(LANGUAGE_LOCAL_STORAGE_KEY) || 'en';\n\n    if (language) {\n      document.documentElement.lang = language;\n    }\n  }, []);\n\n  /**\n   * @internal\n   * @experimental\n   *\n   * The `future-global::` namespace is intended for internal use.\n   * It is experimental and could change or be removed in the future.\n   */\n  const globalComponents = Object.entries(strapi.library.components)\n    .filter(([name]) => name.startsWith('future-global::'))\n    .map(([name, Component]) => ({ name, Component }));\n\n  return (\n    <Providers strapi={strapi} store={store}>\n      <Suspense fallback={<Page.Loading />}>\n        <GlobalNotifications />\n        {window.strapi.future.isEnabled('unstableMediaLibrary') &&\n          globalComponents.map(({ name, Component }) => <Component key={name} />)}\n        <Outlet />\n      </Suspense>\n    </Providers>\n  );\n};\n\nexport { App };\nexport type { AppProps };\n"],"names":["App","strapi","store","useEffect","language","localStorage","getItem","LANGUAGE_LOCAL_STORAGE_KEY","document","documentElement","lang","globalComponents","Object","entries","library","components","filter","name","startsWith","map","Component","_jsx","Providers","_jsxs","Suspense","fallback","Page","Loading","GlobalNotifications","window","future","isEnabled","Outlet"],"mappings":";;;;;;;;;;AAuBA,MAAMA,MAAM,CAAC,EAAEC,MAAM,EAAEC,KAAK,EAAY,GAAA;IACtCC,eAAAA,CAAU,IAAA;AACR,QAAA,MAAMC,QAAAA,GAAWC,YAAAA,CAAaC,OAAO,CAACC,kCAAAA,CAAAA,IAA+B,IAAA;AAErE,QAAc;YACZC,QAAAA,CAASC,eAAe,CAACC,IAAI,GAAGN,QAAAA;AAClC,QAAA;AACF,IAAA,CAAA,EAAG,EAAE,CAAA;AAEL;;;;;;MAOA,MAAMO,gBAAAA,GAAmBC,MAAAA,CAAOC,OAAO,CAACZ,MAAAA,CAAOa,OAAO,CAACC,UAAU,CAAA,CAC9DC,MAAM,CAAC,CAAC,CAACC,IAAAA,CAAK,GAAKA,IAAAA,CAAKC,UAAU,CAAC,iBAAA,CAAA,CAAA,CACnCC,GAAG,CAAC,CAAC,CAACF,IAAAA,EAAMG,SAAAA,CAAU,IAAM;AAAEH,YAAAA,IAAAA;AAAMG,YAAAA;SAAU,CAAA,CAAA;AAEjD,IAAA,qBACEC,cAAA,CAACC,mBAAAA,EAAAA;QAAUrB,MAAAA,EAAQA,MAAAA;QAAQC,KAAAA,EAAOA,KAAAA;AAChC,QAAA,QAAA,gBAAAqB,eAAA,CAACC,cAAAA,EAAAA;YAASC,QAAAA,gBAAUJ,cAAA,CAACK,iBAAKC,OAAO,EAAA,EAAA,CAAA;;8BAC/BN,cAAA,CAACO,uCAAAA,EAAAA,EAAAA,CAAAA;AACAC,gBAAAA,MAAAA,CAAO5B,MAAM,CAAC6B,MAAM,CAACC,SAAS,CAAC,2BAC9BpB,gBAAAA,CAAiBQ,GAAG,CAAC,CAAC,EAAEF,IAAI,EAAEG,SAAS,EAAE,iBAAKC,eAACD,SAAAA,EAAAA,EAAAA,EAAeH,IAAAA,CAAAA,CAAAA;8BAChEI,cAAA,CAACW,qBAAAA,EAAAA,EAAAA;;;;AAIT;;;;"}

package/dist/admin/admin/src/App.mjs

@@ -0,0 +1,41 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { useEffect, Suspense } from 'react';
+import { Outlet } from 'react-router-dom';
+import { GlobalNotifications } from '../../ee/admin/src/components/GlobalNotifications.mjs';
+import { Page } from './components/PageHelpers.mjs';
+import { Providers } from './components/Providers.mjs';
+import { LANGUAGE_LOCAL_STORAGE_KEY } from './reducer.mjs';
+
+const App = ({ strapi, store })=>{
+    useEffect(()=>{
+        const language = localStorage.getItem(LANGUAGE_LOCAL_STORAGE_KEY) || 'en';
+        {
+            document.documentElement.lang = language;
+        }
+    }, []);
+    /**
+   * @internal
+   * @experimental
+   *
+   * The `future-global::` namespace is intended for internal use.
+   * It is experimental and could change or be removed in the future.
+   */ const globalComponents = Object.entries(strapi.library.components).filter(([name])=>name.startsWith('future-global::')).map(([name, Component])=>({
+            name,
+            Component
+        }));
+    return /*#__PURE__*/ jsx(Providers, {
+        strapi: strapi,
+        store: store,
+        children: /*#__PURE__*/ jsxs(Suspense, {
+            fallback: /*#__PURE__*/ jsx(Page.Loading, {}),
+            children: [
+                /*#__PURE__*/ jsx(GlobalNotifications, {}),
+                window.strapi.future.isEnabled('unstableMediaLibrary') && globalComponents.map(({ name, Component })=>/*#__PURE__*/ jsx(Component, {}, name)),
+                /*#__PURE__*/ jsx(Outlet, {})
+            ]
+        })
+    });
+};
+
+export { App };
+//# sourceMappingURL=App.mjs.map

package/dist/admin/admin/src/App.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"App.mjs","sources":["../../../../admin/src/App.tsx"],"sourcesContent":["/**\n *\n * App.js\n *\n */\nimport { Suspense, useEffect } from 'react';\n\nimport { Outlet } from 'react-router-dom';\n\nimport { GlobalNotifications } from '../../ee/admin/src/components/GlobalNotifications';\n\nimport { Page } from './components/PageHelpers';\nimport { Providers } from './components/Providers';\nimport { LANGUAGE_LOCAL_STORAGE_KEY } from './reducer';\n\nimport type { Store } from './core/store/configure';\nimport type { StrapiApp } from './StrapiApp';\n\ninterface AppProps {\n  strapi: StrapiApp;\n  store: Store;\n}\n\nconst App = ({ strapi, store }: AppProps) => {\n  useEffect(() => {\n    const language = localStorage.getItem(LANGUAGE_LOCAL_STORAGE_KEY) || 'en';\n\n    if (language) {\n      document.documentElement.lang = language;\n    }\n  }, []);\n\n  /**\n   * @internal\n   * @experimental\n   *\n   * The `future-global::` namespace is intended for internal use.\n   * It is experimental and could change or be removed in the future.\n   */\n  const globalComponents = Object.entries(strapi.library.components)\n    .filter(([name]) => name.startsWith('future-global::'))\n    .map(([name, Component]) => ({ name, Component }));\n\n  return (\n    <Providers strapi={strapi} store={store}>\n      <Suspense fallback={<Page.Loading />}>\n        <GlobalNotifications />\n        {window.strapi.future.isEnabled('unstableMediaLibrary') &&\n          globalComponents.map(({ name, Component }) => <Component key={name} />)}\n        <Outlet />\n      </Suspense>\n    </Providers>\n  );\n};\n\nexport { App };\nexport type { AppProps };\n"],"names":["App","strapi","store","useEffect","language","localStorage","getItem","LANGUAGE_LOCAL_STORAGE_KEY","document","documentElement","lang","globalComponents","Object","entries","library","components","filter","name","startsWith","map","Component","_jsx","Providers","_jsxs","Suspense","fallback","Page","Loading","GlobalNotifications","window","future","isEnabled","Outlet"],"mappings":";;;;;;;;AAuBA,MAAMA,MAAM,CAAC,EAAEC,MAAM,EAAEC,KAAK,EAAY,GAAA;IACtCC,SAAAA,CAAU,IAAA;AACR,QAAA,MAAMC,QAAAA,GAAWC,YAAAA,CAAaC,OAAO,CAACC,0BAAAA,CAAAA,IAA+B,IAAA;AAErE,QAAc;YACZC,QAAAA,CAASC,eAAe,CAACC,IAAI,GAAGN,QAAAA;AAClC,QAAA;AACF,IAAA,CAAA,EAAG,EAAE,CAAA;AAEL;;;;;;MAOA,MAAMO,gBAAAA,GAAmBC,MAAAA,CAAOC,OAAO,CAACZ,MAAAA,CAAOa,OAAO,CAACC,UAAU,CAAA,CAC9DC,MAAM,CAAC,CAAC,CAACC,IAAAA,CAAK,GAAKA,IAAAA,CAAKC,UAAU,CAAC,iBAAA,CAAA,CAAA,CACnCC,GAAG,CAAC,CAAC,CAACF,IAAAA,EAAMG,SAAAA,CAAU,IAAM;AAAEH,YAAAA,IAAAA;AAAMG,YAAAA;SAAU,CAAA,CAAA;AAEjD,IAAA,qBACEC,GAAA,CAACC,SAAAA,EAAAA;QAAUrB,MAAAA,EAAQA,MAAAA;QAAQC,KAAAA,EAAOA,KAAAA;AAChC,QAAA,QAAA,gBAAAqB,IAAA,CAACC,QAAAA,EAAAA;YAASC,QAAAA,gBAAUJ,GAAA,CAACK,KAAKC,OAAO,EAAA,EAAA,CAAA;;8BAC/BN,GAAA,CAACO,mBAAAA,EAAAA,EAAAA,CAAAA;AACAC,gBAAAA,MAAAA,CAAO5B,MAAM,CAAC6B,MAAM,CAACC,SAAS,CAAC,2BAC9BpB,gBAAAA,CAAiBQ,GAAG,CAAC,CAAC,EAAEF,IAAI,EAAEG,SAAS,EAAE,iBAAKC,IAACD,SAAAA,EAAAA,EAAAA,EAAeH,IAAAA,CAAAA,CAAAA;8BAChEI,GAAA,CAACW,MAAAA,EAAAA,EAAAA;;;;AAIT;;;;"}

package/dist/admin/admin/src/StrapiApp.js

@@ -0,0 +1,515 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+require('react');
+var designSystem = require('@strapi/design-system');
+var icons = require('@strapi/icons');
+var invariant = require('invariant');
+var isFunction = require('lodash/isFunction');
+var merge = require('lodash/merge');
+var pick = require('lodash/pick');
+var uniq = require('lodash/uniq');
+var reactRouterDom = require('react-router-dom');
+var constants = require('../../ee/admin/src/constants.js');
+var logoStrapi2022 = require('./assets/images/logo-strapi-2022.svg.js');
+var constants$1 = require('./constants.js');
+var CustomFields = require('./core/apis/CustomFields.js');
+var Plugin = require('./core/apis/Plugin.js');
+var rbac = require('./core/apis/rbac.js');
+var router = require('./core/apis/router.js');
+var Widgets = require('./core/apis/Widgets.js');
+var configure = require('./core/store/configure.js');
+var basename = require('./core/utils/basename.js');
+var createHook = require('./core/utils/createHook.js');
+var reducer = require('./reducer.js');
+var router$1 = require('./router.js');
+var languageNativeNames = require('./translations/languageNativeNames.js');
+var normalizeAdminLocale = require('./translations/normalizeAdminLocale.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespaceDefaultOnly (e) { return Object.freeze({ __proto__: null, default: e }); }
+
+var invariant__default = /*#__PURE__*/_interopDefault(invariant);
+var isFunction__default = /*#__PURE__*/_interopDefault(isFunction);
+var merge__default = /*#__PURE__*/_interopDefault(merge);
+var pick__default = /*#__PURE__*/_interopDefault(pick);
+var uniq__default = /*#__PURE__*/_interopDefault(uniq);
+
+function __variableDynamicImportRuntime5__(path) {
+  switch (path) {
+    case './translations/ar.json': return Promise.resolve().then(function () { return require('./translations/ar.json.js'); });
+    case './translations/ca.json': return Promise.resolve().then(function () { return require('./translations/ca.json.js'); });
+    case './translations/cs.json': return Promise.resolve().then(function () { return require('./translations/cs.json.js'); });
+    case './translations/da.json': return Promise.resolve().then(function () { return require('./translations/da.json.js'); });
+    case './translations/de.json': return Promise.resolve().then(function () { return require('./translations/de.json.js'); });
+    case './translations/en.json': return Promise.resolve().then(function () { return require('./translations/en.json.js'); });
+    case './translations/es.json': return Promise.resolve().then(function () { return require('./translations/es.json.js'); });
+    case './translations/eu.json': return Promise.resolve().then(function () { return require('./translations/eu.json.js'); });
+    case './translations/fi.json': return Promise.resolve().then(function () { return require('./translations/fi.json.js'); });
+    case './translations/fr.json': return Promise.resolve().then(function () { return require('./translations/fr.json.js'); });
+    case './translations/gu.json': return Promise.resolve().then(function () { return require('./translations/gu.json.js'); });
+    case './translations/he.json': return Promise.resolve().then(function () { return require('./translations/he.json.js'); });
+    case './translations/hi.json': return Promise.resolve().then(function () { return require('./translations/hi.json.js'); });
+    case './translations/hu.json': return Promise.resolve().then(function () { return require('./translations/hu.json.js'); });
+    case './translations/id.json': return Promise.resolve().then(function () { return require('./translations/id.json.js'); });
+    case './translations/it.json': return Promise.resolve().then(function () { return require('./translations/it.json.js'); });
+    case './translations/ja.json': return Promise.resolve().then(function () { return require('./translations/ja.json.js'); });
+    case './translations/ko.json': return Promise.resolve().then(function () { return require('./translations/ko.json.js'); });
+    case './translations/ml.json': return Promise.resolve().then(function () { return require('./translations/ml.json.js'); });
+    case './translations/ms.json': return Promise.resolve().then(function () { return require('./translations/ms.json.js'); });
+    case './translations/nl.json': return Promise.resolve().then(function () { return require('./translations/nl.json.js'); });
+    case './translations/no.json': return Promise.resolve().then(function () { return require('./translations/no.json.js'); });
+    case './translations/pl.json': return Promise.resolve().then(function () { return require('./translations/pl.json.js'); });
+    case './translations/pt-BR.json': return Promise.resolve().then(function () { return require('./translations/pt-BR.json.js'); });
+    case './translations/pt.json': return Promise.resolve().then(function () { return require('./translations/pt.json.js'); });
+    case './translations/ru.json': return Promise.resolve().then(function () { return require('./translations/ru.json.js'); });
+    case './translations/sa.json': return Promise.resolve().then(function () { return require('./translations/sa.json.js'); });
+    case './translations/sk.json': return Promise.resolve().then(function () { return require('./translations/sk.json.js'); });
+    case './translations/sv.json': return Promise.resolve().then(function () { return require('./translations/sv.json.js'); });
+    case './translations/th.json': return Promise.resolve().then(function () { return require('./translations/th.json.js'); });
+    case './translations/tr.json': return Promise.resolve().then(function () { return require('./translations/tr.json.js'); });
+    case './translations/uk.json': return Promise.resolve().then(function () { return require('./translations/uk.json.js'); });
+    case './translations/vi.json': return Promise.resolve().then(function () { return require('./translations/vi.json.js'); });
+    case './translations/zh-Hans.json': return Promise.resolve().then(function () { return require('./translations/zh-Hans.json.js'); });
+    case './translations/zh.json': return Promise.resolve().then(function () { return require('./translations/zh.json.js'); });
+    default: return new Promise(function(resolve, reject) {
+      (typeof queueMicrotask === 'function' ? queueMicrotask : setTimeout)(
+        reject.bind(null, new Error("Unknown variable dynamic import: " + path))
+      );
+    })
+   }
+ }
+
+function __variableDynamicImportRuntime4__(path) {
+  switch (path) {
+    case './translations/en-GB.js': return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespaceDefaultOnly(require('./translations/en-GB.js')); });
+    default: return new Promise(function(resolve, reject) {
+      (typeof queueMicrotask === 'function' ? queueMicrotask : setTimeout)(
+        reject.bind(null, new Error("Unknown variable dynamic import: " + path))
+      );
+    })
+   }
+ }
+/**
+ * Canonical admin locale codes mapped to legacy translation file names still
+ * shipped by some plugins.
+ */ const ADMIN_LOCALE_LEGACY_ALIASES = {
+    da: 'dk'
+};
+const { INJECT_COLUMN_IN_TABLE, INJECT_LIST_VIEW_FILTERS, MUTATE_COLLECTION_TYPES_LINKS, MUTATE_EDIT_VIEW_LAYOUT, MUTATE_SINGLE_TYPES_LINKS } = constants$1.HOOKS;
+class StrapiApp {
+    async bootstrap(customBootstrap) {
+        Object.keys(this.appPlugins).forEach((plugin)=>{
+            const bootstrap = this.appPlugins[plugin].bootstrap;
+            if (bootstrap) {
+                bootstrap({
+                    addSettingsLink: this.addSettingsLink,
+                    addSettingsLinks: this.addSettingsLinks,
+                    getPlugin: this.getPlugin,
+                    registerHook: this.registerHook
+                });
+            }
+        });
+        if (isFunction__default.default(customBootstrap)) {
+            customBootstrap({
+                addComponents: this.addComponents,
+                addFields: this.addFields,
+                addMenuLink: this.addMenuLink,
+                addReducers: this.addReducers,
+                addSettingsLink: this.addSettingsLink,
+                addSettingsLinks: this.addSettingsLinks,
+                getPlugin: this.getPlugin,
+                registerHook: this.registerHook
+            });
+        }
+    }
+    async register(customRegister) {
+        const widgets = [
+            {
+                icon: icons.User,
+                title: {
+                    id: 'widget.profile.title',
+                    defaultMessage: 'Profile'
+                },
+                component: async ()=>{
+                    const { ProfileWidget } = await Promise.resolve().then(function () { return require('./components/Widgets.js'); });
+                    return ProfileWidget;
+                },
+                pluginId: 'admin',
+                id: 'profile-info',
+                link: {
+                    label: {
+                        id: 'global.profile.settings',
+                        defaultMessage: 'Profile settings'
+                    },
+                    href: '/me'
+                }
+            },
+            {
+                icon: icons.TrendUp,
+                title: {
+                    id: 'widget.key-statistics.title',
+                    defaultMessage: 'Project statistics'
+                },
+                component: async ()=>{
+                    const { KeyStatisticsWidget } = await Promise.resolve().then(function () { return require('./components/Widgets.js'); });
+                    return KeyStatisticsWidget;
+                },
+                pluginId: 'admin',
+                id: 'key-statistics',
+                roles: [
+                    'strapi-super-admin'
+                ]
+            }
+        ];
+        if ('strapi-cloud' in this.appPlugins) {
+            widgets.push({
+                icon: icons.Cloud,
+                title: {
+                    id: 'widget.deploy-now.title',
+                    defaultMessage: 'Deploy'
+                },
+                component: async ()=>{
+                    const { DeployNowWidget } = await Promise.resolve().then(function () { return require('./components/Widgets.js'); });
+                    return DeployNowWidget;
+                },
+                pluginId: 'admin',
+                id: 'deploy-now'
+            });
+        }
+        this.widgets.register(widgets);
+        Object.keys(this.appPlugins).forEach((plugin)=>{
+            this.appPlugins[plugin].register(this);
+        });
+        if (isFunction__default.default(customRegister)) {
+            customRegister(this);
+        }
+        // Register Audit Logs widget at the end of the widgets array
+        if (window.strapi.features.isEnabled(window.strapi.features.AUDIT_LOGS)) {
+            this.widgets.register([
+                {
+                    icon: icons.Clock,
+                    title: {
+                        id: 'widget.last-activity.title',
+                        defaultMessage: 'Last activity'
+                    },
+                    component: async ()=>{
+                        const { AuditLogsWidget } = await Promise.resolve().then(function () { return require('../../ee/admin/src/components/AuditLogs/Widgets.js'); });
+                        return AuditLogsWidget;
+                    },
+                    pluginId: 'admin',
+                    id: 'audit-logs',
+                    link: {
+                        label: {
+                            id: 'widget.last-activity.link',
+                            defaultMessage: 'Open Audit Logs'
+                        },
+                        href: `/settings/audit-logs?pageSize=${constants.AUDIT_LOGS_DEFAULT_PAGE_SIZE}&page=1&sort=date:DESC`
+                    },
+                    permissions: [
+                        {
+                            action: 'admin::audit-logs.read'
+                        }
+                    ]
+                }
+            ]);
+        }
+    }
+    mergePluginTranslationsByCanonical(pluginTradsBatch) {
+        return pluginTradsBatch.reduce((acc, current)=>{
+            const canonicalLocale = normalizeAdminLocale.normalizeAdminLocale(current.locale);
+            acc[canonicalLocale] = {
+                ...current.locale === canonicalLocale ? acc[canonicalLocale] : current.data,
+                ...current.locale === canonicalLocale ? current.data : acc[canonicalLocale]
+            };
+            if (current.locale !== canonicalLocale && Object.keys(current.data).length > 0) {
+                const deprecationKey = `${canonicalLocale}:${current.locale}`;
+                if (!this.warnedLegacyLocalePairs.has(deprecationKey)) {
+                    this.warnedLegacyLocalePairs.add(deprecationKey);
+                    console.warn(`[deprecated] Admin locale "${current.locale}" is deprecated. Rename translation files to "${canonicalLocale}.json".`);
+                }
+            }
+            return acc;
+        }, {});
+    }
+    async loadAdminTrads() {
+        const adminLocales = await Promise.all(this.configurations.locales.map(async (locale)=>{
+            try {
+                const { default: data } = await __variableDynamicImportRuntime4__(`./translations/${locale}.js`);
+                return {
+                    data,
+                    locale
+                };
+            } catch  {
+                try {
+                    const { default: data } = await __variableDynamicImportRuntime5__(`./translations/${locale}.json`);
+                    return {
+                        data,
+                        locale
+                    };
+                } catch  {
+                    return {
+                        data: null,
+                        locale
+                    };
+                }
+            }
+        }));
+        return adminLocales.reduce((acc, current)=>{
+            if (current.data) {
+                acc[current.locale] = current.data;
+            }
+            return acc;
+        }, {});
+    }
+    /**
+   * Load the application's translations and merged the custom translations
+   * with the default ones.
+   */ async loadTrads(customTranslations = {}) {
+        const normalizedCustomTranslations = Object.keys(customTranslations).reduce((acc, key)=>{
+            const normalizedKey = normalizeAdminLocale.normalizeAdminLocale(key);
+            acc[normalizedKey] = {
+                ...acc[normalizedKey] || {},
+                ...customTranslations[key]
+            };
+            return acc;
+        }, {});
+        const adminTranslations = await this.loadAdminTrads();
+        const localesForPlugins = uniq__default.default(this.configurations.locales.flatMap((locale)=>{
+            const legacyLocale = ADMIN_LOCALE_LEGACY_ALIASES[locale];
+            return legacyLocale ? [
+                locale,
+                legacyLocale
+            ] : [
+                locale
+            ];
+        }));
+        const arrayOfPromises = Object.keys(this.appPlugins).map((plugin)=>{
+            const registerTrads = this.appPlugins[plugin].registerTrads;
+            if (registerTrads) {
+                return registerTrads({
+                    locales: localesForPlugins
+                });
+            }
+            return null;
+        }).filter((a)=>a);
+        const pluginsTrads = await Promise.all(arrayOfPromises);
+        const mergedTrads = pluginsTrads.reduce((acc, currentPluginTrads)=>{
+            const pluginTrads = this.mergePluginTranslationsByCanonical(currentPluginTrads);
+            Object.keys(pluginTrads).forEach((locale)=>{
+                acc[locale] = {
+                    ...acc[locale],
+                    ...pluginTrads[locale]
+                };
+            });
+            return acc;
+        }, {});
+        const translations = this.configurations.locales.reduce((acc, current)=>{
+            acc[current] = {
+                ...adminTranslations[current],
+                ...mergedTrads[current] || {},
+                ...normalizedCustomTranslations[current] ?? {}
+            };
+            return acc;
+        }, {});
+        this.configurations.translations = translations;
+        return Promise.resolve();
+    }
+    render() {
+        const localeNames = pick__default.default(languageNativeNames.languageNativeNames, this.configurations.locales || []);
+        const storedLocale = localStorage.getItem(reducer.LANGUAGE_LOCAL_STORAGE_KEY) || 'en';
+        const locale = normalizeAdminLocale.normalizeAdminLocale(storedLocale);
+        this.store = configure.configureStore({
+            admin_app: {
+                permissions: merge__default.default({}, constants$1.ADMIN_PERMISSIONS_CE, constants.ADMIN_PERMISSIONS_EE),
+                theme: {
+                    availableThemes: [],
+                    currentTheme: localStorage.getItem(reducer.THEME_LOCAL_STORAGE_KEY) || 'system'
+                },
+                language: {
+                    locale: localeNames[locale] ? locale : 'en',
+                    localeNames
+                },
+                token: reducer.getStoredToken()
+            }
+        }, this.middlewares, this.reducers);
+        const router = this.router.createRouter(this, {
+            basename: basename.getBasename()
+        });
+        return /*#__PURE__*/ jsxRuntime.jsx(reactRouterDom.RouterProvider, {
+            router: router
+        });
+    }
+    constructor({ config, appPlugins } = {}){
+        this.plugins = {};
+        this.hooksDict = {};
+        this.warnedLegacyLocalePairs = new Set();
+        this.admin = {
+            injectionZones: {}
+        };
+        this.translations = {};
+        this.configurations = {
+            authLogo: logoStrapi2022,
+            locales: [
+                'en'
+            ],
+            menuLogo: logoStrapi2022,
+            notifications: {
+                releases: true
+            },
+            themes: {
+                light: designSystem.lightTheme,
+                dark: designSystem.darkTheme
+            },
+            translations: {},
+            tutorials: true
+        };
+        /**
+   * APIs
+   */ this.rbac = new rbac.RBAC();
+        this.library = {
+            components: {},
+            fields: {}
+        };
+        this.middlewares = [];
+        this.reducers = {};
+        this.store = null;
+        this.customFields = new CustomFields.CustomFields();
+        this.widgets = new Widgets.Widgets();
+        this.addComponents = (components)=>{
+            if (Array.isArray(components)) {
+                components.map((comp)=>{
+                    invariant__default.default(comp.Component, 'A Component must be provided');
+                    invariant__default.default(comp.name, 'A type must be provided');
+                    this.library.components[comp.name] = comp.Component;
+                });
+            } else {
+                invariant__default.default(components.Component, 'A Component must be provided');
+                invariant__default.default(components.name, 'A type must be provided');
+                this.library.components[components.name] = components.Component;
+            }
+        };
+        this.addFields = (fields)=>{
+            if (Array.isArray(fields)) {
+                fields.map((field)=>{
+                    invariant__default.default(field.Component, 'A Component must be provided');
+                    invariant__default.default(field.type, 'A type must be provided');
+                    this.library.fields[field.type] = field.Component;
+                });
+            } else {
+                invariant__default.default(fields.Component, 'A Component must be provided');
+                invariant__default.default(fields.type, 'A type must be provided');
+                this.library.fields[fields.type] = fields.Component;
+            }
+        };
+        this.addMiddlewares = (middlewares)=>{
+            middlewares.forEach((middleware)=>{
+                this.middlewares.push(middleware);
+            });
+        };
+        this.addRBACMiddleware = (m)=>{
+            if (Array.isArray(m)) {
+                this.rbac.use(m);
+            } else {
+                this.rbac.use(m);
+            }
+        };
+        this.addReducers = (reducers)=>{
+            /**
+     * TODO: when we upgrade to redux-toolkit@2 and we can also dynamically add middleware,
+     * we'll deprecate these two APIs in favour of their hook counterparts.
+     */ Object.entries(reducers).forEach(([name, reducer])=>{
+                this.reducers[name] = reducer;
+            });
+        };
+        this.addMenuLink = (link)=>this.router.addMenuLink(link);
+        /**
+   * @deprecated use `addSettingsLink` instead, it internally supports
+   * adding multiple links at once.
+   */ this.addSettingsLinks = (sectionId, links)=>{
+            invariant__default.default(Array.isArray(links), 'TypeError expected links to be an array');
+            this.router.addSettingsLink(sectionId, links);
+        };
+        /**
+   * @deprecated use `addSettingsLink` instead, you can pass a section object to
+   * create the section and links at the same time.
+   */ this.createSettingSection = (section, links)=>this.router.addSettingsLink(section, links);
+        /**
+   * Register one or more settings links under an existing or new section.
+   *
+   * @param sectionId - Section id string, or section metadata to create a new section
+   * @param link - A single link or an array of links to register
+   */ this.addSettingsLink = (sectionId, link)=>{
+            this.router.addSettingsLink(sectionId, link);
+        };
+        this.createCustomConfigurations = (customConfig)=>{
+            if (customConfig.locales) {
+                const extraLocales = customConfig.locales?.filter((loc)=>loc !== 'en').map((loc)=>normalizeAdminLocale.normalizeAdminLocale(loc)) || [];
+                this.configurations.locales = uniq__default.default([
+                    'en',
+                    ...extraLocales
+                ]);
+            }
+            if (customConfig.auth?.logo) {
+                this.configurations.authLogo = customConfig.auth.logo;
+            }
+            if (customConfig.menu?.logo) {
+                this.configurations.menuLogo = customConfig.menu.logo;
+            }
+            if (customConfig.theme) {
+                const darkTheme = customConfig.theme.dark;
+                const lightTheme = customConfig.theme.light;
+                if (!darkTheme && !lightTheme) {
+                    console.warn(`[deprecated] In future versions, Strapi will stop supporting this theme customization syntax. The theme configuration accepts a light and a dark key to customize each theme separately. See https://docs.strapi.io/developer-docs/latest/development/admin-customization.html#theme-extension.`.trim());
+                    merge__default.default(this.configurations.themes.light, customConfig.theme);
+                }
+                if (lightTheme) merge__default.default(this.configurations.themes.light, lightTheme);
+                if (darkTheme) merge__default.default(this.configurations.themes.dark, darkTheme);
+            }
+            if (customConfig.notifications?.releases !== undefined) {
+                this.configurations.notifications.releases = customConfig.notifications.releases;
+            }
+            if (customConfig.tutorials !== undefined) {
+                this.configurations.tutorials = customConfig.tutorials;
+            }
+        };
+        this.createHook = (name)=>{
+            this.hooksDict[name] = createHook.createHook();
+        };
+        this.getAdminInjectedComponents = (moduleName, containerName, blockName)=>{
+            try {
+                // @ts-expect-error – we have a catch block so if you don't pass it correctly we still return an array.
+                return this.admin.injectionZones[moduleName][containerName][blockName] || [];
+            } catch (err) {
+                console.error('Cannot get injected component', err);
+                return [];
+            }
+        };
+        this.getPlugin = (pluginId)=>this.plugins[pluginId];
+        this.registerHook = (name, fn)=>{
+            invariant__default.default(this.hooksDict[name], `The hook ${name} is not defined. You are trying to register a hook that does not exist in the application.`);
+            this.hooksDict[name].register(fn);
+        };
+        this.registerPlugin = (pluginConf)=>{
+            const plugin = new Plugin.Plugin(pluginConf);
+            this.plugins[plugin.pluginId] = plugin;
+        };
+        this.runHookSeries = (name, asynchronous = false)=>asynchronous ? this.hooksDict[name].runSeriesAsync() : this.hooksDict[name].runSeries();
+        this.runHookWaterfall = (name, initialValue, store)=>{
+            return this.hooksDict[name].runWaterfall(initialValue, store);
+        };
+        this.runHookParallel = (name)=>this.hooksDict[name].runParallel();
+        this.appPlugins = appPlugins || {};
+        this.createCustomConfigurations(config ?? {});
+        this.createHook(INJECT_COLUMN_IN_TABLE);
+        this.createHook(INJECT_LIST_VIEW_FILTERS);
+        this.createHook(MUTATE_COLLECTION_TYPES_LINKS);
+        this.createHook(MUTATE_SINGLE_TYPES_LINKS);
+        this.createHook(MUTATE_EDIT_VIEW_LAYOUT);
+        this.router = new router.Router(router$1.getInitialRoutes());
+    }
+}
+
+exports.StrapiApp = StrapiApp;
+//# sourceMappingURL=StrapiApp.js.map